@powersync/op-sqlite 0.0.0-dev-20250121082529 → 0.0.0-dev-20250121114305

package/lib/{typescript/commonjs/src → src}/db/OPSQLiteConnection.d.ts

@@ -24,4 +24,3 @@ export declare class OPSQLiteConnection extends BaseObserver<DBAdapterListener>
     get<T>(sql: string, parameters?: any[]): Promise<T>;
     refreshSchema(): Promise<void>;
 }
-//# sourceMappingURL=OPSQLiteConnection.d.ts.map

package/lib/src/db/OPSQLiteConnection.js

@@ -0,0 +1,118 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { BaseObserver, RowUpdateType } from '@powersync/common';
+export class OPSQLiteConnection extends BaseObserver {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.DB = options.baseDB;
+        this.updateBuffer = [];
+        this.DB.rollbackHook(() => {
+            this.updateBuffer = [];
+        });
+        this.DB.updateHook((update) => {
+            this.addTableUpdate(update);
+        });
+    }
+    addTableUpdate(update) {
+        let opType;
+        switch (update.operation) {
+            case 'INSERT':
+                opType = RowUpdateType.SQLITE_INSERT;
+                break;
+            case 'DELETE':
+                opType = RowUpdateType.SQLITE_DELETE;
+                break;
+            case 'UPDATE':
+                opType = RowUpdateType.SQLITE_UPDATE;
+                break;
+        }
+        this.updateBuffer.push({
+            table: update.table,
+            opType,
+            rowId: update.rowId
+        });
+    }
+    flushUpdates() {
+        if (!this.updateBuffer.length) {
+            return;
+        }
+        const groupedUpdates = this.updateBuffer.reduce((grouping, update) => {
+            const { table } = update;
+            const updateGroup = grouping[table] || (grouping[table] = []);
+            updateGroup.push(update);
+            return grouping;
+        }, {});
+        const batchedUpdate = {
+            groupedUpdates,
+            rawUpdates: this.updateBuffer,
+            tables: Object.keys(groupedUpdates)
+        };
+        this.updateBuffer = [];
+        this.iterateListeners((l) => { var _a; return (_a = l.tablesUpdated) === null || _a === void 0 ? void 0 : _a.call(l, batchedUpdate); });
+    }
+    close() {
+        return this.DB.close();
+    }
+    execute(query, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const res = yield this.DB.execute(query, params);
+            return {
+                insertId: res.insertId,
+                rowsAffected: res.rowsAffected,
+                rows: {
+                    _array: (_a = res.rows) !== null && _a !== void 0 ? _a : [],
+                    length: (_c = (_b = res.rows) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0,
+                    item: (index) => { var _a; return (_a = res.rows) === null || _a === void 0 ? void 0 : _a[index]; }
+                }
+            };
+        });
+    }
+    executeBatch(query_1) {
+        return __awaiter(this, arguments, void 0, function* (query, params = []) {
+            var _a;
+            const tuple = [[query, params[0]]];
+            params.slice(1).forEach((p) => tuple.push([query, p]));
+            const result = yield this.DB.executeBatch(tuple);
+            return {
+                rowsAffected: (_a = result.rowsAffected) !== null && _a !== void 0 ? _a : 0
+            };
+        });
+    }
+    getAll(sql, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const result = yield this.DB.execute(sql, parameters);
+            return ((_a = result.rows) !== null && _a !== void 0 ? _a : []);
+        });
+    }
+    getOptional(sql, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const result = yield this.DB.execute(sql, parameters);
+            return (_b = (_a = result.rows) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : null;
+        });
+    }
+    get(sql, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.getOptional(sql, parameters);
+            if (!result) {
+                throw new Error('Result set is empty');
+            }
+            return result;
+        });
+    }
+    refreshSchema() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.get("PRAGMA table_info('sqlite_master')");
+        });
+    }
+}

package/lib/{typescript/module/src → src}/db/OPSqliteAdapter.d.ts

@@ -42,4 +42,3 @@ export declare class OPSQLiteDBAdapter extends BaseObserver<DBAdapterListener> i
     protected internalTransaction<T>(connection: OPSQLiteConnection, fn: (tx: Transaction) => Promise<T>): Promise<T>;
     refreshSchema(): Promise<void>;
 }
