@powersync/web 0.0.0-dev-20240723112746 → 0.0.0-dev-20240726145618

package/README.md

@@ -4,7 +4,7 @@
 
 # PowerSync SDK for Web
 
-_[PowerSync](https://www.powersync.com) is a Postgres-SQLite sync layer, which helps developers to create local-first real-time reactive apps that work seamlessly both online and offline._
+*[PowerSync](https://www.powersync.com) is a Postgres-SQLite sync layer, which helps developers to create local-first real-time reactive apps that work seamlessly both online and offline.*
 
 This package (`packages/web`) is the PowerSync SDK for JavaScript Web clients. It is an extension of `packages/common`.
 
@@ -28,6 +28,30 @@ Install it in your app with:
 npm install @journeyapps/wa-sqlite
 ```
 
+## Polyfills
+
+### WebSocket Connections: Buffer
+
+Note: Beta Release - WebSockets are currently in a beta release. It should be safe to use in production if sufficient testing is done on the client side.
+
+This SDK connects to a PowerSync instance via HTTP streams (enabled by default) or WebSockets. The WebSocket connection method requires `Buffer` to be available in the global scope. When multiple tabs are used the shared web worker will apply a polyfill in its own scope, but the `Buffer` class should be polyfills in the application for cases where multiple tabs are not supported.
+
+Install a suitable Buffer implementation
+
+```bash
+npm install buffer
+```
+
+Apply it in your application if not yet provided
+
+```Javascript
+import { Buffer } from 'buffer';
+
+if (typeof self.Buffer == 'undefined') {
+  self.Buffer = Buffer;
+}
+```
+
 ## Webpack
 
 See the [example Webpack config](https://github.com/powersync-ja/powersync-js/blob/main/demos/example-webpack/webpack.config.js) for details on polyfills and requirements.

package/lib/src/db/PowerSyncDatabase.d.ts

@@ -1,4 +1,4 @@
-import { type AbstractStreamingSyncImplementation, type PowerSyncBackendConnector, type BucketStorageAdapter, type PowerSyncCloseOptions, type PowerSyncConnectionOptions, AbstractPowerSyncDatabase, DBAdapter, SQLOpenOptions, PowerSyncDatabaseOptionsWithDBAdapter, PowerSyncDatabaseOptionsWithOpenFactory, PowerSyncDatabaseOptionsWithSettings, PowerSyncDatabaseOptions } from '@powersync/common';
+import { type AbstractStreamingSyncImplementation, type BucketStorageAdapter, type PowerSyncBackendConnector, type PowerSyncCloseOptions, type PowerSyncConnectionOptions, AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions, PowerSyncDatabaseOptionsWithDBAdapter, PowerSyncDatabaseOptionsWithOpenFactory, PowerSyncDatabaseOptionsWithSettings } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 import { WebSQLFlags } from './adapters/web-sql-flags';
 export interface WebPowerSyncFlags extends WebSQLFlags {
@@ -42,7 +42,7 @@ export declare class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     constructor(options: WebPowerSyncDatabaseOptionsWithSettings);
     constructor(options: WebPowerSyncDatabaseOptions);
     _initialize(): Promise<void>;
-    protected openDBAdapter(options: SQLOpenOptions): DBAdapter;
+    protected openDBAdapter(options: WebPowerSyncDatabaseOptionsWithSettings): DBAdapter;
     /**
      * Closes the database connection.
      * By default the sync stream client is only disconnected if

package/lib/src/db/PowerSyncDatabase.js

@@ -1,21 +1,23 @@
-import { AbstractPowerSyncDatabase, SqliteBucketStorage, DEFAULT_POWERSYNC_CLOSE_OPTIONS } from '@powersync/common';
+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 { AbstractPowerSyncDatabase, DEFAULT_POWERSYNC_CLOSE_OPTIONS, SqliteBucketStorage } from '@powersync/common';
 import { Mutex } from 'async-mutex';
-import { WebRemote } from './sync/WebRemote';
+import { WASQLiteOpenFactory } from './adapters/wa-sqlite/WASQLiteOpenFactory';
+import { DEFAULT_WEB_SQL_FLAGS, resolveWebSQLFlags } from './adapters/web-sql-flags';
 import { SharedWebStreamingSyncImplementation } from './sync/SharedWebStreamingSyncImplementation';
 import { SSRStreamingSyncImplementation } from './sync/SSRWebStreamingSyncImplementation';
+import { WebRemote } from './sync/WebRemote';
 import { WebStreamingSyncImplementation } from './sync/WebStreamingSyncImplementation';
-import { WASQLiteOpenFactory } from './adapters/wa-sqlite/WASQLiteOpenFactory';
-import { DEFAULT_WEB_SQL_FLAGS, resolveWebSQLFlags } from './adapters/web-sql-flags';
-export const DEFAULT_POWERSYNC_FLAGS = {
-    ...DEFAULT_WEB_SQL_FLAGS,
-    externallyUnload: false
-};
+export const DEFAULT_POWERSYNC_FLAGS = Object.assign(Object.assign({}, DEFAULT_WEB_SQL_FLAGS), { externallyUnload: false });
 export const resolveWebPowerSyncFlags = (flags) => {
-    return {
-        ...DEFAULT_POWERSYNC_FLAGS,
-        ...flags,
-        ...resolveWebSQLFlags(flags)
-    };
+    return Object.assign(Object.assign(Object.assign({}, DEFAULT_POWERSYNC_FLAGS), flags), resolveWebSQLFlags(flags));
 };
 /**
  * A PowerSync database which provides SQLite functionality
@@ -32,10 +34,6 @@ export const resolveWebPowerSyncFlags = (flags) => {
  * ```
  */
 export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
-    options;
-    static SHARED_MUTEX = new Mutex();
-    unloadListener;
-    resolvedFlags;
     constructor(options) {
         super(options);
         this.options = options;
@@ -45,9 +43,11 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
             window.addEventListener('unload', this.unloadListener);
         }
     }
-    async _initialize() { }
+    _initialize() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
     openDBAdapter(options) {
-        const defaultFactory = new WASQLiteOpenFactory({ ...options, flags: this.resolvedFlags });
+        const defaultFactory = new WASQLiteOpenFactory(Object.assign(Object.assign({}, options.database), { flags: resolveWebPowerSyncFlags(options.flags) }));
         return defaultFactory.openDB();
     }
     /**
@@ -56,12 +56,13 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
      * multiple tabs are not enabled.
      */
     close(options = DEFAULT_POWERSYNC_CLOSE_OPTIONS) {
+        var _a;
         if (this.unloadListener) {
             window.removeEventListener('unload', this.unloadListener);
         }
         return super.close({
             // Don't disconnect by default if multiple tabs are enabled
-            disconnect: options.disconnect ?? !this.resolvedFlags.enableMultiTabs
+            disconnect: (_a = options.disconnect) !== null && _a !== void 0 ? _a : !this.resolvedFlags.enableMultiTabs
         });
     }
     connect(connector, options) {
@@ -71,7 +72,8 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
          * connection attempts.
          */
         return this.runExclusive(() => {
-            this.options.logger?.debug('Attempting to connect to PowerSync instance');
+            var _a;
+            (_a = this.options.logger) === null || _a === void 0 ? void 0 : _a.debug('Attempting to connect to PowerSync instance');
             return super.connect(connector, options);
         });
     }
@@ -86,17 +88,10 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     }
     generateSyncStreamImplementation(connector) {
         const remote = new WebRemote(connector);
-        const syncOptions = {
-            ...this.options,
-            flags: this.resolvedFlags,
-            adapter: this.bucketStorageAdapter,
-            remote,
-            uploadCrud: async () => {
-                await this.waitForReady();
-                await connector.uploadData(this);
-            },
-            identifier: this.database.name
-        };
+        const syncOptions = Object.assign(Object.assign({}, this.options), { flags: this.resolvedFlags, adapter: this.bucketStorageAdapter, remote, uploadCrud: () => __awaiter(this, void 0, void 0, function* () {
+                yield this.waitForReady();
+                yield connector.uploadData(this);
+            }), identifier: this.database.name });
         switch (true) {
             case this.resolvedFlags.ssrMode:
                 return new SSRStreamingSyncImplementation(syncOptions);
@@ -115,3 +110,4 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
         }
     }
 }
