@powersync/web 0.0.0-dev-20240712065121 → 0.0.0-dev-20240715085239

package/lib/src/db/sync/SharedWebStreamingSyncImplementation.js

@@ -1,103 +1,90 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import * as Comlink from 'comlink';
 import { WebStreamingSyncImplementation } from './WebStreamingSyncImplementation';
 import { SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation';
 import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
 import { openWorkerDatabasePort } from '../../worker/db/open-worker-database';
+import SharedSyncImplementationWorker from '../../worker/sync/SharedSyncImplementation.worker?sharedworker&inline';
 /**
  * The shared worker will trigger methods on this side of the message port
  * via this client provider.
  */
 class SharedSyncClientProvider extends AbstractSharedSyncClientProvider {
+    options;
+    statusChanged;
     constructor(options, statusChanged) {
         super();
         this.options = options;
         this.statusChanged = statusChanged;
     }
-    fetchCredentials() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const credentials = yield this.options.remote.getCredentials();
-            if (credentials == null) {
-                return null;
-            }
-            /**
-             * The credentials need to be serializable.
-             * Users might extend [PowerSyncCredentials] to contain
-             * items which are not serializable.
-             * This returns only the essential fields.
-             */
-            return {
-                endpoint: credentials.endpoint,
-                token: credentials.token,
-                expiresAt: credentials.expiresAt
-            };
-        });
+    async fetchCredentials() {
+        const credentials = await this.options.remote.getCredentials();
+        if (credentials == null) {
+            return null;
+        }
+        /**
+         * The credentials need to be serializable.
+         * Users might extend [PowerSyncCredentials] to contain
+         * items which are not serializable.
+         * This returns only the essential fields.
+         */
+        return {
+            endpoint: credentials.endpoint,
+            token: credentials.token,
+            expiresAt: credentials.expiresAt
+        };
     }
-    uploadCrud() {
-        return __awaiter(this, void 0, void 0, function* () {
-            /**
-             * Don't return anything here, just incase something which is not
-             * serializable is returned from the `uploadCrud` function.
-             */
-            yield this.options.uploadCrud();
-        });
+    async uploadCrud() {
+        /**
+         * Don't return anything here, just incase something which is not
+         * serializable is returned from the `uploadCrud` function.
+         */
+        await this.options.uploadCrud();
     }
     get logger() {
         return this.options.logger;
     }
     trace(...x) {
-        var _a;
-        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.trace(...x);
+        this.logger?.trace(...x);
     }
     debug(...x) {
-        var _a;
-        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(...x);
+        this.logger?.debug(...x);
     }
     info(...x) {
-        var _a;
-        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info(...x);
+        this.logger?.info(...x);
     }
     log(...x) {
-        var _a;
-        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.log(...x);
+        this.logger?.log(...x);
     }
     warn(...x) {
-        var _a;
-        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.warn(...x);
+        this.logger?.warn(...x);
     }
     error(...x) {
-        var _a;
-        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error(...x);
+        this.logger?.error(...x);
     }
     time(label) {
-        var _a;
-        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.time(label);
+        this.logger?.time(label);
     }
     timeEnd(label) {
-        var _a;
-        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.timeEnd(label);
+        this.logger?.timeEnd(label);
     }
 }
 export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplementation {
+    syncManager;
+    clientProvider;
+    messagePort;
+    isInitialized;
     constructor(options) {
         super(options);
         /**
          * Configure or connect to the shared sync worker.
          * This worker will manage all syncing operations remotely.
          */
-        const syncWorker = new SharedWorker(new URL('../../worker/sync/SharedSyncImplementation.worker.js', import.meta.url), {
-            /* @vite-ignore */
-            name: `shared-sync-${this.webOptions.identifier}`,
-            type: 'module'
-        });
+        const syncWorker = new SharedSyncImplementationWorker({ name: `shared-sync-${this.webOptions.identifier}` });
+        // new SharedWorker(new URL('../../worker/sync/SharedSyncImplementation.worker.js', import.meta.url), {
+        //   /* @vite-ignore */
+        //   name: `shared-sync-${this.webOptions.identifier}`,
+        //   type: 'module'
+        // });
         this.messagePort = syncWorker.port;
         this.syncManager = Comlink.wrap(this.messagePort);
         this.triggerCrudUpload = this.syncManager.triggerCrudUpload;
@@ -135,53 +122,39 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
      * Starts the sync process, this effectively acts as a call to
      * `connect` if not yet connected.
      */
-    connect(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.waitForReady();
-            return this.syncManager.connect(options);
-        });
-    }
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.waitForReady();
-            return this.syncManager.disconnect();
-        });
-    }
-    getWriteCheckpoint() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.waitForReady();
-            return this.syncManager.getWriteCheckpoint();
-        });
-    }
-    hasCompletedSync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.syncManager.hasCompletedSync();
-        });
-    }
-    dispose() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.waitForReady();
-            // Signal the shared worker that this client is closing its connection to the worker
-            const closeMessagePayload = {
-                event: SharedSyncClientEvent.CLOSE_CLIENT,
-                data: {}
-            };
-            this.messagePort.postMessage(closeMessagePayload);
-            // Release the proxy
-            this.syncManager[Comlink.releaseProxy]();
-        });
-    }
-    waitForReady() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.isInitialized;
-        });
+    async connect(options) {
+        await this.waitForReady();
+        return this.syncManager.connect(options);
+    }
+    async disconnect() {
+        await this.waitForReady();
+        return this.syncManager.disconnect();
+    }
+    async getWriteCheckpoint() {
+        await this.waitForReady();
+        return this.syncManager.getWriteCheckpoint();
+    }
+    async hasCompletedSync() {
+        return this.syncManager.hasCompletedSync();
+    }
+    async dispose() {
+        await this.waitForReady();
+        // Signal the shared worker that this client is closing its connection to the worker
+        const closeMessagePayload = {
+            event: SharedSyncClientEvent.CLOSE_CLIENT,
+            data: {}
+        };
+        this.messagePort.postMessage(closeMessagePayload);
+        // Release the proxy
+        this.syncManager[Comlink.releaseProxy]();
+    }
+    async waitForReady() {
+        return this.isInitialized;
     }
     /**
      * Used in tests to force a connection states
      */
