fix(verify): stabilize tree-shaking and sqlite runtime compatibility

Author: miccy

bun.lock

@@ -16,13 +16,13 @@
     "build": "turbo --filter @evolu/* build",
     "build:web": "bun run build:docs && turbo --filter web build",
     "build:docs": "bun run docs:generate:api",
-    "test": "bun run test:preflight && vitest run",
+    "test": "bun run test:preflight && bunx vitest run",
     "test:preflight": "bun ./scripts/ensure-better-sqlite3.mts",
-    "test:docs": "vitest run scripts/typedoc-plugin-evolu.test.mts",
+    "test:docs": "bunx vitest run scripts/typedoc-plugin-evolu.test.mts",
     "test:coverage": "bun run test:coverage:vitest && bun run test:coverage:bun",
-    "test:coverage:vitest": "bun run test:preflight && vitest run --coverage",
+    "test:coverage:vitest": "bun run test:preflight && bunx vitest run --coverage",
     "test:coverage:bun": "bun test ./packages/bun/test --coverage --coverage-reporter=text --coverage-reporter=lcov --coverage-dir=coverage/bun",
-    "test:watch": "vitest",
+    "test:watch": "bunx vitest",
     "start": "turbo start",
     "lint": "biome check",
     "lint-monorepo": "bunx sherif@1.6.1",

package.json

@@ -895,6 +895,9 @@ export const createEvolu =
       [Symbol.asyncDispose]: () => {
         console.info("disposeEvolu");
         exportDatabaseDeferred?.[Symbol.dispose]();
+        // Cancel queued microtask batches before sending dispose.
+        mutateBatch[Symbol.dispose]();
+        queryBatch[Symbol.dispose]();
         postMessage({ type: "Dispose" });
         return moved.disposeAsync();
       },

packages/common/src/local-first/Evolu.ts

@@ -39,7 +39,14 @@ if (!Promise.try) {
       }
     });
 }