+PowerSyncDatabase.SHARED_MUTEX = new Mutex();

package/lib/src/db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.js

@@ -7,18 +7,12 @@ import { PowerSyncDatabase, resolveWebPowerSyncFlags } from '../../db/PowerSyncD
  * empty query results in SSR which will allow for generating server partial views.
  */
 export class AbstractWebPowerSyncDatabaseOpenFactory extends AbstractPowerSyncDatabaseOpenFactory {
-    options;
     constructor(options) {
         super(options);
         this.options = options;
     }
     generateOptions() {
-        return {
-            ...this.options,
-            database: this.openDB(),
-            schema: this.schema,
-            flags: resolveWebPowerSyncFlags(this.options.flags)
-        };
+        return Object.assign(Object.assign({}, this.options), { database: this.openDB(), schema: this.schema, flags: resolveWebPowerSyncFlags(this.options.flags) });
     }
     generateInstance(options) {
         return new PowerSyncDatabase(options);

package/lib/src/db/adapters/AbstractWebSQLOpenFactory.js

@@ -1,8 +1,6 @@
 import { SSRDBAdapter } from './SSRDBAdapter';
 import { isServerSide, resolveWebSQLFlags } from './web-sql-flags';
 export class AbstractWebSQLOpenFactory {
-    options;
-    resolvedFlags;
     constructor(options) {
         this.options = options;
         this.resolvedFlags = resolveWebSQLFlags(options.flags);

package/lib/src/db/adapters/SSRDBAdapter.js

@@ -1,3 +1,12 @@
+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 { BaseObserver } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 const MOCK_QUERY_RESPONSE = {
@@ -9,9 +18,6 @@ const MOCK_QUERY_RESPONSE = {
  * server rendered views to initially generate scaffolding components
  */
 export class SSRDBAdapter extends BaseObserver {
-    name;
-    readMutex;
-    writeMutex;
     constructor() {
         super();
         this.name = 'SSR DB';
@@ -19,32 +25,50 @@ export class SSRDBAdapter extends BaseObserver {
         this.writeMutex = new Mutex();
     }
     close() { }
-    async readLock(fn, options) {
-        return this.readMutex.runExclusive(() => fn(this));
+    readLock(fn, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.readMutex.runExclusive(() => fn(this));
+        });
     }
-    async readTransaction(fn, options) {
-        return this.readLock(() => fn(this.generateMockTransactionContext()));
+    readTransaction(fn, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.readLock(() => fn(this.generateMockTransactionContext()));
+        });
     }
-    async writeLock(fn, options) {
-        return this.writeMutex.runExclusive(() => fn(this));
+    writeLock(fn, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.writeMutex.runExclusive(() => fn(this));
+        });
     }
-    async writeTransaction(fn, options) {
-        return this.writeLock(() => fn(this.generateMockTransactionContext()));
+    writeTransaction(fn, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.writeLock(() => fn(this.generateMockTransactionContext()));
+        });
     }
-    async execute(query, params) {
-        return this.writeMutex.runExclusive(async () => MOCK_QUERY_RESPONSE);
+    execute(query, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.writeMutex.runExclusive(() => __awaiter(this, void 0, void 0, function* () { return MOCK_QUERY_RESPONSE; }));
+        });
     }
-    async executeBatch(query, params) {
-        return this.writeMutex.runExclusive(async () => MOCK_QUERY_RESPONSE);
+    executeBatch(query, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.writeMutex.runExclusive(() => __awaiter(this, void 0, void 0, function* () { return MOCK_QUERY_RESPONSE; }));
+        });
     }
-    async getAll(sql, parameters) {
-        return [];
+    getAll(sql, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
     }
-    async getOptional(sql, parameters) {
-        return null;
+    getOptional(sql, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return null;
+        });
     }
-    async get(sql, parameters) {
-        throw new Error(`No values are returned in SSR mode`);
+    get(sql, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error(`No values are returned in SSR mode`);
+        });
     }
     /**
      * Generates a mock context for use in read/write transactions.
@@ -52,14 +76,10 @@ export class SSRDBAdapter extends BaseObserver {
      *  are added here
      */
     generateMockTransactionContext() {
-        return {
-            ...this,
-            commit: async () => {
+        return Object.assign(Object.assign({}, this), { commit: () => __awaiter(this, void 0, void 0, function* () {
                 return MOCK_QUERY_RESPONSE;
-            },
-            rollback: async () => {
+            }), rollback: () => __awaiter(this, void 0, void 0, function* () {
                 return MOCK_QUERY_RESPONSE;
-            }
-        };
+            }) });
     }
 }

