@powersync/web 1.3.0 → 1.5.0

package/lib/src/worker/sync/SharedSyncImplementation.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 Logger from 'js-logger';
 import { BaseObserver, SqliteBucketStorage, SyncStatus, AbortOperation } from '@powersync/common';
@@ -30,6 +21,14 @@ export var SharedSyncClientEvent;
  * Shared sync implementation which runs inside a shared webworker
  */
 export class SharedSyncImplementation extends BaseObserver {
+    ports;
+    syncStreamClient;
+    isInitialized;
+    statusListener;
+    fetchCredentialsController;
+    uploadDataController;
+    syncStatus;
+    broadCastLogger;
     constructor() {
         super();
         this.ports = [];
@@ -37,111 +36,104 @@ export class SharedSyncImplementation extends BaseObserver {
             const callback = this.registerListener({
                 initialized: () => {
                     resolve();
-                    callback === null || callback === void 0 ? void 0 : callback();
+                    callback?.();
                 }
             });
         });
         this.syncStatus = new SyncStatus({});
         this.broadCastLogger = new BroadcastLogger(this.ports);
     }
-    waitForStatus(status) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.waitForReady();
-            return this.syncStreamClient.waitForStatus(status);
-        });
+    async waitForStatus(status) {
+        await this.waitForReady();
+        return this.syncStreamClient.waitForStatus(status);
     }
     get lastSyncedAt() {
-        var _a;
-        return (_a = this.syncStreamClient) === null || _a === void 0 ? void 0 : _a.lastSyncedAt;
+        return this.syncStreamClient?.lastSyncedAt;
     }
     get isConnected() {
-        var _a, _b;
-        return (_b = (_a = this.syncStreamClient) === null || _a === void 0 ? void 0 : _a.isConnected) !== null && _b !== void 0 ? _b : false;
+        return this.syncStreamClient?.isConnected ?? false;
     }
-    waitForReady() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.isInitialized;
-        });
+    async waitForReady() {
+        return this.isInitialized;
     }
     /**
      * Configures the DBAdapter connection and a streaming sync client.
      */
