@oxilite/d1 0.2.2 → 0.3.0

package/README.md

@@ -23,6 +23,20 @@ npx oxilite-d1 schema > migrations/0001_oxilite.sql          # --no-graph-index
 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

package/dist/driver.d.ts

@@ -1,4 +1,4 @@
-import { type CypherOptions, 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";
+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[][]>;
@@ -26,6 +26,9 @@ export interface WasmEngine {
     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;
@@ -85,6 +88,26 @@ export declare class D1Store {
      * 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`. */

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 { JsonLdError, cypherResult, documentText, filterJson, fromJson, jsonLdError, storedDocument, 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 {
 }
@@ -110,6 +110,40 @@ export class D1Store {
         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));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxilite/d1",
-  "version": "0.2.2",
+  "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",
@@ -32,7 +32,7 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@oxilite/common": "0.2.2"
+    "@oxilite/common": "0.3.0"
   },
   "devDependencies": {
     "miniflare": "^4"