package/lib/src/db/adapters/wa-sqlite/WASQLiteDBAdapter.d.ts

@@ -22,6 +22,7 @@ export declare class WASQLiteDBAdapter extends BaseObserver<DBAdapterListener> i
     private logger;
     private dbGetHelpers;
     private methods;
+    private debugMode;
     constructor(options: WASQLiteDBAdapterOptions);
     get name(): string;
     protected get flags(): WASQLiteFlags;

package/lib/src/db/adapters/wa-sqlite/WASQLiteDBAdapter.js

@@ -1,3 +1,12 @@
+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 { BaseObserver } from '@powersync/common';
 import * as Comlink from 'comlink';
 import Logger from 'js-logger';
@@ -7,17 +16,45 @@ import { getWorkerDatabaseOpener } from '../../../worker/db/open-worker-database
  * Adapter for WA-SQLite SQLite connections.
  */
 export class WASQLiteDBAdapter extends BaseObserver {
-    options;
-    initialized;
-    logger;
-    dbGetHelpers;
-    methods;
     constructor(options) {
+        var _a;
         super();
         this.options = options;
+        /**
+         * Wraps the worker execute function, awaiting for it to be available
+         */
+        this._execute = (sql, bindings) => __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            const result = yield this.methods.execute(sql, bindings);
+            return Object.assign(Object.assign({}, result), { rows: Object.assign(Object.assign({}, result.rows), { item: (idx) => result.rows._array[idx] }) });
+        });
+        /**
+         * Wraps the worker executeBatch function, awaiting for it to be available
+         */
+        this._executeBatch = (query, params) => __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            const result = yield this.methods.executeBatch(query, params);
+            return Object.assign(Object.assign({}, result), { rows: undefined });
+        });
         this.logger = Logger.get('WASQLite');
         this.dbGetHelpers = null;
         this.methods = null;
