@evolu/nodejs 3.0.0-next.2 → 3.0.0

package/dist/src/Worker.d.ts

@@ -1,2 +1,4 @@
-export {};
+import type { CreateBroadcastChannel } from "@evolu/common";
+/** Creates a {@link BroadcastChannel} from a Node.js BroadcastChannel. */
+export declare const createBroadcastChannel: CreateBroadcastChannel;
 //# sourceMappingURL=Worker.d.ts.map

package/dist/src/Worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Worker.d.ts","sourceRoot":"","sources":["../../src/Worker.ts"],"names":[],"mappings":""}
+{"version":3,"file":"Worker.d.ts","sourceRoot":"","sources":["../../src/Worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAG9E,0EAA0E;AAC1E,eAAO,MAAM,sBAAsB,EAAE,sBAsCpC,CAAC"}

package/dist/src/Worker.js

@@ -1,4 +1,96 @@
-export {};
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { disposable } from "@evolu/common";
+/** Creates a {@link BroadcastChannel} from a Node.js BroadcastChannel. */
+export const createBroadcastChannel = (name) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const nativeBroadcastChannel = new globalThis.BroadcastChannel(name);
+        const disposer = __addDisposableResource(env_1, new DisposableStack(), false);
+        let disposed = false;
+        disposer.defer(() => {
+            disposed = true;
+            nativeBroadcastChannel.onmessage = null;
+            nativeBroadcastChannel.close();
+        });
+        let onMessageHandler = null;
+        return disposable({
+            postMessage: (message) => {
+                nativeBroadcastChannel.postMessage(message);
+            },
+            get onMessage() {
+                return disposed ? null : onMessageHandler;
+            },
+            set onMessage(fn) {
+                if (disposed)
+                    return;
+                onMessageHandler = fn;
+                nativeBroadcastChannel.onmessage = fn
+                    ? (event) => {
+                        fn(event.data);
+                    }
+                    : null;
+            },
+        }, disposer);
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+};
 // TODO: Implement Node.js Worker API
 //
 // This module should provide Node.js implementations of the common Worker API:

package/dist/src/index.d.ts

@@ -1,6 +1,14 @@
-export * from "./Sqlite.js";
-export * from "./Crypto.js";
-export * from "./local-first/Relay.js";
-export * from "./Task.js";
-export * from "./WebSocket.js";
+/**
+ * @module
+ * @mergeModuleWith <project>
+ */
+export * from "./Cli.ts";
+export * from "./Crypto.ts";
+export * from "./local-first/Relay.ts";
+export * from "./Platform.ts";
+export * from "./Sqlite.ts";
+export * from "./Task.ts";
+export * from "./Time.ts";
+export * from "./WebSocket.ts";
+export * from "./Worker.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC"}

package/dist/src/index.js

@@ -1,5 +1,13 @@
-export * from "./Sqlite.js";
+/**
+ * @module
+ * @mergeModuleWith <project>
+ */
+export * from "./Cli.js";
 export * from "./Crypto.js";
 export * from "./local-first/Relay.js";
+export * from "./Platform.js";
+export * from "./Sqlite.js";
 export * from "./Task.js";
+export * from "./Time.js";
 export * from "./WebSocket.js";
+export * from "./Worker.js";

package/dist/src/local-first/Relay.d.ts

@@ -5,10 +5,10 @@ export interface NodeJsRelayConfig extends RelayConfig {
     readonly port?: number;
 }
 export type RelayDeps = CreateSqliteDriverDep & RandomDep & TimingSafeEqualDep;
-/** Dependencies for {@link startRelay} using better-sqlite3. */
+/** Dependencies for {@link createRelay} using better-sqlite3. */
 export declare const createRelayDeps: () => RelayDeps;
 /**
- * Starts an Evolu relay server using Node.js.
+ * Creates an Evolu Relay server resource using Node.js.
  *
  * Use {@link createRelayDeps} to create dependencies for better-sqlite3, or
  * provide a custom SQLite driver implementation.
@@ -29,27 +29,20 @@ export declare const createRelayDeps: () => RelayDeps;
  *
  * const deps = { ...createRelayDeps(), console };
  *
- * await using run = createRun(deps);
- * await using stack = new AsyncDisposableStack();
+ * await runMain(deps)(
+ *   createRelay({
+ *     port: 4000,
  *
- * stack.use(
- *   await run.orThrow(
- *     startRelay({
- *       port: 4000,
+ *     // Note: Relay requires URL in format ws://host:port?ownerId=<ownerId>
+ *     // isOwnerAllowed: (_ownerId, { signal: _signal }) => true,
  *
- *       // Note: Relay requires URL in format ws://host:port?ownerId=<ownerId>
- *       // isOwnerAllowed: (_ownerId, { signal: _signal }) => true,
- *
- *       isOwnerWithinQuota: (_ownerId, requiredBytes) => {
- *         const maxBytes = 1024 * 1024; // 1MB
- *         return requiredBytes <= maxBytes;
- *       },
- *     }),
- *   ),
+ *     isOwnerWithinQuota: (_ownerId, requiredBytes) => {
+ *       const maxBytes = 1024 * 1024; // 1MB
+ *       return requiredBytes <= maxBytes;
+ *     },
+ *   }),
  * );
- *
- * await run.deps.shutdown;
  * ```
  */
