@powersync/web 0.0.0-dev-20241119081147 → 0.0.0-dev-20241203152232

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powersync/web",
-  "version": "0.0.0-dev-20241119081147",
+  "version": "0.0.0-dev-20241203152232",
   "description": "A Web SDK for JourneyApps PowerSync",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",
@@ -50,19 +50,19 @@
   "author": "JOURNEYAPPS",
   "license": "Apache-2.0",
   "peerDependencies": {
-    "@journeyapps/wa-sqlite": "^0.4.2",
-    "@powersync/common": "^1.21.0"
+    "@journeyapps/wa-sqlite": "^1.0.0",
+    "@powersync/common": "^1.22.0"
   },
   "dependencies": {
     "async-mutex": "^0.4.0",
     "bson": "^6.6.0",
-    "comlink": "^4.4.1",
+    "comlink": "^4.4.2",
     "commander": "^12.1.0",
     "js-logger": "^1.6.1",
-    "@powersync/common": "1.21.0"
+    "@powersync/common": "1.22.0"
   },
   "devDependencies": {
-    "@journeyapps/wa-sqlite": "^0.4.2",
+    "@journeyapps/wa-sqlite": "^1.0.0",
     "@types/uuid": "^9.0.6",
     "@vitest/browser": "^2.1.4",
     "crypto-browserify": "^3.12.0",

package/lib/src/shared/open-db.d.ts

@@ -1,5 +0,0 @@
-import '@journeyapps/wa-sqlite';
-import type { DBFunctionsInterface } from './types';
-export declare function _openDB(dbFileName: string, options?: {
-    useWebWorker: boolean;
-}): Promise<DBFunctionsInterface>;

package/lib/src/shared/open-db.js

@@ -1,192 +0,0 @@
-import * as SQLite from '@journeyapps/wa-sqlite';
-import '@journeyapps/wa-sqlite';
-import * as Comlink from 'comlink';
-import { Mutex } from 'async-mutex';
-let nextId = 1;
-export async function _openDB(dbFileName, options = { useWebWorker: true }) {
-    const { default: moduleFactory } = await import('@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs');
-    const module = await moduleFactory();
-    const sqlite3 = SQLite.Factory(module);
-    const { IDBBatchAtomicVFS } = await import('@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js');
-    const vfs = new IDBBatchAtomicVFS(dbFileName);
-    sqlite3.vfs_register(vfs, true);
-    const db = await sqlite3.open_v2(dbFileName);
-    const statementMutex = new Mutex();
-    /**
-     * Listeners are exclusive to the DB connection.
-     */
-    const listeners = new Map();
-    let updatedTables = new Set();
-    let updateTimer = null;
-    function fireUpdates() {
-        updateTimer = null;
-        const event = { tables: [...updatedTables], groupedUpdates: {}, rawUpdates: [] };
-        updatedTables.clear();
-        Array.from(listeners.values()).forEach((l) => l(event));
-    }
-    sqlite3.register_table_onchange_hook(db, (opType, tableName, rowId) => {
-        updatedTables.add(tableName);
-        if (updateTimer == null) {
-            updateTimer = setTimeout(fireUpdates, 0);
-        }
-    });
-    /**
-     * This executes single SQL statements inside a requested lock.
-     */
-    const execute = async (sql, bindings) => {
-        // Running multiple statements on the same connection concurrently should not be allowed
-        return _acquireExecuteLock(async () => {
-            return executeSingleStatement(sql, bindings);
-        });
-    };
-    /**
-     * This requests a lock for executing statements.
-     * Should only be used internally.
-     */
-    const _acquireExecuteLock = (callback) => {
-        return statementMutex.runExclusive(callback);
-    };
-    /**
-     * This executes a single statement using SQLite3.
-     */
-    const executeSingleStatement = async (sql, bindings) => {
-        const results = [];
-        for await (const stmt of sqlite3.statements(db, sql)) {
-            let columns;
-            const wrappedBindings = bindings ? [bindings] : [[]];
-            for (const binding of wrappedBindings) {
-                // TODO not sure why this is needed currently, but booleans break
-                binding.forEach((b, index, arr) => {
-                    if (typeof b == 'boolean') {
-                        arr[index] = b ? 1 : 0;
-                    }
-                });
-                sqlite3.reset(stmt);
-                if (bindings) {
-                    sqlite3.bind_collection(stmt, binding);
-                }
-                const rows = [];
-                while ((await sqlite3.step(stmt)) === SQLite.SQLITE_ROW) {
-                    const row = sqlite3.row(stmt);
-                    rows.push(row);
-                }
-                columns = columns ?? sqlite3.column_names(stmt);
-                if (columns.length) {
-                    results.push({ columns, rows });
-                }
-            }
-            // When binding parameters, only a single statement is executed.
-            if (bindings) {
-                break;
-            }
-        }
-        const rows = [];
-        for (const resultset of results) {
-            for (const row of resultset.rows) {
-                const outRow = {};
-                resultset.columns.forEach((key, index) => {
-                    outRow[key] = row[index];
-                });
-                rows.push(outRow);
-            }
-        }
-        const result = {
-            insertId: sqlite3.last_insert_id(db),
-            rowsAffected: sqlite3.changes(db),
-            rows: {
-                _array: rows,
-                length: rows.length
-            }
-        };
-        return result;
-    };
-    /**
-     * This executes SQL statements in a batch.
-     */
-    const executeBatch = async (sql, bindings) => {
-        return _acquireExecuteLock(async () => {
-            let affectedRows = 0;
-            const str = sqlite3.str_new(db, sql);
-            const query = sqlite3.str_value(str);
-            try {
-                await executeSingleStatement('BEGIN TRANSACTION');
-                //Prepare statement once
-                const prepared = await sqlite3.prepare_v2(db, query);
-                if (prepared === null) {
-                    return {
-                        rowsAffected: 0,
-                        rows: { _array: [], length: 0 }
-                    };
-                }
-                const wrappedBindings = bindings ? bindings : [];
-                for (const binding of wrappedBindings) {
-                    // TODO not sure why this is needed currently, but booleans break
-                    for (let i = 0; i < binding.length; i++) {
-                        const b = binding[i];
-                        if (typeof b == 'boolean') {
-                            binding[i] = b ? 1 : 0;
-                        }
-                    }
-                    //Reset bindings
-                    sqlite3.reset(prepared.stmt);
-                    if (bindings) {
-                        sqlite3.bind_collection(prepared.stmt, binding);
-                    }
-                    const result = await sqlite3.step(prepared.stmt);
-                    if (result === SQLite.SQLITE_DONE) {
-                        //The value returned by sqlite3_changes() immediately after an INSERT, UPDATE or DELETE statement run on a view is always zero.
-                        affectedRows += sqlite3.changes(db);
-                    }
-                }
-                //Finalize prepared statement
-                await sqlite3.finalize(prepared.stmt);
-                await executeSingleStatement('COMMIT');
-            }
-            catch (err) {
-                await executeSingleStatement('ROLLBACK');
-                return {
-                    rowsAffected: 0,
-                    rows: { _array: [], length: 0 }
-                };
-            }
-            finally {
-                sqlite3.str_finish(str);
-            }
-            const result = {
-                rowsAffected: affectedRows,
-                rows: { _array: [], length: 0 }
-            };
-            return result;
-        });
-    };
-    if (options.useWebWorker) {
-        const registerOnTableChange = (callback) => {
-            const id = nextId++;
-            listeners.set(id, callback);
-            return Comlink.proxy(() => {
-                listeners.delete(id);
-            });
-        };
-        return {
-            execute: Comlink.proxy(execute),
-            executeBatch: Comlink.proxy(executeBatch),
-            registerOnTableChange: Comlink.proxy(registerOnTableChange),
-            close: Comlink.proxy(() => {
-                sqlite3.close(db);
-            })
-        };
-    }
-    const registerOnTableChange = (callback) => {
-        const id = nextId++;
-        listeners.set(id, callback);
-        return () => {
-            listeners.delete(id);
-        };
-    };
-    return {
-        execute: execute,
-        executeBatch: executeBatch,
-        registerOnTableChange: registerOnTableChange,
-        close: () => sqlite3.close(db)
-    };
-}

package/lib/src/shared/types.d.ts

@@ -1,22 +0,0 @@
-import type { BatchedUpdateNotification, QueryResult } from '@powersync/common';
-export type WASQLExecuteResult = Omit<QueryResult, 'rows'> & {
-    rows: {
-        _array: any[];
-        length: number;
-    };
-};
-export type DBFunctionsInterface = {
-    close?: () => void;
-    execute: WASQLiteExecuteMethod;
-    executeBatch: WASQLiteExecuteBatchMethod;
-    registerOnTableChange: (callback: OnTableChangeCallback) => void;
-};
-/**
- * @deprecated use [DBFunctionsInterface instead]
- */
-export type DBWorkerInterface = DBFunctionsInterface;
-export type WASQLiteExecuteMethod = (sql: string, params?: any[]) => Promise<WASQLExecuteResult>;
-export type WASQLiteExecuteBatchMethod = (sql: string, params?: any[]) => Promise<WASQLExecuteResult>;
-export type OnTableChangeCallback = (event: BatchedUpdateNotification) => void;
-export type OpenDB = (dbFileName: string) => DBWorkerInterface;
-export type SQLBatchTuple = [string] | [string, Array<any> | Array<Array<any>>];