+        this.debugMode = (_a = options.debugMode) !== null && _a !== void 0 ? _a : false;
+        if (this.debugMode) {
+            const originalExecute = this._execute.bind(this);
+            this._execute = (sql, bindings) => __awaiter(this, void 0, void 0, function* () {
+                const start = performance.now();
+                try {
+                    const r = yield originalExecute(sql, bindings);
+                    performance.measure(`[SQL] ${sql}`, { start });
+                    return r;
+                }
+                catch (e) {
+                    performance.measure(`[SQL] [ERROR: ${e.message}] ${sql}`, { start });
+                    throw e;
+                }
+            });
+        }
         this.initialized = this.init();
         this.dbGetHelpers = this.generateDBHelpers({
             execute: (query, params) => this.acquireLock(() => this._execute(query, params))
@@ -27,93 +64,88 @@ export class WASQLiteDBAdapter extends BaseObserver {
         return this.options.dbFilename;
     }
     get flags() {
-        return this.options.flags ?? {};
+        var _a;
+        return (_a = this.options.flags) !== null && _a !== void 0 ? _a : {};
     }
     getWorker() { }
-    async init() {
-        const { enableMultiTabs, useWebWorker } = this.flags;
-        if (!enableMultiTabs) {
-            this.logger.warn('Multiple tabs are not enabled in this browser');
-        }
-        if (useWebWorker) {
-            const dbOpener = this.options.workerPort
-                ? Comlink.wrap(this.options.workerPort)
-                : getWorkerDatabaseOpener(this.options.dbFilename, enableMultiTabs);
-            this.methods = await dbOpener(this.options.dbFilename);
-            this.methods.registerOnTableChange(Comlink.proxy((opType, tableName, rowId) => {
-                this.iterateListeners((cb) => cb.tablesUpdated?.({ opType, table: tableName, rowId }));
-            }));
-            return;
-        }
-        this.methods = await _openDB(this.options.dbFilename, { useWebWorker: false });
-        this.methods.registerOnTableChange((opType, tableName, rowId) => {
-            this.iterateListeners((cb) => cb.tablesUpdated?.({ opType, table: tableName, rowId }));
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { enableMultiTabs, useWebWorker } = this.flags;
+            if (!enableMultiTabs) {
+                this.logger.warn('Multiple tabs are not enabled in this browser');
+            }
+            if (useWebWorker) {
+                const dbOpener = this.options.workerPort
+                    ? Comlink.wrap(this.options.workerPort)
+                    : getWorkerDatabaseOpener(this.options.dbFilename, enableMultiTabs);
+                this.methods = yield dbOpener(this.options.dbFilename);
+                this.methods.registerOnTableChange(Comlink.proxy((opType, tableName, rowId) => {
+                    this.iterateListeners((cb) => { var _a; return (_a = cb.tablesUpdated) === null || _a === void 0 ? void 0 : _a.call(cb, { opType, table: tableName, rowId }); });
+                }));
+                return;
+            }
+            this.methods = yield _openDB(this.options.dbFilename, { useWebWorker: false });
+            this.methods.registerOnTableChange((opType, tableName, rowId) => {
+                this.iterateListeners((cb) => { var _a; return (_a = cb.tablesUpdated) === null || _a === void 0 ? void 0 : _a.call(cb, { opType, table: tableName, rowId }); });
+            });
         });
     }
-    async execute(query, params) {
-        return this.writeLock((ctx) => ctx.execute(query, params));
+    execute(query, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.writeLock((ctx) => ctx.execute(query, params));
+        });
     }
-    async executeBatch(query, params) {
-        return this.writeLock((ctx) => this._executeBatch(query, params));
+    executeBatch(query, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.writeLock((ctx) => this._executeBatch(query, params));
+        });
     }