-export declare const startRelay: ({ port, name, isOwnerAllowed, isOwnerWithinQuota, }: NodeJsRelayConfig) => Task<Relay, never, RelayDeps>;
+export declare const createRelay: ({ port, name, isOwnerAllowed, isOwnerWithinQuota, }: NodeJsRelayConfig) => Task<Relay, never, RelayDeps>;
 //# sourceMappingURL=Relay.d.ts.map

package/dist/src/local-first/Relay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Relay.d.ts","sourceRoot":"","sources":["../../../src/local-first/Relay.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,qBAAqB,EAI1B,KAAK,SAAS,EACd,KAAK,IAAI,EACT,KAAK,kBAAkB,EAExB,MAAM,eAAe,CAAC;AACvB,OAAO,EAQL,KAAK,KAAK,EACV,KAAK,WAAW,EACjB,MAAM,2BAA2B,CAAC;AAQnC,MAAM,WAAW,iBAAkB,SAAQ,WAAW;IACpD,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,SAAS,GAAG,qBAAqB,GAAG,SAAS,GAAG,kBAAkB,CAAC;AAE/E,gEAAgE;AAChE,eAAO,MAAM,eAAe,QAAO,SAIjC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,UAAU,GACpB,qDAKE,iBAAiB,KAAG,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,CA6MlD,CAAC"}
+{"version":3,"file":"Relay.d.ts","sourceRoot":"","sources":["../../../src/local-first/Relay.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,qBAAqB,EAK1B,KAAK,SAAS,EACd,KAAK,IAAI,EACT,KAAK,kBAAkB,EAGxB,MAAM,eAAe,CAAC;AACvB,OAAO,EAQL,KAAK,KAAK,EACV,KAAK,WAAW,EACjB,MAAM,2BAA2B,CAAC;AAQnC,MAAM,WAAW,iBAAkB,SAAQ,WAAW;IACpD,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,SAAS,GAAG,qBAAqB,GAAG,SAAS,GAAG,kBAAkB,CAAC;AAE/E,iEAAiE;AACjE,eAAO,MAAM,eAAe,QAAO,SAIjC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,WAAW,wDAMnB,iBAAiB,KAAG,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,CAgNlD,CAAC"}

package/dist/src/local-first/Relay.js

@@ -50,7 +50,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { AbortError, assert, callback, createRandom, createRelation, createSqlite, Name, ok, OwnerId, Uint8Array, } from "@evolu/common";
+import { assert, createRandom, createRelation, createSqlite, daemon, Name, ok, OwnerId, tryAsync, Uint8Array, } from "@evolu/common";
 import { applyProtocolMessageAsRelay, createBaseSqliteStorageTables, createRelaySqliteStorage, createRelayStorageTables, defaultProtocolMessageMaxSize, parseOwnerIdFromOwnerWebSocketTransportUrl, } from "@evolu/common/local-first";
 import { once } from "events";
 import { existsSync } from "fs";
@@ -58,14 +58,14 @@ import { createServer } from "http";
 import { WebSocket, WebSocketServer } from "ws";
 import { createTimingSafeEqual } from "../Crypto.js";
 import { createBetterSqliteDriver } from "../Sqlite.js";
-/** Dependencies for {@link startRelay} using better-sqlite3. */
+/** Dependencies for {@link createRelay} using better-sqlite3. */
 export const createRelayDeps = () => ({
     createSqliteDriver: createBetterSqliteDriver,
     random: createRandom(),
     timingSafeEqual: createTimingSafeEqual(),
 });
 /**
- * Starts an Evolu relay server using Node.js.
+ * Creates an Evolu Relay server resource using Node.js.
  *
  * Use {@link createRelayDeps} to create dependencies for better-sqlite3, or
  * provide a custom SQLite driver implementation.
@@ -86,48 +86,38 @@ export const createRelayDeps = () => ({
  *
  * const deps = { ...createRelayDeps(), console };
  *
- * await using run = createRun(deps);
- * await using stack = new AsyncDisposableStack();
+ * await runMain(deps)(
+ *   createRelay({
+ *     port: 4000,
  *
- * stack.use(
- *   await run.orThrow(
- *     startRelay({
- *       port: 4000,
+ *     // Note: Relay requires URL in format ws://host:port?ownerId=<ownerId>
+ *     // isOwnerAllowed: (_ownerId, { signal: _signal }) => true,
  *
- *       // Note: Relay requires URL in format ws://host:port?ownerId=<ownerId>
- *       // isOwnerAllowed: (_ownerId, { signal: _signal }) => true,
- *
- *       isOwnerWithinQuota: (_ownerId, requiredBytes) => {
- *         const maxBytes = 1024 * 1024; // 1MB
- *         return requiredBytes <= maxBytes;
- *       },
- *     }),
- *   ),
+ *     isOwnerWithinQuota: (_ownerId, requiredBytes) => {
+ *       const maxBytes = 1024 * 1024; // 1MB
+ *       return requiredBytes <= maxBytes;
+ *     },
+ *   }),
  * );
- *
- * await run.deps.shutdown;
  * ```
  */
-export const startRelay = ({ port = 443, name = Name.orThrow("evolu-relay"), isOwnerAllowed, isOwnerWithinQuota, }) => async (run) => {
+export const createRelay = ({ port = 443, name = Name.orThrow("evolu-relay"), isOwnerAllowed, isOwnerWithinQuota, }) => async (run) => {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        const stack = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+        const disposer = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
         const console = run.deps.console.child("relay");
-        stack.defer(() => {
-            console.info("Shutdown complete");
-        });
         const dbFileExists = existsSync(`${name}.db`);
-        const sqlite = stack.use(await run.orThrow(createSqlite(name)));
+        const sqlite = disposer.use(await run.ok(createSqlite(name)));
         const deps = { ...run.deps, sqlite };
         if (!dbFileExists) {
             createBaseSqliteStorageTables(deps);
             createRelayStorageTables(deps);
         }
-        const server = stack.use(createServer());
+        const server = disposer.use(createServer());
         server.once("close", () => {
             console.info("HTTP server closed");
         });
-        const wss = stack.adopt(new WebSocketServer({
+        const wss = disposer.adopt(new WebSocketServer({
             maxPayload: defaultProtocolMessageMaxSize,
             noServer: true,
         }), (wss) => new Promise((resolve) => {
@@ -137,11 +127,8 @@ export const startRelay = ({ port = 443, name = Name.orThrow("evolu-relay"), isO
             });
         }));
         const ownerSocketRelation = createRelation();
-        const relayRun = stack.use(run.create().addDeps({
-            storage: createRelaySqliteStorage(deps)({
-                isOwnerWithinQuota,
-            }),
-        }));
+        const storage = createRelaySqliteStorage(deps)({ isOwnerWithinQuota });
+        const relayRun = disposer.use(run.create({ storage }));
         server.on("upgrade", (request, socket, head) => {
             socket.on("error", console.debug);
             const completeUpgrade = () => {
@@ -169,24 +156,30 @@ export const startRelay = ({ port = 443, name = Name.orThrow("evolu-relay"), isO
                 respondAndDestroy(400);
                 return;
             }
-            const authorizationFiber = relayRun(callback(({ ok, err, signal }) => {
-                void Promise.try(() => isOwnerAllowed(ownerId, { signal })).then(ok, err);
-            }));
+            const authorizationFiber = relayRun.abortable(
+            // Use daemon because authorization can call an external service that
+            // ignores abort. The daemon runs in the root Run, so aborting the
+            // current Run does not make its Fiber wait for the service Promise to
+            // settle.
+            daemon(async (run) => await tryAsync(() => isOwnerAllowed(ownerId, { signal: run.signal }), (error) => ({ type: "OwnerAuthorizationError", error }))));
             const abortAuthorization = () => {
-                authorizationFiber.abort("WebSocket upgrade request socket closed");
+                authorizationFiber.abort({
+                    type: "WebSocketUpgradeSocketClosed",
+                });
             };
             socket.once("close", abortAuthorization);
             socket.once("error", abortAuthorization);
-            void authorizationFiber.then((result) => {
+            void (async () => {
+                const result = await authorizationFiber;
                 socket.removeListener("close", abortAuthorization);
                 socket.removeListener("error", abortAuthorization);
                 if (!result.ok) {
-                    if (!AbortError.is(result.error)) {
-                        console.error("isOwnerAllowed failed", ownerId, result.error);
-                        respondAndDestroy(503);
+                    if (result.error.type === "AbortError") {
+                        socket.destroy();
                         return;
                     }
-                    socket.destroy();
+                    console.error(result.error.error);
+                    respondAndDestroy(503);
                     return;
                 }
                 if (!result.value) {
@@ -195,7 +188,7 @@ export const startRelay = ({ port = 443, name = Name.orThrow("evolu-relay"), isO
                     return;
                 }
                 completeUpgrade();
-            });
+            })();
         });
         wss.on("connection", (ws) => {
             console.debug("on connection", wss.clients.size);
@@ -221,8 +214,10 @@ export const startRelay = ({ port = 443, name = Name.orThrow("evolu-relay"), isO
                 if (!Uint8Array.is(message))
                     return;
                 void (async () => {
-                    const response = await relayRun(applyProtocolMessageAsRelay(message, options));
+                    const response = await relayRun.abortable(applyProtocolMessageAsRelay(message, options));
                     if (!response.ok) {
+                        if (response.error.type === "AbortError")
+                            return;
                         console.error(response);
                         return;
                     }
@@ -234,8 +229,7 @@ export const startRelay = ({ port = 443, name = Name.orThrow("evolu-relay"), isO
                 console.debug("ws close", wss.clients.size);
             });
         });
-        stack.defer(() => {
-            console.info("Shutting down...");
+        disposer.defer(() => {
             for (const client of wss.clients) {
                 if (client.readyState === WebSocket.OPEN) {
                     client.close(1000, "Evolu Relay shutting down");
@@ -246,11 +240,11 @@ export const startRelay = ({ port = 443, name = Name.orThrow("evolu-relay"), isO
         await once(server, "listening");
         const address = server.address();
         assert(address && typeof address !== "string", "Expected TCP address");
-        const moved = stack.move();
+        const disposables = disposer.move();
         console.info(`Started on port ${address.port}`);
         return ok({
             port: address.port,
-            [Symbol.asyncDispose]: () => moved.disposeAsync(),
+            [Symbol.asyncDispose]: () => disposables.disposeAsync(),
         });
     }
     catch (e_1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/nodejs",
-  "version": "3.0.0-next.2",
+  "version": "3.0.0",
   "description": "Evolu for Node.js",
   "author": "Daniel Steigerwald <daniel@steigerwald.cz>",
   "license": "MIT",
@@ -19,6 +19,18 @@
       "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js",
       "default": "./dist/src/index.js"
+    },
+    "./TestBundle": {
+      "types": "./dist/src/TestBundle.d.ts",
+      "import": "./dist/src/TestBundle.js",
+      "default": "./dist/src/TestBundle.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "TestBundle": [
+        "./dist/src/TestBundle.d.ts"
+      ]
     }
   },
   "files": [
@@ -27,19 +39,31 @@
     "README.md"
   ],
   "dependencies": {
-    "better-sqlite3": "^12.6.2",
+    "better-sqlite3": "^12.11.1",
     "ws": "^8.19.0"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.13",
+    "@types/better-sqlite3": "^9.6.0",
     "@types/node": "^24.10.9",
     "@types/ws": "^8.18.1",
-    "typescript": "^6",
-    "@evolu/common": "8.0.0-next.2",
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "vite": "^8.2.0",
+    "webpack": "^5.109.2",
+    "@evolu/common": "8.0.0",
     "@evolu/typescript-config": "0.0.2"
   },
   "peerDependencies": {
-    "@evolu/common": "^8.0.0-next.0"
+    "@evolu/common": "^8.0.0-next.0",
+    "vite": ">=8.0.0",
+    "webpack": ">=5.108.4"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    },
+    "webpack": {
+      "optional": true
+    }
   },
   "engines": {
     "node": ">=24.0.0"

package/src/Cli.ts

@@ -0,0 +1,78 @@
+/**
+ * Abort-aware CLI process utilities.
+ *
+ * @module
+ */
+
+import { callback, err, ok, type Task, type Typed } from "@evolu/common";
+import { spawn as nodeSpawn } from "node:child_process";
+
+/** Runs a command with inherited stdio. */
+export type Spawn = (
+  file: string,
+  args: ReadonlyArray<string>,
+  options?: {
+    readonly cwd?: string | URL;
+  },
+) => Task<void, SpawnError>;
+
+/** Failure to start a command or an unsuccessful command exit. */
+export interface SpawnError extends Typed<"SpawnError"> {
+  readonly command: string;
+  readonly exitCode: number | null;
+  readonly signal: NodeJS.Signals | null;
+  readonly message: string;
+}
+
+/** Dependency wrapper for {@link spawn}. */
+export interface SpawnDep {
+  readonly spawn: Spawn;
+}
+
+/**
+ * Runs a command with inherited stdio and aborts it with the current Run.
+ *
+ * A zero exit code succeeds. A start failure, non-zero exit code, or signal
+ * exit returns {@link SpawnError}.
+ */
+export const spawn: Spawn = (file, args, { cwd } = {}) => {
+  const command = [file, ...args].join(" ");
+
+  return callback(({ run, resolve }) => {
+    const child = nodeSpawn(file, args, {
+      cwd,
+      signal: run.signal,
+      stdio: "inherit",
+    });
+
+    child.once("error", (error) => {
+      if (run.signal.aborted) return;
+      resolve(
+        err({
+          type: "SpawnError",
+          command,
+          exitCode: null,
+          signal: null,
+          message: `Failed to start ${command}: ${error.message}`,
+        }),
+      );
+    });
+    child.once("close", (exitCode, signal) => {
+      if (run.signal.aborted) return;
+      resolve(
+        exitCode === 0
+          ? ok()
+          : err({
+              type: "SpawnError",
+              command,
+              exitCode,
+              signal,
+              message:
+                signal == null
+                  ? `${command} exited with code ${exitCode}.`
+                  : `${command} exited from ${signal}.`,
+            }),
+      );
+    });
+  });
+};

package/src/Platform.ts

@@ -0,0 +1,20 @@
+/**
+ * Node.js platform utilities.
+ *
+ * @module
+ */
+
+import { PositiveInt } from "@evolu/common";
+import { availableParallelism as nodeAvailableParallelism } from "node:os";
+
+/** Returns the recommended amount of parallelism available to this process. */
+export type AvailableParallelism = () => PositiveInt;
+
+/** Dependency wrapper for {@link availableParallelism}. */
+export interface AvailableParallelismDep {
+  readonly availableParallelism: AvailableParallelism;
+}
+
+/** Returns the recommended amount of parallelism available to this process. */
+export const availableParallelism: AvailableParallelism = () =>
+  PositiveInt.orThrow(nodeAvailableParallelism());

package/src/Sqlite.ts

@@ -1,31 +1,42 @@
 import {
+  constVoid,
   createPreparedStatementsCache,
-  lazyVoid,
   ok,
   type CreateSqliteDriver,
-  type SqliteDriver,
   type SqliteRow,
 } from "@evolu/common";
 import BetterSQLite, { type Statement } from "better-sqlite3";
+import { rmSync } from "fs";
 
 export const createBetterSqliteDriver: CreateSqliteDriver =
   (name, options) => () => {
     const filename = options?.mode === "memory" ? ":memory:" : `${name}.db`;
-    const stack = new globalThis.DisposableStack();
-    const db = stack.adopt(new BetterSQLite(filename), (db) => {
+    const filenamesToDelete =
+      options?.mode === "memory"
+        ? []
+        : [
+            filename,
+            `${filename}-shm`,
+            `${filename}-wal`,
+            `${filename}-journal`,
+          ];
+    using disposer = new DisposableStack();
+    const db = disposer.adopt(new BetterSQLite(filename), (db) => {
       db.close();
     });
 
-    const cache = stack.use(
+    const cache = disposer.use(
       createPreparedStatementsCache<Statement>(
         (sql) => db.prepare(sql),
         // Not needed.
         // https://github.com/WiseLibs/better-sqlite3/blob/master/docs/api.md#class-statement
-        lazyVoid,
+        constVoid,
       ),
     );
 
-    const driver: SqliteDriver = {
+    const disposables = disposer.move();
+
+    return ok({
       exec: (query) => {
         // Always prepare is recommended for better-sqlite3
         const prepared = cache.get(query, true);
@@ -51,10 +62,18 @@ export const createBetterSqliteDriver: CreateSqliteDriver =
         return new Uint8Array(file);
       },
 
-      [Symbol.dispose]: () => {
-        stack.dispose();
+      deleteDatabase: () => {
+        using deleteDisposer = new DisposableStack();
+        for (const filename of filenamesToDelete) {
+          deleteDisposer.defer(() => {
+            rmSync(filename, { force: true });
+          });
+        }
+        deleteDisposer.use(disposables);
       },
-    };
 
-    return ok(driver);
+      [Symbol.dispose]: () => {
+        disposables.dispose();
+      },
+    });
   };