-//# sourceMappingURL=OPSqliteAdapter.d.ts.map

package/lib/src/db/OPSqliteAdapter.js

@@ -0,0 +1,267 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { BaseObserver } from '@powersync/common';
+import { ANDROID_DATABASE_PATH, getDylibPath, IOS_LIBRARY_PATH, open } from '@op-engineering/op-sqlite';
+import Lock from 'async-lock';
+import { OPSQLiteConnection } from './OPSQLiteConnection';
+import { Platform } from 'react-native';
+var LockType;
+(function (LockType) {
+    LockType["READ"] = "read";
+    LockType["WRITE"] = "write";
+})(LockType || (LockType = {}));
+const READ_CONNECTIONS = 5;
+export class OPSQLiteDBAdapter extends BaseObserver {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.readQueue = [];
+        this.name = this.options.name;
+        this.locks = new Lock();
+        this.readConnections = null;
+        this.writeConnection = null;
+        this.initialized = this.init();
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { lockTimeoutMs, journalMode, journalSizeLimit, synchronous } = this.options.sqliteOptions;
+            const dbFilename = this.options.name;
+            this.writeConnection = yield this.openConnection(dbFilename);
+            const statements = [
+                `PRAGMA busy_timeout = ${lockTimeoutMs}`,
+                `PRAGMA journal_mode = ${journalMode}`,
+                `PRAGMA journal_size_limit = ${journalSizeLimit}`,
+                `PRAGMA synchronous = ${synchronous}`
+            ];
+            for (const statement of statements) {
+                for (let tries = 0; tries < 30; tries++) {
+                    try {
+                        yield this.writeConnection.execute(statement);
+                        break;
+                    }
+                    catch (e) {
+                        if (e instanceof Error && e.message.includes('database is locked') && tries < 29) {
+                            continue;
+                        }
+                        else {
+                            throw e;
+                        }
+                    }
+                }
+            }
+            // Changes should only occur in the write connection
+            this.writeConnection.registerListener({
+                tablesUpdated: (notification) => this.iterateListeners((cb) => { var _a; return (_a = cb.tablesUpdated) === null || _a === void 0 ? void 0 : _a.call(cb, notification); })
+            });
+            this.readConnections = [];
+            for (let i = 0; i < READ_CONNECTIONS; i++) {
+                const conn = yield this.openConnection(dbFilename);
+                yield conn.execute('PRAGMA query_only = true');
+                this.readConnections.push({ busy: false, connection: conn });
+            }
+        });
+    }
+    openConnection(filenameOverride) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const dbFilename = filenameOverride !== null && filenameOverride !== void 0 ? filenameOverride : this.options.name;
+            const DB = this.openDatabase(dbFilename, (_b = (_a = this.options.sqliteOptions) === null || _a === void 0 ? void 0 : _a.encryptionKey) !== null && _b !== void 0 ? _b : undefined);
+            //Load extensions for all connections
+            this.loadAdditionalExtensions(DB);
+            this.loadPowerSyncExtension(DB);
+            yield DB.execute('SELECT powersync_init()');
+            return new OPSQLiteConnection({
+                baseDB: DB
+            });
+        });
+    }
+    getDbLocation(dbLocation) {
+        if (Platform.OS === 'ios') {
+            return dbLocation !== null && dbLocation !== void 0 ? dbLocation : IOS_LIBRARY_PATH;
+        }
+        else {
+            return dbLocation !== null && dbLocation !== void 0 ? dbLocation : ANDROID_DATABASE_PATH;
+        }
+    }
+    openDatabase(dbFilename, encryptionKey) {
+        //This is needed because an undefined/null dbLocation will cause the open function to fail
+        const location = this.getDbLocation(this.options.dbLocation);
+        //Simarlily if the encryption key is undefined/null when using SQLCipher it will cause the open function to fail
+        if (encryptionKey) {
+            return open({
+                name: dbFilename,
+                location: location,
+                encryptionKey: encryptionKey
+            });
+        }
+        else {
+            return open({
+                name: dbFilename,
+                location: location
+            });
+        }
+    }
+    loadAdditionalExtensions(DB) {
+        var _a;
+        if (((_a = this.options.sqliteOptions) === null || _a === void 0 ? void 0 : _a.extensions) && this.options.sqliteOptions.extensions.length > 0) {
+            for (const extension of this.options.sqliteOptions.extensions) {
+                DB.loadExtension(extension.path, extension.entryPoint);
+            }
+        }
+    }
+    loadPowerSyncExtension(DB) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Platform.OS === 'ios') {
+                const libPath = getDylibPath('co.powersync.sqlitecore', 'powersync-sqlite-core');
+                DB.loadExtension(libPath, 'sqlite3_powersync_init');
+            }
+            else {
+                DB.loadExtension('libpowersync', 'sqlite3_powersync_init');
+            }
+        });
+    }
+    close() {
+        this.initialized.then(() => {
+            this.writeConnection.close();
+            this.readConnections.forEach((c) => c.connection.close());
+        });
+    }
+    readLock(fn, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                const execute = () => __awaiter(this, void 0, void 0, function* () {
+                    // Find an available connection that is not busy
+                    const availableConnection = this.readConnections.find((conn) => !conn.busy);
+                    // If we have an available connection, use it
+                    if (availableConnection) {
+                        availableConnection.busy = true;
+                        try {
+                            resolve(yield fn(availableConnection.connection));
+                        }
+                        catch (error) {
+                            reject(error);
+                        }
+                        finally {
+                            availableConnection.busy = false;
+                            // After query execution, process any queued tasks
+                            this.processQueue();
+                        }
+                    }
+                    else {
+                        // If no available connections, add to the queue
+                        this.readQueue.push(execute);
+                    }
+                });
+                execute();
+            }));
+        });
+    }
+    processQueue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.readQueue.length > 0) {
+                const next = this.readQueue.shift();
+                if (next) {
+                    next();
+                }
+            }
+        });
+    }
+    writeLock(fn, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.locks
+                        .acquire(LockType.WRITE, () => __awaiter(this, void 0, void 0, function* () {
+                        resolve(yield fn(this.writeConnection));
+                    }), { timeout: options === null || options === void 0 ? void 0 : options.timeoutMs })
+                        .then(() => {
+                        // flush updates once a write lock has been released
+                        this.writeConnection.flushUpdates();
+                    });
+                }
+                catch (ex) {
+                    reject(ex);
+                }
+            }));
+        });
+    }
+    readTransaction(fn, options) {
+        return this.readLock((ctx) => this.internalTransaction(ctx, fn));
+    }
+    writeTransaction(fn, options) {
+        return this.writeLock((ctx) => this.internalTransaction(ctx, fn));
+    }
+    getAll(sql, parameters) {
+        return this.readLock((ctx) => ctx.getAll(sql, parameters));
+    }
+    getOptional(sql, parameters) {
+        return this.readLock((ctx) => ctx.getOptional(sql, parameters));
+    }
+    get(sql, parameters) {
+        return this.readLock((ctx) => ctx.get(sql, parameters));
+    }
+    execute(query, params) {
+        return this.writeLock((ctx) => ctx.execute(query, params));
+    }
+    executeBatch(query_1) {
+        return __awaiter(this, arguments, void 0, function* (query, params = []) {
+            return this.writeLock((ctx) => ctx.executeBatch(query, params));
+        });
+    }
+    internalTransaction(connection, fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let finalized = false;
+            const commit = () => __awaiter(this, void 0, void 0, function* () {
+                if (finalized) {
+                    return { rowsAffected: 0 };
+                }
+                finalized = true;
+                return connection.execute('COMMIT');
+            });
+            const rollback = () => __awaiter(this, void 0, void 0, function* () {
+                if (finalized) {
+                    return { rowsAffected: 0 };
+                }
+                finalized = true;
+                return connection.execute('ROLLBACK');
+            });
+            try {
+                yield connection.execute('BEGIN');
+                const result = yield fn({
+                    execute: (query, params) => connection.execute(query, params),
+                    get: (query, params) => connection.get(query, params),
+                    getAll: (query, params) => connection.getAll(query, params),
+                    getOptional: (query, params) => connection.getOptional(query, params),
+                    commit,
+                    rollback
+                });
+                yield commit();
+                return result;
+            }
+            catch (ex) {
+                yield rollback();
+                throw ex;
+            }
+        });
+    }
+    refreshSchema() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initialized;
+            yield this.writeConnection.refreshSchema();
+            if (this.readConnections) {
+                for (let readConnection of this.readConnections) {
+                    yield readConnection.connection.refreshSchema();
+                }
+            }
+        });
+    }
+}

