@powersync/web 1.12.2 → 1.13.0

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

@@ -1,193 +0,0 @@
-import '@journeyapps/wa-sqlite';
-import * as SQLite from '@journeyapps/wa-sqlite';
-import { Mutex } from 'async-mutex';
-import * as Comlink from 'comlink';
-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);
-    /**
-     * Register the PowerSync core SQLite extension
-     */
-    module.ccall('powersync_init_static', 'int', []);
-    const { IDBBatchAtomicVFS } = await import('@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js');
-    // @ts-expect-error The types for this static method are missing upstream
-    const vfs = await IDBBatchAtomicVFS.create(dbFileName, module, { lockPolicy: 'exclusive' });
-    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.update_hook(db, (updateType, dbName, tableName) => {
-        if (!tableName) {
-            return;
-        }
-        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;
-            try {
-                await executeSingleStatement('BEGIN TRANSACTION');
-                const wrappedBindings = bindings ? bindings : [];
-                for await (const stmt of sqlite3.statements(db, sql)) {
-                    if (stmt === null) {
-                        return {
-                            rowsAffected: 0,
-                            rows: { _array: [], length: 0 }
-                        };
-                    }
-                    //Prepare statement once
-                    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;
-                            }
-                        }
-                        if (bindings) {
-                            sqlite3.bind_collection(stmt, binding);
-                        }
-                        const result = await sqlite3.step(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);
-                        }
-                        sqlite3.reset(stmt);
-                    }
-                }
-                await executeSingleStatement('COMMIT');
-            }
-            catch (err) {
-                await executeSingleStatement('ROLLBACK');
-                return {
-                    rowsAffected: 0,
-                    rows: { _array: [], length: 0 }
-                };
-            }
-            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>>];