@powersync/web 1.3.0 → 1.4.0

package/lib/src/db/adapters/web-sql-flags.js

@@ -16,11 +16,14 @@ export const DEFAULT_WEB_SQL_FLAGS = {
     useWebWorker: true
 };
 export function resolveWebSQLFlags(flags) {
-    const resolvedFlags = Object.assign(Object.assign({}, DEFAULT_WEB_SQL_FLAGS), (flags !== null && flags !== void 0 ? flags : {}));
-    if (typeof (flags === null || flags === void 0 ? void 0 : flags.enableMultiTabs) != 'undefined') {
+    const resolvedFlags = {
+        ...DEFAULT_WEB_SQL_FLAGS,
+        ...(flags ?? {})
+    };
+    if (typeof flags?.enableMultiTabs != 'undefined') {
         resolvedFlags.enableMultiTabs = flags.enableMultiTabs;
     }
-    if ((flags === null || flags === void 0 ? void 0 : flags.useWebWorker) === false) {
+    if (flags?.useWebWorker === false) {
         resolvedFlags.enableMultiTabs = false;
     }
     return resolvedFlags;

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

@@ -1,6 +1,8 @@
 import { AbstractStreamingSyncImplementation, LockType } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 export class SSRStreamingSyncImplementation extends AbstractStreamingSyncImplementation {
+    syncMutex;
+    crudMutex;
     constructor(options) {
         super(options);
         this.syncMutex = new Mutex();

package/lib/src/db/sync/SharedWebStreamingSyncImplementation.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 * as Comlink from 'comlink';
 import { WebStreamingSyncImplementation } from './WebStreamingSyncImplementation';
 import { SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation';
@@ -17,76 +8,70 @@ import { openWorkerDatabasePort } from '../../worker/db/open-worker-database';
  * 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);
         /**
@@ -135,53 +120,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.d.ts

@@ -1,5 +1,9 @@
-import { AbstractRemote, BSONImplementation } from '@powersync/common';
+import { type ILogger } from 'js-logger';
+import { AbstractRemote, AbstractRemoteOptions, BSONImplementation, RemoteConnector } from '@powersync/common';
 export declare class WebRemote extends AbstractRemote {
+    protected connector: RemoteConnector;
+    protected logger: ILogger;
     private _bson;
+    constructor(connector: RemoteConnector, logger?: ILogger, options?: Partial<AbstractRemoteOptions>);
     getBSON(): Promise<BSONImplementation>;
 }

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

@@ -1,25 +1,33 @@
-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';
+import { AbstractRemote, DEFAULT_REMOTE_LOGGER, FetchImplementationProvider } from '@powersync/common';
+/*
+ * Depends on browser's implementation of global fetch.
+ */
+class WebFetchProvider extends FetchImplementationProvider {
+    getFetch() {
+        return fetch.bind(globalThis);
+    }
+}
 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;
-            return this._bson;
+    connector;
+    logger;
+    _bson;
+    constructor(connector, logger = DEFAULT_REMOTE_LOGGER, options) {
+        super(connector, logger, {
+            ...(options ?? {}),
+            fetchImplementation: options?.fetchImplementation ?? new WebFetchProvider()
         });
+        this.connector = connector;
+        this.logger = logger;
+    }
+    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;
     }
 }