@powersync/web 0.5.3 → 0.6.1

package/README.md

@@ -32,6 +32,30 @@ 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;
+}
+```
+
 # Getting Started
 
 Our [full SDK reference](https://docs.powersync.com/client-sdk-references/js-web) contains everything you need to know to get started implementing PowerSync in your project.

package/lib/src/db/PowerSyncDatabase.d.ts

@@ -1,4 +1,4 @@
-import { AbstractPowerSyncDatabase, AbstractStreamingSyncImplementation, PowerSyncBackendConnector, BucketStorageAdapter, PowerSyncDatabaseOptions, PowerSyncCloseOptions } from '@powersync/common';
+import { AbstractPowerSyncDatabase, AbstractStreamingSyncImplementation, PowerSyncBackendConnector, BucketStorageAdapter, PowerSyncDatabaseOptions, PowerSyncCloseOptions, PowerSyncConnectionOptions } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 export interface WebPowerSyncFlags {
     /**
@@ -36,7 +36,7 @@ export declare class PowerSyncDatabase extends AbstractPowerSyncDatabase {
      * multiple tabs are not enabled.
      */
     close(options?: PowerSyncCloseOptions): Promise<void>;
-    connect(connector: PowerSyncBackendConnector): Promise<void>;
+    connect(connector: PowerSyncBackendConnector, options?: PowerSyncConnectionOptions): Promise<void>;
     protected generateBucketStorageAdapter(): BucketStorageAdapter;
     protected runExclusive<T>(cb: () => Promise<T>): Promise<any>;
     protected generateSyncStreamImplementation(connector: PowerSyncBackendConnector): AbstractStreamingSyncImplementation;

package/lib/src/db/PowerSyncDatabase.js

@@ -41,7 +41,7 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
             disconnect: (_a = options.disconnect) !== null && _a !== void 0 ? _a : !((_b = this.options.flags) === null || _b === void 0 ? void 0 : _b.enableMultiTabs)
         });
     }
-    connect(connector) {
+    connect(connector, options) {
         /**
          * Using React strict mode might cause calls to connect to fire multiple times
          * Connect is wrapped inside a lock in order to prevent race conditions internally between multiple
@@ -50,7 +50,7 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
         return this.runExclusive(() => {
             var _a;
             (_a = this.options.logger) === null || _a === void 0 ? void 0 : _a.debug('Attempting to connect to PowerSync instance');
-            return super.connect(connector);
+            return super.connect(connector, options);
         });
     }
     generateBucketStorageAdapter() {
@@ -89,4 +89,3 @@ Logs for shared sync worker will only be available in the shared worker context
     }
 }
 PowerSyncDatabase.SHARED_MUTEX = new Mutex();
-//# sourceMappingURL=PowerSyncDatabase.js.map

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

@@ -54,4 +54,3 @@ export class AbstractWebPowerSyncDatabaseOpenFactory extends AbstractPowerSyncDa
         return new PowerSyncDatabase(options);
     }
 }
-//# sourceMappingURL=AbstractWebPowerSyncDatabaseOpenFactory.js.map

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

@@ -83,4 +83,3 @@ export class SSRDBAdapter extends BaseObserver {
             }) });
     }
 }
-//# sourceMappingURL=SSRDBAdapter.js.map

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

@@ -194,4 +194,3 @@ export class WASQLiteDBAdapter extends BaseObserver {
             } });
     }
 }
-//# sourceMappingURL=WASQLiteDBAdapter.js.map

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

@@ -9,4 +9,3 @@ export class WASQLitePowerSyncDatabaseOpenFactory extends AbstractWebPowerSyncDa
         return new PowerSyncDatabase(options);
     }
 }
-//# sourceMappingURL=WASQLitePowerSyncDatabaseOpenFactory.js.map

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

@@ -11,4 +11,3 @@ export class SSRStreamingSyncImplementation extends AbstractStreamingSyncImpleme
         return mutex.runExclusive(lockOptions.callback);
     }
 }
-//# sourceMappingURL=SSRWebStreamingSyncImplementation.js.map

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

@@ -2,7 +2,7 @@ import * as Comlink from 'comlink';
 import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from './WebStreamingSyncImplementation';
 import { SharedSyncImplementation } from '../../worker/sync/SharedSyncImplementation';
 import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
-import { PowerSyncCredentials, SyncStatusOptions } from '@powersync/common';
+import { PowerSyncConnectionOptions, PowerSyncCredentials, SyncStatusOptions } from '@powersync/common';
 /**
  * The shared worker will trigger methods on this side of the message port
  * via this client provider.
@@ -33,7 +33,7 @@ export declare class SharedWebStreamingSyncImplementation extends WebStreamingSy
      * Starts the sync process, this effectively acts as a call to
      * `connect` if not yet connected.
      */
-    connect(): Promise<void>;
+    connect(options?: PowerSyncConnectionOptions): Promise<void>;
     disconnect(): Promise<void>;
     getWriteCheckpoint(): Promise<string>;
     hasCompletedSync(): Promise<boolean>;

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

@@ -135,10 +135,10 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
      * Starts the sync process, this effectively acts as a call to
      * `connect` if not yet connected.
      */
-    connect() {
+    connect(options) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.waitForReady();
-            return this.syncManager.connect();
+            return this.syncManager.connect(options);
         });
     }
     disconnect() {
@@ -185,4 +185,3 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
         });
     }
 }
-//# sourceMappingURL=SharedWebStreamingSyncImplementation.js.map

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

@@ -1,6 +1,3 @@
 import { AbstractRemote } from '@powersync/common';
 export declare class WebRemote extends AbstractRemote {
-    post(path: string, data: any, headers?: Record<string, string>): Promise<any>;
-    get(path: string, headers?: Record<string, string>): Promise<any>;
-    postStreaming(path: string, data: any, headers?: Record<string, string>, signal?: AbortSignal): Promise<any>;
 }

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

@@ -1,134 +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 { AbortOperation, AbstractRemote } from '@powersync/common';
+import { AbstractRemote } from '@powersync/common';
 export class WebRemote extends AbstractRemote {
-    post(path_1, data_1) {
-        return __awaiter(this, arguments, void 0, function* (path, data, headers = {}) {
-            const request = yield this.buildRequest(path);
-            const res = yield fetch(request.url, {
-                method: 'POST',
-                headers: Object.assign(Object.assign({}, headers), request.headers),
-                body: JSON.stringify(data)
-            });
-            if (!res.ok) {
-                throw new Error(`Received ${res.status} - ${res.statusText} when posting to ${path}: ${yield res.text()}}`);
-            }
-            return res.json();
-        });
-    }
-    get(path, headers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const request = yield this.buildRequest(path);
-            const res = yield fetch(request.url, {
-                method: 'GET',
-                headers: Object.assign(Object.assign({}, headers), request.headers)
-            });
-            if (!res.ok) {
-                throw new Error(`Received ${res.status} - ${res.statusText} when getting from ${path}: ${yield res.text()}}`);
-            }
-            return res.json();
-        });
-    }
-    postStreaming(path_1, data_1) {
-        return __awaiter(this, arguments, void 0, function* (path, data, headers = {}, signal) {
-            const request = yield this.buildRequest(path);
-            /**
-             * This abort controller will abort pending fetch requests.
-             * If the request has resolved, it will be used to close the readable stream.
-             * Which will cancel the network request.
-             *
-             * This nested controller is required since:
-             *  Aborting the active fetch request while it is being consumed seems to throw
-             *  an unhandled exception on the window level.
-             */
-            const controller = new AbortController();
-            let requestResolved = false;
-            signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', () => {
-                var _a;
-                if (!requestResolved) {
-                    // Only abort via the abort controller if the request has not resolved yet
-                    controller.abort((_a = signal.reason) !== null && _a !== void 0 ? _a : new AbortOperation('Cancelling network request before it resolves. Abort signal has been received.'));
-                }
-            });
-            const res = yield fetch(request.url, {
-                method: 'POST',
-                headers: Object.assign(Object.assign({}, headers), request.headers),
-                body: JSON.stringify(data),
-                signal: controller.signal,
-                cache: 'no-store'
-            }).catch((ex) => {
-                if (ex.name == 'AbortError') {
-                    throw new AbortOperation(`Pending fetch request to ${request.url} has been aborted.`);
-                }
-                throw ex;
-            });
-            if (!res) {
-                throw new Error('Fetch request was aborted');
-            }
-            requestResolved = true;
-            if (!res.ok || !res.body) {
-                const text = yield res.text();
-                this.logger.error(`Could not POST streaming to ${path} - ${res.status} - ${res.statusText}: ${text}`);
-                const error = new Error(`HTTP ${res.statusText}: ${text}`);
-                error.status = res.status;
-                throw error;
-            }
-            /**
-             * The can-ndjson-stream does not handle aborted streams well.
-             * This will intercept the readable stream and close the stream if
-             * aborted.
-             */
-            const reader = res.body.getReader();
-            // This will close the network request and read stream
-            const closeReader = () => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    yield reader.cancel();
-                }
-                catch (ex) {
-                    // an error will throw if the reader hasn't been used yet
-                }
-                reader.releaseLock();
-            });
-            signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', () => {
-                closeReader();
-            });
-            const outputStream = new ReadableStream({
-                start: (controller) => {
-                    const processStream = () => __awaiter(this, void 0, void 0, function* () {
-                        while (!(signal === null || signal === void 0 ? void 0 : signal.aborted)) {
-                            try {
-                                const { done, value } = yield reader.read();
-                                // When no more data needs to be consumed, close the stream
-                                if (done) {
-                                    break;
-                                }
-                                // Enqueue the next data chunk into our target stream
-                                controller.enqueue(value);
-                            }
-                            catch (ex) {
-                                this.logger.error('Caught exception when reading sync stream', ex);
-                                break;
-                            }
-                        }
-                        if (!(signal === null || signal === void 0 ? void 0 : signal.aborted)) {
-                            // Close the downstream readable stream
-                            yield closeReader();
-                        }
-                        controller.close();
-                    });
-                    processStream();
-                }
-            });
-            // Create a new response out of the intercepted stream
-            return new Response(outputStream).body;
-        });
-    }
 }
-//# sourceMappingURL=WebRemote.js.map

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

@@ -13,4 +13,3 @@ export class WebStreamingSyncImplementation extends AbstractStreamingSyncImpleme
         return navigator.locks.request(identifier, { signal: lockOptions.signal }, lockOptions.callback);
     }
 }
-//# sourceMappingURL=WebStreamingSyncImplementation.js.map

package/lib/src/index.js

@@ -6,4 +6,3 @@ export * from './db/sync/SharedWebStreamingSyncImplementation';
 export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter';
 export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory';
 export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory';
-//# sourceMappingURL=index.js.map

package/lib/src/worker/db/SharedWASQLiteDB.worker.js

@@ -9,15 +9,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import '@journeyapps/wa-sqlite';
 import * as Comlink from 'comlink';
-import { v4 as uuid } from 'uuid';
 import { _openDB } from './open-db';
 const _self = self;
 const DBMap = new Map();
 const OPEN_DB_LOCK = 'open-wasqlite-db';
+let nextClientId = 1;
 const openDB = (dbFileName) => __awaiter(void 0, void 0, void 0, function* () {
     // Prevent multiple simultaneous opens from causing race conditions
     return navigator.locks.request(OPEN_DB_LOCK, () => __awaiter(void 0, void 0, void 0, function* () {
-        const clientId = uuid();
+        const clientId = nextClientId++;
         if (!DBMap.has(dbFileName)) {
             const clientIds = new Set();
             const connection = yield _openDB(dbFileName);
@@ -55,4 +55,3 @@ addEventListener('unload', () => {
         (_a = db.close) === null || _a === void 0 ? void 0 : _a.call(db);
     }));
 });
-//# sourceMappingURL=SharedWASQLiteDB.worker.js.map

package/lib/src/worker/db/WASQLiteDB.worker.js

@@ -10,4 +10,3 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import * as Comlink from 'comlink';
 import { _openDB } from './open-db';
 Comlink.expose((dbFileName) => __awaiter(void 0, void 0, void 0, function* () { return Comlink.proxy(yield _openDB(dbFileName)); }));
-//# sourceMappingURL=WASQLiteDB.worker.js.map

package/lib/src/worker/db/open-db.js

@@ -17,7 +17,7 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 import * as SQLite from '@journeyapps/wa-sqlite';
 import '@journeyapps/wa-sqlite';
 import * as Comlink from 'comlink';
-import { v4 as uuid } from 'uuid';
+let nextId = 1;
 export function _openDB(dbFileName) {
     return __awaiter(this, void 0, void 0, function* () {
         const { default: moduleFactory } = yield import('@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs');
@@ -35,7 +35,7 @@ export function _openDB(dbFileName) {
             Array.from(listeners.values()).forEach((l) => l(opType, tableName, rowId));
         });
         const registerOnTableChange = (callback) => {
-            const id = uuid();
+            const id = nextId++;
             listeners.set(id, callback);
             return Comlink.proxy(() => {
                 listeners.delete(id);
@@ -190,4 +190,3 @@ export function _openDB(dbFileName) {
         };
     });
 }
-//# sourceMappingURL=open-db.js.map

package/lib/src/worker/db/open-worker-database.js

@@ -28,4 +28,3 @@ export function openWorkerDatabasePort(workerIdentifier, multipleTabs = true) {
 export function getWorkerDatabaseOpener(workerIdentifier, multipleTabs = true) {
     return Comlink.wrap(openWorkerDatabasePort(workerIdentifier, multipleTabs));
 }
-//# sourceMappingURL=open-worker-database.js.map

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

@@ -3,4 +3,3 @@
  */
 export class AbstractSharedSyncClientProvider {
 }
-//# sourceMappingURL=AbstractSharedSyncClientProvider.js.map

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

@@ -105,4 +105,3 @@ export class BroadcastLogger {
         return sanitizedParams;
     }
 }
-//# sourceMappingURL=BroadcastLogger.js.map

package/lib/src/worker/sync/SharedSyncImplementation.d.ts

@@ -1,6 +1,6 @@
 import * as Comlink from 'comlink';
 import { ILogger } from 'js-logger';
-import { AbstractStreamingSyncImplementation, StreamingSyncImplementation, BaseObserver, LockOptions, StreamingSyncImplementationListener, SyncStatus, SyncStatusOptions } from '@powersync/common';
+import { AbstractStreamingSyncImplementation, StreamingSyncImplementation, BaseObserver, LockOptions, StreamingSyncImplementationListener, SyncStatus, SyncStatusOptions, PowerSyncConnectionOptions } from '@powersync/common';
 import { WebStreamingSyncImplementationOptions } from '../../db/sync/WebStreamingSyncImplementation';
 import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider';
 /**
@@ -60,7 +60,7 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
      * The connection will simply be reconnected whenever a new tab
      * connects.
      */
-    connect(): Promise<any>;
+    connect(options?: PowerSyncConnectionOptions): Promise<any>;
     disconnect(): Promise<any>;
     /**
      * Adds a new client tab's message port to the list of connected ports

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

@@ -149,11 +149,11 @@ export class SharedSyncImplementation extends BaseObserver {
      * The connection will simply be reconnected whenever a new tab
      * connects.
      */
-    connect() {
+    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(); });
+            return navigator.locks.request('shared-sync-connect', () => { var _a; return (_a = this.syncStreamClient) === null || _a === void 0 ? void 0 : _a.connect(options); });
         });
     }
     disconnect() {
@@ -245,4 +245,3 @@ export class SharedSyncImplementation extends BaseObserver {
         this.updateAllStatuses(status);
     }
 }
-//# sourceMappingURL=SharedSyncImplementation.js.map

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();
@@ -20,4 +24,3 @@ _self.onconnect = function (event) {
     Comlink.expose(sharedSyncImplementation, port);
     sharedSyncImplementation.addPort(port);
 };
-//# sourceMappingURL=SharedSyncImplementation.worker.js.map