@arcote.tech/arc-adapter-db-sqlite-wasm 0.3.0

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@arcote.tech/arc-adapter-db-sqlite-wasm",
+  "version": "0.3.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./worker": {
+      "import": "./dist/worker.js",
+      "types": "./dist/worker.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun build ./src/index.ts ./src/worker.ts --outdir ./dist --target browser --format esm && bun run build:types",
+    "build:types": "tsc --emitDeclarationOnly --declaration --outDir ./dist",
+    "dev": "bun build ./src/index.ts ./src/worker.ts --outdir ./dist --target browser --format esm --watch"
+  },
+  "peerDependencies": {
+    "@arcote.tech/arc": "workspace:*",
+    "@sqlite.org/sqlite-wasm": "^3.46.0-build1"
+  },
+  "devDependencies": {
+    "@arcote.tech/arc": "workspace:*",
+    "@sqlite.org/sqlite-wasm": "^3.46.0-build1",
+    "typescript": "^5.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export {
+  SQLiteWasmAdapter,
+  SQLiteWasmDatabase,
+  createSQLiteWasmAdapterFactory,
+} from "./sqlite-wasm-adapter";
+export type { WorkerRequest, WorkerResponse } from "./types";

package/src/sqlite-wasm-adapter.ts

@@ -0,0 +1,744 @@
+/**
+ * SQLite WASM Adapter
+ *
+ * Communicates with SQLite running in a Web Worker via postMessage.
+ * Implements the same interface as the server-side SQLite adapter.
+ */
+
+import {
+  type ArcContextAny,
+  type DatabaseAdapter,
+  type DatabaseAgnosticColumnInfo,
+  type DatabaseStoreData,
+  type DatabaseStoreSchema,
+  type DBAdapterFactory,
+  type FindOptions,
+  type ReadTransaction,
+  type ReadWriteTransaction,
+  type StoreColumn,
+  type StoreTable,
+  type WhereCondition,
+  extractDatabaseAgnosticSchema,
+} from "@arcote.tech/arc";
+import type { WorkerRequest, WorkerResponse } from "./types";
+
+/**
+ * Wrapper that communicates with the SQLite Worker
+ */
+export class SQLiteWasmDatabase {
+  private requestId = 0;
+  private pendingRequests = new Map<
+    number,
+    { resolve: (value: any) => void; reject: (error: Error) => void }
+  >();
+  private initialized = false;
+  private initPromise: Promise<void> | null = null;
+
+  constructor(
+    private worker: Worker,
+    private dbName: string,
+  ) {
+    this.worker.onmessage = this.handleMessage.bind(this);
+  }
+
+  private handleMessage(event: MessageEvent<WorkerResponse>) {
+    const response = event.data;
+
+    switch (response.type) {
+      case "init-success":
+        this.initialized = true;
+        break;
+      case "init-error":
+        console.error("[SQLite WASM] Init error:", response.error);
+        break;
+      case "exec-success": {
+        const pending = this.pendingRequests.get(response.id);
+        if (pending) {
+          pending.resolve(response.result);
+          this.pendingRequests.delete(response.id);
+        }
+        break;
+      }
+      case "exec-error": {
+        const pending = this.pendingRequests.get(response.id);
+        if (pending) {
+          pending.reject(new Error(response.error));
+          this.pendingRequests.delete(response.id);
+        }
+        break;
+      }
+      case "execBatch-success": {
+        const pending = this.pendingRequests.get(response.id);
+        if (pending) {
+          pending.resolve(undefined);
+          this.pendingRequests.delete(response.id);
+        }
+        break;
+      }
+      case "execBatch-error": {
+        const pending = this.pendingRequests.get(response.id);
+        if (pending) {
+          pending.reject(new Error(response.error));
+          this.pendingRequests.delete(response.id);
+        }
+        break;
+      }
+    }
+  }
+
+  async init(): Promise<void> {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+
+    this.initPromise = new Promise((resolve, reject) => {
+      const handler = (event: MessageEvent<WorkerResponse>) => {
+        if (event.data.type === "init-success") {
+          this.initialized = true;
+          resolve();
+        } else if (event.data.type === "init-error") {
+          reject(new Error(event.data.error));
+        }
+      };
+
+      this.worker.addEventListener("message", handler, { once: true });
+      this.sendRequest({ type: "init", dbName: this.dbName });
+    });
+
+    return this.initPromise;
+  }
+
+  private sendRequest(request: WorkerRequest) {
+    this.worker.postMessage(request);
+  }
+
+  async exec(sql: string, params?: any[]): Promise<any[]> {
+    await this.init();
+
+    const id = ++this.requestId;
+
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, { resolve, reject });
+      this.sendRequest({ type: "exec", id, sql, params });
+    });
+  }
+
+  async execBatch(
+    queries: Array<{ sql: string; params?: any[] }>,
+  ): Promise<void> {
+    await this.init();
+
+    const id = ++this.requestId;
+
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, { resolve, reject });
+      this.sendRequest({ type: "execBatch", id, queries });
+    });
+  }
+}
+
+class SQLiteWasmReadTransaction implements ReadTransaction {
+  constructor(
+    protected db: SQLiteWasmDatabase,
+    protected tables: Map<string, StoreTable>,
+    protected adapter?: SQLiteWasmAdapter,
+  ) {}
+
+  protected hasSoftDelete(tableName: string): boolean {
+    if (this.adapter) return this.adapter.hasSoftDelete(tableName);
+    const table = this.tables.get(tableName);
+    if (!table) return false;
+    return table.columns.some((col) => col.name === "deleted");
+  }
+
+  protected deserializeValue(value: any, column: StoreColumn): any {
+    if (value === null || value === undefined) return null;
+    switch (column.type.toLowerCase()) {
+      case "json":
+        if (typeof value === "string") {
+          try {
+            return JSON.parse(value);
+          } catch {
+            return value;
+          }
+        }
+        return value;
+      case "text":
+        if (
+          typeof value === "string" &&
+          (value.startsWith("{") || value.startsWith("["))
+        ) {
+          try {
+            const parsed = JSON.parse(value);
+            if (typeof parsed === "object" || Array.isArray(parsed))
+              return parsed;
+          } catch {}
+        }
+        return value;
+      case "datetime":
+      case "timestamp":
+        return new Date(value);
+      default:
+        return value;
+    }
+  }
+
+  protected deserializeRow(row: any, table: StoreTable): any {
+    const result: any = {};
+    for (const column of table.columns) {
+      result[column.name] = this.deserializeValue(row[column.name], column);
+    }
+    return result;
+  }
+
+  protected buildWhereClause(
+    where?: WhereCondition,
+    tableName?: string,
+  ): { sql: string; params: any[] } {
+    const conditions: string[] = [];
+    const params: any[] = [];
+
+    if (tableName && this.hasSoftDelete(tableName)) {
+      conditions.push('"deleted" = 0');
+    }
+
+    if (!where) {
+      return {
+        sql: conditions.length > 0 ? conditions.join(" AND ") : "1=1",
+        params,
+      };
+    }
+
+    Object.entries(where).forEach(([key, value]) => {
+      if (
+        typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !(value instanceof Date)
+      ) {
+        // Check if it's a query operator object like { $eq: ... }
+        const operators = [
+          "$eq",
+          "$ne",
+          "$gt",
+          "$gte",
+          "$lt",
+          "$lte",
+          "$in",
+          "$nin",
+          "$exists",
+        ];
+        const isOperatorObject = Object.keys(value).some((k) =>
+          operators.includes(k),
+        );
+
+        if (isOperatorObject) {
+          Object.entries(value as Record<string, unknown>).forEach(
+            ([operator, operand]) => {
+              switch (operator) {
+                case "$eq":
+                case "$ne":
+                case "$gt":
+                case "$gte":
+                case "$lt":
+                case "$lte":
+                  conditions.push(
+                    `"${key}" ${this.getOperatorSymbol(operator)} ?`,
+                  );
+                  params.push(this.serializeWhereValue(operand));
+                  break;
+                case "$in":
+                case "$nin":
+                  if (Array.isArray(operand)) {
+                    conditions.push(
+                      `"${key}" ${operator === "$in" ? "IN" : "NOT IN"} (${operand.map(() => "?").join(", ")})`,
+                    );
+                    params.push(
+                      ...operand.map((v) => this.serializeWhereValue(v)),
+                    );
+                  }
+                  break;
+                case "$exists":
+                  if (typeof operand === "boolean") {
+                    conditions.push(
+                      operand ? `"${key}" IS NOT NULL` : `"${key}" IS NULL`,
+                    );
+                  }
+                  break;
+              }
+            },
+          );
+        } else {
+          // It's a regular object value, serialize it
+          conditions.push(`"${key}" = ?`);
+          params.push(this.serializeWhereValue(value));
+        }
+      } else {
+        conditions.push(`"${key}" = ?`);
+        params.push(this.serializeWhereValue(value));
+      }
+    });
+
+    return { sql: conditions.join(" AND "), params };
+  }
+
+  protected getOperatorSymbol(operator: string): string {
+    const operators: Record<string, string> = {
+      $eq: "=",
+      $ne: "!=",
+      $gt: ">",
+      $gte: ">=",
+      $lt: "<",
+      $lte: "<=",
+    };
+    return operators[operator] || "=";
+  }
+
+  /**
+   * Serialize a value for use in WHERE clause params
+   * Handles Date objects and other non-primitive types
+   */
+  protected serializeWhereValue(value: any): any {
+    if (value === null || value === undefined) return null;
+    if (value instanceof Date) return value.toISOString();
+    if (Array.isArray(value) || typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return value;
+  }
+
+  protected buildOrderByClause(
+    orderBy?: Record<string, "asc" | "desc">,
+  ): string {
+    if (!orderBy) return "";
+    const orderClauses = Object.entries(orderBy)
+      .map(([key, direction]) => `"${key}" ${direction.toUpperCase()}`)
+      .join(", ");
+    return orderClauses ? `ORDER BY ${orderClauses}` : "";
+  }
+
+  async find<T>(store: string, options: FindOptions<T>): Promise<T[]> {
+    const { where, limit, offset, orderBy } = options || {};
+    const whereClause = this.buildWhereClause(where, store);
+    const orderByClause = this.buildOrderByClause(orderBy);
+    const table = this.tables.get(store);
+
+    if (!table) throw new Error(`Store ${store} not found`);
+
+    const query = `SELECT * FROM "${table.name}" WHERE ${whereClause.sql} ${orderByClause} ${limit ? `LIMIT ${limit}` : ""} ${offset ? `OFFSET ${offset}` : ""}`;
+    const rows = await this.db.exec(query, whereClause.params);
+    return rows.map((row: any) => this.deserializeRow(row, table));
+  }
+}
+
+class SQLiteWasmReadWriteTransaction
+  extends SQLiteWasmReadTransaction
+  implements ReadWriteTransaction
+{
+  private queries: Array<{ sql: string; params?: any[] }> = [];
+
+  constructor(
+    db: SQLiteWasmDatabase,
+    tables: Map<string, StoreTable>,
+    protected adapter: SQLiteWasmAdapter,
+  ) {
+    super(db, tables, adapter);
+  }
+
+  async remove(store: string, id: any) {
+    const table = this.tables.get(store);
+    if (!table) throw new Error(`Store ${store} not found`);
+
+    // Check if table has soft delete enabled
+    const hasSoftDelete = this.adapter.hasSoftDelete(store);
+
+    if (hasSoftDelete) {
+      // Soft delete: set deleted flag
+      this.queries.push({
+        sql: `UPDATE "${table.name}" SET "deleted" = 1, "lastUpdate" = ? WHERE "${table.primaryKey}" = ?`,
+        params: [new Date().toISOString(), id],
+      });
+    } else {
+      // Hard delete: actually remove the row
+      this.queries.push({
+        sql: `DELETE FROM "${table.name}" WHERE "${table.primaryKey}" = ?`,
+        params: [id],
+      });
+    }
+  }
+
+  async set(store: string, item: any) {
+    const table = this.tables.get(store);
+    if (!table) throw new Error(`Store ${store} not found`);
+
+    if (this.adapter.hasVersioning(store)) {
+      await this.setWithVersioning(store, item, table);
+    } else {
+      await this.setWithoutVersioning(store, item, table);
+    }
+  }
+
+  private async setWithoutVersioning(
+    _store: string,
+    item: any,
+    table: StoreTable,
+  ) {
+    const columnNames = table.columns.map((col) => col.name);
+    const values = table.columns.map((column) => {
+      let value = item[column.name];
+      if (value === undefined && column.default !== undefined)
+        value = column.default;
+      return this.serializeValue(value, column);
+    });
+
+    const placeholders = columnNames.map(() => "?").join(", ");
+    this.queries.push({
+      sql: `INSERT OR REPLACE INTO "${table.name}" (${columnNames.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`,
+      params: values,
+    });
+  }
+
+  private async setWithVersioning(store: string, item: any, table: StoreTable) {
+    const regularColumns = table.columns.filter(
+      (col) => col.name !== "__version",
+    );
+    const columnNames = regularColumns.map((col) => col.name);
+    const values = regularColumns.map((column) => {
+      let value = item[column.name];
+      if (value === undefined && column.default !== undefined)
+        value = column.default;
+      return this.serializeValue(value, column);
+    });
+
+    columnNames.push("__version");
+    const placeholders = regularColumns.map(() => "?").join(", ");
+
+    this.queries.push({
+      sql: `
+        WITH next_version AS (
+          INSERT INTO __arc_version_counters (table_name, last_version) VALUES (?, 1)
+          ON CONFLICT(table_name) DO UPDATE SET last_version = last_version + 1
+          RETURNING last_version
+        )
+        INSERT OR REPLACE INTO "${table.name}"
+        (${columnNames.map((c) => `"${c}"`).join(", ")})
+        VALUES (${placeholders}, (SELECT last_version FROM next_version))
+      `,
+      params: [...values, store],
+    });
+  }
+
+  async commit() {
+    if (this.queries.length === 0) return;
+    try {
+      await this.db.execBatch(this.queries);
+      this.queries = [];
+    } catch (error) {
+      this.queries = [];
+      throw error;
+    }
+  }
+
+  private serializeValue(value: any, column: StoreColumn): any {
+    if (value === null || value === undefined) return null;
+
+    // Handle empty objects as null (common issue with JSON parsing)
+    if (
+      typeof value === "object" &&
+      !Array.isArray(value) &&
+      !(value instanceof Date) &&
+      Object.keys(value).length === 0
+    ) {
+      return null;
+    }
+
+    switch (column.type.toLowerCase()) {
+      case "timestamp":
+      case "datetime":
+        if (value instanceof Date) return value.toISOString();
+        if (typeof value === "number")
+          return (
+            value > 1e10 ? new Date(value) : new Date(value * 1000)
+          ).toISOString();
+        if (typeof value === "string") {
+          const date = new Date(value);
+          if (!isNaN(date.getTime())) return date.toISOString();
+        }
+        // If it's an object that's not a Date, convert to null or stringify
+        if (typeof value === "object") {
+          console.warn(
+            `[SQLite WASM] Unexpected object value for timestamp column "${column.name}":`,
+            value,
+          );
+          return null;
+        }
+        return value;
+      case "json":
+        return JSON.stringify(value);
+      default:
+        if (value instanceof Date) return value.toISOString();
+        if (Array.isArray(value) || typeof value === "object")
+          return JSON.stringify(value);
+        return value;
+    }
+  }
+}
+
+export class SQLiteWasmAdapter implements DatabaseAdapter {
+  private tables: Map<string, StoreTable> = new Map();
+  private pendingReinitTables: Array<{
+    tableName: string;
+    reinitFn: (tableName: string, dataStorage: any) => Promise<void>;
+  }> = [];
+
+  private mapType(arcType: string, storeData?: DatabaseStoreData): string {
+    if (storeData?.databaseType?.sqlite) return storeData.databaseType.sqlite;
+    switch (arcType) {
+      case "string":
+      case "id":
+      case "customId":
+      case "stringEnum":
+        return "TEXT";
+      case "number":
+        return "INTEGER";
+      case "boolean":
+        return "INTEGER";
+      case "date":
+        return "TIMESTAMP";
+      case "object":
+      case "array":
+      case "record":
+        return "JSON";
+      case "blob":
+        return "BLOB";
+      default:
+        return "TEXT";
+    }
+  }
+
+  private buildConstraints(storeData?: DatabaseStoreData): string[] {
+    const constraints: string[] = [];
+    if (storeData?.isPrimaryKey) constraints.push("PRIMARY KEY");
+    if (storeData?.isAutoIncrement) constraints.push("AUTOINCREMENT");
+    if (storeData?.isUnique) constraints.push("UNIQUE");
+    if (storeData?.foreignKey) {
+      const { table, column, onDelete, onUpdate } = storeData.foreignKey;
+      let fk = `REFERENCES ${table}(${column})`;
+      if (onDelete) fk += ` ON DELETE ${onDelete}`;
+      if (onUpdate) fk += ` ON UPDATE ${onUpdate}`;
+      constraints.push(fk);
+    }
+    return constraints;
+  }
+
+  private generateColumnSQL(
+    columnInfo: DatabaseAgnosticColumnInfo & { name: string },
+  ): string {
+    const type = this.mapType(columnInfo.type, columnInfo.storeData);
+    const constraints: string[] = [];
+    if (!columnInfo.storeData?.isNullable) constraints.push("NOT NULL");
+    constraints.push(...this.buildConstraints(columnInfo.storeData));
+    if (columnInfo.defaultValue !== undefined) {
+      if (typeof columnInfo.defaultValue === "string")
+        constraints.push(`DEFAULT '${columnInfo.defaultValue}'`);
+      else constraints.push(`DEFAULT ${columnInfo.defaultValue}`);
+    }
+    return `"${columnInfo.name}" ${type} ${constraints.join(" ")}`.trim();
+  }
+
+  private generateCreateTableSQL(
+    tableName: string,
+    columns: (DatabaseAgnosticColumnInfo & { name: string })[],
+  ): string {
+    const columnDefinitions = columns.map((col) => this.generateColumnSQL(col));
+    const indexes = columns
+      .filter((col) => col.storeData?.hasIndex && !col.storeData?.isPrimaryKey)
+      .map(
+        (col) =>
+          `CREATE INDEX IF NOT EXISTS idx_${tableName}_${col.name} ON "${tableName}"("${col.name}");`,
+      );
+    let sql = `CREATE TABLE IF NOT EXISTS "${tableName}" (\n  ${columnDefinitions.join(",\n  ")}\n)`;
+    if (indexes.length > 0) sql += ";\n" + indexes.join("\n");
+    return sql;
+  }
+
+  constructor(
+    private db: SQLiteWasmDatabase,
+    private context: ArcContextAny,
+  ) {
+    this.context.elements.forEach((element) => {
+      if (
+        "databaseStoreSchema" in element &&
+        typeof element.databaseStoreSchema === "function"
+      ) {
+        const databaseSchema =
+          element.databaseStoreSchema() as DatabaseStoreSchema;
+        databaseSchema.tables.forEach((dbTable) => {
+          const agnosticSchema = extractDatabaseAgnosticSchema(
+            dbTable.schema,
+            dbTable.name,
+          );
+          const columns = agnosticSchema.columns.map((columnInfo) => ({
+            name: columnInfo.name,
+            type: this.mapType(columnInfo.type, columnInfo.storeData),
+            constraints: this.buildConstraints(columnInfo.storeData),
+            isNullable: columnInfo.storeData?.isNullable || false,
+            defaultValue: columnInfo.defaultValue,
+            isPrimaryKey: columnInfo.storeData?.isPrimaryKey || false,
+          }));
+          const legacyTable: StoreTable = {
+            name: dbTable.name,
+            primaryKey: columns.find((col) => col.isPrimaryKey)?.name || "_id",
+            columns: columns.map((col) => ({
+              name: col.name,
+              type: col.type,
+              isOptional: col.isNullable,
+              default: col.defaultValue,
+            })),
+          };
+          this.tables.set(dbTable.name, legacyTable);
+        });
+      }
+    });
+  }
+
+  public async initialize() {
+    await this.db.init();
+    await this.createVersionCounterTable();
+    await this.createTableVersionsTable();
+
+    const processedSchemas = new Set<DatabaseStoreSchema>();
+    const processedTables = new Set<string>();
+
+    for (const element of this.context.elements) {
+      if (
+        "databaseStoreSchema" in element &&
+        typeof element.databaseStoreSchema === "function"
+      ) {
+        const databaseSchema =
+          element.databaseStoreSchema() as DatabaseStoreSchema;
+
+        if (processedSchemas.has(databaseSchema)) continue;
+        processedSchemas.add(databaseSchema);
+
+        for (const dbTable of databaseSchema.tables) {
+          const tableKey = dbTable.version
+            ? `${dbTable.name}_v${dbTable.version}`
+            : dbTable.name;
+          if (!processedTables.has(tableKey)) {
+            const agnosticSchema = extractDatabaseAgnosticSchema(
+              dbTable.schema,
+              dbTable.name,
+            );
+            let allColumns = [...agnosticSchema.columns];
+            if (dbTable.options?.versioning)
+              allColumns.push({
+                name: "__version",
+                type: "number",
+                storeData: { isNullable: false, hasIndex: true },
+                defaultValue: 1,
+              });
+            if (dbTable.options?.softDelete)
+              allColumns.push({
+                name: "deleted",
+                type: "boolean",
+                storeData: { isNullable: false, hasIndex: true },
+                defaultValue: false,
+              });
+
+            const physicalTableName = this.getPhysicalTableName(
+              dbTable.name,
+              dbTable.version,
+            );
+            await this.createTableIfNotExistsNew(physicalTableName, allColumns);
+
+            // Store reinit function for later execution (only for versioned tables)
+            // reinitTable rebuilds views from events when schema version changes
+            if (dbTable.version && databaseSchema.reinitTable) {
+              this.pendingReinitTables.push({
+                tableName: physicalTableName,
+                reinitFn: databaseSchema.reinitTable,
+              });
+            }
+
+            const legacyTable: StoreTable = {
+              name: physicalTableName,
+              primaryKey:
+                allColumns.find((col) => col.storeData?.isPrimaryKey)?.name ||
+                "_id",
+              columns: allColumns.map((col) => ({
+                name: col.name,
+                type: this.mapType(col.type, col.storeData),
+                isOptional: col.storeData?.isNullable || false,
+                default: col.defaultValue,
+              })),
+            };
+            this.tables.set(dbTable.name, legacyTable);
+            processedTables.add(tableKey);
+          }
+        }
+      }
+    }
+  }
+
+  private async createTableIfNotExistsNew(
+    tableName: string,
+    columns: (DatabaseAgnosticColumnInfo & { name: string })[],
+  ) {
+    await this.db.exec(this.generateCreateTableSQL(tableName, columns));
+  }
+
+  private async createVersionCounterTable() {
+    await this.db.exec(
+      `CREATE TABLE IF NOT EXISTS __arc_version_counters (table_name TEXT PRIMARY KEY, last_version INTEGER NOT NULL DEFAULT 0)`,
+    );
+  }
+
+  private async createTableVersionsTable() {
+    await this.db.exec(
+      `CREATE TABLE IF NOT EXISTS __arc_table_versions (table_name TEXT NOT NULL, version INTEGER NOT NULL, physical_table_name TEXT NOT NULL, created_at DATETIME DEFAULT CURRENT_TIMESTAMP, is_active INTEGER DEFAULT 0, PRIMARY KEY (table_name, version))`,
+    );
+  }
+
+  private getPhysicalTableName(logicalName: string, version?: number): string {
+    return version ? `${logicalName}_v${version}` : logicalName;
+  }
+
+  public hasVersioning(tableName: string): boolean {
+    const table = this.tables.get(tableName);
+    return table
+      ? table.columns.some((col) => col.name === "__version")
+      : false;
+  }
+
+  public hasSoftDelete(tableName: string): boolean {
+    const table = this.tables.get(tableName);
+    return table ? table.columns.some((col) => col.name === "deleted") : false;
+  }
+
+  public async executeReinitTables(dataStorage: any): Promise<void> {
+    for (const { tableName, reinitFn } of this.pendingReinitTables) {
+      await reinitFn(tableName, dataStorage);
+    }
+    this.pendingReinitTables = [];
+  }
+
+  readWriteTransaction(_stores?: string[]) {
+    return new SQLiteWasmReadWriteTransaction(this.db, this.tables, this);
+  }
+  readTransaction(_stores?: string[]) {
+    return new SQLiteWasmReadTransaction(this.db, this.tables, this);
+  }
+}
+
+export const createSQLiteWasmAdapterFactory = (
+  worker: Worker,
+  dbName: string,
+): DBAdapterFactory => {
+  const db = new SQLiteWasmDatabase(worker, dbName);
+
+  return async (context: ArcContextAny): Promise<DatabaseAdapter> => {
+    const adapter = new SQLiteWasmAdapter(db, context);
+    await adapter.initialize();
+    return adapter;
+  };
+};

package/src/types.ts

@@ -0,0 +1,20 @@
+/**
+ * Message types for Worker <-> Main thread communication
+ */
+
+export type WorkerRequest =
+  | { type: "init"; dbName: string }
+  | { type: "exec"; id: number; sql: string; params?: any[] }
+  | {
+      type: "execBatch";
+      id: number;
+      queries: Array<{ sql: string; params?: any[] }>;
+    };
+
+export type WorkerResponse =
+  | { type: "init-success" }
+  | { type: "init-error"; error: string }
+  | { type: "exec-success"; id: number; result: any[] }
+  | { type: "exec-error"; id: number; error: string }
+  | { type: "execBatch-success"; id: number }
+  | { type: "execBatch-error"; id: number; error: string };

package/src/worker.ts

@@ -0,0 +1,124 @@
+/**
+ * SQLite WASM Worker
+ *
+ * This worker runs SQLite in a Web Worker using OPFS for persistence.
+ * Communication happens via postMessage.
+ *
+ * Usage in app:
+ * ```typescript
+ * import SQLiteWorker from '@arcote.tech/arc-adapter-db-sqlite-wasm/worker?worker'
+ * const worker = new SQLiteWorker()
+ * ```
+ */
+
+import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
+import type { WorkerRequest, WorkerResponse } from "./types";
+
+let db: any = null;
+
+const sendResponse = (response: WorkerResponse) => {
+  self.postMessage(response);
+};
+
+const handleInit = async (dbName: string) => {
+  try {
+    const sqlite3 = await sqlite3InitModule({
+      print: console.log,
+      printErr: console.error,
+    });
+
+    console.log(
+      `[SQLite Worker] Running SQLite3 version ${sqlite3.version.libVersion}`,
+    );
+
+    // Use OPFS for persistent storage
+    db = new sqlite3.oo1.DB(`file:${dbName}?vfs=opfs`, "ct");
+
+    sendResponse({ type: "init-success" });
+  } catch (error) {
+    sendResponse({ type: "init-error", error: (error as Error).message });
+  }
+};
+
+const handleExec = (id: number, sql: string, params?: any[]) => {
+  try {
+    if (!db) {
+      throw new Error("Database not initialized");
+    }
+
+    let result: any[];
+
+    if (params && params.length > 0) {
+      // Pass params as array directly - SQLite WASM handles ? placeholders with arrays
+      result = db.exec({
+        sql,
+        bind: params,
+        rowMode: "object",
+        returnValue: "resultRows",
+      });
+    } else {
+      result = db.exec({
+        sql,
+        rowMode: "object",
+        returnValue: "resultRows",
+      });
+    }
+
+    sendResponse({ type: "exec-success", id, result: result || [] });
+  } catch (error) {
+    sendResponse({ type: "exec-error", id, error: (error as Error).message });
+  }
+};
+
+const handleExecBatch = (
+  id: number,
+  queries: Array<{ sql: string; params?: any[] }>,
+) => {
+  try {
+    if (!db) {
+      throw new Error("Database not initialized");
+    }
+
+    // Execute all queries in a transaction
+    db.exec("BEGIN TRANSACTION");
+
+    try {
+      for (const query of queries) {
+        if (query.params && query.params.length > 0) {
+          // Pass params as array directly
+          db.exec({ sql: query.sql, bind: query.params });
+        } else {
+          db.exec(query.sql);
+        }
+      }
+
+      db.exec("COMMIT");
+      sendResponse({ type: "execBatch-success", id });
+    } catch (error) {
+      db.exec("ROLLBACK");
+      throw error;
+    }
+  } catch (error) {
+    sendResponse({
+      type: "execBatch-error",
+      id,
+      error: (error as Error).message,
+    });
+  }
+};
+
+self.onmessage = (event: MessageEvent<WorkerRequest>) => {
+  const request = event.data;
+
+  switch (request.type) {
+    case "init":
+      handleInit(request.dbName);
+      break;
+    case "exec":
+      handleExec(request.id, request.sql, request.params);
+      break;
+    case "execBatch":
+      handleExecBatch(request.id, request.queries);
+      break;
+  }
+};

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable", "WebWorker"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}