@oxilite/d1 0.1.0 → 0.3.0

package/README.md

@@ -1,20 +1,140 @@
+<p align="center">
+  <a href="https://oxilitedb.com"><img src="https://raw.githubusercontent.com/Volland/oxilite/main/site/assets/logo.png" alt="oxilite" width="120"></a>
+</p>
+
 # @oxilite/d1
 
-An Oxigraph-compatible SPARQL 1.1 store on a Cloudflare D1 database. The oxilite core runs as WebAssembly: SPARQL is compiled to SQL and sent to your `env.DB` binding, so every query is one D1 call and every update is one atomic batch.
+[![npm](https://img.shields.io/npm/v/@oxilite/d1.svg)](https://www.npmjs.com/package/@oxilite/d1) [![license](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue.svg)](https://github.com/Volland/oxilite#license)
+
+**An Oxigraph-compatible SPARQL 1.1 and openCypher store on Cloudflare D1 and Durable Objects.** The oxilite core runs as WebAssembly: it compiles each query to SQL for your `env.DB` binding, so a query is one D1 call and an update is one atomic batch. No Rust toolchain needed.
+
+**[Website](https://oxilitedb.com)** · [npm](https://www.npmjs.com/package/@oxilite/d1) · **[Guide and architecture](https://github.com/Volland/oxilite#readme)** · [Changelog and issues](https://github.com/Volland/oxilite/issues)
+
+```bash
+npm install @oxilite/d1
+```
+
+## 1. Create the schema
+
+```bash
+npx wrangler d1 create my-graph
+npx oxilite-d1 schema > migrations/0001_oxilite.sql          # --no-graph-index to save writes
+                                                             # --jsonld for JSON-LD / credential tables
+npx wrangler d1 migrations apply my-graph --remote
+```
+
+> **Upgrading to 0.3.0 from 0.2.x:** 0.3.0 adds the `schema_graphs`, `shapes_index`,
+> `shapes_in` and `datalog_work` tables. A D1 store is opened with `open_existing`, so no
+> DDL runs per request and an existing database will report `no such table: schema_graphs`
+> until you apply a new migration. Regenerate and apply it:
+>
+> ```bash
+> npx wrangler d1 migrations create my-graph oxilite-0-3-0
+> npx oxilite-d1 schema > migrations/0002_oxilite-0-3-0.sql
+> npx wrangler d1 migrations apply my-graph --remote
+> ```
+>
+> Every statement is `CREATE TABLE IF NOT EXISTS`, so re-applying it is safe and your data
+> is untouched.
+
+## 2. Query it from a Worker
 
 ```ts
 import { D1Store } from "@oxilite/d1";
 import wasm from "@oxilite/d1/oxilite.wasm";
 
 export default {
-  async fetch(req: Request, env: { DB: D1Database }) {
+  async fetch(req: Request, env: { DB: D1Database }): Promise<Response> {
     const store = await D1Store.open(env.DB, { wasm, migrated: true });
-    const q = new URL(req.url).searchParams.get("query") ?? "SELECT * WHERE { ?s ?p ?o } LIMIT 10";
-    return new Response(await store.queryJson(q), { headers: { "content-type": "application/sparql-results+json" } });
+    const url = new URL(req.url);
+
+    if (req.method === "POST" && url.pathname === "/update") {
+      await store.update(await req.text());               // one atomic D1 batch
+      return new Response(null, { status: 204 });
+    }
+    const q = url.searchParams.get("query") ?? "SELECT * WHERE { ?s ?p ?o } LIMIT 10";
+    return new Response(await store.queryJson(q), {
+      headers: { "content-type": "application/sparql-results+json" },
+    });
   },
 };
 ```
 
-Create the schema as a migration with `npx oxilite-d1 schema > migrations/0001_oxilite.sql`. In Node (tests, Miniflare), import from `@oxilite/d1/node`.
+## Cypher on D1
+
+```ts
+await store.cypher(
+  "UNWIND $rows AS row MERGE (p:Person {id: row.id}) SET p.name = row.name",
+  { rows: [{ id: 1, name: "Ada" }, { id: 2, name: "Alan" }] },
+  { base: "https://example.com/" },
+);
+const r = await store.cypher(
+  "MATCH p = shortestPath((a:Person {id: 1})-[:KNOWS*]-(b:Person {id: 2})) RETURN length(p) AS hops",
+  {}, { base: "https://example.com/" },
+);
+```
+
+Every Cypher write is one atomic batch; `shortestPath` is a breadth-first search with one request per level. SPARQL and Cypher see the same data.
+
+## JSON-LD documents and Verifiable Credentials on D1
+
+```ts
+const vcs = store.credentials();                     // W3C credential contexts are bundled
+const id = await vcs.put(credentialJson);            // one D1 batch: JSON row + RDF in graph <id>
+await vcs.putPresentation(presentationJson);         // embedded credentials stored too, same batch
+const valid = await vcs.find({ issuer: "did:example:issuer", validAt: new Date() });
+const raw = (await vcs.get(id))?.json;               // the exact bytes
+
+const docs = store.jsonld();                         // any JSON-LD document
+await docs.putContext("https://example.org/my-context", myContext);   // persisted in D1
+await docs.put(documentJson);
+```
+
+Contexts load offline: bundled credential contexts, contexts passed in `options.contexts`, and contexts persisted in D1 with `putContext`. A Worker never fetches contexts. Every write is one batch, and a document too large for one batch fails with `document-too-large` rather than being split. Pass `migrated: true` to `jsonld()` / `credentials()` when your migration already created the tables (`oxilite-d1 schema --jsonld`). JSON-LD and credential support adds about 1.7 MB (0.4 MB gzipped) to the wasm module, which stays well within the Workers size limits.
+
+## Durable Objects
+
+The same store runs on a Durable Object's embedded SQLite through a small adapter over `ctx.storage.sql`, which gives every agent or user a private graph. [`examples/do-agent-memory-ts`](https://github.com/Volland/oxilite/tree/main/examples/do-agent-memory-ts) is a tested agent-memory Worker built this way.
+
+## API
+
+`D1Store` mirrors Oxigraph's JavaScript `Store`, asynchronously: `query`, `queryJson`, `update`, `load`, `bulkLoad`, `dump`, `add`, `delete`, `has`, `match`, `size`, `clear`, plus `cypher`, `explain`, `explainUpdate`, `explainCypher`, `optimize`, `materialize` (OWL 2 RL as SQL rules), `clearInferences`, `jsonld(options)` and `credentials(options)`. Query options add `reasoning: "rdfs" | "owl-ql"` and `include_inferred`; create the store with `textIndex: true` for FTS5 search with `oxl:textMatch`.
+
+| Import | Use |
+|---|---|
+| `@oxilite/d1` | Workers: pass the wasm module (`@oxilite/d1/oxilite.wasm`) to `D1Store.open` |
+| `@oxilite/d1/node` | Node.js, tests and Miniflare: the wasm core loads itself |
+| `npx oxilite-d1 schema [--jsonld]` | Print the schema as a D1 migration (with the JSON-LD tables) |
+
+## Tips
+
+- Run `store.optimize()` after large imports, not on every request: it refreshes planner statistics.
+- Drop the graph index (`--no-graph-index`, `graphIndex: false`) if you only use the default graph: one fewer index write per triple.
+- Use `explain()` in development to check a query compiles fully to SQL. Queries that need the Rust fallback evaluator report "unsupported" on D1.
+
+More in the [D1 guide](https://github.com/Volland/oxilite#using-oxilite-with-cloudflare-d1). A complete Worker with its migration and a Miniflare test is in [`examples/d1-worker-ts`](https://github.com/Volland/oxilite/tree/main/examples/d1-worker-ts).
+
+## The oxilite family
+
+oxilite is an Oxigraph-compatible RDF database and SPARQL 1.1 engine that stores its data in SQLite, so it runs anywhere SQLite runs: in-process, on a system or vendor `libsqlite3`, on Cloudflare D1 and in Durable Objects. The same data can be queried with SPARQL and openCypher, reasoned over with RDFS / OWL, and validated with SHACL and ShEx. Read the overview on **[oxilitedb.com](https://oxilitedb.com)** and the full guide in the [main README](https://github.com/Volland/oxilite#readme).
+
+| Package | What it is for |
+|---|---|
+| [`oxilite`](https://crates.io/crates/oxilite) | The store: a drop-in for `oxigraph::store::Store`, plus `AsyncStore` for D1 |
+| [`oxilite-core`](https://crates.io/crates/oxilite-core) | The sans-IO core: term encoding, schema, SPARQL → SQL compiler and planner |
+| [`oxilite-rusqlite`](https://crates.io/crates/oxilite-rusqlite) | In-process backend with a bundled SQLite (the default) |
+| [`oxilite-dylib`](https://crates.io/crates/oxilite-dylib) | Backend that loads your own `libsqlite3` at runtime |
+| [`oxilite-d1`](https://crates.io/crates/oxilite-d1) | Cloudflare D1 backend for Rust Workers |
+| [`oxilite-cypher`](https://crates.io/crates/oxilite-cypher) | openCypher over the same data, OWL- and SHACL-aware |
+| [`oxilite-jsonld`](https://crates.io/crates/oxilite-jsonld) | JSON-LD documents stored verbatim, one named graph each |
+| [`oxilite-vc`](https://crates.io/crates/oxilite-vc) | Verifiable Credentials: stored under their id, indexed, queryable |
+| [`oxilite-reason`](https://crates.io/crates/oxilite-reason) | OWL 2 RL materialization with `reasonable` |
+| [`oxilite-validate`](https://crates.io/crates/oxilite-validate) | SHACL and ShEx validation with rudof |
+| [`oxilite-cli`](https://crates.io/crates/oxilite-cli) | The `oxilite` command and a SPARQL endpoint like `oxigraph serve` |
+| [`@oxilite/node`](https://www.npmjs.com/package/@oxilite/node) | Node.js bindings, API of Oxigraph's JS package |
+| [`@oxilite/d1`](https://www.npmjs.com/package/@oxilite/d1) | Cloudflare D1 and Durable Objects from TypeScript (WebAssembly core) |
+| [`@oxilite/common`](https://www.npmjs.com/package/@oxilite/common) | RDF/JS terms and shared TypeScript types |
+
+## License
 
-The API mirrors Oxigraph's JavaScript `Store` (`query`, `update`, `load`, `dump`, `add`, `delete`, `has`, `match`, `size`), asynchronously, plus `explain`, `bulkLoad`, `optimize`, `materialize` (OWL 2 RL) and query options for RDFS / OWL reasoning and full-text search. See the [oxilite repository](https://github.com/Volland/oxilite).
+Dual-licensed under [MIT](https://github.com/Volland/oxilite/blob/main/LICENSE-MIT) or [Apache-2.0](https://github.com/Volland/oxilite/blob/main/LICENSE-APACHE), at your option, like Oxigraph.

package/bin/oxilite-d1.mjs

@@ -1,11 +1,16 @@
 #!/usr/bin/env node
-// Usage: npx oxilite-d1 schema [--no-graph-index] > migrations/0001_oxilite.sql
+// Usage: npx oxilite-d1 schema [--no-graph-index] [--jsonld] [--no-metadata-indexes] > migrations/0001_oxilite.sql
 import { D1Store } from "../dist/node.js";
 
 const [command, ...args] = process.argv.slice(2);
 if (command === "schema") {
-  process.stdout.write(D1Store.schemaSql({ graphIndex: !args.includes("--no-graph-index") }));
+  const jsonld = args.includes("--jsonld")
+    ? args.includes("--no-metadata-indexes")
+      ? { issuer: false, subject: false, validUntil: false }
+      : true
+    : false;
+  process.stdout.write(D1Store.schemaSql({ graphIndex: !args.includes("--no-graph-index"), jsonld }));
 } else {
-  console.error("usage: oxilite-d1 schema [--no-graph-index]");
+  console.error("usage: oxilite-d1 schema [--no-graph-index] [--jsonld] [--no-metadata-indexes]");
   process.exit(1);
 }

package/dist/driver.d.ts

@@ -1,4 +1,4 @@
-import { type DumpOptions, type LoadData, type LoadOptions, type Quad, type QueryOptions, type QueryResult, type TermLike } from "@oxilite/common";
+import { type CypherOptions, type DatalogMaterializeResult, type DatalogOptions, type DatalogResult, type CypherResult, type CypherValue, type CredentialOptions, type DocumentFilter, type Drift, type JsonLdOptions, type PresentationKeys, type StoredDocument, type Term, type DumpOptions, type LoadData, type LoadOptions, type Quad, type QueryOptions, type QueryResult, type TermLike } from "@oxilite/common";
 /** The subset of the Cloudflare D1 binding API used by oxilite. */
 export interface D1PreparedStatementLike {
     raw(): Promise<unknown[][]>;
@@ -25,6 +25,11 @@ export interface WasmEngine {
     query(sparql: string, options?: string | null): WasmJob;
     queryJson(sparql: string): WasmJob;
     explain(sparql: string): string;
+    cypher(query: string, params?: string | null, options?: string | null): WasmJob;
+    datalog?(program: string, options?: string | null): WasmJob;
+    datalog_materialize?(program: string, options?: string | null): WasmJob;
+    explain_datalog?(program: string, options?: string | null): string;
+    explainCypher(query: string, params?: string | null, options?: string | null): string;
     update(sparql: string, baseIri?: string | null): WasmJob;
     explainUpdate(sparql: string): string;
     load(data: string, format: string, base?: string | null, graph?: string | null): WasmJob;
@@ -39,6 +44,8 @@ export interface WasmEngine {
     materialize(): WasmJob;
     clearInferences(): WasmJob;
     schemaSql(): string;
+    jsonld(op: string, args: string, options?: string | null): WasmJob;
+    jsonldSchemaSql(indexes?: string | null): string;
 }
 export type EngineConstructor = new (capabilities?: string | null, options?: string | null) => WasmEngine;
 /** A term hash collision (two different terms with the same 59-bit id). */
@@ -60,6 +67,49 @@ export declare class D1Store {
     static openWith(Engine: EngineConstructor, db: D1DatabaseLike, options?: D1StoreOptions): Promise<D1Store>;
     private execute;
     private run;
+    /**
+     * JSON-LD documents: each stored verbatim under a key (by default its `@id`), its RDF in a
+     * named graph (by default the key). Every write is one D1 batch. Contexts load offline:
+     * persist the ones your documents use with `putContext`.
+     */
+    jsonld(options?: JsonLdOptions & {
+        migrated?: boolean;
+    }): D1JsonLdDocuments;
+    /**
+     * Verifiable Credentials (VCDM 1.1 and 2.0) stored under their `id`, RDF in the graph of the
+     * same IRI; the W3C credential contexts are bundled. Proofs are not verified.
+     */
+    credentials(options?: CredentialOptions & {
+        migrated?: boolean;
+    }): D1Credentials;
+    private jsonldCall;
+    /**
+     * A Cypher statement over the property-graph view of the dataset. Reads compile to SQL; a
+     * writing statement reads, then applies its changes as one D1 batch.
+     */
+    cypher(query: string, params?: Record<string, CypherValue>, options?: CypherOptions): Promise<CypherResult>;
+    /**
+     * A Datalog program over the same quads: recursive rules with stratified negation,
+     * constraints and aggregation. A program whose recursion is linear is one SQL statement, so
+     * it costs one round trip here as it does anywhere; a component that has to be iterated
+     * costs one per round, which `rounds` reports.
+     */
+    datalog(program: string, options?: DatalogOptions): Promise<DatalogResult>;
+    /**
+     * Stores what a Datalog program derives as inferences, in the table OWL 2 RL
+     * materialization uses, so SPARQL and Cypher see them with `includeInferred`. The writes
+     * are one D1 batch.
+     */
+    datalogMaterialize(program: string, options?: DatalogOptions): Promise<DatalogMaterializeResult>;
+    /** How a Datalog program runs: its strata, the strategy per recursive component, the SQL. */
+    explainDatalog(program: string, options?: DatalogOptions): string;
+    /**
+     * The Datalog frontend is an opt-in feature of the WebAssembly core, so say which build is
+     * needed rather than failing with "not a function".
+     */
+    private requireDatalog;
+    /** How a Cypher statement runs: its SPARQL, the SQL, and what runs in Rust. */
+    explainCypher(query: string, params?: Record<string, CypherValue>, options?: CypherOptions): string;
     /** SPARQL query: `Map[]` for SELECT, `boolean` for ASK, `Quad[]` for CONSTRUCT/DESCRIBE, or a string with `results_format`. */
     query(query: string, options?: QueryOptions): Promise<QueryResult>;
     /** SPARQL query returning SPARQL 1.1 JSON results. */
@@ -100,3 +150,46 @@ export declare class D1Store {
     /** The schema SQL of this store (for `wrangler d1 migrations`). */
     schemaSql(): string;
 }
+type AsyncCall = (op: string, args: object) => Promise<unknown>;
+/** JSON-LD documents of a D1 store (see `D1Store.jsonld`). */
+export declare class D1JsonLdDocuments {
+    private readonly call;
+    constructor(call: AsyncCall);
+    /** Stores a document (replacing one with the same key) and returns its key. JSON text is stored byte for byte. */
+    put(document: string | object, key?: string): Promise<string>;
+    /** Stores several documents in one D1 batch; returns their keys. */
+    putAll(documents: {
+        document: string | object;
+        key?: string;
+    }[]): Promise<string[]>;
+    get(key: string): Promise<StoredDocument | null>;
+    /** Removes a document and the graphs it owns; false when it was not stored. */
+    remove(key: string): Promise<boolean>;
+    list(options?: {
+        after?: string;
+        limit?: number;
+    }): Promise<StoredDocument[]>;
+    find(filter?: DocumentFilter): Promise<StoredDocument[]>;
+    graphs(key: string): Promise<Term[]>;
+    documentForGraph(graph: TermLike): Promise<StoredDocument | null>;
+    /** Persists a context in D1, so documents that reference `iri` convert offline. */
+    putContext(iri: string, context: object | string): Promise<void>;
+    removeContext(iri: string): Promise<void>;
+    contexts(): Promise<string[]>;
+    rebuild(key: string): Promise<boolean>;
+    check(): Promise<Drift[]>;
+}
+/** Verifiable Credentials of a D1 store (see `D1Store.credentials`). */
+export declare class D1Credentials {
+    private readonly call;
+    readonly documents: D1JsonLdDocuments;
+    constructor(call: AsyncCall);
+    /** Checks and stores a credential; returns its key. */
+    put(credential: string | object, key?: string): Promise<string>;
+    /** Stores a presentation and each credential it embeds, in one D1 batch. */
+    putPresentation(presentation: string | object): Promise<PresentationKeys>;
+    get(key: string): Promise<StoredDocument | null>;
+    remove(key: string): Promise<boolean>;
+    find(filter?: DocumentFilter): Promise<StoredDocument[]>;
+}
+export {};

package/dist/driver.js

@@ -3,7 +3,7 @@
 // The core (WebAssembly) never touches the database. Each operation is a job: the driver
 // feeds it the response of every request it asks for, until it is done. Atomic requests
 // become one `db.batch()` — D1's only transaction.
-import { loadDataToString, outputToResult, toJson, } from "@oxilite/common";
+import { JsonLdError, cypherResult, datalogResult, documentText, filterJson, fromJson, jsonLdError, storedDocument, loadDataToString, outputToResult, toJson, } from "@oxilite/common";
 /** A term hash collision (two different terms with the same 59-bit id). */
 export class OxiliteCollisionError extends Error {
 }
@@ -15,6 +15,9 @@ function mapError(e) {
         return new Error("the graph does not exist");
     if (message.includes("graph_already_exists"))
         return new Error("the graph already exists");
+    if (message.includes("jsonld_graphs.g")) {
+        return new JsonLdError("graph-owned", `a graph of this document is already owned by another document: ${message}`);
+    }
     if (message.includes("computed_value_not_storable")) {
         return new Error("an update template stores a computed non-integer value, which cannot be done on D1");
     }
@@ -66,6 +69,85 @@ export class D1Store {
             job.free?.();
         }
     }
+    /**
+     * JSON-LD documents: each stored verbatim under a key (by default its `@id`), its RDF in a
+     * named graph (by default the key). Every write is one D1 batch. Contexts load offline:
+     * persist the ones your documents use with `putContext`.
+     */
+    jsonld(options = {}) {
+        return new D1JsonLdDocuments(this.jsonldCall(options));
+    }
+    /**
+     * Verifiable Credentials (VCDM 1.1 and 2.0) stored under their `id`, RDF in the graph of the
+     * same IRI; the W3C credential contexts are bundled. Proofs are not verified.
+     */
+    credentials(options = {}) {
+        return new D1Credentials(this.jsonldCall({ ...options, credentials: true }));
+    }
+    jsonldCall(options) {
+        const { migrated, ...opts } = options;
+        const json = JSON.stringify(opts);
+        let ready = migrated ? Promise.resolve() : null;
+        const call = async (op, args) => {
+            try {
+                return await this.run(this.engine.jsonld(op, JSON.stringify(args), json));
+            }
+            catch (e) {
+                throw jsonLdError(e);
+            }
+        };
+        return async (op, args) => {
+            ready ??= call("schema", {});
+            await ready;
+            return call(op, args);
+        };
+    }
+    /**
+     * A Cypher statement over the property-graph view of the dataset. Reads compile to SQL; a
+     * writing statement reads, then applies its changes as one D1 batch.
+     */
+    async cypher(query, params = {}, options = {}) {
+        const out = (await this.run(this.engine.cypher(query, JSON.stringify(params), JSON.stringify(options))));
+        return cypherResult(out);
+    }
+    /**
+     * A Datalog program over the same quads: recursive rules with stratified negation,
+     * constraints and aggregation. A program whose recursion is linear is one SQL statement, so
+     * it costs one round trip here as it does anywhere; a component that has to be iterated
+     * costs one per round, which `rounds` reports.
+     */
+    async datalog(program, options = {}) {
+        const datalog = this.requireDatalog(this.engine.datalog);
+        const out = (await this.run(datalog(program, JSON.stringify(options))));
+        return datalogResult(out);
+    }
+    /**
+     * Stores what a Datalog program derives as inferences, in the table OWL 2 RL
+     * materialization uses, so SPARQL and Cypher see them with `includeInferred`. The writes
+     * are one D1 batch.
+     */
+    async datalogMaterialize(program, options = {}) {
+        const materialize = this.requireDatalog(this.engine.datalog_materialize);
+        return (await this.run(materialize(program, JSON.stringify(options))));
+    }
+    /** How a Datalog program runs: its strata, the strategy per recursive component, the SQL. */
+    explainDatalog(program, options = {}) {
+        return this.requireDatalog(this.engine.explain_datalog)(program, JSON.stringify(options));
+    }
+    /**
+     * The Datalog frontend is an opt-in feature of the WebAssembly core, so say which build is
+     * needed rather than failing with "not a function".
+     */
+    requireDatalog(method) {
+        if (method === undefined) {
+            throw new Error("this build of the oxilite WebAssembly core has no Datalog frontend; rebuild it with the `datalog` feature");
+        }
+        return method.bind(this.engine);
+    }
+    /** How a Cypher statement runs: its SPARQL, the SQL, and what runs in Rust. */
+    explainCypher(query, params = {}, options = {}) {
+        return this.engine.explainCypher(query, JSON.stringify(params), JSON.stringify(options));
+    }
     /** SPARQL query: `Map[]` for SELECT, `boolean` for ASK, `Quad[]` for CONSTRUCT/DESCRIBE, or a string with `results_format`. */
     async query(query, options = {}) {
         const js = {
@@ -159,3 +241,82 @@ export class D1Store {
         return this.engine.schemaSql();
     }
 }
+/** JSON-LD documents of a D1 store (see `D1Store.jsonld`). */
+export class D1JsonLdDocuments {
+    call;
+    constructor(call) {
+        this.call = call;
+    }
+    /** Stores a document (replacing one with the same key) and returns its key. JSON text is stored byte for byte. */
+    async put(document, key) {
+        return (await this.putAll([{ document, key }]))[0];
+    }
+    /** Stores several documents in one D1 batch; returns their keys. */
+    async putAll(documents) {
+        const out = (await this.call("put", {
+            documents: documents.map((d) => ({ json: documentText(d.document), key: d.key })),
+        }));
+        return out.keys;
+    }
+    async get(key) {
+        return storedDocument((await this.call("get", { key })));
+    }
+    /** Removes a document and the graphs it owns; false when it was not stored. */
+    async remove(key) {
+        return (await this.call("remove", { key }));
+    }
+    async list(options = {}) {
+        return (await this.call("list", options)).map((d) => storedDocument(d));
+    }
+    async find(filter = {}) {
+        return (await this.call("find", filterJson(filter))).map((d) => storedDocument(d));
+    }
+    async graphs(key) {
+        return (await this.call("graphs", { key })).map(fromJson);
+    }
+    async documentForGraph(graph) {
+        return storedDocument((await this.call("documentForGraph", { graph: toJson(graph) })));
+    }
+    /** Persists a context in D1, so documents that reference `iri` convert offline. */
+    async putContext(iri, context) {
+        await this.call("putContext", { iri, context });
+    }
+    async removeContext(iri) {
+        await this.call("removeContext", { iri });
+    }
+    async contexts() {
+        return (await this.call("contexts", {}));
+    }
+    async rebuild(key) {
+        return (await this.call("rebuild", { key }));
+    }
+    async check() {
+        return (await this.call("check", {}));
+    }
+}
+/** Verifiable Credentials of a D1 store (see `D1Store.credentials`). */
+export class D1Credentials {
+    call;
+    documents;
+    constructor(call) {
+        this.call = call;
+        this.documents = new D1JsonLdDocuments(call);
+    }
+    /** Checks and stores a credential; returns its key. */
+    async put(credential, key) {
+        return (await this.call("putCredential", { json: documentText(credential), key }));
+    }
+    /** Stores a presentation and each credential it embeds, in one D1 batch. */
+    async putPresentation(presentation) {
+        return (await this.call("putPresentation", { json: documentText(presentation) }));
+    }
+    get(key) {
+        return this.documents.get(key);
+    }
+    remove(key) {
+        return this.documents.remove(key);
+    }
+    async find(filter = {}) {
+        return (await this.call("find", filterJson(filter))).map((d) => storedDocument(d));
+    }
+}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { D1Store as Base, type D1DatabaseLike, type D1StoreOptions } from "./driver.js";
 export * from "@oxilite/common";
-export { OxiliteCollisionError, type D1DatabaseLike, type D1StoreOptions } from "./driver.js";
+export { OxiliteCollisionError, D1Credentials, D1JsonLdDocuments, type D1DatabaseLike, type D1StoreOptions, } from "./driver.js";
 /** Initializes the WebAssembly core (a `WebAssembly.Module`, bytes, or a URL/Response). */
 export declare function initOxilite(wasm?: WebAssembly.Module | BufferSource | Response | URL | string): Promise<void>;
 export declare class D1Store {
@@ -8,9 +8,17 @@ export declare class D1Store {
     static open(db: D1DatabaseLike, options?: D1StoreOptions & {
         wasm?: WebAssembly.Module | BufferSource | Response | URL | string;
     }): Promise<Base>;
-    /** The schema as SQL (for `wrangler d1 migrations`). */
+    /**
+     * The schema as SQL (for `wrangler d1 migrations`); `jsonld` adds the JSON-LD document
+     * tables (`true`, or the metadata indexes to create).
+     */
     static schemaSql(options?: {
         graphIndex?: boolean;
+        jsonld?: boolean | {
+            issuer?: boolean;
+            subject?: boolean;
+            validUntil?: boolean;
+        };
         wasm?: WebAssembly.Module | BufferSource;
     }): Promise<string>;
 }

package/dist/index.js

@@ -6,7 +6,7 @@
 import init, { Engine, initSync } from "../wasm/web/oxilite_wasm.js";
 import { D1Store as Base } from "./driver.js";
 export * from "@oxilite/common";
-export { OxiliteCollisionError } from "./driver.js";
+export { OxiliteCollisionError, D1Credentials, D1JsonLdDocuments, } from "./driver.js";
 let ready = false;
 /** Initializes the WebAssembly core (a `WebAssembly.Module`, bytes, or a URL/Response). */
 export async function initOxilite(wasm) {
@@ -26,10 +26,15 @@ export class D1Store {
         await initOxilite(options.wasm);
         return Base.openWith(Engine, db, options);
     }
-    /** The schema as SQL (for `wrangler d1 migrations`). */
+    /**
+     * The schema as SQL (for `wrangler d1 migrations`); `jsonld` adds the JSON-LD document
+     * tables (`true`, or the metadata indexes to create).
+     */
     static async schemaSql(options = {}) {
         await initOxilite(options.wasm);
         const e = new Engine(null, JSON.stringify({ graphIndex: options.graphIndex ?? true }));
+        if (options.jsonld)
+            return e.jsonldSchemaSql(JSON.stringify(options.jsonld === true ? {} : options.jsonld));
         return e.schemaSql();
     }
 }

package/dist/node.d.ts

@@ -1,9 +1,15 @@
 import { D1Store as Base, type D1DatabaseLike, type D1StoreOptions } from "./driver.js";
 export * from "@oxilite/common";
-export { OxiliteCollisionError, type D1DatabaseLike, type D1StoreOptions } from "./driver.js";
+export { OxiliteCollisionError, D1Credentials, D1JsonLdDocuments, type D1DatabaseLike, type D1StoreOptions, } from "./driver.js";
 export declare class D1Store {
     static open(db: D1DatabaseLike, options?: D1StoreOptions): Promise<Base>;
+    /** The schema as SQL; `jsonld` adds the JSON-LD document tables. */
     static schemaSql(options?: {
         graphIndex?: boolean;
+        jsonld?: boolean | {
+            issuer?: boolean;
+            subject?: boolean;
+            validUntil?: boolean;
+        };
     }): string;
 }

package/dist/node.js

@@ -2,14 +2,18 @@
 import { createRequire } from "node:module";
 import { D1Store as Base } from "./driver.js";
 export * from "@oxilite/common";
-export { OxiliteCollisionError } from "./driver.js";
+export { OxiliteCollisionError, D1Credentials, D1JsonLdDocuments, } from "./driver.js";
 const require = createRequire(import.meta.url);
 const { Engine } = require("../wasm/node/oxilite_wasm.js");
 export class D1Store {
     static async open(db, options = {}) {
         return Base.openWith(Engine, db, options);
     }
+    /** The schema as SQL; `jsonld` adds the JSON-LD document tables. */
     static schemaSql(options = {}) {
-        return new Engine(null, JSON.stringify({ graphIndex: options.graphIndex ?? true })).schemaSql();
+        const e = new Engine(null, JSON.stringify({ graphIndex: options.graphIndex ?? true }));
+        if (options.jsonld)
+            return e.jsonldSchemaSql(JSON.stringify(options.jsonld === true ? {} : options.jsonld));
+        return e.schemaSql();
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oxilite/d1",
-  "version": "0.1.0",
-  "description": "oxilite on Cloudflare D1: an Oxigraph-compatible SPARQL store running on a D1 binding",
+  "version": "0.3.0",
+  "description": "oxilite on Cloudflare D1 and Durable Objects: an Oxigraph-compatible SPARQL 1.1 and openCypher store (WebAssembly core)",
   "license": "MIT OR Apache-2.0",
   "type": "module",
   "main": "dist/index.js",
@@ -32,7 +32,7 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@oxilite/common": "0.1.0"
+    "@oxilite/common": "0.3.0"
   },
   "devDependencies": {
     "miniflare": "^4"
@@ -42,18 +42,23 @@
     "url": "git+https://github.com/Volland/oxilite.git",
     "directory": "packages/d1"
   },
-  "homepage": "https://github.com/Volland/oxilite#readme",
+  "homepage": "https://oxilitedb.com",
   "bugs": "https://github.com/Volland/oxilite/issues",
   "author": "Volodymyr Pavlyshyn",
   "keywords": [
     "rdf",
     "sparql",
+    "cypher",
+    "opencypher",
+    "property-graph",
     "sqlite",
     "oxigraph",
     "rdfjs",
     "cloudflare",
     "d1",
-    "workers"
+    "durable-objects",
+    "workers",
+    "knowledge-graph"
   ],
   "publishConfig": {
     "access": "public"

package/wasm/node/oxilite_wasm.d.ts

@@ -23,6 +23,13 @@ export class Engine {
      * Removes everything.
      */
     clear(): Job;
+    /**
+     * A Cypher statement over the property-graph view (see `oxilite-cypher`). `params` and
+     * `options` are JSON (`oxilite_cypher::json`). The result is `{"kind": "cypher",
+     * "columns", "rows", "stats"}`; a writing statement applies its changes as one atomic
+     * request (one D1 batch).
+     */
+    cypher(query: string, params?: string | null, options?: string | null): Job;
     /**
      * Removes quads (JSON array of RDF/JS quads) atomically.
      */
@@ -31,6 +38,10 @@ export class Engine {
      * Serializes the dataset (or one graph, JSON graph term) in an RDF format.
      */
     dump(format_name: string, graph?: string | null): Job;
+    /**
+     * How a Cypher statement runs: its SPARQL, the SQL it compiles to, and what runs in Rust.
+     */
+    explainCypher(query: string, params?: string | null, options?: string | null): string;
     /**
      * How an update would run (SQL per operation).
      */
@@ -43,6 +54,19 @@ export class Engine {
      * Does the store contain a quad (JSON RDF/JS quad)?
      */
     has(quad: string): Job;
+    /**
+     * The schema with the JSON-LD tables, as a SQL script; `indexes` (JSON) picks the
+     * metadata indexes.
+     */
+    jsonldSchemaSql(indexes?: string | null): string;
+    /**
+     * A JSON-LD document or (with `"credentials": true` in `options`) Verifiable Credentials
+     * operation: `schema`, `put`, `get`, `remove`, `list`, `find`, `graphs`,
+     * `documentForGraph`, `putContext`, `removeContext`, `contexts`, `rebuild`, `check`,
+     * `putCredential`, `putPresentation`. `args` and `options` are JSON
+     * (`oxilite_jsonld::json`); errors read `oxilite-jsonld:{"code", "message"}`.
+     */
+    jsonld(op: string, args: string, options?: string | null): Job;
     /**
      * Loads a document atomically (one batch). `graph` is a JSON graph term.
      */

package/wasm/node/oxilite_wasm.js

@@ -67,6 +67,29 @@ class Engine {
         const ret = wasm.engine_clear(this.__wbg_ptr);
         return Job.__wrap(ret);
     }
+    /**
+     * A Cypher statement over the property-graph view (see `oxilite-cypher`). `params` and
+     * `options` are JSON (`oxilite_cypher::json`). The result is `{"kind": "cypher",
+     * "columns", "rows", "stats"}`; a writing statement applies its changes as one atomic
+     * request (one D1 batch).
+     * @param {string} query
+     * @param {string | null} [params]
+     * @param {string | null} [options]
+     * @returns {Job}
+     */
+    cypher(query, params, options) {
+        const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(params) ? 0 : passStringToWasm0(params, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(options) ? 0 : passStringToWasm0(options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_cypher(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Job.__wrap(ret[0]);
+    }
     /**
      * Removes quads (JSON array of RDF/JS quads) atomically.
      * @param {string} quads
@@ -98,6 +121,37 @@ class Engine {
         }
         return Job.__wrap(ret[0]);
     }
+    /**
+     * How a Cypher statement runs: its SPARQL, the SQL it compiles to, and what runs in Rust.
+     * @param {string} query
+     * @param {string | null} [params]
+     * @param {string | null} [options]
+     * @returns {string}
+     */
+    explainCypher(query, params, options) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(params) ? 0 : passStringToWasm0(params, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            var ptr2 = isLikeNone(options) ? 0 : passStringToWasm0(options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len2 = WASM_VECTOR_LEN;
+            const ret = wasm.engine_explainCypher(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
     /**
      * How an update would run (SQL per operation).
      * @param {string} sparql
@@ -162,6 +216,56 @@ class Engine {
         }
         return Job.__wrap(ret[0]);
     }
+    /**
+     * The schema with the JSON-LD tables, as a SQL script; `indexes` (JSON) picks the
+     * metadata indexes.
+     * @param {string | null} [indexes]
+     * @returns {string}
+     */
+    jsonldSchemaSql(indexes) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            var ptr0 = isLikeNone(indexes) ? 0 : passStringToWasm0(indexes, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len0 = WASM_VECTOR_LEN;
+            const ret = wasm.engine_jsonldSchemaSql(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * A JSON-LD document or (with `"credentials": true` in `options`) Verifiable Credentials
+     * operation: `schema`, `put`, `get`, `remove`, `list`, `find`, `graphs`,
+     * `documentForGraph`, `putContext`, `removeContext`, `contexts`, `rebuild`, `check`,
+     * `putCredential`, `putPresentation`. `args` and `options` are JSON
+     * (`oxilite_jsonld::json`); errors read `oxilite-jsonld:{"code", "message"}`.
+     * @param {string} op
+     * @param {string} args
+     * @param {string | null} [options]
+     * @returns {Job}
+     */
+    jsonld(op, args, options) {
+        const ptr0 = passStringToWasm0(op, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(args, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(options) ? 0 : passStringToWasm0(options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_jsonld(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Job.__wrap(ret[0]);
+    }
     /**
      * Loads a document atomically (one batch). `graph` is a JSON graph term.
      * @param {string} data

package/wasm/node/oxilite_wasm_bg.wasm.d.ts

@@ -7,11 +7,15 @@ export const engine_add: (a: number, b: number, c: number) => [number, number, n
 export const engine_bulkLoad: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
 export const engine_clear: (a: number) => number;
 export const engine_clearInferences: (a: number) => number;
+export const engine_cypher: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
 export const engine_delete: (a: number, b: number, c: number) => [number, number, number];
 export const engine_dump: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
 export const engine_explain: (a: number, b: number, c: number) => [number, number, number, number];
+export const engine_explainCypher: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
 export const engine_explainUpdate: (a: number, b: number, c: number) => [number, number, number, number];
 export const engine_has: (a: number, b: number, c: number) => [number, number, number];
+export const engine_jsonld: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
+export const engine_jsonldSchemaSql: (a: number, b: number, c: number) => [number, number, number, number];
 export const engine_load: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
 export const engine_match: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
 export const engine_materialize: (a: number) => number;

package/wasm/web/oxilite_wasm.d.ts

@@ -23,6 +23,13 @@ export class Engine {
      * Removes everything.
      */
     clear(): Job;
+    /**
+     * A Cypher statement over the property-graph view (see `oxilite-cypher`). `params` and
+     * `options` are JSON (`oxilite_cypher::json`). The result is `{"kind": "cypher",
+     * "columns", "rows", "stats"}`; a writing statement applies its changes as one atomic
+     * request (one D1 batch).
+     */
+    cypher(query: string, params?: string | null, options?: string | null): Job;
     /**
      * Removes quads (JSON array of RDF/JS quads) atomically.
      */
@@ -31,6 +38,10 @@ export class Engine {
      * Serializes the dataset (or one graph, JSON graph term) in an RDF format.
      */
     dump(format_name: string, graph?: string | null): Job;
+    /**
+     * How a Cypher statement runs: its SPARQL, the SQL it compiles to, and what runs in Rust.
+     */
+    explainCypher(query: string, params?: string | null, options?: string | null): string;
     /**
      * How an update would run (SQL per operation).
      */
@@ -43,6 +54,19 @@ export class Engine {
      * Does the store contain a quad (JSON RDF/JS quad)?
      */
     has(quad: string): Job;
+    /**
+     * The schema with the JSON-LD tables, as a SQL script; `indexes` (JSON) picks the
+     * metadata indexes.
+     */
+    jsonldSchemaSql(indexes?: string | null): string;
+    /**
+     * A JSON-LD document or (with `"credentials": true` in `options`) Verifiable Credentials
+     * operation: `schema`, `put`, `get`, `remove`, `list`, `find`, `graphs`,
+     * `documentForGraph`, `putContext`, `removeContext`, `contexts`, `rebuild`, `check`,
+     * `putCredential`, `putPresentation`. `args` and `options` are JSON
+     * (`oxilite_jsonld::json`); errors read `oxilite-jsonld:{"code", "message"}`.
+     */
+    jsonld(op: string, args: string, options?: string | null): Job;
     /**
      * Loads a document atomically (one batch). `graph` is a JSON graph term.
      */
@@ -122,11 +146,15 @@ export interface InitOutput {
     readonly engine_bulkLoad: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
     readonly engine_clear: (a: number) => number;
     readonly engine_clearInferences: (a: number) => number;
+    readonly engine_cypher: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
     readonly engine_delete: (a: number, b: number, c: number) => [number, number, number];
     readonly engine_dump: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
     readonly engine_explain: (a: number, b: number, c: number) => [number, number, number, number];
+    readonly engine_explainCypher: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
     readonly engine_explainUpdate: (a: number, b: number, c: number) => [number, number, number, number];
     readonly engine_has: (a: number, b: number, c: number) => [number, number, number];
+    readonly engine_jsonld: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
+    readonly engine_jsonldSchemaSql: (a: number, b: number, c: number) => [number, number, number, number];
     readonly engine_load: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
     readonly engine_match: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
     readonly engine_materialize: (a: number) => number;

package/wasm/web/oxilite_wasm.js

@@ -67,6 +67,29 @@ export class Engine {
         const ret = wasm.engine_clear(this.__wbg_ptr);
         return Job.__wrap(ret);
     }
+    /**
+     * A Cypher statement over the property-graph view (see `oxilite-cypher`). `params` and
+     * `options` are JSON (`oxilite_cypher::json`). The result is `{"kind": "cypher",
+     * "columns", "rows", "stats"}`; a writing statement applies its changes as one atomic
+     * request (one D1 batch).
+     * @param {string} query
+     * @param {string | null} [params]
+     * @param {string | null} [options]
+     * @returns {Job}
+     */
+    cypher(query, params, options) {
+        const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(params) ? 0 : passStringToWasm0(params, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(options) ? 0 : passStringToWasm0(options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_cypher(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Job.__wrap(ret[0]);
+    }
     /**
      * Removes quads (JSON array of RDF/JS quads) atomically.
      * @param {string} quads
@@ -98,6 +121,37 @@ export class Engine {
         }
         return Job.__wrap(ret[0]);
     }
+    /**
+     * How a Cypher statement runs: its SPARQL, the SQL it compiles to, and what runs in Rust.
+     * @param {string} query
+     * @param {string | null} [params]
+     * @param {string | null} [options]
+     * @returns {string}
+     */
+    explainCypher(query, params, options) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(params) ? 0 : passStringToWasm0(params, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            var ptr2 = isLikeNone(options) ? 0 : passStringToWasm0(options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len2 = WASM_VECTOR_LEN;
+            const ret = wasm.engine_explainCypher(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
     /**
      * How an update would run (SQL per operation).
      * @param {string} sparql
@@ -162,6 +216,56 @@ export class Engine {
         }
         return Job.__wrap(ret[0]);
     }
+    /**
+     * The schema with the JSON-LD tables, as a SQL script; `indexes` (JSON) picks the
+     * metadata indexes.
+     * @param {string | null} [indexes]
+     * @returns {string}
+     */
+    jsonldSchemaSql(indexes) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            var ptr0 = isLikeNone(indexes) ? 0 : passStringToWasm0(indexes, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len0 = WASM_VECTOR_LEN;
+            const ret = wasm.engine_jsonldSchemaSql(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * A JSON-LD document or (with `"credentials": true` in `options`) Verifiable Credentials
+     * operation: `schema`, `put`, `get`, `remove`, `list`, `find`, `graphs`,
+     * `documentForGraph`, `putContext`, `removeContext`, `contexts`, `rebuild`, `check`,
+     * `putCredential`, `putPresentation`. `args` and `options` are JSON
+     * (`oxilite_jsonld::json`); errors read `oxilite-jsonld:{"code", "message"}`.
+     * @param {string} op
+     * @param {string} args
+     * @param {string | null} [options]
+     * @returns {Job}
+     */
+    jsonld(op, args, options) {
+        const ptr0 = passStringToWasm0(op, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(args, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(options) ? 0 : passStringToWasm0(options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_jsonld(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Job.__wrap(ret[0]);
+    }
     /**
      * Loads a document atomically (one batch). `graph` is a JSON graph term.
      * @param {string} data

package/wasm/web/oxilite_wasm_bg.wasm.d.ts

@@ -7,11 +7,15 @@ export const engine_add: (a: number, b: number, c: number) => [number, number, n
 export const engine_bulkLoad: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
 export const engine_clear: (a: number) => number;
 export const engine_clearInferences: (a: number) => number;
+export const engine_cypher: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
 export const engine_delete: (a: number, b: number, c: number) => [number, number, number];
 export const engine_dump: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
 export const engine_explain: (a: number, b: number, c: number) => [number, number, number, number];
+export const engine_explainCypher: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
 export const engine_explainUpdate: (a: number, b: number, c: number) => [number, number, number, number];
 export const engine_has: (a: number, b: number, c: number) => [number, number, number];
+export const engine_jsonld: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
+export const engine_jsonldSchemaSql: (a: number, b: number, c: number) => [number, number, number, number];
 export const engine_load: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
 export const engine_match: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
 export const engine_materialize: (a: number) => number;