-    /**
-     * Wraps the worker execute function, awaiting for it to be available
-     */
-    _execute = async (sql, bindings) => {
-        await this.initialized;
-        const result = await this.methods.execute(sql, bindings);
-        return {
-            ...result,
-            rows: {
-                ...result.rows,
-                item: (idx) => result.rows._array[idx]
-            }
-        };
-    };
-    /**
-     * Wraps the worker executeBatch function, awaiting for it to be available
-     */
-    _executeBatch = async (query, params) => {
-        await this.initialized;
-        const result = await this.methods.executeBatch(query, params);
-        return {
-            ...result,
-            rows: undefined
-        };
-    };
     /**
      * Attempts to close the connection.
      * Shared workers might not actually close the connection if other
      * tabs are still using it.
      */
     close() {
-        this.methods?.close?.();
+        var _a, _b;
+        (_b = (_a = this.methods) === null || _a === void 0 ? void 0 : _a.close) === null || _b === void 0 ? void 0 : _b.call(_a);
     }
-    async getAll(sql, parameters) {
-        await this.initialized;
-        return this.dbGetHelpers.getAll(sql, parameters);
+    getAll(sql, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            return this.dbGetHelpers.getAll(sql, parameters);
+        });
     }
-    async getOptional(sql, parameters) {
-        await this.initialized;
-        return this.dbGetHelpers.getOptional(sql, parameters);
+    getOptional(sql, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            return this.dbGetHelpers.getOptional(sql, parameters);
+        });
     }
-    async get(sql, parameters) {
-        await this.initialized;
-        return this.dbGetHelpers.get(sql, parameters);
+    get(sql, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            return this.dbGetHelpers.get(sql, parameters);
+        });
     }
-    async readLock(fn, options) {
-        await this.initialized;
-        return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute })));
+    readLock(fn, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            return this.acquireLock(() => __awaiter(this, void 0, void 0, function* () { return fn(this.generateDBHelpers({ execute: this._execute })); }));
+        });
     }
