@powersync/capacitor 0.0.0-dev-20260305124002 → 0.0.0-dev-20260503073249

package/src/adapter/CapacitorSQLiteAdapter.ts

@@ -4,15 +4,17 @@ import { Capacitor } from '@capacitor/core';
 import {
   BaseObserver,
   BatchedUpdateNotification,
+  ConnectionPool,
   DBAdapter,
+  DBAdapterDefaultMixin,
   DBAdapterListener,
   DBLockOptions,
   LockContext,
-  mutexRunExclusive,
+  Mutex,
   QueryResult,
+  timeoutSignal,
   Transaction
 } from '@powersync/web';
-import { Mutex } from 'async-mutex';
 import { PowerSyncCore } from '../plugin/PowerSyncCore.js';
 import { messageForErrorCode } from '../plugin/PowerSyncPlugin.js';
 import { CapacitorSQLiteOpenFactoryOptions, DEFAULT_SQLITE_OPTIONS } from './CapacitorSQLiteOpenFactory.js';
@@ -30,13 +32,8 @@ async function monitorQuery(sql: string, executor: () => Promise<QueryResult>):
     throw e;
   }
 }
-/**
- * An implementation of {@link DBAdapter} using the Capacitor Community SQLite [plugin](https://github.com/capacitor-community/sqlite).
- *
- * @experimental
- * @alpha This is currently experimental and may change without a major version bump.
- */
-export class CapacitorSQLiteAdapter extends BaseObserver<DBAdapterListener> implements DBAdapter {
+
+class CapacitorConnectionPool extends BaseObserver<DBAdapterListener> implements ConnectionPool {
   protected _writeConnection: SQLiteDBConnection | null;
   protected _readConnection: SQLiteDBConnection | null;
   protected initializedPromise: Promise<void>;
@@ -206,26 +203,8 @@ export class CapacitorSQLiteAdapter extends BaseObserver<DBAdapterListener> impl
       return results.rows?._array.map((row) => Object.values(row)) ?? [];
     };
 
-    return {
-      getAll,
-      getOptional,
-      get,
-      executeRaw,
-      execute
-    };
-  }
-
-  execute(query: string, params?: any[]): Promise<QueryResult> {
-    return this.writeLock((tx) => tx.execute(query, params));
-  }
-
-  executeRaw(query: string, params?: any[]): Promise<any[][]> {
-    return this.writeLock((tx) => tx.executeRaw(query, params));
-  }
-
-  async executeBatch(query: string, params: any[][] = []): Promise<QueryResult> {
-    return this.writeLock(async (tx) => {
-      let result = await this.writeConnection.executeSet(
+    const executeBatch = async (query: string, params: any[][] = []): Promise<QueryResult> => {
+      let result = await db.executeSet(
         params.map((param) => ({
           statement: query,
           values: param
@@ -236,55 +215,44 @@ export class CapacitorSQLiteAdapter extends BaseObserver<DBAdapterListener> impl
         rowsAffected: result.changes?.changes ?? 0,
         insertId: result.changes?.lastId
       };
-    });
-  }
+    };
 
-  readLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions): Promise<T> {
-    return mutexRunExclusive(
-      this.readMutex,
-      async () => {
-        await this.initializedPromise;
-        return await fn(this.generateLockContext(this.readConnection));
-      },
-      options
-    );
+    return {
+      getAll,
+      getOptional,
+      get,
+      executeRaw,
+      execute,
+      executeBatch
+    };
   }
 
-  readTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions): Promise<T> {
-    return this.readLock(async (ctx) => {
-      return this.internalTransaction(ctx, fn);
-    });
+  readLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions): Promise<T> {
+    return this.readMutex.runExclusive(async () => {
+      await this.initializedPromise;
+      return fn(this.generateLockContext(this.readConnection));
+    }, timeoutSignal(options?.timeoutMs));
   }
 
   writeLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions): Promise<T> {
-    return mutexRunExclusive(
-      this.writeMutex,
-      async () => {
-        await this.initializedPromise;
-        const result = await fn(this.generateLockContext(this.writeConnection));
-
-        // Fetch table updates
-        const updates = await this.writeConnection.query("SELECT powersync_update_hooks('get') AS table_name");
-        const jsonUpdates = updates.values?.[0];
-        if (!jsonUpdates || !jsonUpdates.table_name) {
-          throw new Error('Could not fetch table updates');
-        }
-        const notification: BatchedUpdateNotification = {
-          rawUpdates: [],
-          tables: JSON.parse(jsonUpdates.table_name),
-          groupedUpdates: {}
-        };
-        this.iterateListeners((l) => l.tablesUpdated?.(notification));
-        return result;
-      },
-      options
-    );
-  }
-
-  writeTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions): Promise<T> {
-    return this.writeLock(async (ctx) => {
-      return this.internalTransaction(ctx, fn);
-    });
+    return this.writeMutex.runExclusive(async () => {
+      await this.initializedPromise;
+      const result = await fn(this.generateLockContext(this.writeConnection));
+
+      // Fetch table updates
+      const updates = await this.writeConnection.query("SELECT powersync_update_hooks('get') AS table_name");
+      const jsonUpdates = updates.values?.[0];
+      if (!jsonUpdates || !jsonUpdates.table_name) {
+        throw new Error('Could not fetch table updates');
+      }
+      const notification: BatchedUpdateNotification = {
+        rawUpdates: [],
+        tables: JSON.parse(jsonUpdates.table_name),
+        groupedUpdates: {}
+      };
+      this.iterateListeners((l) => l.tablesUpdated?.(notification));
+      return result;
+    }, timeoutSignal(options?.timeoutMs));
   }
 
   refreshSchema(): Promise<void> {
@@ -296,52 +264,12 @@ export class CapacitorSQLiteAdapter extends BaseObserver<DBAdapterListener> impl
       });
     });
   }