-require(process.argv[1]);
+const { pathToFileURL } = require("node:url");
+(async () => {
+  const fileUrl = pathToFileURL(process.argv[1]).href;
+  await import(fileUrl);
+})().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});
 `;
 
   const result = spawnSync(process.execPath, ["-e", bootstrap, bundlePath], {
@@ -102,21 +109,25 @@ const bundleSize = async (fixturePath: string): Promise<BundleSize> => {
   return await new Promise((resolve, reject) => {
     compiler.run((err: Error | null, stats: Stats | undefined) => {
       compiler.close(() => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        if (stats?.hasErrors()) {
-          reject(new Error(stats.toString()));
-          return;
+        try {
+          if (err) {
+            reject(err);
+            return;
+          }
+          if (stats?.hasErrors()) {
+            reject(new Error(stats.toString()));
+            return;
+          }
+          const bundlePath = join(outputDir, "bundle.js");
+          runBundle(bundlePath);
+          const bundle = readFileSync(bundlePath);
+          resolve({
+            raw: bundle.byteLength,
+            gzip: gzipSync(bundle).byteLength,
+          });
+        } catch (error) {
+          reject(error);
         }
-        const bundlePath = join(outputDir, "bundle.js");
-        runBundle(bundlePath);
-        const bundle = readFileSync(bundlePath);
-        resolve({
-          raw: bundle.byteLength,
-          gzip: gzipSync(bundle).byteLength,
-        });
       });
     });
   });

packages/common/test/TreeShaking.test.ts

@@ -1,5 +1,8 @@
-import { timingSafeEqual } from "node:crypto";
+import { randomUUID, timingSafeEqual } from "node:crypto";
+import { readFileSync, rmSync } from "node:fs";
 import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { assert } from "../src/Assert.js";
 import type { TimingSafeEqual } from "../src/Crypto.js";
 import { lazyTrue, lazyVoid } from "../src/Function.js";
@@ -121,9 +124,46 @@ interface BunSqliteModule {
   readonly Database: new (filename: string) => BunSqliteDbLike;
 }
 
+interface NodeSqliteStatementLike {
+  readonly all: (...parameters: ReadonlyArray<SqliteValue>) => Array<SqliteRow>;
+  readonly run: (...parameters: ReadonlyArray<SqliteValue>) => {
+    readonly changes?: number;
+  };
+}
+
+interface NodeSqliteDbLike {
+  readonly prepare: (sql: string) => NodeSqliteStatementLike;
+  readonly exec: (sql: string) => void;
+  readonly close: () => void;
+}
+
+interface NodeSqliteModule {
+  readonly DatabaseSync: new (filename: string) => NodeSqliteDbLike;
+}
+
 const isReaderSql = (sql: string): boolean =>
   /^\s*(select|pragma|with|explain|values)\b/i.test(sql);
 
+const sqliteEscape = (value: string): string => value.replaceAll("'", "''");
+
+const serializeToBytes = (exec: (sql: string) => void): Uint8Array => {
+  const path = join(tmpdir(), `evolu-test-export-${randomUUID()}.db`);
+
+  try {
+    exec(`vacuum into '${sqliteEscape(path)}'`);
+    const file = readFileSync(path);
+    const { buffer } = file;
+
+    if (buffer instanceof ArrayBuffer) {
+      return new Uint8Array(buffer, file.byteOffset, file.byteLength);
+    }
+
+    return new Uint8Array(file);
+  } finally {
+    rmSync(path, { force: true });
+  }
+};
+
 const createDb = (filename: string): DbLike => {
   try {
     const BetterSQLite = require("better-sqlite3") as BetterSqliteConstructor;
@@ -141,10 +181,9 @@ const createDb = (filename: string): DbLike => {
       serialize: () => db.serialize(),
       close: () => db.close(),
     };
-  } catch (error) {
-    const hasBunRuntime = (globalThis as Record<string, unknown>).Bun != null;
-    if (!hasBunRuntime) throw error;
+  } catch {}
 
+  try {
     const { Database } = require("bun:sqlite") as BunSqliteModule;
     const db = new Database(filename);
 
@@ -160,7 +199,25 @@ const createDb = (filename: string): DbLike => {
       serialize: () => db.serialize(),
       close: () => db.close(),
     };
-  }
+  } catch {}
+
+  const { DatabaseSync } = require("node:sqlite") as NodeSqliteModule;
+  const db = new DatabaseSync(filename);
+
+  return {
+    prepare: (sql) => {
+      const statement = db.prepare(sql);
+      return {
+        reader: isReaderSql(sql),
+        all: (...parameters) => statement.all(...parameters),
+        run: (...parameters) => ({
+          changes: statement.run(...parameters).changes ?? 0,
+        }),
+      };
+    },
+    serialize: () => serializeToBytes((sql) => db.exec(sql)),
+    close: () => db.close(),
+  };
 };
 
 // Duplicated from @evolu/nodejs because @evolu/common cannot depend on it

packages/common/test/_deps.ts

@@ -50,7 +50,10 @@ type BetterSqliteConstructor = new () => BetterSqliteDbLike;
 
 const BetterSQLite = (() => {
   try {
-    return require("better-sqlite3") as BetterSqliteConstructor;
+    const SQLite = require("better-sqlite3") as BetterSqliteConstructor;
+    const db = new SQLite();
+    db.prepare("select 1 as one").all();
+    return SQLite;
   } catch {
     return null;
   }

packages/common/test/local-first/Timestamp.test.ts

@@ -1,4 +1,8 @@
+import { randomUUID } from "node:crypto";
+import { readFileSync, rmSync } from "node:fs";
 import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import {
   type CreateSqliteDriver,
   createPreparedStatementsCache,
@@ -58,9 +62,46 @@ interface BunSqliteModule {
   readonly Database: new (filename: string) => BunSqliteDbLike;
 }
 
+interface NodeSqliteStatementLike {
+  readonly all: (...parameters: ReadonlyArray<SqliteValue>) => Array<SqliteRow>;
+  readonly run: (...parameters: ReadonlyArray<SqliteValue>) => {
+    readonly changes?: number;
+  };
+}
+
+interface NodeSqliteDbLike {
+  readonly prepare: (sql: string) => NodeSqliteStatementLike;
+  readonly exec: (sql: string) => void;
+  readonly close: () => void;
+}
+
+interface NodeSqliteModule {
+  readonly DatabaseSync: new (filename: string) => NodeSqliteDbLike;
+}
+
 const isReaderSql = (sql: string): boolean =>
   /^\s*(select|pragma|with|explain|values)\b/i.test(sql);
 
+const sqliteEscape = (value: string): string => value.replaceAll("'", "''");
+
+const serializeToBytes = (exec: (sql: string) => void): Uint8Array => {
+  const path = join(tmpdir(), `evolu-export-${randomUUID()}.db`);
+
+  try {
+    exec(`vacuum into '${sqliteEscape(path)}'`);
+    const file = readFileSync(path);
+    const { buffer } = file;
+
+    if (buffer instanceof ArrayBuffer) {
+      return new Uint8Array(buffer, file.byteOffset, file.byteLength);
+    }
+
+    return new Uint8Array(file);
+  } finally {
+    rmSync(path, { force: true });
+  }
+};
+
 const createBetterDb = (filename: string): DbLike => {
   const BetterSQLite = require("better-sqlite3") as BetterSqliteConstructor;
   const db = new BetterSQLite(filename);
@@ -97,6 +138,26 @@ const createBunDb = (filename: string): DbLike => {
   };
 };
 
+const createNodeDb = (filename: string): DbLike => {
+  const { DatabaseSync } = require("node:sqlite") as NodeSqliteModule;
+  const db = new DatabaseSync(filename);
+
+  return {
+    prepare: (sql) => {
+      const statement = db.prepare(sql);
+      return {
+        reader: isReaderSql(sql),
+        all: (...parameters) => statement.all(...parameters),
+        run: (...parameters) => ({
+          changes: statement.run(...parameters).changes ?? 0,
+        }),
+      };
+    },
+    serialize: () => serializeToBytes((sql) => db.exec(sql)),
+    close: () => db.close(),
+  };
+};
+
 const createDb = (filename: string): DbLike => {
   const hasBunRuntime = (globalThis as Record<string, unknown>).Bun != null;
 
@@ -107,12 +168,24 @@ const createDb = (filename: string): DbLike => {
       try {
         return createBetterDb(filename);
       } catch {
-        throw bunError;
+        try {
+          return createNodeDb(filename);
+        } catch {
+          throw bunError;
+        }
       }
     }
   }
 
-  return createBetterDb(filename);
+  try {
+    return createBetterDb(filename);
+  } catch (betterError) {
+    try {
+      return createNodeDb(filename);
+    } catch {
+      throw betterError;
+    }
+  }
 };
 
 export const createBetterSqliteDriver: CreateSqliteDriver =

packages/nodejs/src/Sqlite.ts

@@ -23,7 +23,10 @@ type BetterSqliteConstructor = new (
 
 const BetterSQLite = (() => {
   try {
-    return require("better-sqlite3") as BetterSqliteConstructor;
+    const SQLite = require("better-sqlite3") as BetterSqliteConstructor;
+    const db = new SQLite(":memory:");
+    db.close();
+    return SQLite;
   } catch {
     return null;
   }