@powersync/web 0.0.0-dev-20240506092851

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

@@ -0,0 +1,196 @@
+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 { BaseObserver } from '@powersync/common';
+import * as Comlink from 'comlink';
+import Logger from 'js-logger';
+import { getWorkerDatabaseOpener } from '../../../worker/db/open-worker-database';
+/**
+ * Adapter for WA-SQLite
+ */
+export class WASQLiteDBAdapter extends BaseObserver {
+    constructor(options) {
+        super();
+        this.options = options;
+        /**
+         * Wraps the worker execute function, awaiting for it to be available
+         */
+        this._execute = (sql, bindings) => __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            const result = yield this.workerMethods.execute(sql, bindings);
+            return Object.assign(Object.assign({}, result), { rows: Object.assign(Object.assign({}, result.rows), { item: (idx) => result.rows._array[idx] }) });
+        });
+        /**
+         * Wraps the worker executeBatch function, awaiting for it to be available
+         */
+        this._executeBatch = (query, params) => __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            const result = yield this.workerMethods.executeBatch(query, params);
+            return Object.assign(Object.assign({}, result), { rows: undefined });
+        });
+        this.logger = Logger.get('WASQLite');
+        this.dbGetHelpers = null;
+        this.workerMethods = null;
+        this.initialized = this.init();
+        this.dbGetHelpers = this.generateDBHelpers({ execute: this._execute.bind(this) });
+    }
+    get name() {
+        return this.options.dbFilename;
+    }
+    get flags() {
+        var _a;
+        return (_a = this.options.flags) !== null && _a !== void 0 ? _a : {};
+    }
+    getWorker() { }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { enableMultiTabs } = this.flags;
+            if (!enableMultiTabs) {
+                this.logger.warn('Multiple tabs are not enabled in this browser');
+            }
+            const dbOpener = this.options.workerPort
+                ? Comlink.wrap(this.options.workerPort)
+                : getWorkerDatabaseOpener(this.options.dbFilename, enableMultiTabs);
+            this.workerMethods = yield dbOpener(this.options.dbFilename);
+            this.workerMethods.registerOnTableChange(Comlink.proxy((opType, tableName, rowId) => {
+                this.iterateListeners((cb) => { var _a; return (_a = cb.tablesUpdated) === null || _a === void 0 ? void 0 : _a.call(cb, { opType, table: tableName, rowId }); });
+            }));
+        });
+    }
+    execute(query, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.writeLock((ctx) => ctx.execute(query, params));
+        });
+    }
+    executeBatch(query, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.writeLock((ctx) => this._executeBatch(query, params));
+        });
+    }
+    /**
+     * Attempts to close the connection.
+     * Shared workers might not actually close the connection if other
+     * tabs are still using it.
+     */
+    close() {
+        var _a, _b;
+        (_b = (_a = this.workerMethods) === null || _a === void 0 ? void 0 : _a.close) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    getAll(sql, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            return this.dbGetHelpers.getAll(sql, parameters);
+        });
+    }
+    getOptional(sql, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            return this.dbGetHelpers.getOptional(sql, parameters);
+        });
+    }
+    get(sql, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            return this.dbGetHelpers.get(sql, parameters);
+        });
+    }
+    readLock(fn, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            return this.acquireLock(() => __awaiter(this, void 0, void 0, function* () { return fn(this.generateDBHelpers({ execute: this._execute })); }));
+        });
+    }
+    writeLock(fn, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            return this.acquireLock(() => __awaiter(this, void 0, void 0, function* () { return fn(this.generateDBHelpers({ execute: this._execute })); }));
+        });
+    }
+    acquireLock(callback) {
+        return navigator.locks.request(`db-lock-${this.options.dbFilename}`, callback);
+    }
+    readTransaction(fn, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.readLock(this.wrapTransaction(fn));
+        });
+    }
+    writeTransaction(fn, options) {
+        return this.writeLock(this.wrapTransaction(fn));
+    }
+    /**
+     * Wraps a lock context into a transaction context
+     */
+    wrapTransaction(cb) {
+        return (tx) => __awaiter(this, void 0, void 0, function* () {
+            yield this._execute('BEGIN TRANSACTION');
+            let finalized = false;
+            const commit = () => __awaiter(this, void 0, void 0, function* () {
+                if (finalized) {
+                    return { rowsAffected: 0 };
+                }
+                finalized = true;
+                return this._execute('COMMIT');
+            });
+            const rollback = () => {
+                finalized = true;
+                return this._execute('ROLLBACK');
+            };
+            try {
+                const result = yield cb(Object.assign(Object.assign({}, tx), { commit,
+                    rollback }));
+                if (!finalized) {
+                    yield commit();
+                }
+                return result;
+            }
+            catch (ex) {
+                this.logger.debug('Caught ex in transaction', ex);
+                yield rollback();
+                throw ex;
+            }
+        });
+    }
+    generateDBHelpers(tx) {
+        return Object.assign(Object.assign({}, tx), { 
+            /**
+             *  Execute a read-only query and return results
+             */
+            getAll(sql, parameters) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    const res = yield tx.execute(sql, parameters);
+                    return (_b = (_a = res.rows) === null || _a === void 0 ? void 0 : _a._array) !== null && _b !== void 0 ? _b : [];
+                });
+            },
+            /**
+             * Execute a read-only query and return the first result, or null if the ResultSet is empty.
+             */
+            getOptional(sql, parameters) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    const res = yield tx.execute(sql, parameters);
+                    return (_b = (_a = res.rows) === null || _a === void 0 ? void 0 : _a.item(0)) !== null && _b !== void 0 ? _b : null;
+                });
+            },
+            /**
+             * Execute a read-only query and return the first result, error if the ResultSet is empty.
+             */
+            get(sql, parameters) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    const res = yield tx.execute(sql, parameters);
+                    const first = (_a = res.rows) === null || _a === void 0 ? void 0 : _a.item(0);
+                    if (!first) {
+                        throw new Error('Result set is empty');
+                    }
+                    return first;
+                });
+            } });
+    }
+}

