@powersync/web 0.0.0-dev-20260202162549 → 0.0.0-dev-20260202163643

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

@@ -0,0 +1,26 @@
+import { AbstractPowerSyncDatabaseOpenFactory } from '@powersync/common';
+import { PowerSyncDatabase, resolveWebPowerSyncFlags } from '../../db/PowerSyncDatabase.js';
+/**
+ * Intermediate PowerSync Database Open factory for Web which uses a mock
+ * SSR DB Adapter if running on server side.
+ * Most SQLite DB implementations only run on client side, this will safely return
+ * empty query results in SSR which will allow for generating server partial views.
+ */
+export class AbstractWebPowerSyncDatabaseOpenFactory extends AbstractPowerSyncDatabaseOpenFactory {
+    options;
+    constructor(options) {
+        super(options);
+        this.options = options;
+    }
+    generateOptions() {
+        return {
+            ...this.options,
+            database: this.openDB(),
+            schema: this.schema,
+            flags: resolveWebPowerSyncFlags(this.options.flags)
+        };
+    }
+    generateInstance(options) {
+        return new PowerSyncDatabase(options);
+    }
+}

package/lib/src/db/adapters/AbstractWebSQLOpenFactory.d.ts

@@ -0,0 +1,17 @@
+import { DBAdapter, type ILogger, SQLOpenFactory } from '@powersync/common';
+import { ResolvedWebSQLFlags, WebSQLOpenFactoryOptions } from './web-sql-flags.js';
+export declare abstract class AbstractWebSQLOpenFactory implements SQLOpenFactory {
+    protected options: WebSQLOpenFactoryOptions;
+    protected resolvedFlags: ResolvedWebSQLFlags;
+    protected logger: ILogger;
+    constructor(options: WebSQLOpenFactoryOptions);
+    /**
+     * Opens a DBAdapter if not in SSR mode
+     */
+    protected abstract openAdapter(): DBAdapter;
+    /**
+     * Opens a {@link DBAdapter} using resolved flags.
+     * A SSR implementation is loaded if SSR mode is detected.
+     */
+    openDB(): DBAdapter;
+}

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

@@ -0,0 +1,33 @@
+import { createLogger } from '@powersync/common';
+import { SSRDBAdapter } from './SSRDBAdapter.js';
+import { isServerSide, resolveWebSQLFlags } from './web-sql-flags.js';
+export class AbstractWebSQLOpenFactory {
+    options;
+    resolvedFlags;
+    logger;
+    constructor(options) {
+        this.options = options;
+        this.resolvedFlags = resolveWebSQLFlags(options.flags);
+        this.logger = options.logger ?? createLogger(`AbstractWebSQLOpenFactory - ${this.options.dbFilename}`);
+    }
+    /**
+     * Opens a {@link DBAdapter} using resolved flags.
+     * A SSR implementation is loaded if SSR mode is detected.
+     */
+    openDB() {
+        const { resolvedFlags: { disableSSRWarning, enableMultiTabs, ssrMode = isServerSide() } } = this;
+        if (ssrMode && !disableSSRWarning) {
+            this.logger.warn(`
+  Running PowerSync in SSR mode.
+  Only empty query results will be returned.
+  Disable this warning by setting 'disableSSRWarning: true' in options.`);
+        }
+        if (!enableMultiTabs) {
+            this.logger.warn('Multiple tab support is not enabled. Using this site across multiple tabs may not function correctly.');
+        }
+        if (ssrMode) {
+            return new SSRDBAdapter();
+        }
+        return this.openAdapter();
+    }
+}

package/lib/src/db/adapters/AsyncDatabaseConnection.d.ts