-    _testUpdateStatus(status) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.syncManager['_testUpdateAllStatuses'](status.toJSON());
-        });
+    async _testUpdateStatus(status) {
+        return this.syncManager['_testUpdateAllStatuses'](status.toJSON());
     }
 }

package/lib/src/db/sync/WebRemote.js

@@ -1,25 +1,15 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { AbstractRemote } from '@powersync/common';
 export class WebRemote extends AbstractRemote {
-    getBSON() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._bson) {
-                return this._bson;
-            }
-            /**
-             * Dynamic import to be used only when needed.
-             */
-            const { BSON } = yield import('bson');
-            this._bson = BSON;
+    _bson;
+    async getBSON() {
+        if (this._bson) {
             return this._bson;
-        });
+        }
+        /**
+         * Dynamic import to be used only when needed.
+         */
+        const { BSON } = await import('bson');
+        this._bson = BSON;
+        return this._bson;
     }
 }

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

@@ -1,207 +1,176 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
 import * as SQLite from '@journeyapps/wa-sqlite';
 import '@journeyapps/wa-sqlite';
 import * as Comlink from 'comlink';
 let nextId = 1;
-export function _openDB(dbFileName_1) {
-    return __awaiter(this, arguments, void 0, function* (dbFileName, options = { useWebWorker: true }) {
-        const { default: moduleFactory } = yield import('@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs');
-        const module = yield moduleFactory();
-        const sqlite3 = SQLite.Factory(module);
-        const { IDBBatchAtomicVFS } = yield import('@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js');
-        const vfs = new IDBBatchAtomicVFS(dbFileName);
-        sqlite3.vfs_register(vfs, true);
-        const db = yield sqlite3.open_v2(dbFileName);
-        /**
-         * Listeners are exclusive to the DB connection.
-         */
-        const listeners = new Map();
-        sqlite3.register_table_onchange_hook(db, (opType, tableName, rowId) => {
-            Array.from(listeners.values()).forEach((l) => l(opType, tableName, rowId));
-        });
-        /**
-         * This executes single SQL statements inside a requested lock.
-         */
-        const execute = (sql, bindings) => __awaiter(this, void 0, void 0, function* () {
-            // Running multiple statements on the same connection concurrently should not be allowed
-            return _acquireExecuteLock(() => __awaiter(this, void 0, void 0, function* () {
-                return executeSingleStatement(sql, bindings);
-            }));
+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);
+    /**
+     * Listeners are exclusive to the DB connection.
+     */
+    const listeners = new Map();
+    sqlite3.register_table_onchange_hook(db, (opType, tableName, rowId) => {
+        Array.from(listeners.values()).forEach((l) => l(opType, tableName, rowId));
+    });
+    /**
+     * 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 interanlly.
-         */
-        const _acquireExecuteLock = (callback) => {
-            return navigator.locks.request(`db-execute-${dbFileName}`, callback);
+    };
+    /**
+     * This requests a lock for executing statements.
+     * Should only be used interanlly.
+     */
+    const _acquireExecuteLock = (callback) => {
+        return navigator.locks.request(`db-execute-${dbFileName}`, 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
+            }
         };
-        /**
-         * This executes a single statement using SQLite3.
-         */
-        const executeSingleStatement = (sql, bindings) => __awaiter(this, void 0, void 0, function* () {
-            var _a, e_1, _b, _c;
-            const results = [];
+        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 {
-                for (var _d = true, _e = __asyncValues(sqlite3.statements(db, sql)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const stmt = _c;
-                    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 ((yield sqlite3.step(stmt)) === SQLite.SQLITE_ROW) {
-                            const row = sqlite3.row(stmt);
-                            rows.push(row);
-                        }
-                        columns = columns !== null && columns !== void 0 ? columns : sqlite3.column_names(stmt);
-                        if (columns.length) {
-                            results.push({ columns, rows });
+                await executeSingleStatement('BEGIN TRANSACTION');
+                //Prepare statement once
+                const prepared = await sqlite3.prepare_v2(db, query);
+                if (prepared === null) {
+                    return {
+                        rowsAffected: 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;
                         }
                     }
-                    // When binding parameters, only a single statement is executed.
+                    //Reset bindings
+                    sqlite3.reset(prepared.stmt);
                     if (bindings) {
-                        break;
+                        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 (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                }
-                finally { if (e_1) throw e_1.error; }
+            catch (err) {
+                await executeSingleStatement('ROLLBACK');
+                return {
+                    rowsAffected: 0
+                };
             }
-            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);
-                }
+            finally {
+                sqlite3.str_finish(str);
             }
             const result = {
-                insertId: sqlite3.last_insert_id(db),
-                rowsAffected: sqlite3.changes(db),
-                rows: {
-                    _array: rows,
-                    length: rows.length
-                }
+                rowsAffected: affectedRows
             };
             return result;
         });
-        /**
-         * This executes SQL statements in a batch.
-         */
-        const executeBatch = (sql, bindings) => __awaiter(this, void 0, void 0, function* () {
-            return _acquireExecuteLock(() => __awaiter(this, void 0, void 0, function* () {
-                let affectedRows = 0;
-                const str = sqlite3.str_new(db, sql);
-                const query = sqlite3.str_value(str);
-                try {
-                    yield executeSingleStatement('BEGIN TRANSACTION');
-                    //Prepare statement once
-                    const prepared = yield sqlite3.prepare_v2(db, query);
-                    if (prepared === null) {
-                        return {
-                            rowsAffected: 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 = yield 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
-                    yield sqlite3.finalize(prepared.stmt);
-                    yield executeSingleStatement('COMMIT');
-                }
-                catch (err) {
-                    yield executeSingleStatement('ROLLBACK');
-                    return {
-                        rowsAffected: 0
-                    };
-                }
-                finally {
-                    sqlite3.str_finish(str);
-                }
-                const result = {
-                    rowsAffected: affectedRows
-                };
-                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);
-                })
-            };
-        }
+    };
+    if (options.useWebWorker) {
         const registerOnTableChange = (callback) => {
             const id = nextId++;
             listeners.set(id, callback);
-            return () => {
+            return Comlink.proxy(() => {
                 listeners.delete(id);
-            };
+            });
         };
         return {
-            execute: execute,
-            executeBatch: executeBatch,
-            registerOnTableChange: registerOnTableChange,
-            close: () => sqlite3.close(db)
+            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)
+    };
 }