@evolu/sqlite-wasm 2.2.4 → 3.53.4-build1

package/dist/src/WasmUrl.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Where the package's wasm binary is.
+ *
+ * @module
+ */
+/**
+ * The URL of the wasm binary the package ships, to load with
+ * {@link createSqliteWasm}.
+ *
+ * It is `new URL("../wasm/sqlite3.wasm", import.meta.url)`, which Vite,
+ * webpack, Next.js and other bundlers recognize: they emit the binary with the
+ * app and give the URL of their copy. In the published package, the binary is
+ * `dist/wasm/sqlite3.wasm`, beside the compiled modules in `dist/src`.
+ *
+ * Vite does not process the URL in a dependency it prebundles, so add
+ * `@evolu/sqlite-wasm` to `optimizeDeps.exclude`. Vite emits the binary
+ * whenever the app imports `@evolu/sqlite-wasm`, even without this URL, and
+ * webpack only when the app uses it.
+ */
+export declare const sqliteWasmUrl: URL;
+//# sourceMappingURL=WasmUrl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WasmUrl.d.ts","sourceRoot":"","sources":["../../src/WasmUrl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa,EAAE,GAG3B,CAAC"}

package/dist/src/WasmUrl.js

@@ -0,0 +1,20 @@
+/**
+ * Where the package's wasm binary is.
+ *
+ * @module
+ */
+/**
+ * The URL of the wasm binary the package ships, to load with
+ * {@link createSqliteWasm}.
+ *
+ * It is `new URL("../wasm/sqlite3.wasm", import.meta.url)`, which Vite,
+ * webpack, Next.js and other bundlers recognize: they emit the binary with the
+ * app and give the URL of their copy. In the published package, the binary is
+ * `dist/wasm/sqlite3.wasm`, beside the compiled modules in `dist/src`.
+ *
+ * Vite does not process the URL in a dependency it prebundles, so add
+ * `@evolu/sqlite-wasm` to `optimizeDeps.exclude`. Vite emits the binary
+ * whenever the app imports `@evolu/sqlite-wasm`, even without this URL, and
+ * webpack only when the app uses it.
+ */
+export const sqliteWasmUrl = /*#__PURE__*/ new URL("../wasm/sqlite3.wasm", import.meta.url);

package/dist/src/c-api/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * SQLite's C API as the wasm exports it: the C-named functions, the SQLITE_*
+ * constants, and the struct layouts.
+ *
+ * @module
+ */
+export * from "../CApi.ts";
+export * from "../Constants.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/c-api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/c-api/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC"}

package/dist/src/c-api/index.js

@@ -0,0 +1,8 @@
+/**
+ * SQLite's C API as the wasm exports it: the C-named functions, the SQLITE_*
+ * constants, and the struct layouts.
+ *
+ * @module
+ */
+export * from "../CApi.js";
+export * from "../Constants.js";

package/dist/src/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * SQLite compiled to WebAssembly, with Evolu's own TypeScript layer, which also
+ * encrypts databases.
+ *
+ * @module
+ * @mergeModuleWith <project>
+ */
+export type { SqlitePrimaryResultCode, SqliteResultCode } from "./Constants.ts";
+export * from "./Database.ts";
+export * from "./Memory.ts";
+export * from "./Pointer.ts";
+export * from "./SahPool.ts";
+export * from "./Wasm.ts";
+export * from "./WasmUrl.ts";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,YAAY,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAChF,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,13 @@
+/**
+ * SQLite compiled to WebAssembly, with Evolu's own TypeScript layer, which also
+ * encrypts databases.
+ *
+ * @module
+ * @mergeModuleWith <project>
+ */
+export * from "./Database.js";
+export * from "./Memory.js";
+export * from "./Pointer.js";
+export * from "./SahPool.js";
+export * from "./Wasm.js";
+export * from "./WasmUrl.js";

package/package.json

@@ -1,76 +1,76 @@
 {
   "name": "@evolu/sqlite-wasm",
-  "version": "2.2.4",
-  "description": "SQLite Wasm conveniently wrapped as an ES Module. (Multiple Ciphers Support)",
+  "version": "3.53.4-build1",
+  "description": "SQLite compiled to WebAssembly, with Evolu's own TypeScript layer, which also encrypts databases",
   "keywords": [
-    "sqlite",
-    "sqlite3",
-    "sqlite-wasm",
-    "sqlite3-wasm",
-    "sqlite-wasm-cipher",
-    "sqlite3-multiple-ciphers",
-    "webassembly",
-    "cipher",
     "evolu",
+    "sqlite",
     "wasm",
-    "esm",
-    "opfs",
-    "origin-private-file-system"
+    "opfs"
   ],
-  "main": "index.mjs",
-  "node": "node.mjs",
+  "author": "Daniel Steigerwald <daniel@steigerwald.cz>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/evoluhq/evolu.git"
+  },
+  "bugs": {
+    "url": "https://github.com/evoluhq/evolu/issues"
+  },
+  "homepage": "https://evolu.dev",
   "type": "module",