-    async writeLock(fn, options) {
-        await this.initialized;
-        return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute })));
+    writeLock(fn, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            return this.acquireLock(() => __awaiter(this, void 0, void 0, function* () { return fn(this.generateDBHelpers({ execute: this._execute })); }));
+        });
     }
     acquireLock(callback) {
         return navigator.locks.request(`db-lock-${this.options.dbFilename}`, callback);
     }
-    async readTransaction(fn, options) {
-        return this.readLock(this.wrapTransaction(fn));
+    readTransaction(fn, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.readLock(this.wrapTransaction(fn));
+        });
     }
     writeTransaction(fn, options) {
         return this.writeLock(this.wrapTransaction(fn));
@@ -122,35 +154,32 @@ export class WASQLiteDBAdapter extends BaseObserver {
      * Wraps a lock context into a transaction context
      */
     wrapTransaction(cb) {
-        return async (tx) => {
-            await this._execute('BEGIN TRANSACTION');
+        return (tx) => __awaiter(this, void 0, void 0, function* () {
+            yield this._execute('BEGIN TRANSACTION');
             let finalized = false;
-            const commit = async () => {
+            const commit = () => __awaiter(this, void 0, void 0, function* () {
                 if (finalized) {
                     return { rowsAffected: 0 };
                 }
                 finalized = true;
                 return this._execute('COMMIT');
-            };
+            });
             const rollback = () => {
                 finalized = true;
                 return this._execute('ROLLBACK');
             };
             try {
-                const result = await cb({
-                    ...tx,
-                    commit,
-                    rollback
-                });
+                const result = yield cb(Object.assign(Object.assign({}, tx), { commit,
+                    rollback }));
                 if (!finalized) {
-                    await commit();
+                    yield commit();
                 }
                 return result;
             }
             catch (ex) {
                 this.logger.debug('Caught ex in transaction', ex);
                 try {
-                    await rollback();
+                    yield rollback();
                 }
                 catch (ex2) {
                     // In rare cases, a rollback may fail.
@@ -158,36 +187,43 @@ export class WASQLiteDBAdapter extends BaseObserver {
                 }
                 throw ex;
             }
-        };
+        });
     }
     generateDBHelpers(tx) {
-        return {
-            ...tx,
+        return Object.assign(Object.assign({}, tx), { 
             /**
              *  Execute a read-only query and return results
              */
-            async getAll(sql, parameters) {
-                const res = await tx.execute(sql, parameters);
-                return res.rows?._array ?? [];
+            getAll(sql, parameters) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    const res = yield tx.execute(sql, parameters);
+                    return (_b = (_a = res.rows) === null || _a === void 0 ? void 0 : _a._array) !== null && _b !== void 0 ? _b : [];
+                });
             },
             /**
              * Execute a read-only query and return the first result, or null if the ResultSet is empty.
              */
-            async getOptional(sql, parameters) {
-                const res = await tx.execute(sql, parameters);
-                return res.rows?.item(0) ?? null;
+            getOptional(sql, parameters) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    const res = yield tx.execute(sql, parameters);
+                    return (_b = (_a = res.rows) === null || _a === void 0 ? void 0 : _a.item(0)) !== null && _b !== void 0 ? _b : null;
+                });
             },
             /**
              * Execute a read-only query and return the first result, error if the ResultSet is empty.
              */
-            async get(sql, parameters) {
-                const res = await tx.execute(sql, parameters);
-                const first = res.rows?.item(0);
-                if (!first) {
-                    throw new Error('Result set is empty');
-                }
-                return first;
-            }
-        };
+            get(sql, parameters) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    const res = yield tx.execute(sql, parameters);
+                    const first = (_a = res.rows) === null || _a === void 0 ? void 0 : _a.item(0);
+                    if (!first) {
+                        throw new Error('Result set is empty');
+                    }
+                    return first;
+                });
+            } });
     }
 }

package/lib/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.js

@@ -5,9 +5,6 @@ import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory';
  */
 export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
     openAdapter() {
-        return new WASQLiteDBAdapter({
-            ...this.options,
-            flags: this.resolvedFlags
-        });
+        return new WASQLiteDBAdapter(Object.assign(Object.assign({}, this.options), { flags: this.resolvedFlags }));
     }
 }