-    init(dbWorkerPort, params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            if (this.syncStreamClient) {
-                // Cannot modify already existing sync implementation
-                return;
-            }
-            const logger = ((_b = (_a = params.streamOptions) === null || _a === void 0 ? void 0 : _a.flags) === null || _b === void 0 ? void 0 : _b.broadcastLogs) ? this.broadCastLogger : Logger.get('shared-sync');
-            self.onerror = (event) => {
-                // Share any uncaught events on the broadcast logger
-                logger.error('Uncaught exception in PowerSync shared sync worker', event);
-            };
-            this.syncStreamClient = new WebStreamingSyncImplementation(Object.assign(Object.assign({ adapter: new SqliteBucketStorage(new WASQLiteDBAdapter({
-                    dbFilename: params.dbName,
-                    workerPort: dbWorkerPort,
-                    flags: { enableMultiTabs: true, useWebWorker: true },
-                    logger
-                }), new Mutex(), logger), remote: new WebRemote({
-                    fetchCredentials: () => __awaiter(this, void 0, void 0, function* () {
-                        const lastPort = this.ports[this.ports.length - 1];
-                        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                            const abortController = new AbortController();
-                            this.fetchCredentialsController = {
-                                controller: abortController,
-                                activePort: lastPort
-                            };
-                            abortController.signal.onabort = reject;
-                            try {
-                                resolve(yield lastPort.clientProvider.fetchCredentials());
-                            }
-                            catch (ex) {
-                                reject(ex);
-                            }
-                            finally {
-                                this.fetchCredentialsController = undefined;
-                            }
-                        }));
-                    })
-                }), uploadCrud: () => __awaiter(this, void 0, void 0, function* () {
+    async init(dbWorkerPort, params) {
+        if (this.syncStreamClient) {
+            // Cannot modify already existing sync implementation
+            return;
+        }
+        const logger = params.streamOptions?.flags?.broadcastLogs ? this.broadCastLogger : Logger.get('shared-sync');
+        self.onerror = (event) => {
+            // Share any uncaught events on the broadcast logger
+            logger.error('Uncaught exception in PowerSync shared sync worker', event);
+        };
+        this.syncStreamClient = new WebStreamingSyncImplementation({
+            adapter: new SqliteBucketStorage(new WASQLiteDBAdapter({
+                dbFilename: params.dbName,
+                workerPort: dbWorkerPort,
+                flags: { enableMultiTabs: true, useWebWorker: true },
+                logger
+            }), new Mutex(), logger),
+            remote: new WebRemote({
+                fetchCredentials: async () => {
                     const lastPort = this.ports[this.ports.length - 1];
-                    return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                    return new Promise(async (resolve, reject) => {
                         const abortController = new AbortController();
-                        this.uploadDataController = {
+                        this.fetchCredentialsController = {
                             controller: abortController,
                             activePort: lastPort
                         };
-                        // Resolving will make it retry
-                        abortController.signal.onabort = () => resolve();
+                        abortController.signal.onabort = reject;
                         try {
-                            resolve(yield lastPort.clientProvider.uploadCrud());
+                            resolve(await lastPort.clientProvider.fetchCredentials());
                         }
                         catch (ex) {
                             reject(ex);
                         }
                         finally {
-                            this.uploadDataController = undefined;
+                            this.fetchCredentialsController = undefined;
                         }
-                    }));
-                }) }, params.streamOptions), { 
-                // Logger cannot be transferred just yet
-                logger }));
-            this.syncStreamClient.registerListener({
-                statusChanged: (status) => {
-                    this.updateAllStatuses(status.toJSON());
+                    });
                 }
-            });
-            this.iterateListeners((l) => { var _a; return (_a = l.initialized) === null || _a === void 0 ? void 0 : _a.call(l); });
+            }),
+            uploadCrud: async () => {
+                const lastPort = this.ports[this.ports.length - 1];
+                return new Promise(async (resolve, reject) => {
+                    const abortController = new AbortController();
+                    this.uploadDataController = {
+                        controller: abortController,
+                        activePort: lastPort
+                    };
+                    // Resolving will make it retry
+                    abortController.signal.onabort = () => resolve();
+                    try {
+                        resolve(await lastPort.clientProvider.uploadCrud());
+                    }
+                    catch (ex) {
+                        reject(ex);
+                    }
+                    finally {
+                        this.uploadDataController = undefined;
+                    }
+                });
+            },
+            ...params.streamOptions,
+            // Logger cannot be transferred just yet
+            logger
         });
-    }
-    dispose() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            yield this.waitForReady();
-            (_a = this.statusListener) === null || _a === void 0 ? void 0 : _a.call(this);
-            return (_b = this.syncStreamClient) === null || _b === void 0 ? void 0 : _b.dispose();
+        this.syncStreamClient.registerListener({
+            statusChanged: (status) => {
+                this.updateAllStatuses(status.toJSON());
+            }
         });
+        this.iterateListeners((l) => l.initialized?.());
+    }
+    async dispose() {
+        await this.waitForReady();
+        this.statusListener?.();
+        return this.syncStreamClient?.dispose();
     }
     /**
      * Connects to the PowerSync backend instance.
@@ -149,32 +141,27 @@ export class SharedSyncImplementation extends BaseObserver {
      * The connection will simply be reconnected whenever a new tab
      * connects.
      */
