process-graph 1.0.5 → 1.1.0

package/dist/status-Bm1CGu9C.js

@@ -0,0 +1,11 @@
+//#region ../../core/graph/domain/dist/status.js
+/** The derived states of an element, in the order the derivation considers them. */
+const statuses = [
+	"done",
+	"unknown",
+	"skipped",
+	"ready",
+	"blocked"
+];
+//#endregion
+export { statuses as t };

package/dist/store/node.d.ts

@@ -0,0 +1,24 @@
+import { b as GraphStore } from "../index-DhbvDgK4.js";
+import { DatabaseSyncOptions } from "node:sqlite";
+import { NodeSQLiteDatabase } from "drizzle-orm/node-sqlite";
+//#region ../../adapters/graph/sqlite-node/dist/open.d.ts
+/** An open store and the handles behind it. */
+interface NodeGraphStore {
+  /** The store, to serve with `createGraphStoreRouter`. */
+  readonly store: GraphStore;
+  /** The Drizzle database the store runs on, for tools that read the tables directly. */
+  readonly db: NodeSQLiteDatabase;
+  /** Closes the database. The store must not be used afterwards. */
+  readonly close: () => void;
+}
+/**
+ * Opens a graph store on a SQLite database file, creating the file when it does not exist. The schema is migrated on the store's first operation.
+ *
+ * A file database is switched to write-ahead logging, so readers in other processes (a command line beside a server) are not blocked by a writer. Each process's change feed sees only its own writes.
+ * @param path - The database file, or `":memory:"` for a private database that lives as long as the store.
+ * @param options - `node:sqlite` options passed through unchanged, such as `timeout` for how long a write waits for another process's lock.
+ * @returns The store, its database and a way to close it.
+ */
+export declare const openNodeGraphStore: (path: string, options?: DatabaseSyncOptions) => NodeGraphStore;
+//#endregion
+export type { NodeGraphStore };

package/dist/store/node.js

@@ -0,0 +1,2 @@
+import { t as openNodeGraphStore } from "../open-CyRXJ4bt.js";
+export { openNodeGraphStore };

package/dist/store/wasm/worker.d.ts

@@ -0,0 +1,16 @@
+//#region ../../adapters/graph/sqlite-wasm/dist/worker.d.ts
+/** Which database a worker serves. */
+export interface GraphStoreWorkerOptions {
+  /**
+   * The database's name. It names the OPFS `opfs-sahpool` pool (and so its directory), the Web Lock that serialises tabs, and the channel changes are shared on, so every worker in the origin given the same name serves the same database.
+   */
+  readonly name: string;
+}
+/**
+ * Serves the graph store from inside a dedicated worker, to the page that started it, over oRPC's message-port transport. Call it once at the top level of the worker module; connect from the page with `connectGraphStore`.
+ *
+ * The SQLite module starts initialising at once and the first store operation waits for it. The database is opened only inside each store operation, under a Web Lock shared by every tab, so tabs take turns rather than failing; see `openWorkerDatabase`. Changes committed in any tab reach every tab's `changes` subscribers through a `BroadcastChannel`.
+ * @param options - Which database to serve.
+ */
+export declare const serveGraphStoreInWorker: (options: GraphStoreWorkerOptions) => void;
+//#endregion

package/dist/store/wasm/worker.js

