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

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

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

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

@@ -0,0 +1,49 @@
+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/db/adapters/wa-sqlite/WASQLiteOpenFactory.d.ts

@@ -0,0 +1,23 @@
+import { DBAdapter, type ILogLevel } from '@powersync/common';
+import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory.js';
+import { AsyncDatabaseConnection } from '../AsyncDatabaseConnection.js';
+import { ResolvedWebSQLOpenOptions, WebSQLOpenFactoryOptions } from '../web-sql-flags.js';
+import { WASQLiteVFS } from './WASQLiteConnection.js';
+export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
+    vfs?: WASQLiteVFS;
+}
+export interface ResolvedWASQLiteOpenFactoryOptions extends ResolvedWebSQLOpenOptions {
+    vfs: WASQLiteVFS;
+}
+export interface WorkerDBOpenerOptions extends ResolvedWASQLiteOpenFactoryOptions {
+    logLevel: ILogLevel;
+}
+/**
+ * Opens a SQLite connection using WA-SQLite.
+ */
+export declare class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
+    constructor(options: WASQLiteOpenFactoryOptions);
+    get waOptions(): WASQLiteOpenFactoryOptions;
+    protected openAdapter(): DBAdapter;
+    openConnection(): Promise<AsyncDatabaseConnection>;
+}

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

@@ -0,0 +1,96 @@
+import * as Comlink from 'comlink';
+import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database.js';
+import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory.js';
+import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
+import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags.js';
+import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
+import { WASQLiteVFS, WASqliteConnection } from './WASQLiteConnection.js';
+/**
+ * Opens a SQLite connection using WA-SQLite.
+ */
+export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
+    constructor(options) {
+        super(options);
+        assertValidWASQLiteOpenFactoryOptions(options);
+    }
+    get waOptions() {
+        // Cast to extended type
+        return this.options;
+    }
+    openAdapter() {
+        return new InternalWASQLiteDBAdapter({
+            name: this.options.dbFilename,
+            openConnection: () => this.openConnection(),
+            debugMode: this.options.debugMode,
+            logger: this.logger
+        });
+    }
+    async openConnection() {
+        const { enableMultiTabs, useWebWorker } = this.resolvedFlags;
+        const { vfs = WASQLiteVFS.IDBBatchAtomicVFS, temporaryStorage = TemporaryStorageOption.MEMORY, cacheSizeKb = DEFAULT_CACHE_SIZE_KB, encryptionKey } = this.waOptions;
+        if (!enableMultiTabs) {
+            this.logger.warn('Multiple tabs are not enabled in this browser');
+        }
+        if (useWebWorker) {
+            const optionsDbWorker = this.options.worker;
+            const workerPort = typeof optionsDbWorker == 'function'
+                ? resolveWorkerDatabasePortFactory(() => optionsDbWorker({
+                    ...this.options,
+                    temporaryStorage,
+                    cacheSizeKb,
+                    flags: this.resolvedFlags,
+                    encryptionKey
+                }))
+                : openWorkerDatabasePort(this.options.dbFilename, enableMultiTabs, optionsDbWorker, this.waOptions.vfs);
+            const workerDBOpener = Comlink.wrap(workerPort);
+            return new WorkerWrappedAsyncDatabaseConnection({
+                remote: workerDBOpener,
+                // This tab owns the worker, so we're guaranteed to outlive it.
+                remoteCanCloseUnexpectedly: false,
+                baseConnection: await workerDBOpener({
+                    dbFilename: this.options.dbFilename,
+                    vfs,
+                    temporaryStorage,
+                    cacheSizeKb,
+                    flags: this.resolvedFlags,
+                    encryptionKey: encryptionKey,
+                    logLevel: this.logger.getLevel()
+                }),
+                identifier: this.options.dbFilename,
+                onClose: () => {
+                    if (workerPort instanceof Worker) {
+                        workerPort.terminate();
+                    }
+                    else {
+                        workerPort.close();
+                    }
+                }
+            });
+        }
+        else {
+            // Don't use a web worker
+            return new WASqliteConnection({
+                dbFilename: this.options.dbFilename,
+                dbLocation: this.options.dbLocation,
+                debugMode: this.options.debugMode,
+                vfs,
+                temporaryStorage,
+                cacheSizeKb,
+                flags: this.resolvedFlags,
+                encryptionKey: encryptionKey
+            });
+        }
+    }
+}
+/**
+ * Asserts that the factory options are valid.
+ */
+function assertValidWASQLiteOpenFactoryOptions(options) {
+    // The OPFS VFS only works in dedicated web workers.
+    if ('vfs' in options && 'flags' in options) {
+        const { vfs, flags = {} } = options;
+        if (vfs !== WASQLiteVFS.IDBBatchAtomicVFS && 'useWebWorker' in flags && !flags.useWebWorker) {
+            throw new Error(`Invalid configuration: The 'useWebWorker' flag must be true when using an OPFS-based VFS (${vfs}).`);
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import { AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions } from '@powersync/common';
+import { AbstractWebPowerSyncDatabaseOpenFactory } from '../AbstractWebPowerSyncDatabaseOpenFactory.js';
+/**
+ * @deprecated {@link PowerSyncDatabase} can now be constructed directly
+ * @example
+ * ```typescript
+ * const powersync = new PowerSyncDatabase({database: {
+ *  dbFileName: 'powersync.db'
+ * }});
+ * ```
+ */
+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,21 @@
+import { PowerSyncDatabase } from '../../../db/PowerSyncDatabase.js';
+import { AbstractWebPowerSyncDatabaseOpenFactory } from '../AbstractWebPowerSyncDatabaseOpenFactory.js';
+import { WASQLiteOpenFactory } from './WASQLiteOpenFactory.js';
+/**
+ * @deprecated {@link PowerSyncDatabase} can now be constructed directly
+ * @example
+ * ```typescript
+ * const powersync = new PowerSyncDatabase({database: {
+ *  dbFileName: 'powersync.db'
+ * }});
+ * ```
+ */
+export class WASQLitePowerSyncDatabaseOpenFactory extends AbstractWebPowerSyncDatabaseOpenFactory {
+    openDB() {
+        const factory = new WASQLiteOpenFactory(this.options);
+        return factory.openDB();
+    }
+    generateInstance(options) {
+        return new PowerSyncDatabase(options);
+    }
+}