-  "files": [
-    "index.d.ts",
-    "index.mjs",
-    "node.mjs",
-    "sqlite-wasm/"
-  ],
-  "types": "index.d.ts",
+  "types": "./dist/src/index.d.ts",
   "exports": {
     ".": {
-      "types": "./index.d.ts",
-      "node": "./node.mjs",
-      "import": "./index.mjs",
-      "main": "./index.mjs",
-      "browser": "./index.mjs"
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js",
+      "browser": "./dist/src/index.js"
     },
-    "./package.json": "./package.json",
-    "./sqlite3.wasm": "./sqlite-wasm/jswasm/sqlite3.wasm"
+    "./c-api": {
+      "types": "./dist/src/c-api/index.d.ts",
+      "import": "./dist/src/c-api/index.js",
+      "browser": "./dist/src/c-api/index.js"
+    }
   },
-  "bin": {
-    "sqlite-wasm": "bin/index.js"
+  "typesVersions": {
+    "*": {
+      "c-api": [
+        "./dist/src/c-api/index.d.ts"
+      ]
+    }
   },
-  "scripts": {
-    "publint": "npx publint",
-    "check-types": "tsc",
-    "clean": "shx rm -rf sqlite-wasm",
-    "build": "npm run clean && node bin/index.js",
-    "start": "npx http-server --coop",
-    "start:node": "cd demo && node node.mjs",
-    "fix": "npx prettier . --write",
-    "prepublishOnly": "npm run build && npm run fix && npm run publint && npm run check-types",
-    "deploy": "npm run prepublishOnly && git add . && git commit -am 'New release' && git push && npm publish --access public"
+  "files": [
+    "dist/src/**",
+    "!dist/**/*.test.*",
+    "dist/wasm/sqlite3.wasm",
+    "src/**",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@evolu/common": "8.19.0",
+    "@evolu/typescript-config": "0.1.1",
+    "@types/node": "^24.10.9",
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "prettier": "^3.9.6",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "wabt": "1.0.39"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/evoluhq/sqlite-wasm-cipher.git"
+  "peerDependencies": {
+    "@evolu/common": "^8.19.0"
   },
-  "author": "EvoluHQ",
-  "license": "Apache-2.0",
-  "bugs": {
-    "url": "https://github.com/evoluhq/sqlite-wasm-cipher/issues"
+  "publishConfig": {
+    "access": "public"
   },
-  "homepage": "https://github.com/evoluhq/sqlite-wasm-cipher#readme",
-  "devDependencies": {
-    "decompress": "^4.2.1",
-    "http-server": "github:vapier/http-server",
-    "module-workers-polyfill": "^0.3.2",
-    "node-fetch": "^3.3.2",
-    "prettier": "^3.6.2",
-    "prettier-plugin-jsdoc": "^1.3.3",
-    "publint": "^0.3.12",
-    "shx": "^0.4.0",
-    "typescript": "^5.9.2"
+  "engines": {
+    "node": ">=24.20.0"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@awasm/noble": "0.1.4"
+  },
+  "scripts": {
+    "build": "tsc --build tsconfig.build.json",
+    "format": "prettier --write \"src/*.{ts,tsx,md}\"",
+    "generate": "node scripts/generate.mts"
   }
-}
+}

package/src/CApi.test.ts

@@ -0,0 +1,217 @@
+import { test } from "node:test";
+
+import { assertEqual, assertSame, assertTrue, assertType } from "@evolu/common";
+import {
+  sqlite3_config,
+  sqlite3_db_config,
+  type SqliteCExports,
+} from "./CApi.ts";
+import {
+  SQLITE_CONFIG_GETMALLOC,
+  SQLITE_CONFIG_LOOKASIDE,
+  SQLITE_CONFIG_MEMDB_MAXSIZE,
+  SQLITE_CONFIG_URI,
+  SQLITE_DBCONFIG_ENABLE_FKEY,
+  SQLITE_DBCONFIG_FP_DIGITS,
+  SQLITE_DBCONFIG_LOOKASIDE,
+  SQLITE_DBCONFIG_MAINDBNAME,
+  SQLITE_DBCONFIG_MAX,
+  SQLITE_MISUSE,
+  SQLITE_NOTFOUND,
+  SQLITE_OK,
+  SQLITE_SERIALIZE_NOCOPY,
+  type SqliteResultCode,
+} from "./Constants.ts";
+import type { readCString } from "./Memory.ts";
+import type {
+  CStringPtr,
+  NullPtr,
+  SqliteDbPtr,
+  SqliteOwnedCStringPtr,
+  SqliteOwnedPtr,
+  SqliteOwnedValuePtr,
+  SqliteStmtPtr,
+  SqliteValuePtr,
+  WasmPtr,
+} from "./Pointer.ts";
+import type { SqliteWasmDep } from "./Wasm.ts";
+
+// The exports need a loaded binary, so these tests call stubs of their types
+// to prove which calls TypeScript accepts, and fakes of the variadic shims to
+// prove how options are dispatched.
+
+const db = 8 as SqliteDbPtr;
+const pStmt = 16 as SqliteStmtPtr;
+const sqlite3_free: SqliteCExports["sqlite3_free"] = () => undefined;
+
+test("sqlite3_serialize returns memory sqlite3_free accepts only for mFlags 0", () => {
+  const sqlite3_serialize: SqliteCExports["sqlite3_serialize"] = () => 0;
+  const piSize = 24 as WasmPtr;
+  const mFlags: number = SQLITE_SERIALIZE_NOCOPY;
+
+  const copy = sqlite3_serialize(db, 0, piSize, 0);
+  assertType<typeof copy, SqliteOwnedPtr | NullPtr>();
+  sqlite3_free(copy);
+
+  const buffer = sqlite3_serialize(db, 0, piSize, SQLITE_SERIALIZE_NOCOPY);
+  assertType<typeof buffer, WasmPtr | NullPtr>();
+  // @ts-expect-error SQLITE_SERIALIZE_NOCOPY can return SQLite's own buffer.
+  sqlite3_free(buffer);
+
+  const unknown = sqlite3_serialize(db, 0, piSize, mFlags);
+  // @ts-expect-error Flags not known to be 0 can include SQLITE_SERIALIZE_NOCOPY.
+  sqlite3_free(unknown);
+});
+
+test("sqlite3_value_free accepts only values sqlite3_value_dup returns", () => {
+  const sqlite3_column_value: SqliteCExports["sqlite3_column_value"] = () =>
+    32 as SqliteValuePtr;
+  const sqlite3_value_dup: SqliteCExports["sqlite3_value_dup"] = () => 0;
+  const sqlite3_value_free: SqliteCExports["sqlite3_value_free"] = () =>
+    undefined;
+
+  const column = sqlite3_column_value(pStmt, 0);
+  const copy = sqlite3_value_dup(column);
+  assertType<typeof copy, SqliteOwnedValuePtr | NullPtr>();
+  sqlite3_value_free(copy);
+
+  // @ts-expect-error A column value is borrowed from the statement.
+  sqlite3_value_free(column);
+  // @ts-expect-error A copied value is freed with sqlite3_value_free.
+  sqlite3_free(copy);
+});
+
+test("sqlite3_expanded_sql returns a C string sqlite3_free accepts", () => {
+  const sqlite3_expanded_sql: SqliteCExports["sqlite3_expanded_sql"] = () => 0;
+  const read: ReturnType<typeof readCString> = () => "";
+
+  const sql = sqlite3_expanded_sql(pStmt);
+  assertType<typeof sql, SqliteOwnedCStringPtr | NullPtr>();
+  if (sql !== 0) read(sql);
+  sqlite3_free(sql);
+});
+
+/**
+ * A fake {@link SqliteWasmDep} whose variadic shims record their calls and
+ * return SQLITE_OK.
+ */
+const setupFakeShims = () => {
+  const calls: Array<ReadonlyArray<unknown>> = [];
+  const shim =
+    (name: string) =>
+    (...args: ReadonlyArray<unknown>): SqliteResultCode => {
+      calls.push([name, ...args]);
+      return SQLITE_OK;
+    };
+  const deps: SqliteWasmDep = {
+    sqliteWasm: {
+      exports: {
+        sqlite3__wasm_config_i: shim("sqlite3__wasm_config_i"),
+        sqlite3__wasm_config_ii: shim("sqlite3__wasm_config_ii"),
+        sqlite3__wasm_config_j: shim("sqlite3__wasm_config_j"),
+        sqlite3__wasm_db_config_s: shim("sqlite3__wasm_db_config_s"),
+        sqlite3__wasm_db_config_pii: shim("sqlite3__wasm_db_config_pii"),
+        sqlite3__wasm_db_config_ip: shim("sqlite3__wasm_db_config_ip"),
+      } as unknown as SqliteCExports,
+      functionTable: new WebAssembly.Table({ initial: 0, element: "anyfunc" }),
+      getHeapU8: () => new Uint8Array(),
+      getHeapDataView: () => new DataView(new ArrayBuffer(0)),
+      call: (fn) => fn(),
+      isBroken: () => false,
+    },
+  };
+  return { deps, calls };
+};
+
+test("sqlite3_config passes each option to the shim for its arguments", () => {
+  const { deps, calls } = setupFakeShims();
+  const config = sqlite3_config(deps);
+
+  assertEqual(config(SQLITE_CONFIG_URI, 1), SQLITE_OK);
+  assertEqual(config(SQLITE_CONFIG_LOOKASIDE, 64, 10), SQLITE_OK);
+  assertEqual(config(SQLITE_CONFIG_MEMDB_MAXSIZE, 1024n), SQLITE_OK);
+
+  assertEqual(calls, [
+    ["sqlite3__wasm_config_i", SQLITE_CONFIG_URI, 1],
+    ["sqlite3__wasm_config_ii", SQLITE_CONFIG_LOOKASIDE, 64, 10],
+    ["sqlite3__wasm_config_j", SQLITE_CONFIG_MEMDB_MAXSIZE, 1024n],
+  ]);
+});
+
+test("sqlite3_config returns SQLITE_NOTFOUND for any other option without calling wasm", () => {
+  const { deps, calls } = setupFakeShims();
+
+  // @ts-expect-error SQLITE_CONFIG_GETMALLOC takes a pointer the shims do not pass.
+  const result = sqlite3_config(deps)(SQLITE_CONFIG_GETMALLOC, 1);
+
+  assertEqual(result, SQLITE_NOTFOUND);
+  assertEqual(calls, []);
+});
+
+test("sqlite3_db_config passes each option to the shim for its arguments, and pResult as NULL when omitted", () => {
+  const { deps, calls } = setupFakeShims();
+  const dbConfig = sqlite3_db_config(deps);
+  const zName = 24 as CStringPtr;
+  const buf = 32 as WasmPtr;
+  const pResult = 40 as WasmPtr;
+
+  assertEqual(dbConfig(db, SQLITE_DBCONFIG_MAINDBNAME, zName), SQLITE_OK);
+  assertEqual(dbConfig(db, SQLITE_DBCONFIG_LOOKASIDE, buf, 64, 10), SQLITE_OK);
+  assertEqual(dbConfig(db, SQLITE_DBCONFIG_ENABLE_FKEY, 1, pResult), SQLITE_OK);
+  assertEqual(dbConfig(db, SQLITE_DBCONFIG_FP_DIGITS, 5), SQLITE_OK);
+
+  assertEqual(calls, [
+    ["sqlite3__wasm_db_config_s", db, SQLITE_DBCONFIG_MAINDBNAME, zName],
+    ["sqlite3__wasm_db_config_pii", db, SQLITE_DBCONFIG_LOOKASIDE, buf, 64, 10],
+    ["sqlite3__wasm_db_config_ip", db, SQLITE_DBCONFIG_ENABLE_FKEY, 1, pResult],
+    ["sqlite3__wasm_db_config_ip", db, SQLITE_DBCONFIG_FP_DIGITS, 5, 0],
+  ]);
+});
+
+test("sqlite3_db_config returns SQLITE_MISUSE for any other option without calling wasm", () => {
+  const { deps, calls } = setupFakeShims();
+
+  // @ts-expect-error The value after SQLITE_DBCONFIG_MAX is not an option.
+  const result = sqlite3_db_config(deps)(db, SQLITE_DBCONFIG_MAX + 1, 0);
+
+  assertEqual(result, SQLITE_MISUSE);
+  assertEqual(calls, []);
+});
+
+test("every generated binding returns the export it names", async () => {
+  const exportsByName = new Map<string | symbol, () => void>();
+  const exports = new Proxy(
+    {},
+    {
+      get: (_, name) => {
+        const fake = exportsByName.get(name) ?? (() => undefined);
+        exportsByName.set(name, fake);
+        return fake;
+      },
+    },
+  ) as SqliteCExports;
+  const deps = { sqliteWasm: { exports } } as SqliteWasmDep;
+  // The variadic functions dispatch to shims, tested above, and
+  // sqlite3_vtab_config is its shim.
+  const exportNames: Readonly<Record<string, string | null>> = {
+    sqlite3_config: null,
+    sqlite3_db_config: null,
+    sqlite3_vtab_config: "sqlite3__wasm_vtab_config",
+  };
+  const capi = (await import("./CApi.ts")) as unknown as Readonly<
+    Record<string, unknown>
+  >;
+
+  let checked = 0;
+  for (const [name, binding] of Object.entries(capi)) {
+    if (typeof binding !== "function") continue;
+    const exportName = name in exportNames ? exportNames[name] : name;
+    if (exportName == null) continue;
+    assertSame(
+      (binding as (deps: SqliteWasmDep) => unknown)(deps),
+      exports[exportName as keyof SqliteCExports],
+    );
+    checked++;
+  }
+  assertTrue(checked > 154);
+});