@@ -0,0 +1,49 @@
+import { BatchedUpdateNotification, QueryResult } from '@powersync/common';
+import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
+/**
+ * @internal
+ * Proxied query result does not contain a function for accessing row values
+ */
+export type ProxiedQueryResult = Omit<QueryResult, 'rows'> & {
+    rows: {
+        _array: any[];
+        length: number;
+    };
+};
+/**
+ * @internal
+ */
+export type OnTableChangeCallback = (event: BatchedUpdateNotification) => void;
+/**
+ * @internal
+ * An async Database connection which provides basic async SQL methods.
+ * This is usually a proxied through a web worker.
+ */
+export interface AsyncDatabaseConnection<Config extends ResolvedWebSQLOpenOptions = ResolvedWebSQLOpenOptions> {
+    init(): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Marks the connection as in-use by a certain actor.
+     * @returns A hold ID which can be used to release the hold.
+     */
+    markHold(): Promise<string>;
+    /**
+     * Releases a hold on the connection.
+     * @param holdId The hold ID to release.
+     */
+    releaseHold(holdId: string): Promise<void>;
+    /**
+     * Checks if the database connection is in autocommit mode.
+     * @returns true if in autocommit mode, false if in a transaction
+     */
+    isAutoCommit(): Promise<boolean>;
+    execute(sql: string, params?: any[]): Promise<ProxiedQueryResult>;
+    executeRaw(sql: string, params?: any[]): Promise<any[][]>;
+    executeBatch(sql: string, params?: any[]): Promise<ProxiedQueryResult>;
+    registerOnTableChange(callback: OnTableChangeCallback): Promise<() => void>;
+    getConfig(): Promise<Config>;
+}
+/**
+ * @internal
+ */
+export type OpenAsyncDatabaseConnection<Config extends ResolvedWebSQLOpenOptions = ResolvedWebSQLOpenOptions> = (config: Config) => AsyncDatabaseConnection;

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

@@ -0,0 +1 @@
+export {};

package/lib/src/db/adapters/LockedAsyncDatabaseAdapter.d.ts

@@ -0,0 +1,109 @@
+import { BaseObserver, DBAdapterListener, DBLockOptions, LockContext, QueryResult, Transaction, type ILogger } from '@powersync/common';
+import { AsyncDatabaseConnection } from './AsyncDatabaseConnection.js';
+import { SharedConnectionWorker, WebDBAdapter, WebDBAdapterConfiguration } from './WebDBAdapter.js';
+import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
+/**
+ * @internal
+ */
+export interface LockedAsyncDatabaseAdapterOptions {
+    name: string;
+    openConnection: () => Promise<AsyncDatabaseConnection>;
+    debugMode?: boolean;
+    logger?: ILogger;
+    defaultLockTimeoutMs?: number;
+    reOpenOnConnectionClosed?: boolean;
+}
+export type LockedAsyncDatabaseAdapterListener = DBAdapterListener & {
+    initialized?: () => void;
+    /**
+     * Fired when the database is re-opened after being closed.
+     */
+    databaseReOpened?: () => void;
+};
+/**
+ * @internal
+ * Wraps a {@link AsyncDatabaseConnection} and provides exclusive locking functions in
+ * order to implement {@link DBAdapter}.
+ */
+export declare class LockedAsyncDatabaseAdapter extends BaseObserver<LockedAsyncDatabaseAdapterListener> implements WebDBAdapter {
+    protected options: LockedAsyncDatabaseAdapterOptions;
+    private logger;
+    private dbGetHelpers;
+    private debugMode;
+    private _dbIdentifier;
+    protected initPromise: Promise<void>;
+    private _db;
+    protected _disposeTableChangeListener: (() => void) | null;
+    private _config;
+    protected pendingAbortControllers: Set<AbortController>;
+    protected requiresHolds: boolean | null;
+    protected databaseOpenPromise: Promise<void> | null;
+    closing: boolean;
+    closed: boolean;
+    constructor(options: LockedAsyncDatabaseAdapterOptions);
+    protected get baseDB(): AsyncDatabaseConnection<ResolvedWebSQLOpenOptions>;
+    get name(): string;
+    /**
+     * Init is automatic, this helps catch errors or explicitly await initialization
+     */
+    init(): Promise<void>;
+    protected openInternalDB(): Promise<any>;
+    protected _reOpen(): Promise<void>;
+    /**
+     * Re-opens the underlying database.
+     * Returns a pending operation if one is already in progress.
+     */
+    reOpenInternalDB(): Promise<void>;
+    protected _init(): Promise<void>;
+    getConfiguration(): WebDBAdapterConfiguration;
+    protected waitForInitialized(): Promise<void>;
+    shareConnection(): Promise<SharedConnectionWorker>;
+    /**
+     * Registers a table change notification callback with the base database.
+     * This can be extended by custom implementations in order to handle proxy events.
+     */
+    protected registerOnChangeListener(db: AsyncDatabaseConnection): Promise<void>;
+    /**
+     * This is currently a no-op on web
+     */
+    refreshSchema(): Promise<void>;
+    execute(query: string, params?: any[] | undefined): Promise<QueryResult>;
+    executeRaw(query: string, params?: any[] | undefined): Promise<any[][]>;
+    executeBatch(query: string, params?: any[][]): Promise<QueryResult>;
+    /**
+     * Attempts to close the connection.
+     * Shared workers might not actually close the connection if other
+     * tabs are still using it.
+     */
+    close(): Promise<void>;
+    getAll<T>(sql: string, parameters?: any[] | undefined): Promise<T[]>;
+    getOptional<T>(sql: string, parameters?: any[] | undefined): Promise<T | null>;
+    get<T>(sql: string, parameters?: any[] | undefined): Promise<T>;
+    readLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions | undefined): Promise<T>;
+    writeLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions | undefined): Promise<T>;
+    protected _acquireLock(callback: () => Promise<any>, options?: {
+        timeoutMs?: number;
+    }): Promise<any>;
+    protected acquireLock(callback: () => Promise<any>, options?: {
+        timeoutMs?: number;
+    }): Promise<any>;
+    readTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions | undefined): Promise<T>;
+    writeTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions | undefined): Promise<T>;
+    private generateDBHelpers;
+    /**
+     * Wraps a lock context into a transaction context
+     */
+    private wrapTransaction;
+    /**
+     * Wraps the worker execute function, awaiting for it to be available
+     */
+    private _execute;
+    /**
+     * Wraps the worker executeRaw function, awaiting for it to be available
+     */
+    private _executeRaw;
+    /**
+     * Wraps the worker executeBatch function, awaiting for it to be available
+     */
+    private _executeBatch;
+}

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

