restructure js bindings

bindings/javascript/packages/browser/index.js

@@ -0,0 +1,77 @@
+import {
+  createOnMessage as __wasmCreateOnMessageForFsProxy,
+  getDefaultContext as __emnapiGetDefaultContext,
+  instantiateNapiModule as __emnapiInstantiateNapiModule,
+  WASI as __WASI,
+} from '@napi-rs/wasm-runtime'
+
+
+
+const __wasi = new __WASI({
+  version: 'preview1',
+})
+
+const __wasmUrl = new URL('./turso.wasm32-wasi.debug.wasm', import.meta.url).href
+const __emnapiContext = __emnapiGetDefaultContext()
+
+
+const __sharedMemory = new WebAssembly.Memory({
+  initial: 4000,
+  maximum: 65536,
+  shared: true,
+})
+
+const __wasmFile = await fetch(__wasmUrl).then((res) => res.arrayBuffer())
+
+export let MainWorker = null;
+
+function panic(name) {
+  throw new Error(`method ${name} must be invoked only from the main thread`);
+}
+
+const {
+  instance: __napiInstance,
+  module: __wasiModule,
+  napiModule: __napiModule,
+} = await __emnapiInstantiateNapiModule(__wasmFile, {
+  context: __emnapiContext,
+  asyncWorkPoolSize: 1,
+  wasi: __wasi,
+  onCreateWorker() {
+    const worker = new Worker(new URL('./worker.mjs', import.meta.url), {
+      type: 'module',
+    })
+    MainWorker = worker;
+    return worker
+  },
+  overwriteImports(importObject) {
+    importObject.env = {
+      ...importObject.env,
+      ...importObject.napi,
+      ...importObject.emnapi,
+      memory: __sharedMemory,
+      is_web_worker: () => false,
+      lookup_file: () => panic("lookup_file"),
+      read: () => panic("read"),
+      write: () => panic("write"),
+      sync: () => panic("sync"),
+      truncate: () => panic("truncate"),
+      size: () => panic("size"),
+    }
+    return importObject
+  },
+  beforeInit({ instance }) {
+    for (const name of Object.keys(instance.exports)) {
+      if (name.startsWith('__napi_register__')) {
+        instance.exports[name]()
+      }
+    }
+  },
+})
+export default __napiModule.exports
+export const Database = __napiModule.exports.Database
+export const Opfs = __napiModule.exports.Opfs
+export const OpfsFile = __napiModule.exports.OpfsFile
+export const Statement = __napiModule.exports.Statement
+export const connect = __napiModule.exports.connect
+export const initThreadPool = __napiModule.exports.initThreadPool

bindings/javascript/packages/browser/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@tursodatabase/database-browser",
+  "version": "0.1.5-pre.4",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tursodatabase/turso"
+  },
+  "license": "MIT",
+  "main": "index.js",
+  "packageManager": "yarn@4.9.2",
+  "devDependencies": {
+    "@napi-rs/cli": "^3.1.5",
+    "@napi-rs/wasm-runtime": "^1.0.3",
+    "@vitest/browser": "^3.2.4",
+    "playwright": "^1.55.0",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "napi-build": "napi build --features browser --release --platform --target wasm32-wasip1-threads --no-js --manifest-path ../../Cargo.toml --output-dir . && rm index.d.ts turso.wasi* wasi* browser.js",
+    "tsc-build": "npm exec tsc",
+    "build": "npm run napi-build && npm run tsc-build",
+    "test": "CI=1 vitest --browser=chromium --run && CI=1 vitest --browser=firefox --run"
+  },
+  "napi": {
+    "binaryName": "turso",
+    "targets": [
+      "wasm32-wasip1-threads"
+    ]
+  },
+  "dependencies": {
+    "@tursodatabase/database-core": "^0.1.5-pre.4"
+  }
+}

bindings/javascript/packages/browser/promise.test.ts

