@powersync/node 0.0.0-dev-20250925184532 → 0.0.0-dev-20251003085035

package/download_core.js

@@ -1,39 +1,27 @@
-// 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.5';
+const version = '0.4.6';
 const versionHashes = {
-  'powersync_x64.dll': '0e9e47f7265257c9f8f7416a1b5ddf91d82199ff88760b595ff6cb1776231489',
-  'libpowersync_x64.so': '6421d9b280604ca4497b99949e3de24c4245b24105dee5c1e86500942ee27a17',
-  'libpowersync_aarch64.so': 'fda0951274d5ce623b19a32dee6473597cd401f898f871062421557b2c36936a',
-  'libpowersync_x64.dylib': '7337dcf21295d293dd073254014386a7e7809a3bb9acec0362158581c5ab3cdb',
-  'libpowersync_aarch64.dylib': '7d54da7b57f76eb5fd5286151d8f4f75f3ebc9d60e66391a0e6c5cca2ee5c5bc'
+  'powersync_x64.dll': '5efaa9ad4975094912a36843cb7b503376cacd233d21ae0956f0f4b42dcb457b',
+  'libpowersync_x64.so': 'e9d78620d69d3cf7d57353891fe0bf85b79d326b42c4669b9500b9e610388f76',
+  'libpowersync_aarch64.so': '0d84c0dc0134fc89af65724d11e2c45e3c15569c575ecda52d0ec2fa2aeec495',
+  '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);
+// Map of all assets to their destinations
+const assetMap = {
+  'powersync_x64.dll': 'powersync.dll',
+  'libpowersync_x64.so': 'libpowersync.so',
+  'libpowersync_aarch64.so': 'libpowersync-aarch64.so',
+  'libpowersync_x64.dylib': 'libpowersync.dylib',
+  'libpowersync_aarch64.dylib': 'libpowersync-aarch64.dylib'
+};
 
 const hashStream = async (input) => {
   for await (const chunk of input.pipe(createHash('sha256')).setEncoding('hex')) {
@@ -41,9 +29,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 +42,92 @@ 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, destination) => {
+  const destinationPath = path.resolve('lib', destination);
+  const expectedHash = versionHashes[asset];
+
+  // Check if file exists and has correct hash
+  const currentHash = await hashLocal(destinationPath);
+  if (currentHash === expectedHash) {
+    console.debug(`${destination} 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 ${destination}`);
+};
+
+const checkAsset = async (asset, destination) => {
+  const destinationPath = path.resolve('lib', destination);
+  const expectedHash = versionHashes[asset];
+  const currentHash = await hashLocal(destinationPath);
+
+  return {
+    asset,
+    destination,
+    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(
+    Object.entries(assetMap).map(([asset, destination]) => checkAsset(asset, destination))
+  );
 
-  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.destination}`);
+    }
+  }
+
+  if (toDownload.length > 0) {
+    console.log('\nFiles to download:');
+    for (const check of toDownload) {
+      if (!check.exists) {
+        console.log(`  • ${check.destination} (missing)`);
+      } else {
+        console.log(`  • ${check.destination} (hash mismatch)`);
+      }
+    }
+
+    console.log('\nStarting downloads...');
+    // Download required assets in parallel
+    await Promise.all(toDownload.map((check) => downloadAsset(check.asset, check.destination)));
+
+    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,9 @@ 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>;
 }
 export declare function startPowerSyncWorker(options?: Partial<PowerSyncWorkerOptions>): void;

package/lib/db/SqliteWorker.js

@@ -1,112 +1,47 @@
-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
-                }
-            };
-        }
-        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 };
-    }
-}
-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');
-        }
-        const asyncDb = new BlockingAsyncDatabase(baseDB);
-        asyncDb.installUpdateHooks();
-        return Comlink.proxy(asyncDb);
-    }
-}
+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';
 export function startPowerSyncWorker(options) {
     const resolvedOptions = {
         extensionPath() {
-            const isCommonJsModule = import.meta.isBundlingToCommonJs ?? false;
+            const isCommonJsModule = isBundledToCommonJs;
             const platform = OS.platform();
+            const arch = OS.arch();
             let extensionPath;
             if (platform === 'win32') {
-                extensionPath = 'powersync.dll';
+                if (arch === 'x64') {
+                    extensionPath = 'powersync.dll';
+                }
+                else {
+                    throw 'Windows platform only supports x64 architecture.';
+                }
             }
             else if (platform === 'linux') {
-                extensionPath = 'libpowersync.so';
+                if (arch === 'x64') {
+                    extensionPath = 'libpowersync.so';
+                }
+                else if (arch === 'arm64') {
+                    extensionPath = 'libpowersync-aarch64.so';
+                }
+                else {
+                    throw 'Linux platform only supports x64 and arm64 architectures.';
+                }
             }
             else if (platform === 'darwin') {
-                extensionPath = 'libpowersync.dylib';
+                if (arch === 'x64') {
+                    extensionPath = 'libpowersync.dylib';
+                }
+                else if (arch === 'arm64') {
+                    extensionPath = 'libpowersync-aarch64.dylib';
+                }
+                else {
+                    throw 'macOS platform only supports x64 and arm64 architectures.';
+                }
             }
             else {
                 throw 'Unknown platform, PowerSync for Node.js currently supports Windows, Linux and macOS.';
@@ -120,7 +55,32 @@ export function startPowerSyncWorker(options) {
             }
             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}

@@ -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}

@@ -5,11 +5,15 @@ import * as Comlink from 'comlink';
 import { BaseObserver } from '@powersync/common';
 import { AsyncResource } from 'node:async_hooks';
 import { RemoteConnection } from './RemoteConnection.js';
+import { isBundledToCommonJs } from '../utils/modules.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,23 @@ 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);
+            }
+            await connection.execute('pragma journal_mode = WAL');
+            if (!isWriter) {
+                await connection.execute('pragma query_only = true');
+            }
+            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 +163,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,

package/lib/db/options.d.ts

@@ -1,11 +1,27 @@
 import { type Worker } from 'node:worker_threads';
-import { SQLOpenOptions } from '@powersync/common';
+import { LockContext, SQLOpenOptions } from '@powersync/common';
 export type WorkerOpener = (...args: ConstructorParameters<typeof Worker>) => InstanceType<typeof Worker>;
+/**
+ * Use the [better-sqlite3](https://github.com/WiseLibs/better-sqlite3) package as a SQLite driver for PowerSync.
+ */
+export interface BetterSqlite3Options {
+    type: 'better-sqlite3';
+}
+/**
+ * Use the experimental `node:sqlite` interface as a SQLite driver for PowerSync.
+ *
+ * Note that this option is not currently tested and highly unstable.
+ */
+export interface NodeSqliteOptions {
+    type: 'node:sqlite';
+}
+export type NodeDatabaseImplementation = BetterSqlite3Options | NodeSqliteOptions;
 /**
  * The {@link SQLOpenOptions} available across all PowerSync SDKs for JavaScript extended with
  * Node.JS-specific options.
  */
 export interface NodeSQLOpenOptions extends SQLOpenOptions {
+    implementation?: NodeDatabaseImplementation;
     /**
      * The Node.JS SDK will use one worker to run writing queries and additional workers to run reads.
      * This option controls how many workers to use for reads.
@@ -19,4 +35,10 @@ export interface NodeSQLOpenOptions extends SQLOpenOptions {
      * @returns the resolved worker.
      */
     openWorker?: WorkerOpener;
+    /**
+     * Initializes a created database connection.
+     *
+     * This can be used to e.g. set encryption keys, if an encrypted database should be used.
+     */
+    initializeConnection?: (db: LockContext, isWriter: boolean) => Promise<void>;
 }