@@ -0,0 +1,401 @@
+import { BaseObserver, ConnectionClosedError, createLogger } from '@powersync/common';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection.js';
+import { WASQLiteVFS } from './wa-sqlite/WASQLiteConnection.js';
+/**
+ * @internal
+ * Wraps a {@link AsyncDatabaseConnection} and provides exclusive locking functions in
+ * order to implement {@link DBAdapter}.
+ */
+export class LockedAsyncDatabaseAdapter extends BaseObserver {
+    options;
+    logger;
+    dbGetHelpers;
+    debugMode;
+    _dbIdentifier;
+    initPromise;
+    _db = null;
+    _disposeTableChangeListener = null;
+    _config = null;
+    pendingAbortControllers;
+    requiresHolds;
+    databaseOpenPromise = null;
+    closing;
+    closed;
+    constructor(options) {
+        super();
+        this.options = options;
+        this._dbIdentifier = options.name;
+        this.logger = options.logger ?? createLogger(`LockedAsyncDatabaseAdapter - ${this._dbIdentifier}`);
+        this.pendingAbortControllers = new Set();
+        this.closed = false;
+        this.closing = false;
+        this.requiresHolds = null;
+        // Set the name if provided. We can query for the name if not available yet
+        this.debugMode = options.debugMode ?? false;
+        if (this.debugMode) {
+            const originalExecute = this._execute.bind(this);
+            this._execute = async (sql, bindings) => {
+                const start = performance.now();
+                try {
+                    const r = await originalExecute(sql, bindings);
+                    performance.measure(`[SQL] ${sql}`, { start });
+                    return r;
+                }
+                catch (e) {
+                    performance.measure(`[SQL] [ERROR: ${e.message}] ${sql}`, { start });
+                    throw e;
+                }
+            };
+        }
+        this.dbGetHelpers = this.generateDBHelpers({
+            execute: (query, params) => this.acquireLock(() => this._execute(query, params)),
+            executeRaw: (query, params) => this.acquireLock(() => this._executeRaw(query, params))
+        });
+        this.initPromise = this._init();
+    }
+    get baseDB() {
+        if (!this._db) {
+            throw new Error(`Initialization has not completed yet. Cannot access base db`);
+        }
+        return this._db;
+    }
+    get name() {
+        return this._dbIdentifier;
+    }
+    /**
+     * Init is automatic, this helps catch errors or explicitly await initialization
+     */
+    async init() {
+        return this.initPromise;
+    }
+    async openInternalDB() {
+        /**
+         * Execute opening of the db in a lock in order not to interfere with other operations.
+         */
+        return this._acquireLock(async () => {
+            // Dispose any previous table change listener.
+            this._disposeTableChangeListener?.();
+            this._disposeTableChangeListener = null;
+            this._db?.close().catch((ex) => this.logger.warn(`Error closing database before opening new instance`, ex));
+            const isReOpen = !!this._db;
+            this._db = null;
+            this._db = await this.options.openConnection();
+            await this._db.init();
+            this._config = await this._db.getConfig();
+            await this.registerOnChangeListener(this._db);
+            if (isReOpen) {
+                this.iterateListeners((cb) => cb.databaseReOpened?.());
+            }
+            /**
+             * This is only required for the long-lived shared IndexedDB connections.
+             */
+            this.requiresHolds = this._config.vfs == WASQLiteVFS.IDBBatchAtomicVFS;
+        });
+    }
+    _reOpen() {
+        this.databaseOpenPromise = this.openInternalDB().finally(() => {
+            this.databaseOpenPromise = null;
+        });
+        return this.databaseOpenPromise;
+    }
+    /**
+     * Re-opens the underlying database.
+     * Returns a pending operation if one is already in progress.
+     */
+    async reOpenInternalDB() {
+        if (this.closing || !this.options.reOpenOnConnectionClosed) {
+            // No-op
+            return;
+        }
+        else if (this.databaseOpenPromise) {
+            // Already busy opening
+            return this.databaseOpenPromise;
+        }
+        else {
+            return this._reOpen();
+        }
+    }
+    async _init() {
+        /**
+         * For OPFS, we can see this open call sometimes fail due to NoModificationAllowedError.
+         * We should be able to recover from this by re-opening the database.
+         */
+        const maxAttempts = 3;
+        for (let count = 0; count < maxAttempts; count++) {
+            try {
+                await this.openInternalDB();
+                break;
+            }
+            catch (ex) {
+                if (count == maxAttempts - 1) {
+                    throw ex;
+                }
+                this.logger.warn(`Attempt ${count + 1} of ${maxAttempts} to open database failed, retrying in 1 second...`, ex);
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+        }
+        this.iterateListeners((cb) => cb.initialized?.());
+    }
+    getConfiguration() {
+        if (!this._config) {
+            throw new Error(`Cannot get config before initialization is completed`);
+        }
+        return {
+            ...this._config,
+            // This can be overridden by the adapter later
+            requiresPersistentTriggers: false
+        };
+    }
+    async waitForInitialized() {
+        // Awaiting this will expose errors on function calls like .execute etc
+        await this.initPromise;
+    }
+    async shareConnection() {
+        if (false == this._db instanceof WorkerWrappedAsyncDatabaseConnection) {
+            throw new Error(`Only worker connections can be shared`);
+        }
+        return this._db.shareConnection();
+    }
+    /**
+     * Registers a table change notification callback with the base database.
+     * This can be extended by custom implementations in order to handle proxy events.
+     */
+    async registerOnChangeListener(db) {
+        this._disposeTableChangeListener = await db.registerOnTableChange((event) => {
+            this.iterateListeners((cb) => cb.tablesUpdated?.(event));
+        });
+    }
+    /**
+     * This is currently a no-op on web
+     */
+    async refreshSchema() { }
+    async execute(query, params) {
+        return this.writeLock((ctx) => ctx.execute(query, params));
+    }
+    async executeRaw(query, params) {
+        return this.writeLock((ctx) => ctx.executeRaw(query, params));
+    }
+    async executeBatch(query, params) {
+        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.
+     */
+    async close() {
+        this.closing = true;
+        /**
+         * Note that we obtain a reference to the callback to avoid calling the callback with `this` as the context.
+         * This is to avoid Comlink attempting to clone `this` when calling the method.
+         */
+        const dispose = this._disposeTableChangeListener;
+        if (dispose) {
+            dispose();
+        }
+        this.pendingAbortControllers.forEach((controller) => controller.abort('Closed'));
+        await this.baseDB?.close?.();
+        this.closed = true;
+    }
+    async getAll(sql, parameters) {
+        await this.waitForInitialized();
+        return this.dbGetHelpers.getAll(sql, parameters);
+    }
+    async getOptional(sql, parameters) {
+        await this.waitForInitialized();
+        return this.dbGetHelpers.getOptional(sql, parameters);
+    }
+    async get(sql, parameters) {
+        await this.waitForInitialized();
+        return this.dbGetHelpers.get(sql, parameters);
+    }
+    async readLock(fn, options) {
+        await this.waitForInitialized();
+        return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })), {
+            timeoutMs: options?.timeoutMs ?? this.options.defaultLockTimeoutMs
+        });
+    }
+    async writeLock(fn, options) {
+        await this.waitForInitialized();
+        return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })), {
+            timeoutMs: options?.timeoutMs ?? this.options.defaultLockTimeoutMs
+        });
+    }
+    async _acquireLock(callback, options) {
+        if (this.closing) {
+            throw new Error(`Cannot acquire lock, the database is closing`);
+        }
+        const abortController = new AbortController();
+        this.pendingAbortControllers.add(abortController);
+        const { timeoutMs } = options ?? {};
+        const timeoutId = timeoutMs
+            ? setTimeout(() => {
+                abortController.abort(`Timeout after ${timeoutMs}ms`);
+                this.pendingAbortControllers.delete(abortController);
+            }, timeoutMs)
+            : null;
+        return getNavigatorLocks().request(`db-lock-${this._dbIdentifier}`, { signal: abortController.signal }, async () => {
+            this.pendingAbortControllers.delete(abortController);
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            return await callback();
+        });
+    }
+    async acquireLock(callback, options) {
+        await this.waitForInitialized();
+        // The database is being (re)opened in the background. Wait for it here.
+        if (this.databaseOpenPromise) {
+            await this.databaseOpenPromise;
+        }
+        else if (!this._db) {
+            /**
+             * The database is not open anymore, we might need to re-open it.
+             * Typically, _db, can be `null` if we tried to reOpen the database, but failed to succeed in re-opening.
+             * This can happen when disconnecting the client.
+             * Note: It is safe to re-enter this method multiple times.
+             */
+            await this.reOpenInternalDB();
+        }
+        return this._acquireLock(async () => {
+            let holdId = null;
+            try {
+                /**
+                 * We can't await this since it uses the same lock as we're in now.
+                 * If there is a pending open, this call will throw.
+                 * If there is no pending open, but there is also no database - the open
+                 * might have failed. We need to re-open the database.
+                 */
+                if (this.databaseOpenPromise || !this._db) {
+                    throw new ConnectionClosedError('Connection is busy re-opening');
+                }
+                holdId = this.requiresHolds ? await this.baseDB.markHold() : null;
+                return await callback();
+            }
+            catch (ex) {
+                if (ConnectionClosedError.MATCHES(ex)) {
+                    // Immediately re-open the database. We need to miss as little table updates as possible.
+                    // Note, don't await this since it uses the same lock as we're in now.
+                    this.reOpenInternalDB();
+                }
+                throw ex;
+            }
+            finally {
+                if (holdId) {
+                    await this.baseDB.releaseHold(holdId);
+                }
+            }
+        }, options);
+    }
+    async readTransaction(fn, options) {
+        return this.readLock(this.wrapTransaction(fn));
+    }
+    writeTransaction(fn, options) {
+        return this.writeLock(this.wrapTransaction(fn, true));
+    }
+    generateDBHelpers(tx) {
+        return {
+            ...tx,
+            /**
+             *  Execute a read-only query and return results
+             */
+            async getAll(sql, parameters) {
+                const res = await tx.execute(sql, parameters);
+                return res.rows?._array ?? [];
+            },
+            /**
+             * Execute a read-only query and return the first result, or null if the ResultSet is empty.
+             */
+            async getOptional(sql, parameters) {
+                const res = await tx.execute(sql, parameters);
+                return res.rows?.item(0) ?? null;
+            },
+            /**
+             * Execute a read-only query and return the first result, error if the ResultSet is empty.
+             */
+            async get(sql, parameters) {
+                const res = await tx.execute(sql, parameters);
+                const first = res.rows?.item(0);
+                if (!first) {
+                    throw new Error('Result set is empty');
+                }
+                return first;
+            }
+        };
+    }
+    /**
+     * Wraps a lock context into a transaction context
+     */
+    wrapTransaction(cb, write = false) {
+        return async (tx) => {
+            await this._execute(write ? 'BEGIN EXCLUSIVE' : 'BEGIN');
+            let finalized = false;
+            const commit = async () => {
+                if (finalized) {
+                    return { rowsAffected: 0 };
+                }
+                finalized = true;
+                return this._execute('COMMIT');
+            };
+            const rollback = () => {
+                finalized = true;
+                return this._execute('ROLLBACK');
+            };
+            try {
+                const result = await cb({
+                    ...tx,
+                    commit,
+                    rollback
+                });
+                if (!finalized) {
+                    await commit();
+                }
+                return result;
+            }
+            catch (ex) {
+                this.logger.debug('Caught ex in transaction', ex);
+                try {
+                    await rollback();
+                }
+                catch (ex2) {
+                    // In rare cases, a rollback may fail.
+                    // Safe to ignore.
+                }
+                throw ex;
+            }
+        };
+    }
+    /**
+     * Wraps the worker execute function, awaiting for it to be available
+     */
+    _execute = async (sql, bindings) => {
+        await this.waitForInitialized();
+        const result = await this.baseDB.execute(sql, bindings);
+        return {
+            ...result,
+            rows: {
+                ...result.rows,
+                item: (idx) => result.rows._array[idx]
+            }
+        };
+    };
+    /**
+     * Wraps the worker executeRaw function, awaiting for it to be available
+     */
+    _executeRaw = async (sql, bindings) => {
+        await this.waitForInitialized();
+        return await this.baseDB.executeRaw(sql, bindings);
+    };
+    /**
+     * Wraps the worker executeBatch function, awaiting for it to be available
+     */
+    _executeBatch = async (query, params) => {
+        await this.waitForInitialized();
+        const result = await this.baseDB.executeBatch(query, params);
+        return {
+            ...result,
+            rows: undefined
+        };
+    };
+}

