@powersync/web 1.2.4 → 1.4.0

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,30 +28,6 @@ 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,23 +1,21 @@
-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, SqliteBucketStorage, DEFAULT_POWERSYNC_CLOSE_OPTIONS } from '@powersync/common';
+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 = Object.assign(Object.assign({}, DEFAULT_WEB_SQL_FLAGS), { externallyUnload: false });
+export const DEFAULT_POWERSYNC_FLAGS = {
+    ...DEFAULT_WEB_SQL_FLAGS,
+    externallyUnload: false
+};
 export const resolveWebPowerSyncFlags = (flags) => {
-    return Object.assign(Object.assign(Object.assign({}, DEFAULT_POWERSYNC_FLAGS), flags), resolveWebSQLFlags(flags));
+    return {
+        ...DEFAULT_POWERSYNC_FLAGS,
+        ...flags,
+        ...resolveWebSQLFlags(flags)
+    };
 };
 /**
  * A PowerSync database which provides SQLite functionality
@@ -34,6 +32,10 @@ export const resolveWebPowerSyncFlags = (flags) => {
  * ```
  */
 export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
+    options;
+    static SHARED_MUTEX = new Mutex();
+    unloadListener;
+    resolvedFlags;
     constructor(options) {
         super(options);
         this.options = options;
@@ -43,11 +45,12 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
             window.addEventListener('unload', this.unloadListener);
         }
     }
-    _initialize() {
-        return __awaiter(this, void 0, void 0, function* () { });
-    }
+    async _initialize() { }
     openDBAdapter(options) {
-        const defaultFactory = new WASQLiteOpenFactory(Object.assign(Object.assign({}, options), { flags: this.resolvedFlags }));
+        const defaultFactory = new WASQLiteOpenFactory({
+            ...options.database,
+            flags: resolveWebPowerSyncFlags(options.flags)
+        });
         return defaultFactory.openDB();
     }
     /**
@@ -56,13 +59,12 @@ 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: (_a = options.disconnect) !== null && _a !== void 0 ? _a : !this.resolvedFlags.enableMultiTabs
+            disconnect: options.disconnect ?? !this.resolvedFlags.enableMultiTabs
         });
     }
     connect(connector, options) {
@@ -72,8 +74,7 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
          * connection attempts.
          */
         return this.runExclusive(() => {
-            var _a;
-            (_a = this.options.logger) === null || _a === void 0 ? void 0 : _a.debug('Attempting to connect to PowerSync instance');
+            this.options.logger?.debug('Attempting to connect to PowerSync instance');
             return super.connect(connector, options);
         });
     }
@@ -88,10 +89,17 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     }
     generateSyncStreamImplementation(connector) {
         const remote = new WebRemote(connector);
-        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 });
+        const syncOptions = {
+            ...this.options,
+            flags: this.resolvedFlags,
+            adapter: this.bucketStorageAdapter,
+            remote,
+            uploadCrud: async () => {
+                await this.waitForReady();
+                await connector.uploadData(this);
+            },
+            identifier: this.database.name
+        };
         switch (true) {
             case this.resolvedFlags.ssrMode:
                 return new SSRStreamingSyncImplementation(syncOptions);
@@ -110,4 +118,3 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
         }
     }
 }
-PowerSyncDatabase.SHARED_MUTEX = new Mutex();

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

@@ -7,12 +7,18 @@ 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 Object.assign(Object.assign({}, this.options), { database: this.openDB(), schema: this.schema, flags: resolveWebPowerSyncFlags(this.options.flags) });
+        return {
+            ...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,6 +1,8 @@
 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,12 +1,3 @@
-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 = {
@@ -18,6 +9,9 @@ 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';
@@ -25,50 +19,32 @@ export class SSRDBAdapter extends BaseObserver {
         this.writeMutex = new Mutex();
     }
     close() { }
-    readLock(fn, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.readMutex.runExclusive(() => fn(this));
-        });
+    async readLock(fn, options) {
+        return this.readMutex.runExclusive(() => fn(this));
     }
-    readTransaction(fn, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.readLock(() => fn(this.generateMockTransactionContext()));
-        });
+    async readTransaction(fn, options) {
+        return this.readLock(() => fn(this.generateMockTransactionContext()));
     }
-    writeLock(fn, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.writeMutex.runExclusive(() => fn(this));
-        });
+    async writeLock(fn, options) {
+        return this.writeMutex.runExclusive(() => fn(this));
     }
-    writeTransaction(fn, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.writeLock(() => fn(this.generateMockTransactionContext()));
-        });
+    async writeTransaction(fn, options) {
+        return this.writeLock(() => fn(this.generateMockTransactionContext()));
     }
-    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 execute(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 executeBatch(query, params) {
+        return this.writeMutex.runExclusive(async () => MOCK_QUERY_RESPONSE);
     }
-    getAll(sql, parameters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return [];
-        });
+    async getAll(sql, parameters) {
+        return [];
     }
-    getOptional(sql, parameters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return null;
-        });
+    async getOptional(sql, parameters) {
+        return null;
     }
