WebAssembly API¶

import init, { Database } from '@grafeo-db/wasm';

await init();
const db = new Database();

db.execute("INSERT (:Person {name: 'Alix', age: 30})");
db.execute("INSERT (:Person {name: 'Gus', age: 25})");

const results = db.execute("MATCH (p:Person) RETURN p.name, p.age");
console.log(results); // [{name: "Alix", age: 30}, {name: "Gus", age: 25}]

const db = new Database();   // in-memory (all WASM databases are in-memory)
const kept = new Database({ historyRetention: 60 * 60 * 1000 });  // keeps an hour of history

db.execute(gql);                              // GQL: returns array of row objects
db.executeRaw(gql);                          // GQL: returns {columns, rows, executionTimeMs, counters}, and profile for PROFILE
db.executeWithParams(gql, params);           // GQL with parameter binding
db.executeWithLanguage(query, language);     // "gql", "cypher", "graphql", etc.
db.executeWithLanguageAndParams(query, language, params);  // language + params
db.executeCypher(query);                     // Cypher shorthand
db.executeGremlin(query);                    // Gremlin shorthand
db.executeGraphql(query);                    // GraphQL shorthand
db.executeSparql(query);                     // SPARQL shorthand (requires rdf feature)
db.executeSql(query);                        // SQL/PGQ shorthand
db.executeRawWithLanguage(query, language);  // raw result with language selection
db.executeRawWithParams(gql, params);        // raw result with parameter binding
db.executeRawWithLanguageAndParams(query, language, params);  // raw result, language + params

const then = db.currentEpoch();                           // a bigint
const view = db.asOf({ ago: 5 * 60 * 1000 });            // read-only, as five minutes ago
view.execute("MATCH (p:Person) RETURN count(p) AS n");   // also executeWithParams and executeRaw
view.close();                                             // releases the history it keeps
db.executeAsOf("MATCH (p:Person) RETURN p.name", then);  // one query, optional params
db.epochAsOf(new Date("2026-03-01T12:00:00+01:00"));     // the epoch a point reads at

db.getNodeEdges(id, { direction: "out", edgeTypes: ["KNOWS"] });  // [[neighborId, edgeId], ...]
db.detachDeleteNode(id);  // deletes the node with its edges; false if it does not exist
db.nodeCount();   // number of nodes
db.edgeCount();   // number of edges
db.schema();      // database schema as JSON
Database.version(); // Grafeo version string

db.execute("RETURN 0.1 + 0.2 AS x");      // [{ x: { $decimal: '0.3' } }]
db.executeWithParams("RETURN $p * 3 AS x", { p: { $decimal: '0.10' } });  // { $decimal: '0.30' }

db.executeSparql('SELECT ?s WHERE { ?s <http://ex.org/label> "Pomme"@fr }');
// [{ s: { termType: 'NamedNode', value: 'http://ex.org/apple' } }]
const [{ s }] = db.executeSparql('SELECT ?s WHERE { ?s <http://ex.org/label> "Pomme"@fr }');
s.equals({ termType: 'NamedNode', value: 'http://ex.org/apple' });  // true

db.createTextIndex("Document", "content");
const results = db.textSearch("Document", "content", "graph database", 10);
// [{id, score}, ...]

// Options: BM25 k1 (>= 0, default 1.2) and b (0 to 1, default 0.75), the
// tokenizer ("simple", the default, "standard" or "cjk_bigram") and stop words
db.createTextIndex("Note", "body", { tokenizer: "cjk_bigram", k1: 1.5, stopWords: ["住在"] });

// Only the nodes the filters match, as in vectorSearch()
const berlin = db.textSearch("Document", "content", "graph", 10, { filters: { city: "Berlin" } });

db.rebuildTextIndex("Document", "content");
db.dropTextIndex("Document", "content");

// Create indexes via GQL queries
db.execute("CREATE INDEX document_content FOR (d:Document) ON (d.content) USING TEXT");
db.execute("CREATE VECTOR INDEX document_embedding ON :Document(embedding) DIMENSION 384");

const results = db.hybridSearch(
    "Document",
    "content",                        // text field
    "embedding",                      // vector field
    "graph database",                 // text query
    10,                               // top-k
    { filters: { city: "Berlin" } }   // optional: property filters, as in vectorSearch()
);

const result = db.importLpg({
    nodes: [
        { labels: ["Person"], properties: { name: "Alix", age: 30 } },
        { labels: ["Person"], properties: { name: "Gus", age: 25 } },
    ],
    edges: [
        { source: 0, target: 1, type: "KNOWS", properties: { since: 2020 } }
    ]
});
console.log(result); // { nodes: 2, edges: 1 }

// One transaction each; IDs in input order
const ids = db.batchCreateNodesWithProps(["Person"], [{ name: "Alix" }, { name: "Gus" }]);
db.batchCreateEdges([{ src: ids[0], dst: ids[1], type: "KNOWS", properties: { since: 2020 } }]);

// Create or update by a key property: {created, updated, skipped, skippedRows}
db.upsertNodes(["File"], [{ path: "a.rs", size: 3 }], { key: "path" });
db.upsertEdges("IMPORTS", [{ id: "a-b", src: "a.rs", dst: "b.rs" }],
    { endpointKey: "path", endpointLabels: ["File"] });

db.execute("CREATE GRAPH trips");
const trips = db.graph("trips");
trips.execute("INSERT (:City {name: 'Prague'})");
trips.execute("MATCH (c:City) RETURN c.name");  // the default graph stays empty

const result = db.importRdf({
    triples: [
        {
            subject: "http://example.org/Alix",
            predicate: "http://www.w3.org/1999/02/22-rdf-syntax-ns#type",
            object: "http://example.org/Person"
        },
        {
            subject: "http://example.org/Alix",
            predicate: "http://example.org/name",
            object: { value: "Alix" }
        },
        {
            subject: "http://example.org/Alix",
            predicate: "http://example.org/age",
            object: { value: "30", datatype: "http://www.w3.org/2001/XMLSchema#integer" }
        }
    ]
});
console.log(result); // { triples: 3 }

const report = db.compact();

// Export
const snapshot = db.exportSnapshot();
// Store in IndexedDB...

// Import
const db2 = Database.importSnapshot(snapshot);