-
-  getAll<T>(sql: string, parameters?: any[]): Promise<T[]> {
-    return this.readLock((tx) => tx.getAll<T>(sql, parameters));
-  }
-
-  getOptional<T>(sql: string, parameters?: any[]): Promise<T | null> {
-    return this.readLock((tx) => tx.getOptional<T>(sql, parameters));
-  }
-
-  get<T>(sql: string, parameters?: any[]): Promise<T> {
-    return this.readLock((tx) => tx.get<T>(sql, parameters));
-  }
-
-  protected async internalTransaction<T>(ctx: LockContext, fn: (tx: Transaction) => Promise<T>): Promise<T> {
-    let finalized = false;
-    const commit = async (): Promise<QueryResult> => {
-      if (finalized) {
-        return { rowsAffected: 0 };
-      }
-      finalized = true;
-      return ctx.execute('COMMIT');
-    };
-    const rollback = async (): Promise<QueryResult> => {
-      if (finalized) {
-        return { rowsAffected: 0 };
-      }
-      finalized = true;
-      return ctx.execute('ROLLBACK');
-    };
-    try {
-      await ctx.execute('BEGIN');
-      const result = await fn({
-        ...ctx,
-        commit,
-        rollback
-      });
-      await commit();
-      return result;
-    } catch (ex) {
-      try {
-        await rollback();
-      } catch (ex2) {
-        // In rare cases, a rollback may fail.
-        // Safe to ignore.
-      }
-      throw ex;
-    }
-  }
 }
+
+/**
+ * An implementation of {@link DBAdapter} using the Capacitor Community SQLite [plugin](https://github.com/capacitor-community/sqlite).
+ *
+ * @experimental
+ * @alpha This is currently experimental and may change without a major version bump.
+ */
+export class CapacitorSQLiteAdapter extends DBAdapterDefaultMixin(CapacitorConnectionPool) {}

package/src/sync/CapacitorBucketStorageAdapter.ts

@@ -0,0 +1,22 @@
+import { PowerSyncControlCommand, SqliteBucketStorage } from '@powersync/web';
+
+export class CapacitorBucketStorageAdapter extends SqliteBucketStorage {
+  control(op: PowerSyncControlCommand, payload: string | Uint8Array | ArrayBuffer | null): Promise<string> {
+    if (payload instanceof Uint8Array && (payload as any)['_isBuffer'] == true) {
+      /**
+       * The Buffer polyfill, used in @powersync/common, is a Uint8Array subclass which defines additional fields like
+       * `_isBuffer` and `parent` on its `prototype`. The additional fields are serialized when passed through the native bridge.
+       * The Capacitor Community SQLite lib expects a dictionarty of indexes to numerical bytes.
+       * The additiona fields (which are not an index to numerical byte mapping) cause the parsing logic in the SQLite lib to throw an error:
+       *  "Error in reading buffer".
+       *
+       * Re-wrapping the same backing buffer as a plain Uint8Array removes the Buffer subclass wrapper
+       * while keeping the same underlying bytes. This creates a new view, not a byte copy, so the
+       * overhead should be minimal.
+       */
+      payload = new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength);
+    }
+
+    return super.control(op, payload);
+  }
+}

package/src/sync/CapacitorRemote.ts

@@ -0,0 +1,12 @@
+import { Capacitor } from '@capacitor/core';
+import { WebRemote } from '@powersync/web';
+
+export class CapacitorRemote extends WebRemote {
+  protected get supportsStreamingBinaryResponses(): boolean {
+    /**
+     * We'd like to avoid passing Binary buffers to SQLite when using
+     * iOS for now. This is due to inefficient binary processing.
+     */
+    return Capacitor.getPlatform() !== 'ios';
+  }
+}

package/src/sync/CapacitorSyncImplementation.ts

@@ -1,5 +1,4 @@
-import { AbstractStreamingSyncImplementation, LockOptions, LockType, mutexRunExclusive } from '@powersync/web';
-import { Mutex } from 'async-mutex';
+import { AbstractStreamingSyncImplementation, LockOptions, LockType, Mutex } from '@powersync/web';
 
 type MutexMap = {
   /**
@@ -56,11 +55,8 @@ export class CapacitorStreamingSyncImplementation extends AbstractStreamingSyncI
     mutexRecord.tracking.add(this.instanceId);
     const mutex = mutexRecord.locks[lockOptions.type];
 
-    return mutexRunExclusive(mutex, async () => {
-      if (lockOptions.signal?.aborted) {
-        throw new Error('Aborted');
-      }
+    return mutex.runExclusive(async () => {
       return await lockOptions.callback();
-    });
+    }, lockOptions.signal);
   }
 }