package/lib/src/db/adapters/SSRDBAdapter.d.ts

@@ -0,0 +1,31 @@
+import { BaseObserver, DBAdapterListener, DBAdapter, DBLockOptions, LockContext, QueryResult, Transaction } from '@powersync/common';
+import { Mutex } from 'async-mutex';
+/**
+ * Implements a Mock DB adapter for use in Server Side Rendering (SSR).
+ * This adapter will return empty results for queries, which will allow
+ * server rendered views to initially generate scaffolding components
+ */
+export declare class SSRDBAdapter extends BaseObserver<DBAdapterListener> implements DBAdapter {
+    name: string;
+    readMutex: Mutex;
+    writeMutex: Mutex;
+    constructor();
+    close(): void;
+    readLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions): Promise<T>;
+    readTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions): Promise<T>;
+    writeLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions): Promise<T>;
+    writeTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions): Promise<T>;
+    execute(query: string, params?: any[]): Promise<QueryResult>;
+    executeRaw(query: string, params?: any[]): Promise<any[][]>;
+    executeBatch(query: string, params?: any[][]): Promise<QueryResult>;
+    getAll<T>(sql: string, parameters?: any[]): Promise<T[]>;
+    getOptional<T>(sql: string, parameters?: any[] | undefined): Promise<T | null>;
+    get<T>(sql: string, parameters?: any[] | undefined): Promise<T>;
+    /**
+     * Generates a mock context for use in read/write transactions.
+     * `this` already mocks most of the API, commit and rollback mocks
+     *  are added here
+     */
+    private generateMockTransactionContext;
+    refreshSchema(): Promise<void>;
+}