@powersync/web 1.35.0 → 1.37.0

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

@@ -1,147 +0,0 @@
-import { BaseObserver, ConnectionClosedError } from '@powersync/common';
-import * as Comlink from 'comlink';
-/**
- * Wraps a provided instance of {@link AsyncDatabaseConnection}, providing necessary proxy
- * functions for worker listeners.
- */
-export class WorkerWrappedAsyncDatabaseConnection extends BaseObserver {
-    options;
-    lockAbortController = new AbortController();
-    notifyRemoteClosed;
-    constructor(options) {
-        super();
-        this.options = options;
-        if (options.remoteCanCloseUnexpectedly) {
-            this.notifyRemoteClosed = new AbortController();
-        }
-    }
-    get baseConnection() {
-        return this.options.baseConnection;
-    }
-    init() {
-        return this.baseConnection.init();
-    }
-    /**
-     * Marks the remote as closed.
-     *
-     * This can sometimes happen outside of our control, e.g. when a shared worker requests a connection from a tab. When
-     * it happens, all methods on the {@link baseConnection} would never resolve. To avoid livelocks in this scenario, we
-     * throw on all outstanding promises and forbid new calls.
-     */
-    markRemoteClosed() {
-        // Can non-null assert here because this function is only supposed to be called when remoteCanCloseUnexpectedly was
-        // set.
-        this.notifyRemoteClosed.abort();
-    }
-    markHold() {
-        return this.withRemote(() => this.baseConnection.markHold());
-    }
-    releaseHold(holdId) {
-        return this.withRemote(() => this.baseConnection.releaseHold(holdId));
-    }
-    isAutoCommit() {
-        return this.withRemote(() => this.baseConnection.isAutoCommit());
-    }
-    withRemote(workerPromise, fireActionOnAbort = false) {
-        const controller = this.notifyRemoteClosed;
-        if (controller) {
-            return new Promise((resolve, reject) => {
-                if (controller.signal.aborted) {
-                    reject(new ConnectionClosedError('Called operation on closed remote'));
-                    if (!fireActionOnAbort) {
-                        // Don't run the operation if we're going to reject
-                        // We might want to fire-and-forget the operation in some cases (like a close operation)
-                        return;
-                    }
-                }
-                function handleAbort() {
-                    reject(new ConnectionClosedError('Remote peer closed with request in flight'));
-                }
-                function completePromise(action) {
-                    controller.signal.removeEventListener('abort', handleAbort);
-                    action();
-                }
-                controller.signal.addEventListener('abort', handleAbort);
-                workerPromise()
-                    .then((data) => completePromise(() => resolve(data)))
-                    .catch((e) => completePromise(() => reject(e)));
-            });
-        }
-        else {
-            // Can't close, so just return the inner worker promise unguarded.
-            return workerPromise();
-        }
-    }
-    /**
-     * Get a MessagePort which can be used to share the internals of this connection.
-     */
-    async shareConnection() {
-        const { identifier, remote } = this.options;
-        /**
-         * Hold a navigator lock in order to avoid features such as Chrome's frozen tabs,
-         * or Edge's sleeping tabs from pausing the thread for this connection.
-         * This promise resolves once a lock is obtained.
-         * This lock will be held as long as this connection is open.
-         * The `shareConnection` method should not be called on multiple tabs concurrently.
-         */
-        await new Promise((resolve, reject) => navigator.locks
-            .request(`shared-connection-${this.options.identifier}-${Date.now()}-${Math.round(Math.random() * 10000)}`, {
-            signal: this.lockAbortController.signal
-        }, async () => {
-            resolve();
-            // Free the lock when the connection is already closed.
-            if (this.lockAbortController.signal.aborted) {
-                return;
-            }
-            // Hold the lock while the shared connection is in use.
-            await new Promise((releaseLock) => {
-                this.lockAbortController.signal.addEventListener('abort', () => {
-                    releaseLock();
-                });
-            });
-        })
-            // We aren't concerned with abort errors here
-            .catch((ex) => {
-            if (ex.name == 'AbortError') {
-                resolve();
-            }
-            else {
-                reject(ex);
-            }
-        }));
-        const newPort = await remote[Comlink.createEndpoint]();
-        return { port: newPort, identifier };
-    }
-    /**
-     * Registers a table change notification callback with the base database.
-     * This can be extended by custom implementations in order to handle proxy events.
-     */
-    async registerOnTableChange(callback) {
-        return this.baseConnection.registerOnTableChange(Comlink.proxy(callback));
-    }
-    async close() {
-        // Abort any pending lock requests.
-        this.lockAbortController.abort();
-        try {
-            // fire and forget the close operation
-            await this.withRemote(() => this.baseConnection.close(), true);
-        }
-        finally {
-            this.options.remote[Comlink.releaseProxy]();
-            this.options.onClose?.();
-            this.iterateListeners((l) => l.closing?.());
-        }
-    }
-    execute(sql, params) {
-        return this.withRemote(() => this.baseConnection.execute(sql, params));
-    }
-    executeRaw(sql, params) {
-        return this.withRemote(() => this.baseConnection.executeRaw(sql, params));
-    }
-    executeBatch(sql, params) {
-        return this.withRemote(() => this.baseConnection.executeBatch(sql, params));
-    }
-    getConfig() {
-        return this.withRemote(() => this.baseConnection.getConfig());
-    }
-}

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

