@powersync/node 0.11.1 → 0.13.0

package/download_core.js

@@ -1,39 +1,25 @@
-// TODO: Make this a pre-publish hook and just bundle everything
 import { createHash } from 'node:crypto';
-import * as OS from 'node:os';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { Readable } from 'node:stream';
 import { finished } from 'node:stream/promises';
-import { exit } from 'node:process';
 
 // When changing this version, run node download_core.js update_hashes
 const version = '0.4.6';
 const versionHashes = {
   'powersync_x64.dll': '5efaa9ad4975094912a36843cb7b503376cacd233d21ae0956f0f4b42dcb457b',
+  'powersync_x86.dll': '4151ba8aa6f024b50b7aebe52ba59f2c5be54e3fed26f7f3f48e1127dcda027d',
+  'powersync_aarch64.dll': '3abe46074432593ff5cfc2098b186c592f020c5cfa81285f8e49962732a94bf5',
+  'libpowersync_x86.so': '1321a7de13fda0b2de7d2bc231a68cb5691f84010f3858e5cf02e47f88ba6f4a',
   'libpowersync_x64.so': 'e9d78620d69d3cf7d57353891fe0bf85b79d326b42c4669b9500b9e610388f76',
   'libpowersync_aarch64.so': '0d84c0dc0134fc89af65724d11e2c45e3c15569c575ecda52d0ec2fa2aeec495',
+  'libpowersync_armv7.so': 'c7887181ce9c524b68a7ac284ab447b8584511c87527ca26186e5874bf9ba3d6',
+  'libpowersync_riscv64gc.so': 'a89f3a71f22f707707d97517e9310e42e2a57dc5343cee08d09002a8cea048d5',
   'libpowersync_x64.dylib': '9b484eaf361451f7758ca6ad53190a73563be930a8f8a39ccefd29390046ef6c',
   'libpowersync_aarch64.dylib': 'bfb4f1ec207b298aff560f1825f8123d24316edaa27b6df3a17dd49466576b92'
 };
 