-    connect(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.waitForReady();
-            // This effectively queues connect and disconnect calls. Ensuring multiple tabs' requests are synchronized
-            return navigator.locks.request('shared-sync-connect', () => { var _a; return (_a = this.syncStreamClient) === null || _a === void 0 ? void 0 : _a.connect(options); });
-        });
+    async connect(options) {
+        await this.waitForReady();
+        // This effectively queues connect and disconnect calls. Ensuring multiple tabs' requests are synchronized
+        return navigator.locks.request('shared-sync-connect', () => this.syncStreamClient?.connect(options));
     }
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.waitForReady();
-            // This effectively queues connect and disconnect calls. Ensuring multiple tabs' requests are synchronized
-            return navigator.locks.request('shared-sync-connect', () => { var _a; return (_a = this.syncStreamClient) === null || _a === void 0 ? void 0 : _a.disconnect(); });
-        });
+    async disconnect() {
+        await this.waitForReady();
+        // This effectively queues connect and disconnect calls. Ensuring multiple tabs' requests are synchronized
+        return navigator.locks.request('shared-sync-connect', () => this.syncStreamClient?.disconnect());
     }
     /**
      * Adds a new client tab's message port to the list of connected ports
      */
     addPort(port) {
-        var _a;
         const portProvider = {
             port,
             clientProvider: Comlink.wrap(port)
         };
         this.ports.push(portProvider);
         // Give the newly connected client the latest status
-        const status = (_a = this.syncStreamClient) === null || _a === void 0 ? void 0 : _a.syncStatus;
+        const status = this.syncStreamClient?.syncStatus;
         if (status) {
             portProvider.clientProvider.statusChanged(status.toJSON());
         }
@@ -198,31 +185,25 @@ export class SharedSyncImplementation extends BaseObserver {
          * not resolve. Abort them here.
          */
         [this.fetchCredentialsController, this.uploadDataController].forEach((abortController) => {
-            if ((abortController === null || abortController === void 0 ? void 0 : abortController.activePort.port) == port) {
+            if (abortController?.activePort.port == port) {
                 abortController.controller.abort(new AbortOperation('Closing pending requests after client port is removed'));
             }
         });
     }
     triggerCrudUpload() {
-        this.waitForReady().then(() => { var _a; return (_a = this.syncStreamClient) === null || _a === void 0 ? void 0 : _a.triggerCrudUpload(); });
+        this.waitForReady().then(() => this.syncStreamClient?.triggerCrudUpload());
     }
-    obtainLock(lockOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.waitForReady();
-            return this.syncStreamClient.obtainLock(lockOptions);
-        });
+    async obtainLock(lockOptions) {
+        await this.waitForReady();
+        return this.syncStreamClient.obtainLock(lockOptions);
     }
-    hasCompletedSync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.waitForReady();
-            return this.syncStreamClient.hasCompletedSync();
-        });
+    async hasCompletedSync() {
+        await this.waitForReady();
+        return this.syncStreamClient.hasCompletedSync();
     }
-    getWriteCheckpoint() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.waitForReady();
-            return this.syncStreamClient.getWriteCheckpoint();
-        });
+    async getWriteCheckpoint() {
+        await this.waitForReady();
+        return this.syncStreamClient.getWriteCheckpoint();
     }
     /**
      * A method to update the all shared statuses for each

package/lib/src/worker/sync/SharedSyncImplementation.worker.js

@@ -1,10 +1,6 @@
 import * as Comlink from 'comlink';
 import { SharedSyncImplementation, SharedSyncClientEvent } from './SharedSyncImplementation';
 import Logger from 'js-logger';
-import { Buffer } from 'buffer';
-if (typeof self.Buffer == 'undefined') {
-    self.Buffer = Buffer;
-}
 const _self = self;
 Logger.useDefaults();
 const sharedSyncImplementation = new SharedSyncImplementation();
@@ -16,7 +12,7 @@ _self.onconnect = function (event) {
      */
     port.addEventListener('message', (event) => {
         const payload = event.data;
-        if ((payload === null || payload === void 0 ? void 0 : payload.event) == SharedSyncClientEvent.CLOSE_CLIENT) {
+        if (payload?.event == SharedSyncClientEvent.CLOSE_CLIENT) {
             console.log('closing shared for port', port);
             sharedSyncImplementation.removePort(port);
         }