-    get(sql, parameters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error(`No values are returned in SSR mode`);
-        });
+    async get(sql, parameters) {
+        throw new Error(`No values are returned in SSR mode`);
     }
     /**
      * Generates a mock context for use in read/write transactions.
@@ -76,10 +52,14 @@ export class SSRDBAdapter extends BaseObserver {
      *  are added here
      */
     generateMockTransactionContext() {
-        return Object.assign(Object.assign({}, this), { commit: () => __awaiter(this, void 0, void 0, function* () {
+        return {
+            ...this,
+            commit: async () => {
                 return MOCK_QUERY_RESPONSE;
-            }), rollback: () => __awaiter(this, void 0, void 0, function* () {
+            },
+            rollback: async () => {
                 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,12 +1,3 @@
-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';
@@ -16,28 +7,34 @@ import { getWorkerDatabaseOpener } from '../../../worker/db/open-worker-database
  * Adapter for WA-SQLite SQLite connections.
  */
 export class WASQLiteDBAdapter extends BaseObserver {
+    options;
+    initialized;
+    logger;
+    dbGetHelpers;
+    methods;
+    debugMode;
     constructor(options) {
         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 = options.debugMode ?? false;
+        if (this.debugMode) {
+            const originalExecute = this._execute.bind(this);
+            this._execute = async (sql, bindings) => {
+                const start = performance.now();
+                try {
+                    const r = await 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))
@@ -47,88 +44,93 @@ export class WASQLiteDBAdapter extends BaseObserver {
         return this.options.dbFilename;
     }
     get flags() {
-        var _a;
-        return (_a = this.options.flags) !== null && _a !== void 0 ? _a : {};
+        return this.options.flags ?? {};
     }
     getWorker() { }
-    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 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 }));
         });
     }
-    execute(query, params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.writeLock((ctx) => ctx.execute(query, params));
-        });
+    async execute(query, params) {
+        return this.writeLock((ctx) => ctx.execute(query, params));
     }
-    executeBatch(query, params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.writeLock((ctx) => this._executeBatch(query, params));
-        });
+    async executeBatch(query, params) {
+        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() {
-        var _a, _b;
-        (_b = (_a = this.methods) === null || _a === void 0 ? void 0 : _a.close) === null || _b === void 0 ? void 0 : _b.call(_a);
+        this.methods?.close?.();
     }
-    getAll(sql, parameters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.initialized;
-            return this.dbGetHelpers.getAll(sql, parameters);
-        });
+    async getAll(sql, parameters) {
+        await this.initialized;
+        return this.dbGetHelpers.getAll(sql, parameters);
     }
-    getOptional(sql, parameters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.initialized;
-            return this.dbGetHelpers.getOptional(sql, parameters);
-        });
+    async getOptional(sql, parameters) {
+        await this.initialized;
+        return this.dbGetHelpers.getOptional(sql, parameters);
     }
-    get(sql, parameters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.initialized;
-            return this.dbGetHelpers.get(sql, parameters);
-        });
+    async get(sql, parameters) {
+        await this.initialized;
+        return this.dbGetHelpers.get(sql, parameters);
     }
-    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 readLock(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 })); }));
-        });
+    async writeLock(fn, options) {
+        await this.initialized;
+        return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute })));
     }
     acquireLock(callback) {
         return navigator.locks.request(`db-lock-${this.options.dbFilename}`, callback);
     }
-    readTransaction(fn, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.readLock(this.wrapTransaction(fn));
-        });
+    async readTransaction(fn, options) {
+        return this.readLock(this.wrapTransaction(fn));
     }
     writeTransaction(fn, options) {
         return this.writeLock(this.wrapTransaction(fn));
@@ -137,32 +139,35 @@ export class WASQLiteDBAdapter extends BaseObserver {
      * Wraps a lock context into a transaction context
      */
     wrapTransaction(cb) {
-        return (tx) => __awaiter(this, void 0, void 0, function* () {
-            yield this._execute('BEGIN TRANSACTION');
+        return async (tx) => {
+            await this._execute('BEGIN TRANSACTION');
             let finalized = false;
-            const commit = () => __awaiter(this, void 0, void 0, function* () {
+            const commit = async () => {
                 if (finalized) {
                     return { rowsAffected: 0 };
                 }
                 finalized = true;
                 return this._execute('COMMIT');
-            });
+            };
             const rollback = () => {
                 finalized = true;
                 return this._execute('ROLLBACK');
             };
             try {
-                const result = yield cb(Object.assign(Object.assign({}, tx), { commit,
-                    rollback }));
+                const result = await cb({
+                    ...tx,
+                    commit,
+                    rollback
+                });
                 if (!finalized) {
-                    yield commit();
+                    await commit();
                 }
                 return result;
             }
             catch (ex) {
                 this.logger.debug('Caught ex in transaction', ex);
                 try {
-                    yield rollback();
+                    await rollback();
                 }
                 catch (ex2) {
                     // In rare cases, a rollback may fail.
@@ -170,43 +175,36 @@ export class WASQLiteDBAdapter extends BaseObserver {
                 }
                 throw ex;
             }
-        });
+        };
     }
     generateDBHelpers(tx) {
-        return Object.assign(Object.assign({}, tx), { 
+        return {
+            ...tx,
             /**
              *  Execute a read-only query and return results
              */
-            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 : [];
-                });
+            async getAll(sql, parameters) {
+                const res = await tx.execute(sql, parameters);
+                return res.rows?._array ?? [];
             },
             /**
              * Execute a read-only query and return the first result, or null if the ResultSet is empty.
              */
-            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;
-                });
+            async getOptional(sql, parameters) {
+                const res = await tx.execute(sql, parameters);
+                return res.rows?.item(0) ?? null;
             },
             /**
              * Execute a read-only query and return the first result, error if the ResultSet is empty.
              */
-            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;
-                });
-            } });
+            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;
+            }
+        };
     }
 }

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

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