package/lib/src/db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory.d.ts

@@ -0,0 +1,6 @@
+import { AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions } from '@powersync/common';
+import { AbstractWebPowerSyncDatabaseOpenFactory } from '../AbstractWebPowerSyncDatabaseOpenFactory';
+export declare class WASQLitePowerSyncDatabaseOpenFactory extends AbstractWebPowerSyncDatabaseOpenFactory {
+    protected openDB(): DBAdapter;
+    generateInstance(options: PowerSyncDatabaseOptions): AbstractPowerSyncDatabase;
+}

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

@@ -0,0 +1,11 @@
+import { PowerSyncDatabase } from '../../../db/PowerSyncDatabase';
+import { WASQLiteDBAdapter } from './WASQLiteDBAdapter';
+import { AbstractWebPowerSyncDatabaseOpenFactory } from '../AbstractWebPowerSyncDatabaseOpenFactory';
+export class WASQLitePowerSyncDatabaseOpenFactory extends AbstractWebPowerSyncDatabaseOpenFactory {
+    openDB() {
+        return new WASQLiteDBAdapter(Object.assign(Object.assign({}, this.options), { flags: this.resolveDBFlags() }));
+    }
+    generateInstance(options) {
+        return new PowerSyncDatabase(options);
+    }
+}

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

@@ -0,0 +1,8 @@
+import { AbstractStreamingSyncImplementation, AbstractStreamingSyncImplementationOptions, LockOptions } from '@powersync/common';
+import { Mutex } from 'async-mutex';
+export declare class SSRStreamingSyncImplementation extends AbstractStreamingSyncImplementation {
+    syncMutex: Mutex;
+    crudMutex: Mutex;
+    constructor(options: AbstractStreamingSyncImplementationOptions);
+    obtainLock<T>(lockOptions: LockOptions<T>): Promise<T>;
+}

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

