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

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

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

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

@@ -1,8 +1,6 @@
 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,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 * as Comlink from 'comlink';
 import { WebStreamingSyncImplementation } from './WebStreamingSyncImplementation';
 import { SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation';
@@ -8,70 +17,76 @@ 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;
     }
-    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
-        };
+    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 uploadCrud() {
-        /**
-         * Don't return anything here, just incase something which is not
-         * serializable is returned from the `uploadCrud` function.
-         */
-        await this.options.uploadCrud();
+    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();
+        });
     }
     get logger() {
         return this.options.logger;
     }
     trace(...x) {
-        this.logger?.trace(...x);
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.trace(...x);
     }
     debug(...x) {
-        this.logger?.debug(...x);
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(...x);
     }
     info(...x) {
-        this.logger?.info(...x);
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info(...x);
     }
     log(...x) {
-        this.logger?.log(...x);
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.log(...x);
     }
     warn(...x) {
-        this.logger?.warn(...x);
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.warn(...x);
     }
     error(...x) {
-        this.logger?.error(...x);
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error(...x);
     }
     time(label) {
-        this.logger?.time(label);
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.time(label);
     }
     timeEnd(label) {
-        this.logger?.timeEnd(label);
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.timeEnd(label);
     }
 }
 export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplementation {
-    syncManager;
-    clientProvider;
-    messagePort;
-    isInitialized;
     constructor(options) {
         super(options);
         /**
@@ -120,39 +135,53 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
      * Starts the sync process, this effectively acts as a call to
      * `connect` if not yet connected.
      */
-    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;
+    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;
+        });
     }
     /**
      * Used in tests to force a connection states
      */
-    async _testUpdateStatus(status) {
-        return this.syncManager['_testUpdateAllStatuses'](status.toJSON());
+    _testUpdateStatus(status) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.syncManager['_testUpdateAllStatuses'](status.toJSON());
+        });
     }
 }

package/lib/src/db/sync/WebRemote.d.ts

@@ -1,9 +1,5 @@
-import { type ILogger } from 'js-logger';
-import { AbstractRemote, AbstractRemoteOptions, BSONImplementation, RemoteConnector } from '@powersync/common';
+import { AbstractRemote, BSONImplementation } 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,33 +1,25 @@
-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);
-    }
-}
+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 {
-    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) {
+    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;
-        }
-        /**
-         * Dynamic import to be used only when needed.
-         */
-        const { BSON } = await import('bson');
-        this._bson = BSON;
-        return this._bson;
+        });
     }
 }