@@ -1,12 +0,0 @@
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
-import { WebDBAdapterConfiguration } from '../WebDBAdapter.js';
-/**
- * @internal
- * An intermediary implementation of WASQLiteDBAdapter, which takes the same
- * constructor arguments as {@link LockedAsyncDatabaseAdapter}, but provides some
- * basic WA-SQLite specific functionality.
- * This base class is used to avoid requiring overloading the constructor of {@link WASQLiteDBAdapter}
- */
-export declare class InternalWASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
-    getConfiguration(): WebDBAdapterConfiguration;
-}

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

@@ -1,19 +0,0 @@
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
-import { WASQLiteVFS } from './WASQLiteConnection.js';
-/**
- * @internal
- * An intermediary implementation of WASQLiteDBAdapter, which takes the same
- * constructor arguments as {@link LockedAsyncDatabaseAdapter}, but provides some
- * basic WA-SQLite specific functionality.
- * This base class is used to avoid requiring overloading the constructor of {@link WASQLiteDBAdapter}
- */
-export class InternalWASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
-    getConfiguration() {
-        // This is valid since we only handle WASQLite connections
-        const baseConfig = super.getConfiguration();
-        return {
-            ...super.getConfiguration(),
-            requiresPersistentTriggers: baseConfig.vfs == WASQLiteVFS.OPFSCoopSyncVFS || baseConfig.vfs == WASQLiteVFS.AccessHandlePoolVFS
-        };
-    }
-}

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

