Use proper read-only connections with op-sqlite (#1012)

simolus3 · simolus3 · commit 3aad5a4738bc · 2026-07-06T14:53:49.000+02:00
diff --git a/demos/react-native-barebones-opsqlite/package.json b/demos/react-native-barebones-opsqlite/package.json
@@ -10,7 +10,7 @@
   },
   "dependencies": {
     "@azure/core-asynciterator-polyfill": "^1.0.2",
-    "@op-engineering/op-sqlite": "^17.0.0",
+    "@op-engineering/op-sqlite": "^17.1.0",
     "@powersync/react": "^1.10.0",
     "@powersync/react-native": "^1.35.7",
     "react": "19.1.0",
diff --git a/demos/react-native-supabase-background-sync/package.json b/demos/react-native-supabase-background-sync/package.json
@@ -10,7 +10,7 @@
   },
   "dependencies": {
     "@expo/vector-icons": "^15.1.1",
-    "@op-engineering/op-sqlite": "^17.0.0",
+    "@op-engineering/op-sqlite": "^17.1.0",
     "@powersync/react-native": "^1.35.7",
     "@react-navigation/bottom-tabs": "^7.3.10",
     "@react-navigation/elements": "^2.3.8",
diff --git a/demos/react-native-supabase-todolist/package.json b/demos/react-native-supabase-todolist/package.json
@@ -12,7 +12,7 @@
     "@azure/core-asynciterator-polyfill": "^1.0.2",
     "@dr.pogodin/react-native-fs": "2.37.0",
     "@expo/vector-icons": "^15.1.1",
-    "@op-engineering/op-sqlite": "^17.0.0",
+    "@op-engineering/op-sqlite": "^17.1.0",
     "@powersync/attachments-storage-react-native": "^0.0.2",
     "@powersync/common": "^1.57.0",
     "@powersync/react": "^1.10.0",
diff --git a/packages/adapter-sql-js/src/SQLJSAdapter.ts b/packages/adapter-sql-js/src/SQLJSAdapter.ts
@@ -173,10 +173,6 @@ class SqlJsLockContext extends LockContext {
     super();
   }
 
-  get connectionType(): 'readWrite' {
-    return 'readWrite';
-  }
-
   async executeRaw(query: string, params?: any[]): Promise<RawQueryResult> {
     const db = this.db;
     const statement = db.prepare(query);
diff --git a/packages/capacitor/src/adapter/CapacitorSQLiteAdapter.ts b/packages/capacitor/src/adapter/CapacitorSQLiteAdapter.ts
@@ -264,10 +264,6 @@ export class CapacitorSQLiteAdapter extends DBAdapter {
     };
 
     class CapacitorLockContext extends LockContext {
-      get connectionType(): 'readWrite' {
-        return 'readWrite';
-      }
-
       getAll<T>(sql: string, parameters?: any[]): Promise<T[]> {
         return getAll(sql, parameters);
       }
diff --git a/packages/common/etc/common.api.md b/packages/common/etc/common.api.md
@@ -658,7 +658,6 @@ export interface LocalStorageAdapter {
 
 // @public (undocumented)
 export abstract class LockContext implements SqlExecutor, DBGetUtils {
-    abstract get connectionType(): 'readWrite' | 'queryOnly' | 'readOnly';
     // (undocumented)
     execute<T = SqliteRecord>(query: string, params?: any[] | undefined): Promise<QueryResult<T>>;
     // (undocumented)
diff --git a/packages/common/src/db/DBAdapter.ts b/packages/common/src/db/DBAdapter.ts
@@ -87,16 +87,6 @@ export interface SqlExecutor {
  * @public
  */
 export abstract class LockContext implements SqlExecutor, DBGetUtils {
-  /**
-   * How the connection has been opened.
-   *
-   * `readWrite` indicates that the lock context is capable of writing to the database.
-   * `queryOnly` indicates that the lock context has been opened in a readwrite mode, but a `PRAGMA query_only = TRUE`
-   * disabled writes.
-   * `readOnly` indicates that the lock context has been opened by passing `SQLITE_OPEN_READONLY` to `sqlite3_open_v2`.
-   */
-  abstract get connectionType(): 'readWrite' | 'queryOnly' | 'readOnly';
-
   abstract executeRaw<T>(query: string, params?: any[] | undefined): Promise<RawQueryResult>;
 
   async getAll<T>(sql: string, parameters?: any[]): Promise<T[]> {
@@ -237,10 +227,6 @@ class TransactionImplementation extends LockContext {
     super();
   }
 
-  get connectionType() {
-    return this.inner.connectionType;
-  }
-
   async commit(): Promise<void> {
     if (this.finalized) {
       return;
@@ -272,16 +258,8 @@ class TransactionImplementation extends LockContext {
   static async runWith<T>(ctx: LockContext, fn: (tx: Transaction) => Promise<T>): Promise<T> {
     let tx = new TransactionImplementation(ctx);
 
-    // For write transactions, use BEGIN IMMEDIATE to immediately obtain a write lock on the database (instead of doing
-    // that on the first statement). If we have a genuine read-only connection, we also use BEGIN IMMEDIATE there: In
-    // WAL mode, that ensures we pin the current state of the database (instead of the state at the first statement in
-    // the transaction). But if we have a "fake" read-only connection implemented through `pragma query_only = true`, we
-    // can't use this trick because it would attempt to lock the connection. So there, we use a regular `BEGIN`
-    // statement.
-    const useBeginImmediate = ctx.connectionType != 'queryOnly';
-
     try {
-      await ctx.execute(useBeginImmediate ? 'BEGIN IMMEDIATE' : 'BEGIN');
+      await ctx.execute('BEGIN IMMEDIATE');
 
       const result = await fn(tx);
       await tx.commit();
diff --git a/packages/node/src/db/RemoteConnection.ts b/packages/node/src/db/RemoteConnection.ts
@@ -14,12 +14,7 @@ export class RemoteConnection extends LockContext {
 
   private readonly notifyWorkerClosed = new AbortController();
 
-  constructor(
-    worker: Worker,
-    comlink: Remote<AsyncDatabaseOpener>,
-    database: Remote<AsyncDatabase>,
-    private readonly readonly: boolean
-  ) {
+  constructor(worker: Worker, comlink: Remote<AsyncDatabaseOpener>, database: Remote<AsyncDatabase>) {
     super();
     this.worker = worker;
     this.comlink = comlink;
@@ -30,10 +25,6 @@ export class RemoteConnection extends LockContext {
     });
   }
 
-  public get connectionType() {
-    return this.readonly ? 'readOnly' : 'readWrite';
-  }
-
   /**
    * Runs the inner function, but appends the stack trace where this function was called. This is useful for workers
    * because stack traces from worker errors are otherwise unrelated to the application issue that has caused them.
diff --git a/packages/node/src/db/WorkerConnectionPool.ts b/packages/node/src/db/WorkerConnectionPool.ts
@@ -119,7 +119,7 @@ export class WorkerConnectionPool extends DBAdapter {
         await database.executeRaw("SELECT powersync_update_hooks('install');", []);
       }
 
-      const connection = new RemoteConnection(worker, comlink, database, !isWriter);
+      const connection = new RemoteConnection(worker, comlink, database);
       if (this.options.initializeConnection) {
         await this.options.initializeConnection(connection, isWriter);
       }
diff --git a/packages/react-native/package.json b/packages/react-native/package.json
@@ -35,7 +35,7 @@
   },
   "homepage": "https://docs.powersync.com/",
   "peerDependencies": {
-    "@op-engineering/op-sqlite": "^17.0.0",
+    "@op-engineering/op-sqlite": "^17.1.0",
     "@powersync/common": "workspace:^1.57.0",
     "react": "*",
     "react-native": "*"
diff --git a/packages/react-native/src/db/adapters/op-sqlite/OPSQLiteConnection.ts b/packages/react-native/src/db/adapters/op-sqlite/OPSQLiteConnection.ts
@@ -12,7 +12,6 @@ import {
 
 export type OPSQLiteConnectionOptions = {
   baseDB: DB;
-  readonly: boolean;
 };
 
 export type OPSQLiteUpdateNotification = {
@@ -41,10 +40,6 @@ export class OPSQLiteConnection extends LockContext {
     });
   }
 
-  get connectionType() {
-    return this.options.readonly ? 'queryOnly' : 'readWrite';
-  }
-
   addTableUpdate(update: OPSQLiteUpdateNotification) {
     this.updateBuffer.add(update.table);
   }
diff --git a/packages/react-native/src/db/adapters/op-sqlite/OPSqliteAdapter.ts b/packages/react-native/src/db/adapters/op-sqlite/OPSqliteAdapter.ts
@@ -57,8 +57,6 @@ export class OPSQLiteDBAdapter extends DBAdapter {
       `PRAGMA synchronous = ${synchronous}`
     ];
 
-    const readConnectionStatements = [...baseStatements, 'PRAGMA query_only = true'];
-
     for (const statement of writeConnectionStatements) {
       for (let tries = 0; tries < 30; tries++) {
         try {
@@ -82,7 +80,7 @@ export class OPSQLiteDBAdapter extends DBAdapter {
     const underlyingReadConnections = [];
     for (let i = 0; i < READ_CONNECTIONS; i++) {
       const conn = await this.openConnection(true, dbFilename);
-      for (let statement of readConnectionStatements) {
+      for (let statement of baseStatements) {
         await conn.execute(statement);
       }
       underlyingReadConnections.push(conn);
@@ -92,9 +90,9 @@ export class OPSQLiteDBAdapter extends DBAdapter {
     this.readConnections = new Semaphore(underlyingReadConnections);
   }
 
-  protected async openConnection(readonly: boolean, filenameOverride?: string): Promise<OPSQLiteConnection> {
+  protected async openConnection(readOnly: boolean, filenameOverride?: string): Promise<OPSQLiteConnection> {
     const dbFilename = filenameOverride ?? this.options.name;
-    const DB: DB = this.openDatabase(dbFilename, this.options.sqliteOptions?.encryptionKey ?? undefined);
+    const DB: DB = this.openDatabase(dbFilename, readOnly, this.options.sqliteOptions?.encryptionKey ?? undefined);
 
     //Load extensions for all connections
     this.loadAdditionalExtensions(DB);
@@ -103,14 +101,14 @@ export class OPSQLiteDBAdapter extends DBAdapter {
     await DB.execute('SELECT powersync_init()');
 
     return new OPSQLiteConnection({
-      baseDB: DB,
-      readonly
+      baseDB: DB
     });
   }
 
-  private openDatabase(dbFilename: string, encryptionKey?: string): DB {
+  private openDatabase(dbFilename: string, readOnly: boolean, encryptionKey?: string): DB {
     const openOptions: Parameters<typeof open>[0] = {
-      name: dbFilename
+      name: dbFilename,
+      readOnly
     };
 
     if (this.options.dbLocation) {
diff --git a/packages/tauri/guest-js/pool.ts b/packages/tauri/guest-js/pool.ts
@@ -53,7 +53,7 @@ export class RustDatabaseAdapter extends DBAdapter {
     const handle = (connection as any).CreatedHandle as number;
 
     try {
-      return await fn(new RustLockContext(handle, write ? 'readWrite' : 'readOnly'));
+      return await fn(new RustLockContext(handle));
     } finally {
       await await powersyncCommand({ CloseHandle: handle });
     }
@@ -65,10 +65,7 @@ export class RustDatabaseAdapter extends DBAdapter {
 }
 
 class RustLockContext extends LockContext {
-  constructor(
-    readonly handle: number,
-    readonly connectionType: 'readWrite' | 'readOnly'
-  ) {
+  constructor(readonly handle: number) {
     super();
   }
 
diff --git a/packages/web/src/db/adapters/SSRDBAdapter.ts b/packages/web/src/db/adapters/SSRDBAdapter.ts
@@ -38,10 +38,6 @@ export class SSRDBAdapter extends DBAdapter {
 }
 
 class StubLockContext extends LockContext {
-  get connectionType(): 'readWrite' {
-    return 'readWrite';
-  }
-
   async executeRaw(): Promise<RawQueryResult> {
     return MOCK_QUERY_RESPONSE;
   }
diff --git a/packages/web/src/db/adapters/wa-sqlite/DatabaseClient.ts b/packages/web/src/db/adapters/wa-sqlite/DatabaseClient.ts
@@ -194,10 +194,6 @@ class ClientLockContext extends LockContext {
     this.#token = token;
   }
 
-  get connectionType(): 'readWrite' {
-    return 'readWrite';
-  }
-
   /**
    * Requests an operation from the worker, potentially tracing it if that option has been enabled.
    */
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
diff --git a/tools/powersynctests/ios/Podfile.lock b/tools/powersynctests/ios/Podfile.lock

Original file line number	Diff line number	Diff line change
`@@ -119,7 +119,7 @@ export class WorkerConnectionPool extends DBAdapter {`
`119`	`119`	`await database.executeRaw("SELECT powersync_update_hooks('install');", []);`
`120`	`120`	`}`
`121`	`121`
`122`		`- const connection = new RemoteConnection(worker, comlink, database, !isWriter);`
	`122`	`+ const connection = new RemoteConnection(worker, comlink, database);`
`123`	`123`	`if (this.options.initializeConnection) {`
`124`	`124`	`await this.options.initializeConnection(connection, isWriter);`
`125`	`125`	`}`