package/lib/{typescript/commonjs/src → src}/db/OPSqliteDBOpenFactory.d.ts

@@ -9,4 +9,3 @@ export declare class OPSqliteOpenFactory implements SQLOpenFactory {
     constructor(options: OPSQLiteOpenFactoryOptions);
     openDB(): DBAdapter;
 }
-//# sourceMappingURL=OPSqliteDBOpenFactory.d.ts.map

package/lib/src/db/OPSqliteDBOpenFactory.js

@@ -0,0 +1,15 @@
+import { OPSQLiteDBAdapter } from './OPSqliteAdapter';
+import { DEFAULT_SQLITE_OPTIONS } from './SqliteOptions';
+export class OPSqliteOpenFactory {
+    constructor(options) {
+        this.options = options;
+        this.sqliteOptions = Object.assign(Object.assign({}, DEFAULT_SQLITE_OPTIONS), this.options.sqliteOptions);
+    }
+    openDB() {
+        return new OPSQLiteDBAdapter({
+            name: this.options.dbFilename,
+            dbLocation: this.options.dbLocation,
+            sqliteOptions: this.sqliteOptions
+        });
+    }
+}

package/lib/{typescript/commonjs/src → src}/db/SqliteOptions.d.ts

@@ -24,7 +24,7 @@ export interface SqliteOptions {
      * Encryption key for the database.
      * If set, the database will be encrypted using SQLCipher.
      */
-    encryptionKey?: string;
+    encryptionKey?: string | null;
     /**
      * Load extensions using the path and entryPoint.
      * More info can be found here https://op-engineering.github.io/op-sqlite/docs/api#loading-extensions.
@@ -49,4 +49,3 @@ declare enum SqliteSynchronous {
 }
 export declare const DEFAULT_SQLITE_OPTIONS: Required<SqliteOptions>;
 export {};
-//# sourceMappingURL=SqliteOptions.d.ts.map

package/lib/src/db/SqliteOptions.js

@@ -0,0 +1,29 @@
+// SQLite journal mode. Set on the primary connection.
+// This library is written with WAL mode in mind - other modes may cause
+// unexpected locking behavior.
+var SqliteJournalMode;
+(function (SqliteJournalMode) {
+    // Use a write-ahead log instead of a rollback journal.
+    // This provides good performance and concurrency.
+    SqliteJournalMode["wal"] = "WAL";
+    SqliteJournalMode["delete"] = "DELETE";
+    SqliteJournalMode["truncate"] = "TRUNCATE";
+    SqliteJournalMode["persist"] = "PERSIST";
+    SqliteJournalMode["memory"] = "MEMORY";
+    SqliteJournalMode["off"] = "OFF";
+})(SqliteJournalMode || (SqliteJournalMode = {}));
+// SQLite file commit mode.
+var SqliteSynchronous;
+(function (SqliteSynchronous) {
+    SqliteSynchronous["normal"] = "NORMAL";
+    SqliteSynchronous["full"] = "FULL";
+    SqliteSynchronous["off"] = "OFF";
+})(SqliteSynchronous || (SqliteSynchronous = {}));
+export const DEFAULT_SQLITE_OPTIONS = {
+    journalMode: SqliteJournalMode.wal,
+    synchronous: SqliteSynchronous.normal,
+    journalSizeLimit: 6 * 1024 * 1024,
+    lockTimeoutMs: 30000,
+    encryptionKey: null,
+    extensions: []
+};

package/lib/{typescript/commonjs/src → src}/index.d.ts

@@ -1,2 +1 @@
 export { OPSqliteOpenFactory, OPSQLiteOpenFactoryOptions } from './db/OPSqliteDBOpenFactory';
-//# sourceMappingURL=index.d.ts.map

package/lib/src/index.js

@@ -0,0 +1 @@
+export { OPSqliteOpenFactory } from './db/OPSqliteDBOpenFactory';