@@ -1,155 +0,0 @@
-import * as SQLite from '@journeyapps/wa-sqlite';
-import { BaseObserver, BatchedUpdateNotification } from '@powersync/common';
-import { Mutex } from 'async-mutex';
-import { AsyncDatabaseConnection, OnTableChangeCallback, ProxiedQueryResult } from '../AsyncDatabaseConnection.js';
-import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory.js';
-/**
- * List of currently tested virtual filesystems
- */
-export declare enum WASQLiteVFS {
-    IDBBatchAtomicVFS = "IDBBatchAtomicVFS",
-    OPFSCoopSyncVFS = "OPFSCoopSyncVFS",
-    AccessHandlePoolVFS = "AccessHandlePoolVFS"
-}
-/**
- * @internal
- */
-export type WASQLiteBroadCastTableUpdateEvent = {
-    changedTables: Set<string>;
-    connectionId: number;
-};
-/**
- * @internal
- */
-export type WASQLiteConnectionListener = {
-    tablesUpdated: (event: BatchedUpdateNotification) => void;
-    /**
-     * Triggered when an active hold is overwritten by a new hold.
-     * This is most likely to happen when a shared connection has been closed
-     * without releasing the hold.
-     * This listener can be used to cleanup any resources associated with the previous hold.
-     * @param holdId - The id of the hold that has been overwritten.
-     */
-    holdOverwritten: (holdId: string) => Promise<void>;
-};
-/**
- * @internal
- */
-export type SQLiteModule = Parameters<typeof SQLite.Factory>[0];
-/**
- * @internal
- */
-export type WASQLiteModuleFactoryOptions = {
-    dbFileName: string;
-    encryptionKey?: string;
-};
-/**
- * @internal
- */
-export type WASQLiteModuleFactory = (options: WASQLiteModuleFactoryOptions) => Promise<{
-    module: SQLiteModule;
-    vfs: SQLiteVFS;
-}>;
-/**
- * @internal
- */
-export declare const AsyncWASQLiteModuleFactory: () => Promise<any>;
-/**
- * @internal
- */
-export declare const MultiCipherAsyncWASQLiteModuleFactory: () => Promise<any>;
-/**
- * @internal
- */
-export declare const SyncWASQLiteModuleFactory: () => Promise<any>;
-/**
- * @internal
- */
-export declare const MultiCipherSyncWASQLiteModuleFactory: () => Promise<any>;
-/**
- * @internal
- */
-export declare const DEFAULT_MODULE_FACTORIES: {
-    IDBBatchAtomicVFS: (options: WASQLiteModuleFactoryOptions) => Promise<{
-        module: any;
-        vfs: any;
-    }>;
-    AccessHandlePoolVFS: (options: WASQLiteModuleFactoryOptions) => Promise<{
-        module: any;
-        vfs: any;
-    }>;
-    OPFSCoopSyncVFS: (options: WASQLiteModuleFactoryOptions) => Promise<{
-        module: any;
-        vfs: any;
-    }>;
-};
-/**
- * @internal
- * WA-SQLite connection which directly interfaces with WA-SQLite.
- * This is usually instantiated inside a worker.
- */
-export declare class WASqliteConnection extends BaseObserver<WASQLiteConnectionListener> implements AsyncDatabaseConnection<ResolvedWASQLiteOpenFactoryOptions> {
-    protected options: ResolvedWASQLiteOpenFactoryOptions;
-    private _sqliteAPI;
-    private _dbP;
-    private _moduleFactory;
-    protected updatedTables: Set<string>;
-    protected updateTimer: ReturnType<typeof setTimeout> | null;
-    protected statementMutex: Mutex;
-    protected broadcastChannel: BroadcastChannel | null;
-    /**
-     * Unique id for this specific connection. This is used to prevent broadcast table change
-     * notification loops.
-     */
-    protected connectionId: number;
-    protected _holdCounter: number;
-    protected _holdId: string | null;
-    constructor(options: ResolvedWASQLiteOpenFactoryOptions);
-    /**
-     * Gets the id for the current hold.
-     * This can be used to check for invalid states.
-     */
-    get currentHoldId(): string | null;
-    protected get sqliteAPI(): SQLiteAPI;
-    protected get dbP(): number;
-    /**
-     * Checks if the database connection is in autocommit mode.
-     * @returns true if in autocommit mode, false if in a transaction
-     */
-    isAutoCommit(): Promise<boolean>;
-    markHold(): Promise<string>;
-    releaseHold(holdId: string): Promise<void>;
-    protected openDB(): Promise<number>;
-    protected executeEncryptionPragma(): Promise<void>;
-    protected openSQLiteAPI(): Promise<SQLiteAPI>;
-    protected registerBroadcastListeners(): void;
-    protected queueTableUpdate(tableNames: Set<string>, shouldBroadcast?: boolean): void;
-    init(): Promise<void>;
-    getConfig(): Promise<ResolvedWASQLiteOpenFactoryOptions>;
-    fireUpdates(shouldBroadcast?: boolean): void;
-    /**
-     * This executes SQL statements in a batch.
-     */
-    executeBatch(sql: string, bindings?: any[][]): Promise<ProxiedQueryResult>;
-    /**
-     * This executes single SQL statements inside a requested lock.
-     */
-    execute(sql: string | TemplateStringsArray, bindings?: any[]): Promise<ProxiedQueryResult>;
-    executeRaw(sql: string | TemplateStringsArray, bindings?: any[]): Promise<any[][]>;
-    close(): Promise<void>;
-    registerOnTableChange(callback: OnTableChangeCallback): Promise<() => void>;
-    /**
-     * This requests a lock for executing statements.
-     * Should only be used internally.
-     */
-    protected acquireExecuteLock: <T>(callback: () => Promise<T>) => Promise<T>;
-    /**
-     * This executes a single statement using SQLite3.
-     */
-    protected executeSingleStatement(sql: string | TemplateStringsArray, bindings?: any[]): Promise<ProxiedQueryResult>;
-    /**
-     * This executes a single statement using SQLite3 and returns the results as an array of arrays.
-     */
-    protected executeSingleStatementRaw(sql: string | TemplateStringsArray, bindings?: any[]): Promise<any[][]>;
-    private _execute;
-}