@@ -0,0 +1,13 @@
+import { AbstractStreamingSyncImplementation, LockType } from '@powersync/common';
+import { Mutex } from 'async-mutex';
+export class SSRStreamingSyncImplementation extends AbstractStreamingSyncImplementation {
+    constructor(options) {
+        super(options);
+        this.syncMutex = new Mutex();
+        this.crudMutex = new Mutex();
+    }
+    obtainLock(lockOptions) {
+        const mutex = lockOptions.type == LockType.CRUD ? this.crudMutex : this.syncMutex;
+        return mutex.runExclusive(lockOptions.callback);
+    }
+}

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

@@ -0,0 +1,47 @@
+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';
+/**
+ * The shared worker will trigger methods on this side of the message port
+ * via this client provider.
+ */
+declare class SharedSyncClientProvider extends AbstractSharedSyncClientProvider {
+    protected options: WebStreamingSyncImplementationOptions;
+    statusChanged: (status: SyncStatusOptions) => void;
+    constructor(options: WebStreamingSyncImplementationOptions, statusChanged: (status: SyncStatusOptions) => void);
+    fetchCredentials(): Promise<PowerSyncCredentials | null>;
+    uploadCrud(): Promise<void>;
+    get logger(): import("js-logger").ILogger | undefined;
+    trace(...x: any[]): void;
+    debug(...x: any[]): void;
+    info(...x: any[]): void;
+    log(...x: any[]): void;
+    warn(...x: any[]): void;
+    error(...x: any[]): void;
+    time(label: string): void;
+    timeEnd(label: string): void;
+}
+export declare class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplementation {
+    protected syncManager: Comlink.Remote<SharedSyncImplementation>;
+    protected clientProvider: SharedSyncClientProvider;
+    protected messagePort: MessagePort;
+    protected isInitialized: Promise<void>;
+    constructor(options: WebStreamingSyncImplementationOptions);
+    /**
+     * Starts the sync process, this effectively acts as a call to
+     * `connect` if not yet connected.
+     */
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getWriteCheckpoint(): Promise<string>;
+    hasCompletedSync(): Promise<boolean>;
+    dispose(): Promise<void>;
+    waitForReady(): Promise<void>;
+    /**
+     * Used in tests to force a connection states
+     */
+    private _testUpdateStatus;
+}
+export {};

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