@@ -0,0 +1,98 @@
+import { O as storeChangeSchema, h as ChangeFeed, t as createSqliteGraphStore } from "../../store-BcR70CaO.js";
+import { t as createGraphStoreRouter } from "../../router-D4gtTlXm.js";
+import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
+import { RPCHandler } from "@orpc/server/message-port";
+import { drizzle } from "drizzle-orm/sqlite-proxy";
+//#region ../../adapters/graph/sqlite-wasm/dist/database.js
+/**
+* Opens a database on the `opfs-sahpool` VFS so that any number of tabs, each with its own worker, can use it with no cross-origin isolation headers.
+*
+* A pool holds its OPFS sync access handles exclusively, so only one worker in the origin can have it open at a time. Each store operation therefore takes an exclusive Web Lock named after the pool, unpauses the pool (reacquiring its handles), opens the file, runs, then closes the file and pauses the pool (releasing them) before the lock is released. A Drizzle transaction is several statements, so the lock covers the whole store operation rather than each statement. The choice and the evidence for it are recorded in https://github.com/ExaDev/process-graph/issues/22.
+* @param sqlite3 - The SQLite module, initialising; the first operation waits for it.
+* @param location - The pool and file.
+* @returns The database and its exclusivity.
+*/
+const openWorkerDatabase = (sqlite3, location) => {
+	let pool;
+	let open;
+	const db = drizzle(async (statement, params, method) => {
+		if (method === "get") throw new Error("The graph store's worker database does not serve get");
+		if (open === void 0) throw new Error("The database was used outside a store operation; only the store's exclusive section may run statements");
+		const rows = open.exec(statement, {
+			bind: params,
+			rowMode: "array",
+			returnValue: "resultRows"
+		});
+		return Promise.resolve({ rows });
+	});
+	const exclusive = async (operation) => navigator.locks.request(location.pool, { mode: "exclusive" }, async () => {
+		const installing = pool === void 0;
+		pool ??= sqlite3.then(async (module) => module.installOpfsSAHPoolVfs({ name: location.pool }));
+		const held = await pool;
+		if (!installing) await held.unpauseVfs();
+		open = new held.OpfsSAHPoolDb(location.file);
+		try {
+			return await operation();
+		} finally {
+			open.close();
+			open = void 0;
+			held.pauseVfs();
+		}
+	});
+	return {
+		db,
+		exclusive
+	};
+};
+//#endregion
+//#region ../../adapters/graph/sqlite-wasm/dist/feed.js
+/**
+* A change feed shared by every worker serving the same database in this origin: each change committed here is published locally and posted on a `BroadcastChannel`, and each change another worker posts there is published locally. Every tab's subscribers therefore hear every tab's writes.
+*/
+var BroadcastChangeFeed = class extends ChangeFeed {
+	#channel;
+	/**
+	* @param name - The channel name, one per database, so two databases in one origin do not hear each other.
+	*/
+	constructor(name) {
+		super();
+		this.#channel = new BroadcastChannel(name);
+		this.#channel.addEventListener("message", (event) => {
+			const parsed = storeChangeSchema.safeParse(event.data);
+			if (parsed.success) super.publish(parsed.data);
+		});
+	}
+	/**
+	* Publishes a change committed in this worker, here and to every other worker on the channel.
+	* @param change - The committed change.
+	*/
+	publish(change) {
+		super.publish(change);
+		this.#channel.postMessage(change);
+	}
+	/** Stops hearing and posting changes. */
+	close() {
+		this.#channel.close();
+	}
+};
+//#endregion
+//#region ../../adapters/graph/sqlite-wasm/dist/worker.js
+/**
+* Serves the graph store from inside a dedicated worker, to the page that started it, over oRPC's message-port transport. Call it once at the top level of the worker module; connect from the page with `connectGraphStore`.
+*
+* The SQLite module starts initialising at once and the first store operation waits for it. The database is opened only inside each store operation, under a Web Lock shared by every tab, so tabs take turns rather than failing; see `openWorkerDatabase`. Changes committed in any tab reach every tab's `changes` subscribers through a `BroadcastChannel`.
+* @param options - Which database to serve.
+*/
+const serveGraphStoreInWorker = (options) => {
+	const { db, exclusive } = openWorkerDatabase(sqlite3InitModule(), {
+		pool: options.name,
+		file: "/graph.sqlite3"
+	});
+	new RPCHandler(createGraphStoreRouter(createSqliteGraphStore({
+		db,
+		exclusive,
+		feed: new BroadcastChangeFeed(options.name)
+	}))).upgrade(self);
+};
+//#endregion
+export { serveGraphStoreInWorker };

package/dist/store/wasm.d.ts

@@ -0,0 +1,9 @@
+import { Q as GraphStoreClient } from "../index-DhbvDgK4.js";
+//#region ../../adapters/graph/sqlite-wasm/dist/client.d.ts
+/**
+ * A client for the graph store a worker serves with `serveGraphStoreInWorker`. Every procedure of the contract is available, with its abort signal and typed errors, as if the store were in the page.
+ * @param worker - The dedicated worker running the store.
+ * @returns The store's oRPC client.
+ */
+export declare const connectGraphStore: (worker: Readonly<Worker>) => GraphStoreClient;
+//#endregion

package/dist/store/wasm.js

@@ -0,0 +1,11 @@
+import { createORPCClient } from "@orpc/client";
+import { RPCLink } from "@orpc/client/message-port";
+//#region ../../adapters/graph/sqlite-wasm/dist/client.js
+/**
+* A client for the graph store a worker serves with `serveGraphStoreInWorker`. Every procedure of the contract is available, with its abort signal and typed errors, as if the store were in the page.
+* @param worker - The dedicated worker running the store.
+* @returns The store's oRPC client.
+*/
+const connectGraphStore = (worker) => createORPCClient(new RPCLink({ port: worker }));
+//#endregion
+export { connectGraphStore };