@arcote.tech/arc-adapter-db-sqlite-wasm 0.5.6 → 0.5.8

package/dist/index.d.ts

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

package/dist/index.js

@@ -5273,6 +5273,30 @@ class SQLiteWasmAdapter {
   }
   async createTableIfNotExistsNew(tableName, columns) {
     await this.db.exec(this.generateCreateTableSQL(tableName, columns));
+    await this.addMissingColumns(tableName, columns);
+  }
+  async addMissingColumns(tableName, columns) {
+    const existing = await this.db.exec(`PRAGMA table_info("${tableName}")`);
+    const existingNames = new Set(existing.map((row) => row.name));
+    for (const col of columns) {
+      if (existingNames.has(col.name))
+        continue;
+      const sql = this.generateAlterAddColumnSQL(tableName, col);
+      await this.db.exec(sql);
+    }
+  }
+  generateAlterAddColumnSQL(tableName, col) {
+    const type = this.mapType(col.type, col.storeData);
+    const constraints = [];
+    if (col.defaultValue !== undefined) {
+      const def = typeof col.defaultValue === "string" ? `'${col.defaultValue.replace(/'/g, "''")}'` : String(col.defaultValue);
+      constraints.push(`DEFAULT ${def}`);
+    }
+    if (!col.storeData?.isNullable && col.defaultValue === undefined) {} else if (!col.storeData?.isNullable) {
+      constraints.push("NOT NULL");
+    }
+    const constraintsSql = constraints.length ? " " + constraints.join(" ") : "";
+    return `ALTER TABLE "${tableName}" ADD COLUMN "${col.name}" ${type}${constraintsSql}`;
   }
   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)`);

package/dist/sqlite-wasm-adapter.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 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 DBAdapterFactory, type FindOptions, type ReadTransaction, type ReadWriteTransaction, type StoreColumn, type StoreTable, type WhereCondition } from "@arcote.tech/arc";
+/**
+ * Wrapper that communicates with the SQLite Worker
+ */
+export declare class SQLiteWasmDatabase {
+    private worker;
+    private dbName;
+    private requestId;
+    private pendingRequests;
+    private initialized;
+    private initPromise;
+    constructor(worker: Worker, dbName: string);
+    private handleMessage;
+    init(): Promise<void>;
+    private sendRequest;
+    exec(sql: string, params?: any[]): Promise<any[]>;
+    execBatch(queries: Array<{
+        sql: string;
+        params?: any[];
+    }>): Promise<void>;
+}
+declare class SQLiteWasmReadTransaction implements ReadTransaction {
+    protected db: SQLiteWasmDatabase;
+    protected tables: Map<string, StoreTable>;
+    protected adapter?: SQLiteWasmAdapter;
+    constructor(db: SQLiteWasmDatabase, tables: Map<string, StoreTable>, adapter?: SQLiteWasmAdapter);
+    protected hasSoftDelete(tableName: string): boolean;
+    protected deserializeValue(value: any, column: StoreColumn): any;
+    protected deserializeRow(row: any, table: StoreTable): any;
+    protected buildWhereClause(where?: WhereCondition, tableName?: string): {
+        sql: string;
+        params: any[];
+    };
+    protected getOperatorSymbol(operator: string): string;
+    /**
+     * Serialize a value for use in WHERE clause params
+     * Handles Date objects and other non-primitive types
+     */
+    protected serializeWhereValue(value: any): any;
+    protected buildOrderByClause(orderBy?: Record<string, "asc" | "desc">): string;
+    find<T>(store: string, options: FindOptions<T>): Promise<T[]>;
+}
+declare class SQLiteWasmReadWriteTransaction extends SQLiteWasmReadTransaction implements ReadWriteTransaction {
+    protected adapter: SQLiteWasmAdapter;
+    private queries;
+    constructor(db: SQLiteWasmDatabase, tables: Map<string, StoreTable>, adapter: SQLiteWasmAdapter);
+    remove(store: string, id: any): Promise<void>;
+    set(store: string, item: any): Promise<void>;
+    private setWithoutVersioning;
+    private setWithVersioning;
+    commit(): Promise<void>;
+    private serializeValue;
+}
+export declare class SQLiteWasmAdapter implements DatabaseAdapter {
+    private db;
+    private context;
+    private tables;
+    private pendingReinitTables;
+    private mapType;
+    private buildConstraints;
+    private generateColumnSQL;
+    private generateCreateTableSQL;
+    constructor(db: SQLiteWasmDatabase, context: ArcContextAny);
+    initialize(): Promise<void>;
+    private createTableIfNotExistsNew;
+    private createVersionCounterTable;
+    private createTableVersionsTable;
+    private getPhysicalTableName;
+    hasVersioning(tableName: string): boolean;
+    hasSoftDelete(tableName: string): boolean;
+    executeReinitTables(dataStorage: any): Promise<void>;
+    readWriteTransaction(_stores?: string[]): SQLiteWasmReadWriteTransaction;
+    readTransaction(_stores?: string[]): SQLiteWasmReadTransaction;
+}
+export declare const createSQLiteWasmAdapterFactory: (worker: Worker, dbName: string) => DBAdapterFactory;
+export {};

package/dist/types.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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/dist/worker.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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()
+ * ```
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcote.tech/arc-adapter-db-sqlite-wasm",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -17,13 +17,29 @@
       "types": "./dist/worker.d.ts"
     }
   },
+  "arc": {
+    "browserAssets": [
+      {
+        "from": "./dist/worker.js",
+        "to": "sqlite-worker.js"
+      },
+      {
+        "from": "@sqlite.org/sqlite-wasm/sqlite-wasm/jswasm/sqlite3.wasm",
+        "to": "sqlite3.wasm"
+      },
+      {
+        "from": "@sqlite.org/sqlite-wasm/sqlite-wasm/jswasm/sqlite3-opfs-async-proxy.js",
+        "to": "sqlite3-opfs-async-proxy.js"
+      }
+    ]
+  },
   "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": "^0.5.6",
+    "@arcote.tech/arc": "^0.5.8",
     "@sqlite.org/sqlite-wasm": "^3.46.0-build1"
   },
   "devDependencies": {