@powersync/web 1.35.0 → 1.37.0

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

@@ -1,401 +0,0 @@
-import * as SQLite from '@journeyapps/wa-sqlite';
-import { BaseObserver } from '@powersync/common';
-import { Mutex } from 'async-mutex';
-/**
- * List of currently tested virtual filesystems
- */
-export var WASQLiteVFS;
-(function (WASQLiteVFS) {
-    WASQLiteVFS["IDBBatchAtomicVFS"] = "IDBBatchAtomicVFS";
-    WASQLiteVFS["OPFSCoopSyncVFS"] = "OPFSCoopSyncVFS";
-    WASQLiteVFS["AccessHandlePoolVFS"] = "AccessHandlePoolVFS";
-})(WASQLiteVFS || (WASQLiteVFS = {}));
-/**
- * @internal
- */
-export const AsyncWASQLiteModuleFactory = async () => {
-    const { default: factory } = await import('@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs');
-    return factory();
-};
-/**
- * @internal
- */
-export const MultiCipherAsyncWASQLiteModuleFactory = async () => {
-    const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite-async.mjs');
-    return factory();
-};
-/**
- * @internal
- */
-export const SyncWASQLiteModuleFactory = async () => {
-    const { default: factory } = await import('@journeyapps/wa-sqlite/dist/wa-sqlite.mjs');
-    return factory();
-};
-/**
- * @internal
- */
-export const MultiCipherSyncWASQLiteModuleFactory = async () => {
-    const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite.mjs');
-    return factory();
-};
-/**
- * @internal
- */
-export const DEFAULT_MODULE_FACTORIES = {
-    [WASQLiteVFS.IDBBatchAtomicVFS]: async (options) => {
-        let module;
-        if (options.encryptionKey) {
-            module = await MultiCipherAsyncWASQLiteModuleFactory();
-        }
-        else {
-            module = await AsyncWASQLiteModuleFactory();
-        }
-        const { IDBBatchAtomicVFS } = await import('@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js');
-        return {
-            module,
-            // @ts-expect-error The types for this static method are missing upstream
-            vfs: await IDBBatchAtomicVFS.create(options.dbFileName, module, { lockPolicy: 'exclusive' })
-        };
-    },
-    [WASQLiteVFS.AccessHandlePoolVFS]: async (options) => {
-        let module;
-        if (options.encryptionKey) {
-            module = await MultiCipherSyncWASQLiteModuleFactory();
-        }
-        else {
-            module = await SyncWASQLiteModuleFactory();
-        }
-        // @ts-expect-error The types for this static method are missing upstream
-        const { AccessHandlePoolVFS } = await import('@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js');
-        return {
-            module,
-            vfs: await AccessHandlePoolVFS.create(options.dbFileName, module)
-        };
-    },
-    [WASQLiteVFS.OPFSCoopSyncVFS]: async (options) => {
-        let module;
-        if (options.encryptionKey) {
-            module = await MultiCipherSyncWASQLiteModuleFactory();
-        }
-        else {
-            module = await SyncWASQLiteModuleFactory();
-        }
-        // @ts-expect-error The types for this static method are missing upstream
-        const { OPFSCoopSyncVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js');
-        const vfs = await OPFSCoopSyncVFS.create(options.dbFileName, module);
-        return {
-            module,
-            vfs
-        };
-    }
-};
-/**
- * @internal
- * WA-SQLite connection which directly interfaces with WA-SQLite.
- * This is usually instantiated inside a worker.
- */
-export class WASqliteConnection extends BaseObserver {
-    options;
-    _sqliteAPI = null;
-    _dbP = null;
-    _moduleFactory;
-    updatedTables;
-    updateTimer;
-    statementMutex;
-    broadcastChannel;
-    /**
-     * Unique id for this specific connection. This is used to prevent broadcast table change
-     * notification loops.
-     */
-    connectionId;
-    _holdCounter;
-    _holdId;
-    constructor(options) {
-        super();
-        this.options = options;
-        this.updatedTables = new Set();
-        this.updateTimer = null;
-        this.broadcastChannel = null;
-        this.connectionId = new Date().valueOf() + Math.random();
-        this.statementMutex = new Mutex();
-        this._moduleFactory = DEFAULT_MODULE_FACTORIES[this.options.vfs];
-        this._holdCounter = 0;
-        this._holdId = null;
-    }
-    /**
-     * Gets the id for the current hold.
-     * This can be used to check for invalid states.
-     */
-    get currentHoldId() {
-        return this._holdId;
-    }
-    get sqliteAPI() {
-        if (!this._sqliteAPI) {
-            throw new Error(`Initialization has not completed`);
-        }
-        return this._sqliteAPI;
-    }
-    get dbP() {
-        if (!this._dbP) {
-            throw new Error(`Initialization has not completed`);
-        }
-        return this._dbP;
-    }
-    /**
-     * Checks if the database connection is in autocommit mode.
-     * @returns true if in autocommit mode, false if in a transaction
-     */
-    async isAutoCommit() {
-        return this.sqliteAPI.get_autocommit(this.dbP) != 0;
-    }
-    async markHold() {
-        const previousHoldId = this._holdId;
-        this._holdId = `${++this._holdCounter}`;
-        if (previousHoldId) {
-            await this.iterateAsyncListeners(async (cb) => cb.holdOverwritten?.(previousHoldId));
-        }
-        return this._holdId;
-    }
-    async releaseHold(holdId) {
-        if (holdId != this._holdId) {
-            throw new Error(`Invalid hold state, expected ${this._holdId} but got ${holdId}`);
-        }
-        this._holdId = null;
-    }
-    async openDB() {
-        this._dbP = await this.sqliteAPI.open_v2(this.options.dbFilename);
-        return this._dbP;
-    }
-    async executeEncryptionPragma() {
-        if (this.options.encryptionKey) {
-            await this.executeSingleStatement(`PRAGMA key = "${this.options.encryptionKey}"`);
-        }
-        return;
-    }
-    async openSQLiteAPI() {
-        const { module, vfs } = await this._moduleFactory({
-            dbFileName: this.options.dbFilename,
-            encryptionKey: this.options.encryptionKey
-        });
-        const sqlite3 = SQLite.Factory(module);
-        sqlite3.vfs_register(vfs, true);
-        /**
-         * Register the PowerSync core SQLite extension
-         */
-        module.ccall('powersync_init_static', 'int', []);
-        /**
-         * Create the multiple cipher vfs if an encryption key is provided
-         */
-        if (this.options.encryptionKey) {
-            const createResult = module.ccall('sqlite3mc_vfs_create', 'int', ['string', 'int'], [this.options.dbFilename, 1]);
-            if (createResult !== 0) {
-                throw new Error('Failed to create multiple cipher vfs, Database encryption will not work');
-            }
-        }
-        return sqlite3;
-    }
-    registerBroadcastListeners() {
-        this.broadcastChannel = new BroadcastChannel(`${this.options.dbFilename}-table-updates`);
-        this.broadcastChannel.addEventListener('message', (event) => {
-            const data = event.data;
-            if (this.connectionId == data.connectionId) {
-                // Ignore messages from the same connection
-                return;
-            }
-            // Ensuring that we don't rebroadcast the same message
-            this.queueTableUpdate(data.changedTables, false);
-        });
-    }
-    queueTableUpdate(tableNames, shouldBroadcast = true) {
-        tableNames.forEach((tableName) => this.updatedTables.add(tableName));
-        if (this.updateTimer == null) {
-            this.updateTimer = setTimeout(() => this.fireUpdates(shouldBroadcast), 0);
-        }
-    }
-    async init() {
-        this._sqliteAPI = await this.openSQLiteAPI();
-        await this.openDB();
-        this.registerBroadcastListeners();
-        await this.executeSingleStatement(`PRAGMA temp_store = ${this.options.temporaryStorage};`);
-        await this.executeEncryptionPragma();
-        await this.executeSingleStatement(`PRAGMA cache_size = -${this.options.cacheSizeKb};`);
-        this.sqliteAPI.update_hook(this.dbP, (updateType, dbName, tableName) => {
-            if (!tableName) {
-                return;
-            }
-            const changedTables = new Set([tableName]);
-            this.queueTableUpdate(changedTables);
-        });
-    }
-    async getConfig() {
-        return this.options;
-    }
-    fireUpdates(shouldBroadcast = true) {
-        this.updateTimer = null;
-        const event = { tables: [...this.updatedTables], groupedUpdates: {}, rawUpdates: [] };
-        // Share to other connections
-        if (shouldBroadcast) {
-            this.broadcastChannel.postMessage({
-                changedTables: this.updatedTables,
-                connectionId: this.connectionId
-            });
-        }
-        this.updatedTables.clear();
-        this.iterateListeners((cb) => cb.tablesUpdated?.(event));
-    }
-    /**
-     * This executes SQL statements in a batch.
-     */
-    async executeBatch(sql, bindings) {
-        return this.acquireExecuteLock(async () => {
-            let affectedRows = 0;
-            try {
-                await this.executeSingleStatement('BEGIN TRANSACTION');
-                const wrappedBindings = bindings ? bindings : [];
-                for await (const stmt of this.sqliteAPI.statements(this.dbP, sql)) {
-                    if (stmt === null) {
-                        return {
-                            rowsAffected: 0,
-                            rows: { _array: [], length: 0 }
-                        };
-                    }
-                    //Prepare statement once
-                    for (const binding of wrappedBindings) {
-                        // TODO not sure why this is needed currently, but booleans break
-                        for (let i = 0; i < binding.length; i++) {
-                            const b = binding[i];
-                            if (typeof b == 'boolean') {
-                                binding[i] = b ? 1 : 0;
-                            }
-                        }
-                        if (bindings) {
-                            this.sqliteAPI.bind_collection(stmt, binding);
-                        }
-                        const result = await this.sqliteAPI.step(stmt);
-                        if (result === SQLite.SQLITE_DONE) {
-                            //The value returned by sqlite3_changes() immediately after an INSERT, UPDATE or DELETE statement run on a view is always zero.
-                            affectedRows += this.sqliteAPI.changes(this.dbP);
-                        }
-                        this.sqliteAPI.reset(stmt);
-                    }
-                }
-                await this.executeSingleStatement('COMMIT');
-            }
-            catch (err) {
-                await this.executeSingleStatement('ROLLBACK');
-                return {
-                    rowsAffected: 0,
-                    rows: { _array: [], length: 0 }
-                };
-            }
-            const result = {
-                rowsAffected: affectedRows,
-                rows: { _array: [], length: 0 }
-            };
-            return result;
-        });
-    }
-    /**
-     * This executes single SQL statements inside a requested lock.
-     */
-    async execute(sql, bindings) {
-        // Running multiple statements on the same connection concurrently should not be allowed
-        return this.acquireExecuteLock(async () => {
-            return this.executeSingleStatement(sql, bindings);
-        });
-    }
-    async executeRaw(sql, bindings) {
-        return this.acquireExecuteLock(async () => {
-            return this.executeSingleStatementRaw(sql, bindings);
-        });
-    }
-    async close() {
-        this.broadcastChannel?.close();
-        await this.acquireExecuteLock(async () => {
-            /**
-             * Running the close operation inside the same execute mutex prevents errors like:
-             * ```
-             * unable to close due to unfinalized statements or unfinished backups
-             * ```
-             */
-            await this.sqliteAPI.close(this.dbP);
-        });
-    }
-    async registerOnTableChange(callback) {
-        return this.registerListener({
-            tablesUpdated: (event) => callback(event)
-        });
-    }
-    /**
-     * This requests a lock for executing statements.
-     * Should only be used internally.
-     */
-    acquireExecuteLock = (callback) => {
-        return this.statementMutex.runExclusive(callback);
-    };
-    /**
-     * This executes a single statement using SQLite3.
-     */
-    async executeSingleStatement(sql, bindings) {
-        const results = await this._execute(sql, bindings);
-        const rows = [];
-        for (const resultSet of results) {
-            for (const row of resultSet.rows) {
-                const outRow = {};
-                resultSet.columns.forEach((key, index) => {
-                    outRow[key] = row[index];
-                });
-                rows.push(outRow);
-            }
-        }
-        const result = {
-            insertId: this.sqliteAPI.last_insert_id(this.dbP),
-            rowsAffected: this.sqliteAPI.changes(this.dbP),
-            rows: {
-                _array: rows,
-                length: rows.length
-            }
-        };
-        return result;
-    }
-    /**
-     * This executes a single statement using SQLite3 and returns the results as an array of arrays.
-     */
-    async executeSingleStatementRaw(sql, bindings) {
-        const results = await this._execute(sql, bindings);
-        return results.flatMap((resultset) => resultset.rows.map((row) => resultset.columns.map((_, index) => row[index])));
-    }
-    async _execute(sql, bindings) {
-        const results = [];
-        for await (const stmt of this.sqliteAPI.statements(this.dbP, sql)) {
-            let columns;
-            const wrappedBindings = bindings ? [bindings] : [[]];
-            for (const binding of wrappedBindings) {
-                // TODO not sure why this is needed currently, but booleans break
-                binding.forEach((b, index, arr) => {
-                    if (typeof b == 'boolean') {
-                        arr[index] = b ? 1 : 0;
-                    }
-                });
-                this.sqliteAPI.reset(stmt);
-                if (bindings) {
-                    this.sqliteAPI.bind_collection(stmt, binding);
-                }
-                const rows = [];
-                while ((await this.sqliteAPI.step(stmt)) === SQLite.SQLITE_ROW) {
-                    const row = this.sqliteAPI.row(stmt);
-                    rows.push(row);
-                }
-                columns = columns ?? this.sqliteAPI.column_names(stmt);
-                if (columns.length) {
-                    results.push({ columns, rows });
-                }
-            }
-            // When binding parameters, only a single statement is executed.
-            if (bindings) {
-                break;
-            }
-        }
-        return results;
-    }
-}

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

@@ -1,32 +0,0 @@
-import { type PowerSyncOpenFactoryOptions } from '@powersync/common';
-import { ResolvedWebSQLOpenOptions, TemporaryStorageOption, WebSQLFlags } from '../web-sql-flags.js';
-import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
-import { WASQLiteVFS } from './WASQLiteConnection.js';
-/**
- * These flags are the same as {@link WebSQLFlags}.
- * This export is maintained only for API consistency
- */
-export type WASQLiteFlags = WebSQLFlags;
-export interface WASQLiteDBAdapterOptions extends Omit<PowerSyncOpenFactoryOptions, 'schema'> {
-    flags?: WASQLiteFlags;
-    /**
-     * Use an existing port to an initialized worker.
-     * A worker will be initialized if none is provided
-     */
-    workerPort?: MessagePort;
-    worker?: string | URL | ((options: ResolvedWebSQLOpenOptions) => Worker | SharedWorker);
-    vfs?: WASQLiteVFS;
-    temporaryStorage?: TemporaryStorageOption;
-    cacheSizeKb?: number;
-    /**
-     * Encryption key for the database.
-     * If set, the database will be encrypted using multiple-ciphers.
-     */
-    encryptionKey?: string;
-}
-/**
- * Adapter for WA-SQLite SQLite connections.
- */
-export declare class WASQLiteDBAdapter extends InternalWASQLiteDBAdapter {
-    constructor(options: WASQLiteDBAdapterOptions);
-}

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

@@ -1,49 +0,0 @@
-import * as Comlink from 'comlink';
-import { resolveWebPowerSyncFlags } from '../../PowerSyncDatabase.js';
-import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags.js';
-import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
-import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
-import { WASQLiteOpenFactory } from './WASQLiteOpenFactory.js';
-/**
- * Adapter for WA-SQLite SQLite connections.
- */
-export class WASQLiteDBAdapter extends InternalWASQLiteDBAdapter {
-    constructor(options) {
-        super({
-            name: options.dbFilename,
-            openConnection: async () => {
-                const { workerPort, temporaryStorage, cacheSizeKb } = options;
-                if (workerPort) {
-                    const remote = Comlink.wrap(workerPort);
-                    return new WorkerWrappedAsyncDatabaseConnection({
-                        remote,
-                        remoteCanCloseUnexpectedly: false,
-                        identifier: options.dbFilename,
-                        baseConnection: await remote({
-                            ...options,
-                            temporaryStorage: temporaryStorage ?? TemporaryStorageOption.MEMORY,
-                            cacheSizeKb: cacheSizeKb ?? DEFAULT_CACHE_SIZE_KB,
-                            flags: resolveWebPowerSyncFlags(options.flags),
-                            encryptionKey: options.encryptionKey
-                        })
-                    });
-                }
-                const openFactory = new WASQLiteOpenFactory({
-                    dbFilename: options.dbFilename,
-                    dbLocation: options.dbLocation,
-                    debugMode: options.debugMode,
-                    flags: options.flags,
-                    temporaryStorage,
-                    cacheSizeKb,
-                    logger: options.logger,
-                    vfs: options.vfs,
-                    encryptionKey: options.encryptionKey,
-                    worker: options.worker
-                });
-                return openFactory.openConnection();
-            },
-            debugMode: options.debugMode,
-            logger: options.logger
-        });
-    }
-}

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

@@ -1,42 +0,0 @@
-import { ILogger } from '@powersync/common';
-import { AsyncDatabaseConnection, OnTableChangeCallback, ProxiedQueryResult } from '../../db/adapters/AsyncDatabaseConnection.js';
-import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags.js';
-/**
- * Keeps track of open DB connections and the clients which
- * are using it.
- */
-export type SharedDBWorkerConnection = {
-    clientIds: Set<number>;
-    db: AsyncDatabaseConnection;
-};
-export type SharedWASQLiteConnectionOptions = {
-    dbMap: Map<string, SharedDBWorkerConnection>;
-    dbFilename: string;
-    clientId: number;
-    logger: ILogger;
-};
-export declare class SharedWASQLiteConnection implements AsyncDatabaseConnection {
-    protected options: SharedWASQLiteConnectionOptions;
-    protected isClosing: boolean;
-    protected activeHoldId: string | null;
-    constructor(options: SharedWASQLiteConnectionOptions);
-    protected get logger(): ILogger;
-    protected get dbEntry(): SharedDBWorkerConnection;
-    protected get connection(): AsyncDatabaseConnection<ResolvedWebSQLOpenOptions>;
-    protected get clientIds(): Set<number>;
-    init(): Promise<void>;
-    markHold(): Promise<string>;
-    releaseHold(id: string): Promise<void>;
-    isAutoCommit(): Promise<boolean>;
-    /**
-     * Handles closing of a shared connection.
-     * The connection is only closed if there are no active clients using it.
-     */
-    close(): Promise<void>;
-    protected withClosing<T>(action: () => Promise<T>): Promise<T>;
-    execute(sql: string, params?: any[]): Promise<ProxiedQueryResult>;
-    executeRaw(sql: string, params?: any[]): Promise<any[][]>;
-    executeBatch(sql: string, params?: any[] | undefined): Promise<ProxiedQueryResult>;
-    registerOnTableChange(callback: OnTableChangeCallback): Promise<() => void>;
-    getConfig(): Promise<ResolvedWebSQLOpenOptions>;
-}

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

@@ -1,90 +0,0 @@
-export class SharedWASQLiteConnection {
-    options;
-    isClosing;
-    // Keeps track if this current hold if the shared connection has a hold
-    activeHoldId;
-    constructor(options) {
-        this.options = options;
-        // Add this client ID to the set of known clients
-        this.clientIds.add(options.clientId);
-        this.isClosing = false;
-        this.activeHoldId = null;
-    }
-    get logger() {
-        return this.options.logger;
-    }
-    get dbEntry() {
-        return this.options.dbMap.get(this.options.dbFilename);
-    }
-    get connection() {
-        return this.dbEntry.db;
-    }
-    get clientIds() {
-        return this.dbEntry.clientIds;
-    }
-    async init() {
-        // No-op since the connection is already initialized when it was created
-    }
-    async markHold() {
-        this.activeHoldId = await this.connection.markHold();
-        return this.activeHoldId;
-    }
-    async releaseHold(id) {
-        try {
-            await this.connection.releaseHold(id);
-        }
-        finally {
-            this.activeHoldId = null;
-        }
-    }
-    async isAutoCommit() {
-        return this.connection.isAutoCommit();
-    }
-    /**
-     * Handles closing of a shared connection.
-     * The connection is only closed if there are no active clients using it.
-     */
-    async close() {
-        // This prevents further statements on this connection from being executed
-        this.isClosing = true;
-        const { clientIds, logger } = this;
-        const { clientId, dbFilename, dbMap } = this.options;
-        logger.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
-        clientIds.delete(clientId);
-        if (this.activeHoldId) {
-            // We can't cleanup here since we're not in a lock context.
-            // The cleanup will occur once a new hold is acquired.
-            this.logger.info(`Hold ${this.activeHoldId} was still active when the connection was closed. Cleanup will occur once a new hold is acquired.`);
-        }
-        if (clientIds.size == 0) {
-            logger.debug(`Closing connection to ${this.options}.`);
-            const connection = this.connection;
-            dbMap.delete(dbFilename);
-            await connection.close();
-            return;
-        }
-        logger.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
-        return;
-    }
-    async withClosing(action) {
-        if (this.isClosing) {
-            throw new Error('Connection is closing');
-        }
-        return action();
-    }
-    async execute(sql, params) {
-        return this.withClosing(() => this.connection.execute(sql, params));
-    }
-    async executeRaw(sql, params) {
-        return this.withClosing(() => this.connection.executeRaw(sql, params));
-    }
-    executeBatch(sql, params) {
-        return this.withClosing(() => this.connection.executeBatch(sql, params));
-    }
-    registerOnTableChange(callback) {
-        return this.connection.registerOnTableChange(callback);
-    }
-    getConfig() {
-        return this.connection.getConfig();
-    }
-}

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

@@ -1,9 +0,0 @@
-import { OnTableChangeCallback } from '../../db/adapters/AsyncDatabaseConnection.js';
-import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection.js';
-/**
- * A Small proxy wrapper around the WASqliteConnection.
- * This ensures that certain return types are properly proxied.
- */
-export declare class WorkerWASQLiteConnection extends WASqliteConnection {
-    registerOnTableChange(callback: OnTableChangeCallback): Promise<() => void>;
-}

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

@@ -1,12 +0,0 @@
-import * as Comlink from 'comlink';
-import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection.js';
-/**
- * A Small proxy wrapper around the WASqliteConnection.
- * This ensures that certain return types are properly proxied.
- */
-export class WorkerWASQLiteConnection extends WASqliteConnection {
-    async registerOnTableChange(callback) {
-        // Proxy the callback remove function
-        return Comlink.proxy(await super.registerOnTableChange(callback));
-    }
-}

package/src/db/adapters/AbstractWebSQLOpenFactory.ts

@@ -1,48 +0,0 @@
-import { DBAdapter, type ILogger, SQLOpenFactory, createLogger } from '@powersync/common';
-import { SSRDBAdapter } from './SSRDBAdapter.js';
-import { ResolvedWebSQLFlags, WebSQLOpenFactoryOptions, isServerSide, resolveWebSQLFlags } from './web-sql-flags.js';
-
-export abstract class AbstractWebSQLOpenFactory implements SQLOpenFactory {
-  protected resolvedFlags: ResolvedWebSQLFlags;
-  protected logger: ILogger;
-
-  constructor(protected options: WebSQLOpenFactoryOptions) {
-    this.resolvedFlags = resolveWebSQLFlags(options.flags);
-    this.logger = options.logger ?? createLogger(`AbstractWebSQLOpenFactory - ${this.options.dbFilename}`);
-  }
-
-  /**
-   * 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() {
-    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();
-  }
-}