@@ -0,0 +1,187 @@
+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';
+import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
+import { openWorkerDatabasePort } from '../../worker/db/open-worker-database';
+/**
+ * The shared worker will trigger methods on this side of the message port
+ * via this client provider.
+ */
+class SharedSyncClientProvider extends AbstractSharedSyncClientProvider {
+    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
+            };
+        });
+    }
+    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) {
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.trace(...x);
+    }
+    debug(...x) {
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(...x);
+    }
+    info(...x) {
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info(...x);
+    }
+    log(...x) {
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.log(...x);
+    }
+    warn(...x) {
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.warn(...x);
+    }
+    error(...x) {
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error(...x);
+    }
+    time(label) {
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.time(label);
+    }
+    timeEnd(label) {
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.timeEnd(label);
+    }
+}
+export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplementation {
+    constructor(options) {
+        super(options);
+        /**
+         * Configure or connect to the shared sync worker.
+         * This worker will manage all syncing operations remotely.
+         */
+        const syncWorker = new SharedWorker(new URL('../../worker/sync/SharedSyncImplementation.worker.js', import.meta.url), {
+            /* @vite-ignore */
+            name: `shared-sync-${this.webOptions.identifier}`,
+            type: 'module'
+        });
+        this.messagePort = syncWorker.port;
+        this.syncManager = Comlink.wrap(this.messagePort);
+        this.triggerCrudUpload = this.syncManager.triggerCrudUpload;
+        /**
+         * Opens MessagePort to the existing shared DB worker.
+         * The sync worker cannot initiate connections directly to the
+         * DB worker, but a port to the DB worker can be transferred to the
+         * sync worker.
+         */
+        const { crudUploadThrottleMs, identifier, retryDelayMs } = this.options;
+        const dbOpenerPort = openWorkerDatabasePort(this.options.identifier, true);
+        this.isInitialized = this.syncManager.init(Comlink.transfer(dbOpenerPort, [dbOpenerPort]), {
+            dbName: this.options.identifier,
+            streamOptions: {
+                crudUploadThrottleMs,
+                identifier,
+                retryDelayMs,
+                flags: this.webOptions.flags
+            }
+        });
+        /**
+         * Pass along any sync status updates to this listener
+         */
+        this.clientProvider = new SharedSyncClientProvider(this.webOptions, (status) => {
+            this.iterateListeners((l) => this.updateSyncStatus(status));
+        });
+        /**
+         * The sync worker will call this client provider when it needs
+         * to fetch credentials or upload data.
+         * This performs bi-directional method calling.
+         */
+        Comlink.expose(this.clientProvider, this.messagePort);
+    }
+    /**
+     * Starts the sync process, this effectively acts as a call to
+     * `connect` if not yet connected.
+     */
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.waitForReady();
+            return this.syncManager.connect();
+        });
+    }
+    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
+     */
+    _testUpdateStatus(status) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.syncManager['_testUpdateAllStatuses'](status.toJSON());
+        });
+    }
+}

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,133 @@
+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';
+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;
+        });
+    }
+}

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

@@ -0,0 +1,11 @@
+import { AbstractStreamingSyncImplementation, AbstractStreamingSyncImplementationOptions, LockOptions } from '@powersync/common';
+export interface WebStreamingSyncImplementationOptions extends AbstractStreamingSyncImplementationOptions {
+    flags?: {
+        broadcastLogs?: boolean;
+    };
+}
+export declare class WebStreamingSyncImplementation extends AbstractStreamingSyncImplementation {
+    constructor(options: WebStreamingSyncImplementationOptions);
+    get webOptions(): WebStreamingSyncImplementationOptions;
+    obtainLock<T>(lockOptions: LockOptions<T>): Promise<T>;
+}

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

@@ -0,0 +1,15 @@
+import { AbstractStreamingSyncImplementation, LockType } from '@powersync/common';
+export class WebStreamingSyncImplementation extends AbstractStreamingSyncImplementation {
+    constructor(options) {
+        // Super will store and provide default values for options
+        super(options);
+    }
+    get webOptions() {
+        return this.options;
+    }
+    obtainLock(lockOptions) {
+        const identifier = `streaming-sync-${lockOptions.type}-${this.webOptions.identifier}`;
+        lockOptions.type == LockType.SYNC && console.debug('requesting lock for ', identifier);
+        return navigator.locks.request(identifier, { signal: lockOptions.signal }, lockOptions.callback);
+    }
+}

package/lib/src/index.d.ts

@@ -0,0 +1,8 @@
+export * from '@powersync/common';
+export * from './db/PowerSyncDatabase';
+export * from './db/sync/WebRemote';
+export * from './db/sync/WebStreamingSyncImplementation';
+export * from './db/sync/SharedWebStreamingSyncImplementation';
+export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter';
+export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory';
+export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory';

package/lib/src/index.js

@@ -0,0 +1,8 @@
+export * from '@powersync/common';
+export * from './db/PowerSyncDatabase';
+export * from './db/sync/WebRemote';
+export * from './db/sync/WebStreamingSyncImplementation';
+export * from './db/sync/SharedWebStreamingSyncImplementation';
+export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter';
+export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory';
+export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory';

package/lib/src/worker/db/SharedWASQLiteDB.worker.d.ts

@@ -0,0 +1 @@
+import '@journeyapps/wa-sqlite';