-const platform = OS.platform();
-let destination;
-let asset;
-
-if (platform === 'win32') {
-  asset = 'powersync_x64.dll';
-  destination = 'powersync.dll';
-} else if (platform === 'linux') {
-  asset = OS.arch() === 'x64' ? 'libpowersync_x64.so' : 'libpowersync_aarch64.so';
-  destination = 'libpowersync.so';
-} else if (platform === 'darwin') {
-  asset = OS.arch() === 'x64' ? 'libpowersync_x64.dylib' : 'libpowersync_aarch64.dylib';
-  destination = 'libpowersync.dylib';
-}
-
-const expectedHash = versionHashes[asset];
-const destinationPath = path.resolve('lib', destination);
+const assets = Object.keys(versionHashes);
 
 const hashStream = async (input) => {
   for await (const chunk of input.pipe(createHash('sha256')).setEncoding('hex')) {
@@ -41,9 +27,9 @@ const hashStream = async (input) => {
   }
 };
 
-const hashLocal = async () => {
+const hashLocal = async (filePath) => {
   try {
-    const handle = await fs.open(destinationPath, 'r');
+    const handle = await fs.open(filePath, 'r');
     const input = handle.createReadStream();
 
     const result = await hashStream(input);
@@ -54,31 +40,88 @@ const hashLocal = async () => {
   }
 };
 
-const download = async () => {
-  if ((await hashLocal()) == expectedHash) {
-    console.debug('Local copy is up-to-date, skipping download');
-    exit(0);
+const downloadAsset = async (asset) => {
+  const destinationPath = path.resolve('lib', asset);
+  const expectedHash = versionHashes[asset];
+
+  // Check if file exists and has correct hash
+  const currentHash = await hashLocal(destinationPath);
+  if (currentHash == expectedHash) {
+    console.debug(`${asset} is up-to-date, skipping download`);
+    return;
   }
 
   const url = `https://github.com/powersync-ja/powersync-sqlite-core/releases/download/v${version}/${asset}`;
+  console.log(`Downloading ${url}`);
   const response = await fetch(url);
   if (response.status != 200) {
     throw `Could not download ${url}`;
   }
 
+  const file = await fs.open(destinationPath, 'w');
+  await finished(Readable.fromWeb(response.body).pipe(file.createWriteStream()));
+  await file.close();
+
+  const hashAfterDownloading = await hashLocal(destinationPath);
+  if (hashAfterDownloading != expectedHash) {
+    throw `Unexpected hash after downloading ${asset} (got ${hashAfterDownloading}, expected ${expectedHash})`;
+  }
+  console.log(`Successfully downloaded ${asset}`);
+};
+
+const checkAsset = async (asset) => {
+  const destinationPath = path.resolve('lib', asset);
+  const expectedHash = versionHashes[asset];
+  const currentHash = await hashLocal(destinationPath);
+
+  return {
+    asset,
+    destinationPath,
+    expectedHash,
+    currentHash,
+    exists: currentHash !== null,
+    isValid: currentHash == expectedHash
+  };
+};
+
+const download = async () => {
   try {
     await fs.access('lib');
   } catch {
     await fs.mkdir('lib');
   }
 
-  const file = await fs.open(destinationPath, 'w');
-  await finished(Readable.fromWeb(response.body).pipe(file.createWriteStream()));
-  await file.close();
+  // First check all assets
+  console.log('Checking existing files...');
+  const checks = await Promise.all(assets.map((asset) => checkAsset(asset, asset)));
 
-  const hashAfterDownloading = await hashLocal();
-  if (hashAfterDownloading != expectedHash) {
-    throw `Unexpected hash after downloading (got ${hashAfterDownloading}, expected ${expectedHash})`;
+  const toDownload = checks.filter((check) => !check.isValid);
+  const upToDate = checks.filter((check) => check.isValid);
+
+  // Print summary
+  if (upToDate.length > 0) {
+    console.log('\nUp-to-date files:');
+    for (const check of upToDate) {
+      console.log(`  ✓ ${check.asset}`);
+    }
+  }
+
+  if (toDownload.length > 0) {
+    console.log('\nFiles to download:');
+    for (const check of toDownload) {
+      if (!check.exists) {
+        console.log(`  • ${check.asset} (missing)`);
+      } else {
+        console.log(`  • ${check.asset} (hash mismatch)`);
+      }
+    }
+
+    console.log('\nStarting downloads...');
+    await Promise.all(toDownload.map((check) => downloadAsset(check.asset)));
+
+    console.log('\nAll downloads completed successfully!');
+  } else {
+    console.log('\nAll files are up-to-date, nothing to download.');
   }
 };
 

package/lib/db/AsyncDatabase.d.ts

@@ -1,17 +1,22 @@
 import { QueryResult } from '@powersync/common';
+import { NodeDatabaseImplementation } from './options.js';
 export type ProxiedQueryResult = Omit<QueryResult, 'rows'> & {
     rows?: {
         _array: any[];
         length: number;
     };
 };
+export interface AsyncDatabaseOpenOptions {
+    path: string;
+    isWriter: boolean;
+    implementation: NodeDatabaseImplementation;
+}
 export interface AsyncDatabaseOpener {
-    open(path: string, isWriter: boolean): Promise<AsyncDatabase>;
+    open(options: AsyncDatabaseOpenOptions): Promise<AsyncDatabase>;
 }
 export interface AsyncDatabase {
     execute: (query: string, params: any[]) => Promise<ProxiedQueryResult>;
     executeRaw: (query: string, params: any[]) => Promise<any[][]>;
     executeBatch: (query: string, params: any[][]) => Promise<ProxiedQueryResult>;
     close: () => Promise<void>;
-    collectCommittedUpdates: () => Promise<string[]>;
 }

package/lib/db/BetterSqliteWorker.d.ts

@@ -0,0 +1,26 @@
+import type { Database } from 'better-sqlite3';
+import { AsyncDatabase, AsyncDatabaseOpenOptions } from './AsyncDatabase.js';
+import { PowerSyncWorkerOptions } from './SqliteWorker.js';
+declare class BlockingAsyncDatabase implements AsyncDatabase {
+    private readonly db;
+    constructor(db: Database);
+    close(): Promise<void>;
+    execute(query: string, params: any[]): Promise<{
+        rowsAffected: number;
+        rows: {
+            _array: unknown[];
+            length: number;
+        };
+        insertId?: undefined;
+    } | {
+        rowsAffected: number;
+        insertId: number;
+        rows?: undefined;
+    }>;
+    executeRaw(query: string, params: any[]): Promise<any[][]>;
+    executeBatch(query: string, params: any[][]): Promise<{
+        rowsAffected: number;
+    }>;
+}
+export declare function openDatabase(worker: PowerSyncWorkerOptions, options: AsyncDatabaseOpenOptions): Promise<BlockingAsyncDatabase>;
+export {};

package/lib/db/BetterSqliteWorker.js

@@ -0,0 +1,58 @@
+import { threadId } from 'node:worker_threads';
+class BlockingAsyncDatabase {
+    db;
+    constructor(db) {
+        this.db = db;
+        db.function('node_thread_id', () => threadId);
+    }
+    async close() {
+        this.db.close();
+    }
+    async execute(query, params) {
+        const stmt = this.db.prepare(query);
+        if (stmt.reader) {
+            const rows = stmt.all(params);
+            return {
+                rowsAffected: 0,
+                rows: {
+                    _array: rows,
+                    length: rows.length
+                }
+            };
+        }
+        else {
+            const info = stmt.run(params);
+            return {
+                rowsAffected: info.changes,
+                insertId: Number(info.lastInsertRowid)
+            };
+        }
+    }
+    async executeRaw(query, params) {
+        const stmt = this.db.prepare(query);
+        if (stmt.reader) {
+            return stmt.raw().all(params);
+        }
+        else {
+            stmt.raw().run(params);
+            return [];
+        }
+    }
+    async executeBatch(query, params) {
+        params = params ?? [];
+        let rowsAffected = 0;
+        const stmt = this.db.prepare(query);
+        for (const paramSet of params) {
+            const info = stmt.run(paramSet);
+            rowsAffected += info.changes;
+        }
+        return { rowsAffected };
+    }
+}
+export async function openDatabase(worker, options) {
+    const BetterSQLite3Database = await worker.loadBetterSqlite3();
+    const baseDB = new BetterSQLite3Database(options.path);
+    baseDB.loadExtension(worker.extensionPath(), 'sqlite3_powersync_init');
+    const asyncDb = new BlockingAsyncDatabase(baseDB);
+    return asyncDb;
+}

package/lib/db/NodeSqliteWorker.d.ts

@@ -0,0 +1,21 @@
+import type { DatabaseSync } from 'node:sqlite';
+import { AsyncDatabase, AsyncDatabaseOpenOptions } from './AsyncDatabase.js';
+import { PowerSyncWorkerOptions } from './SqliteWorker.js';
+declare class BlockingNodeDatabase implements AsyncDatabase {
+    private readonly db;
+    constructor(db: DatabaseSync, write: boolean);
+    close(): Promise<void>;
+    execute(query: string, params: any[]): Promise<{
+        rowsAffected: number;
+        rows: {
+            _array: Record<string, import("node:sqlite").SQLOutputValue>[];
+            length: number;
+        };
+    }>;
+    executeRaw(query: string, params: any[]): Promise<any[][]>;
+    executeBatch(query: string, params: any[][]): Promise<{
+        rowsAffected: number;
+    }>;
+}
+export declare function openDatabase(worker: PowerSyncWorkerOptions, options: AsyncDatabaseOpenOptions): Promise<BlockingNodeDatabase>;
+export {};

package/lib/db/NodeSqliteWorker.js

@@ -0,0 +1,46 @@
+import { threadId } from 'node:worker_threads';
+import { dynamicImport } from '../utils/modules.js';
+class BlockingNodeDatabase {
+    db;
+    constructor(db, write) {
+        this.db = db;
+        db.function('node_thread_id', () => threadId);
+    }
+    async close() {
+        this.db.close();
+    }
+    async execute(query, params) {
+        const stmt = this.db.prepare(query);
+        const rows = stmt.all(...params);
+        return {
+            rowsAffected: 0,
+            rows: {
+                _array: rows,
+                length: rows.length
+            }
+        };
+    }
+    async executeRaw(query, params) {
+        const stmt = this.db.prepare(query);
+        stmt.setReturnArrays(true); // Missing in @types/node, https://nodejs.org/api/sqlite.html#statementsetreturnarraysenabled
+        return stmt.all(...params);
+    }
+    async executeBatch(query, params) {
+        params = params ?? [];
+        let rowsAffected = 0;
+        const stmt = this.db.prepare(query);
+        for (const paramSet of params) {
+            const info = stmt.run(...paramSet);
+            rowsAffected += info.changes;
+        }
+        return { rowsAffected };
+    }
+}
+export async function openDatabase(worker, options) {
+    // NOTE: We want to import node:sqlite dynamically, to avoid bundlers unconditionally requiring node:sqlite in the
+    // end, since that would make us incompatible with older Node.JS versions.
+    const { DatabaseSync } = await dynamicImport('node:sqlite');
+    const baseDB = new DatabaseSync(options.path, { allowExtension: true });
+    baseDB.loadExtension(worker.extensionPath(), 'sqlite3_powersync_init');
+    return new BlockingNodeDatabase(baseDB, options.isWriter);
+}

package/lib/db/PowerSyncDatabase.js

@@ -1,7 +1,7 @@
 import { AbstractPowerSyncDatabase, SqliteBucketStorage } from '@powersync/common';
 import { NodeRemote } from '../sync/stream/NodeRemote.js';
 import { NodeStreamingSyncImplementation } from '../sync/stream/NodeStreamingSyncImplementation.js';
-import { BetterSQLite3DBAdapter } from './BetterSQLite3DBAdapter.js';
+import { WorkerConnectionPool } from './WorkerConnectionPool.js';
 /**
  * A PowerSync database which provides SQLite functionality
  * which is automatically synced.
@@ -27,7 +27,7 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
      * Opens a DBAdapter using better-sqlite3 as the default SQLite open factory.
      */
     openDBAdapter(options) {
-        return new BetterSQLite3DBAdapter(options.database);
+        return new WorkerConnectionPool(options.database);
     }
     generateBucketStorageAdapter() {
         return new SqliteBucketStorage(this.database, this.logger);

package/lib/db/SqliteWorker.d.ts

@@ -5,5 +5,13 @@ export interface PowerSyncWorkerOptions {
      * @returns The absolute path of the PowerSync SQLite core extensions library.
      */
     extensionPath: () => string;
+    /**
+     * A function that returns the `Database` constructor from the `better-sqlite3` package.
+     */
+    loadBetterSqlite3: () => Promise<any>;
 }
+/**
+ * @returns The relevant PowerSync extension binary filename for the current platform and architecture
+ */
+export declare function getPowerSyncExtensionFilename(): string;
 export declare function startPowerSyncWorker(options?: Partial<PowerSyncWorkerOptions>): void;

package/lib/db/SqliteWorker.js

@@ -1,126 +1,103 @@
-import * as path from 'node:path';
-import BetterSQLite3Database from '@powersync/better-sqlite3';
 import * as Comlink from 'comlink';
-import { parentPort, threadId } from 'node:worker_threads';
 import OS from 'node:os';
+import * as path from 'node:path';
 import url from 'node:url';
-class BlockingAsyncDatabase {
-    db;
-    uncommittedUpdatedTables = new Set();
-    committedUpdatedTables = new Set();
-    constructor(db) {
-        this.db = db;
-        db.function('node_thread_id', () => threadId);
-    }
-    collectCommittedUpdates() {
-        const resolved = Promise.resolve([...this.committedUpdatedTables]);
-        this.committedUpdatedTables.clear();
-        return resolved;
-    }
-    installUpdateHooks() {
-        this.db.updateHook((_op, _dbName, tableName, _rowid) => {
-            this.uncommittedUpdatedTables.add(tableName);
-        });
-        this.db.commitHook(() => {
-            for (const tableName of this.uncommittedUpdatedTables) {
-                this.committedUpdatedTables.add(tableName);
-            }
-            this.uncommittedUpdatedTables.clear();
-            return true;
-        });
-        this.db.rollbackHook(() => {
-            this.uncommittedUpdatedTables.clear();
-        });
-    }
-    async close() {
-        this.db.close();
-    }
-    async execute(query, params) {
-        const stmt = this.db.prepare(query);
-        if (stmt.reader) {
-            const rows = stmt.all(params);
-            return {
-                rowsAffected: 0,
-                rows: {
-                    _array: rows,
-                    length: rows.length
-                }
-            };
+import { parentPort } from 'node:worker_threads';
+import { dynamicImport, isBundledToCommonJs } from '../utils/modules.js';
+import { openDatabase as openBetterSqliteDatabase } from './BetterSqliteWorker.js';
+import { openDatabase as openNodeDatabase } from './NodeSqliteWorker.js';
+/**
+ * @returns The relevant PowerSync extension binary filename for the current platform and architecture
+ */
+export function getPowerSyncExtensionFilename() {
+    const platform = OS.platform();
+    const arch = OS.arch();
+    let extensionFile;
+    if (platform == 'win32') {
+        if (arch == 'x64') {
+            extensionFile = 'powersync_x64.dll';
+        }
+        else if (arch == 'ia32') {
+            extensionFile = 'powersync_x86.dll';
+        }
+        else if (arch == 'arm64') {
+            extensionFile = 'powersync_aarch64.dll';
         }
         else {
-            const info = stmt.run(params);
-            return {
-                rowsAffected: info.changes,
-                insertId: Number(info.lastInsertRowid)
-            };
+            throw new Error('Windows platform only supports arm64, ia32 and x64 architecture.');
         }
     }
-    async executeRaw(query, params) {
-        const stmt = this.db.prepare(query);
-        if (stmt.reader) {
-            return stmt.raw().all(params);
+    else if (platform == 'linux') {
+        if (arch == 'x64') {
+            extensionFile = 'libpowersync_x64.so';
+        }
+        else if (arch == 'arm64') {
+            // TODO detect armv7 as an option
+            extensionFile = 'libpowersync_aarch64.so';
+        }
+        else if (arch == 'riscv64') {
+            extensionFile = 'libpowersync_riscv64gc.so';
         }
         else {
-            stmt.raw().run(params);
-            return [];
+            throw new Error('Linux platform only supports x64, arm64 and riscv64 architectures.');
         }
     }
-    async executeBatch(query, params) {
-        params = params ?? [];
-        let rowsAffected = 0;
-        const stmt = this.db.prepare(query);
-        for (const paramSet of params) {
-            const info = stmt.run(paramSet);
-            rowsAffected += info.changes;
+    else if (platform == 'darwin') {
+        if (arch == 'x64') {
+            extensionFile = 'libpowersync_x64.dylib';
         }
-        return { rowsAffected };
-    }
-}
-class BetterSqliteWorker {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    async open(path, isWriter) {
-        const baseDB = new BetterSQLite3Database(path);
-        baseDB.pragma('journal_mode = WAL');
-        baseDB.loadExtension(this.options.extensionPath(), 'sqlite3_powersync_init');
-        if (!isWriter) {
-            baseDB.pragma('query_only = true');
+        else if (arch == 'arm64') {
+            extensionFile = 'libpowersync_aarch64.dylib';
+        }
+        else {
+            throw new Error('macOS platform only supports x64 and arm64 architectures.');
         }
-        const asyncDb = new BlockingAsyncDatabase(baseDB);
-        asyncDb.installUpdateHooks();
-        return Comlink.proxy(asyncDb);
     }
+    else {
+        throw new Error(`Unknown platform: ${platform}, PowerSync for Node.js currently supports Windows, Linux and macOS.`);
+    }
+    return extensionFile;
 }
 export function startPowerSyncWorker(options) {
     const resolvedOptions = {
         extensionPath() {
-            const isCommonJsModule = import.meta.isBundlingToCommonJs ?? false;
-            const platform = OS.platform();
-            let extensionPath;
-            if (platform === 'win32') {
-                extensionPath = 'powersync.dll';
-            }
-            else if (platform === 'linux') {
-                extensionPath = 'libpowersync.so';
-            }
-            else if (platform === 'darwin') {
-                extensionPath = 'libpowersync.dylib';
-            }
-            else {
-                throw 'Unknown platform, PowerSync for Node.js currently supports Windows, Linux and macOS.';
-            }
+            const isCommonJsModule = isBundledToCommonJs;
+            const extensionFilename = getPowerSyncExtensionFilename();
             let resolved;
             if (isCommonJsModule) {
-                resolved = path.resolve(__dirname, '../lib/', extensionPath);
+                resolved = path.resolve(__dirname, '../lib/', extensionFilename);
             }
             else {
-                resolved = url.fileURLToPath(new URL(`../${extensionPath}`, import.meta.url));
+                resolved = url.fileURLToPath(new URL(`../${extensionFilename}`, import.meta.url));
             }
             return resolved;
         },
+        async loadBetterSqlite3() {
+            const module = await dynamicImport('better-sqlite3');
+            return module.default;
+        },
         ...options
     };
-    Comlink.expose(new BetterSqliteWorker(resolvedOptions), parentPort);
+    Comlink.expose(new DatabaseOpenHelper(resolvedOptions), parentPort);
+}
+class DatabaseOpenHelper {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async open(options) {
+        let database;
+        const implementation = options.implementation;
+        switch (implementation.type) {
+            case 'better-sqlite3':
+                database = await openBetterSqliteDatabase(this.options, options);
+                break;
+            case 'node:sqlite':
+                database = await openNodeDatabase(this.options, options);
+                break;
+            default:
+                throw new Error(`Unknown database implementation: ${options.implementation}.`);
+        }
+        return Comlink.proxy(database);
+    }
 }

package/lib/db/{BetterSQLite3DBAdapter.d.ts → WorkerConnectionPool.d.ts}

@@ -1,4 +1,4 @@
-import { BaseObserver, DBAdapter, DBAdapterListener, LockContext, Transaction, DBLockOptions, QueryResult } from '@powersync/common';
+import { BaseObserver, DBAdapter, DBAdapterListener, DBLockOptions, LockContext, QueryResult, Transaction } from '@powersync/common';
 import { NodeSQLOpenOptions } from './options.js';
 export type BetterSQLite3LockContext = LockContext & {
     executeBatch(query: string, params?: any[][]): Promise<QueryResult>;
@@ -7,7 +7,7 @@ export type BetterSQLite3Transaction = Transaction & BetterSQLite3LockContext;
 /**
  * Adapter for better-sqlite3
  */
-export declare class BetterSQLite3DBAdapter extends BaseObserver<DBAdapterListener> implements DBAdapter {
+export declare class WorkerConnectionPool extends BaseObserver<DBAdapterListener> implements DBAdapter {
     private readonly options;
     readonly name: string;
     private readConnections;

package/lib/db/{BetterSQLite3DBAdapter.js → WorkerConnectionPool.js}

@@ -1,15 +1,19 @@
+import * as Comlink from 'comlink';
 import fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { Worker } from 'node:worker_threads';
-import * as Comlink from 'comlink';
 import { BaseObserver } from '@powersync/common';
 import { AsyncResource } from 'node:async_hooks';
+import { isBundledToCommonJs } from '../utils/modules.js';
 import { RemoteConnection } from './RemoteConnection.js';
 const READ_CONNECTIONS = 5;
+const defaultDatabaseImplementation = {
+    type: 'better-sqlite3'
+};
 /**
  * Adapter for better-sqlite3
  */
-export class BetterSQLite3DBAdapter extends BaseObserver {
+export class WorkerConnectionPool extends BaseObserver {
     options;
     name;
     readConnections;
@@ -42,7 +46,7 @@ export class BetterSQLite3DBAdapter extends BaseObserver {
             dbFilePath = path.join(this.options.dbLocation, dbFilePath);
         }
         const openWorker = async (isWriter) => {
-            const isCommonJsModule = import.meta.isBundlingToCommonJs ?? false;
+            const isCommonJsModule = isBundledToCommonJs;
             let worker;
             const workerName = isWriter ? `write ${dbFilePath}` : `read ${dbFilePath}`;
             const workerFactory = this.options.openWorker ?? ((...args) => new Worker(...args));
@@ -78,8 +82,27 @@ export class BetterSQLite3DBAdapter extends BaseObserver {
             worker.once('error', (e) => {
                 console.error('Unexpected PowerSync database worker error', e);
             });
-            const database = (await comlink.open(dbFilePath, isWriter));
-            return new RemoteConnection(worker, comlink, database);
+            const database = (await comlink.open({
+                path: dbFilePath,
+                isWriter,
+                implementation: this.options.implementation ?? defaultDatabaseImplementation
+            }));
+            if (isWriter) {
+                await database.execute("SELECT powersync_update_hooks('install');", []);
+            }
+            const connection = new RemoteConnection(worker, comlink, database);
+            if (this.options.initializeConnection) {
+                await this.options.initializeConnection(connection, isWriter);
+            }
+            if (!isWriter) {
+                await connection.execute('pragma query_only = true');
+            }
+            else {
+                // We only need to enable this on the writer connection.
+                // We can get `database is locked` errors if we enable this on concurrently opening read connections.
+                await connection.execute('pragma journal_mode = WAL');
+            }
+            return connection;
         };
         // Open the writer first to avoid multiple threads enabling WAL concurrently (causing "database is locked" errors).
         this.writeConnection = await openWorker(true);
@@ -144,7 +167,8 @@ export class BetterSQLite3DBAdapter extends BaseObserver {
                     return await fn(this.writeConnection);
                 }
                 finally {
-                    const updates = await this.writeConnection.database.collectCommittedUpdates();
+                    const serializedUpdates = await this.writeConnection.database.executeRaw("SELECT powersync_update_hooks('get');", []);
+                    const updates = JSON.parse(serializedUpdates[0][0]);
                     if (updates.length > 0) {
                         const event = {
                             tables: updates,