@@ -0,0 +1,55 @@
+import { expect, test, afterEach } from 'vitest'
+import { connect } from './promise.js'
+
+test('in-memory db', async () => {
+    const db = await connect(":memory:");
+    await db.exec("CREATE TABLE t(x)");
+    await db.exec("INSERT INTO t VALUES (1), (2), (3)");
+    const stmt = db.prepare("SELECT * FROM t WHERE x % 2 = ?");
+    const rows = await stmt.all([1]);
+    expect(rows).toEqual([{ x: 1 }, { x: 3 }]);
+})
+
+test('on-disk db', async () => {
+    const path = `test-${(Math.random() * 10000) | 0}.db`;
+    const db1 = await connect(path);
+    await db1.exec("CREATE TABLE t(x)");
+    await db1.exec("INSERT INTO t VALUES (1), (2), (3)");
+    const stmt1 = db1.prepare("SELECT * FROM t WHERE x % 2 = ?");
+    expect(stmt1.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+    const rows1 = await stmt1.all([1]);
+    expect(rows1).toEqual([{ x: 1 }, { x: 3 }]);
+    await db1.close();
+
+    const db2 = await connect(path);
+    const stmt2 = db2.prepare("SELECT * FROM t WHERE x % 2 = ?");
+    expect(stmt2.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+    const rows2 = await stmt2.all([1]);
+    expect(rows2).toEqual([{ x: 1 }, { x: 3 }]);
+    db2.close();
+})
+
+test('attach', async () => {
+    const path1 = `test-${(Math.random() * 10000) | 0}.db`;
+    const path2 = `test-${(Math.random() * 10000) | 0}.db`;
+    const db1 = await connect(path1);
+    await db1.exec("CREATE TABLE t(x)");
+    await db1.exec("INSERT INTO t VALUES (1), (2), (3)");
+    const db2 = await connect(path2);
+    await db2.exec("CREATE TABLE q(x)");
+    await db2.exec("INSERT INTO q VALUES (4), (5), (6)");
+
+    await db1.exec(`ATTACH '${path2}' as secondary`);
+
+    const stmt = db1.prepare("SELECT * FROM t UNION ALL SELECT * FROM secondary.q");
+    expect(stmt.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+    const rows = await stmt.all([1]);
+    expect(rows).toEqual([{ x: 1 }, { x: 2 }, { x: 3 }, { x: 4 }, { x: 5 }, { x: 6 }]);
+})
+
+test('blobs', async () => {
+    const db = await connect(":memory:");
+    const rows = await db.prepare("SELECT x'1020' as x").all();
+    expect(rows).toEqual([{ x: new Uint8Array([16, 32]) }])
+})
+

bindings/javascript/packages/browser/promise.ts

@@ -0,0 +1,78 @@
+import { DatabasePromise, NativeDatabase, DatabaseOpts, SqliteError } from "@tursodatabase/database-core"
+import { connect as nativeConnect, initThreadPool, MainWorker } from "./index.js";
+
+let workerRequestId = 0;
+class Database extends DatabasePromise {
+    files: string[];
+    constructor(db: NativeDatabase, files: string[], opts: DatabaseOpts = {}) {
+        super(db, opts)
+        this.files = files;
+    }
+    async close() {
+        let currentId = workerRequestId;
+        workerRequestId += this.files.length;
+
+        let tasks = [];
+        for (const file of this.files) {
+            (MainWorker as any).postMessage({ __turso__: "unregister", path: file, id: currentId });
+            tasks.push(waitFor(currentId));
+            currentId += 1;
+        }
+        await Promise.all(tasks);
+        this.db.close();
+    }
+}
+
+function waitFor(id: number): Promise<any> {
+    let waitResolve, waitReject;
+    const callback = msg => {
+        if (msg.data.id == id) {
+            if (msg.data.error != null) {
+                waitReject(msg.data.error)
+            } else {
+                waitResolve()
+            }
+            cleanup();
+        }
+    };
+    const cleanup = () => (MainWorker as any).removeEventListener("message", callback);
+
+    (MainWorker as any).addEventListener("message", callback);
+    const result = new Promise((resolve, reject) => {
+        waitResolve = resolve;
+        waitReject = reject;
+    });
+    return result;
+}
+
+/**
+ * Creates a new database connection asynchronously.
+ * 
+ * @param {string} path - Path to the database file.
+ * @param {Object} opts - Options for database behavior.
+ * @returns {Promise<Database>} - A promise that resolves to a Database instance.
+ */
+async function connect(path: string, opts: DatabaseOpts = {}): Promise<Database> {
+    if (path == ":memory:") {
+        const db = await nativeConnect(path, { tracing: opts.tracing });
+        return new Database(db, [], opts);
+    }
+    await initThreadPool();
+    if (MainWorker == null) {
+        throw new Error("panic: MainWorker is not set");
+    }
+
+    let currentId = workerRequestId;
+    workerRequestId += 2;
+
+    let dbHandlePromise = waitFor(currentId);
+    let walHandlePromise = waitFor(currentId + 1);
+    (MainWorker as any).postMessage({ __turso__: "register", path: `${path}`, id: currentId });
+    (MainWorker as any).postMessage({ __turso__: "register", path: `${path}-wal`, id: currentId + 1 });
+    await Promise.all([dbHandlePromise, walHandlePromise]);
+    const db = await nativeConnect(path, { tracing: opts.tracing });
+    const files = [path, `${path}-wal`];
+    return new Database(db, files, opts);
+}
+
+export { connect, Database, SqliteError }

bindings/javascript/packages/browser/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "module": "nodenext",
+    "target": "esnext",
+    "outDir": "dist/",
+    "lib": [
+      "es2020"
+    ],
+  },
+  "include": [
+    "*"
+  ]
+}

bindings/javascript/packages/browser/vitest.config.ts

@@ -0,0 +1,23 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  define: {
+    'process.env.NODE_DEBUG_NATIVE': 'false',
+  },
+  server: {
+    headers: {
+      "Cross-Origin-Embedder-Policy": "require-corp",
+      "Cross-Origin-Opener-Policy": "same-origin"
+    },
+  },
+  test: {
+    browser: {
+      enabled: true,
+      provider: 'playwright',
+      instances: [
+        { browser: 'chromium' },
+        { browser: 'firefox' }
+      ],
+    },
+  },
+})

