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

package/lib/src/worker/sync/SharedSyncImplementation.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 Logger from 'js-logger';
 import { BaseObserver, SqliteBucketStorage, SyncStatus, AbortOperation } from '@powersync/common';
@@ -21,14 +30,6 @@ 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 = [];
@@ -36,104 +37,111 @@ export class SharedSyncImplementation extends BaseObserver {
             const callback = this.registerListener({
                 initialized: () => {
                     resolve();
-                    callback?.();
+                    callback === null || callback === void 0 ? void 0 : callback();
                 }
             });
         });
         this.syncStatus = new SyncStatus({});
         this.broadCastLogger = new BroadcastLogger(this.ports);
     }
-    async waitForStatus(status) {
-        await this.waitForReady();
-        return this.syncStreamClient.waitForStatus(status);
+    waitForStatus(status) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.waitForReady();
+            return this.syncStreamClient.waitForStatus(status);
+        });
     }
     get lastSyncedAt() {
-        return this.syncStreamClient?.lastSyncedAt;
+        var _a;
+        return (_a = this.syncStreamClient) === null || _a === void 0 ? void 0 : _a.lastSyncedAt;
     }
     get isConnected() {
-        return this.syncStreamClient?.isConnected ?? false;
+        var _a, _b;
+        return (_b = (_a = this.syncStreamClient) === null || _a === void 0 ? void 0 : _a.isConnected) !== null && _b !== void 0 ? _b : false;
     }
-    async waitForReady() {
-        return this.isInitialized;
+    waitForReady() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.isInitialized;
+        });
     }
     /**
      * Configures the DBAdapter connection and a streaming sync client.
      */
-    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 () => {
+    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* () {
                     const lastPort = this.ports[this.ports.length - 1];
-                    return new Promise(async (resolve, reject) => {
+                    return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                         const abortController = new AbortController();
-                        this.fetchCredentialsController = {
+                        this.uploadDataController = {
                             controller: abortController,
                             activePort: lastPort
                         };
-                        abortController.signal.onabort = reject;
+                        // Resolving will make it retry
+                        abortController.signal.onabort = () => resolve();
                         try {
-                            resolve(await lastPort.clientProvider.fetchCredentials());
+                            resolve(yield lastPort.clientProvider.uploadCrud());
                         }
                         catch (ex) {
                             reject(ex);
                         }
                         finally {
-                            this.fetchCredentialsController = undefined;
+                            this.uploadDataController = undefined;
                         }
-                    });
+                    }));
+                }) }, params.streamOptions), { 
+                // Logger cannot be transferred just yet
+                logger }));
+            this.syncStreamClient.registerListener({
+                statusChanged: (status) => {
+                    this.updateAllStatuses(status.toJSON());
                 }
-            }),
-            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
-        });
-        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); });
         });
-        this.iterateListeners((l) => l.initialized?.());
     }
-    async dispose() {
-        await this.waitForReady();
-        this.statusListener?.();
-        return this.syncStreamClient?.dispose();
+    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();
+        });
     }
     /**
      * Connects to the PowerSync backend instance.
@@ -141,27 +149,32 @@ export class SharedSyncImplementation extends BaseObserver {
      * The connection will simply be reconnected whenever a new tab
      * connects.
      */
-    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));
+    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 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());
+    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(); });
+        });
     }
     /**
      * 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 = this.syncStreamClient?.syncStatus;
+        const status = (_a = this.syncStreamClient) === null || _a === void 0 ? void 0 : _a.syncStatus;
         if (status) {
             portProvider.clientProvider.statusChanged(status.toJSON());
         }
@@ -185,25 +198,31 @@ export class SharedSyncImplementation extends BaseObserver {
          * not resolve. Abort them here.
          */
         [this.fetchCredentialsController, this.uploadDataController].forEach((abortController) => {
-            if (abortController?.activePort.port == port) {
+            if ((abortController === null || abortController === void 0 ? void 0 : abortController.activePort.port) == port) {
                 abortController.controller.abort(new AbortOperation('Closing pending requests after client port is removed'));
             }
         });
     }
     triggerCrudUpload() {
-        this.waitForReady().then(() => this.syncStreamClient?.triggerCrudUpload());
+        this.waitForReady().then(() => { var _a; return (_a = this.syncStreamClient) === null || _a === void 0 ? void 0 : _a.triggerCrudUpload(); });
     }
-    async obtainLock(lockOptions) {
-        await this.waitForReady();
-        return this.syncStreamClient.obtainLock(lockOptions);
+    obtainLock(lockOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.waitForReady();
+            return this.syncStreamClient.obtainLock(lockOptions);
+        });
     }
-    async hasCompletedSync() {
-        await this.waitForReady();
-        return this.syncStreamClient.hasCompletedSync();
+    hasCompletedSync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.waitForReady();
+            return this.syncStreamClient.hasCompletedSync();
+        });
     }
-    async getWriteCheckpoint() {
-        await this.waitForReady();
-        return this.syncStreamClient.getWriteCheckpoint();
+    getWriteCheckpoint() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield 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,6 +1,10 @@
 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();
@@ -12,7 +16,7 @@ _self.onconnect = function (event) {
      */
     port.addEventListener('message', (event) => {
         const payload = event.data;
-        if (payload?.event == SharedSyncClientEvent.CLOSE_CLIENT) {
+        if ((payload === null || payload === void 0 ? void 0 : payload.event) == SharedSyncClientEvent.CLOSE_CLIENT) {
             console.log('closing shared for port', port);
             sharedSyncImplementation.removePort(port);
         }