bindings/javascript/packages/browser/worker.mjs

@@ -0,0 +1,160 @@
+import { instantiateNapiModuleSync, MessageHandler, WASI } from '@napi-rs/wasm-runtime'
+
+var fileByPath = new Map();
+var fileByHandle = new Map();
+let fileHandles = 0;
+var memory = null;
+
+function getUint8ArrayFromWasm(ptr, len) {
+  ptr = ptr >>> 0;
+  return new Uint8Array(memory.buffer).subarray(ptr, ptr + len);
+}
+
+
+async function registerFile(path) {
+  if (fileByPath.has(path)) {
+    return;
+  }
+  const opfsRoot = await navigator.storage.getDirectory();
+  const opfsHandle = await opfsRoot.getFileHandle(path, { create: true });
+  const opfsSync = await opfsHandle.createSyncAccessHandle();
+  fileHandles += 1;
+  fileByPath.set(path, { handle: fileHandles, sync: opfsSync });
+  fileByHandle.set(fileHandles, opfsSync);
+}
+
+async function unregisterFile(path) {
+  const file = fileByPath.get(path);
+  if (file == null) {
+    return;
+  }
+  fileByPath.delete(path);
+  fileByHandle.delete(file.handle);
+  file.sync.close();
+}
+
+function lookup_file(pathPtr, pathLen) {
+  try {
+    const buffer = getUint8ArrayFromWasm(pathPtr, pathLen);
+    const notShared = new Uint8Array(buffer.length);
+    notShared.set(buffer);
+    const decoder = new TextDecoder('utf-8');
+    const path = decoder.decode(notShared);
+    const file = fileByPath.get(path);
+    if (file == null) {
+      return -404;
+    }
+    return file.handle;
+  } catch (e) {
+    console.error('lookupFile', pathPtr, pathLen, e);
+    return -1;
+  }
+}
+function read(handle, bufferPtr, bufferLen, offset) {
+  try {
+    const buffer = getUint8ArrayFromWasm(bufferPtr, bufferLen);
+    const file = fileByHandle.get(Number(handle));
+    const result = file.read(buffer, { at: Number(offset) });
+    return result;
+  } catch (e) {
+    console.error('read', handle, bufferPtr, bufferLen, offset, e);
+    return -1;
+  }
+}
+function write(handle, bufferPtr, bufferLen, offset) {
+  try {
+    const buffer = getUint8ArrayFromWasm(bufferPtr, bufferLen);
+    const file = fileByHandle.get(Number(handle));
+    const result = file.write(buffer, { at: Number(offset) });
+    return result;
+  } catch (e) {
+    console.error('write', handle, bufferPtr, bufferLen, offset, e);
+    return -1;
+  }
+}
+function sync(handle) {
+  try {
+    const file = fileByHandle.get(Number(handle));
+    file.flush();
+    return 0;
+  } catch (e) {
+    console.error('sync', handle, e);
+    return -1;
+  }
+}
+function truncate(handle, size) {
+  try {
+    const file = fileByHandle.get(Number(handle));
+    const result = file.truncate(size);
+    return result;
+  } catch (e) {
+    console.error('truncate', handle, size, e);
+    return -1;
+  }
+}
+function size(handle) {
+  try {
+    const file = fileByHandle.get(Number(handle));
+    const size = file.getSize()
+    return size;
+  } catch (e) {
+    console.error('size', handle, e);
+    return -1;
+  }
+}
+
+const handler = new MessageHandler({
+  onLoad({ wasmModule, wasmMemory }) {
+    memory = wasmMemory;
+    const wasi = new WASI({
+      print: function () {
+        // eslint-disable-next-line no-console
+        console.log.apply(console, arguments)
+      },
+      printErr: function () {
+        // eslint-disable-next-line no-console
+        console.error.apply(console, arguments)
+      },
+    })
+    return instantiateNapiModuleSync(wasmModule, {
+      childThread: true,
+      wasi,
+      overwriteImports(importObject) {
+        importObject.env = {
+          ...importObject.env,
+          ...importObject.napi,
+          ...importObject.emnapi,
+          memory: wasmMemory,
+          is_web_worker: () => true,
+          lookup_file: lookup_file,
+          read: read,
+          write: write,
+          sync: sync,
+          truncate: truncate,
+          size: size,
+        }
+      },
+    })
+  },
+})
+
+globalThis.onmessage = async function (e) {
+  if (e.data.__turso__ == 'register') {
+    try {
+      await registerFile(e.data.path)
+      self.postMessage({ id: e.data.id })
+    } catch (error) {
+      self.postMessage({ id: e.data.id, error: error });
+    }
+    return;
+  } else if (e.data.__turso__ == 'unregister') {
+    try {
+      await unregisterFile(e.data.path)
+      self.postMessage({ id: e.data.id })
+    } catch (error) {
+      self.postMessage({ id: e.data.id, error: error });
+    }
+    return;
+  }
+  handler.handle(e)
+}