@powersync/react-native 1.31.0 → 1.33.0

package/dist/index.js

@@ -3,7 +3,6 @@
 var common = require('@powersync/common');
 var react = require('@powersync/react');
 var reactNative = require('react-native');
-var asyncMutex = require('async-mutex');
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -19258,8 +19257,8 @@ class ReactNativeStreamingSyncImplementation extends common.AbstractStreamingSyn
             return;
         }
         this.locks = new Map();
-        this.locks.set(common.LockType.CRUD, new asyncMutex.Mutex());
-        this.locks.set(common.LockType.SYNC, new asyncMutex.Mutex());
+        this.locks.set(common.LockType.CRUD, new common.Mutex());
+        this.locks.set(common.LockType.SYNC, new common.Mutex());
         if (identifier) {
             LOCKS.set(identifier, this.locks);
         }
@@ -19270,11 +19269,8 @@ class ReactNativeStreamingSyncImplementation extends common.AbstractStreamingSyn
             throw new Error(`Lock type ${lockOptions.type} not found`);
         }
         return lock.runExclusive(async () => {
-            if (lockOptions.signal?.aborted) {
-                throw new Error('Aborted');
-            }
             return lockOptions.callback();
-        });
+        }, lockOptions.signal);
     }
 }
 
@@ -19300,15 +19296,9 @@ function uint8ArrayToArrayBuffer(array) {
     }
 }
 
-/**
- * Adapter for React Native Quick SQLite
- */
-class RNQSDBAdapter extends common.BaseObserver {
+class RNQSConnectionPool extends common.BaseObserver {
     baseDB;
     name;
-    getAll;
-    getOptional;
-    get;
     constructor(baseDB, name) {
         super();
         this.baseDB = baseDB;
@@ -19317,41 +19307,48 @@ class RNQSDBAdapter extends common.BaseObserver {
         baseDB.registerTablesChangedHook((update) => {
             this.iterateListeners((cb) => cb.tablesUpdated?.(update));
         });
-        const topLevelUtils = this.generateDBHelpers({
-            // Arrow function binds `this` for use in readOnlyExecute
-            execute: (sql, params) => this.readOnlyExecute(sql, params)
-        });
-        // Only assigning get helpers
-        this.getAll = topLevelUtils.getAll;
-        this.getOptional = topLevelUtils.getOptional;
-        this.get = topLevelUtils.get;
     }
     close() {
         return this.baseDB.close();
     }
     readLock(fn, options) {
-        return this.baseDB.readLock((dbTx) => fn(this.generateDBHelpers(this.generateContext(dbTx))), options);
-    }
-    readTransaction(fn, options) {
-        return this.baseDB.readTransaction((dbTx) => fn(this.generateDBHelpers(this.generateContext(dbTx))), options);
+        return this.baseDB.readLock((dbTx) => fn(this.generateContext(dbTx)), options);
     }
     writeLock(fn, options) {
-        return this.baseDB.writeLock((dbTx) => fn(this.generateDBHelpers(this.generateContext(dbTx))), options);
+        return this.baseDB.writeLock((dbTx) => fn(this.generateContext(dbTx)), options);
     }
-    writeTransaction(fn, options) {
-        return this.baseDB.writeTransaction((dbTx) => fn(this.generateDBHelpers(this.generateContext(dbTx))), options);
+    generateContext(ctx) {
+        return new QuickSqliteContext(ctx);
+    }
+    async refreshSchema() {
+        await this.baseDB.refreshSchema();
+    }
+}
+class QuickSqliteExecutor {
+    context;
+    constructor(context) {
+        this.context = context;
     }
     execute(query, params) {
-        return this.baseDB.execute(query, params);
+        return this.context.execute(query, params);
     }
     /**
      * 'executeRaw' is not implemented in RNQS, this falls back to 'execute'.
      */
     async executeRaw(query, params) {
-        const result = await this.baseDB.execute(query, params);
+        const result = await this.context.execute(query, params);
         const rows = result.rows?._array ?? [];
         return rows.map((row) => Object.values(row));
     }
+}
+class QuickSqliteContext extends common.DBGetUtilsDefaultMixin(QuickSqliteExecutor) {
+}
+/**
+ * Adapter for React Native Quick SQLite
+ */
+class RNQSDBAdapter extends common.DBAdapterDefaultMixin(RNQSConnectionPool) {
+    // We don't want the default implementation here, RNQS does not support executeBatch for lock contexts so that would
+    // be less efficient.
     async executeBatch(query, params = []) {
         const commands = [];
         for (let i = 0; i < params.length; i++) {
@@ -19362,64 +19359,6 @@ class RNQSDBAdapter extends common.BaseObserver {
             rowsAffected: result.rowsAffected ? result.rowsAffected : 0
         };
     }
-    generateContext(ctx) {
-        return {
-            ...ctx,
-            // 'executeRaw' is not implemented in RNQS, this falls back to 'execute'.
-            executeRaw: async (sql, params) => {
-                const result = await ctx.execute(sql, params);
-                const rows = result.rows?._array ?? [];
-                return rows.map((row) => Object.values(row));
-            }
-        };
-    }
-    /**
-     * This provides a top-level read only execute method which is executed inside a read-lock.
-     * This is necessary since the high level `execute` method uses a write-lock under
-     * the hood. Helper methods such as `get`, `getAll` and `getOptional` are read only,
-     * and should use this method.
-     */
-    readOnlyExecute(sql, params) {
-        return this.baseDB.readLock((ctx) => ctx.execute(sql, params));
-    }
-    /**
-     * Adds DB get utils to lock contexts and transaction contexts
-     * @param tx
-     * @returns
-     */
-    generateDBHelpers(tx) {
-        return {
-            ...tx,
-            /**
-             *  Execute a read-only query and return results
-             */
-            getAll: async (sql, parameters) => {
-                const res = await tx.execute(sql, parameters);
-                return res.rows?._array ?? [];
-            },
-            /**
-             * Execute a read-only query and return the first result, or null if the ResultSet is empty.
-             */
-            getOptional: async (sql, parameters) => {
-                const res = await tx.execute(sql, parameters);
-                return res.rows?.item(0) ?? null;
-            },
-            /**
-             * Execute a read-only query and return the first result, error if the ResultSet is empty.
-             */
-            get: async (sql, parameters) => {
-                const res = await tx.execute(sql, parameters);
-                const first = res.rows?.item(0);
-                if (!first) {
-                    throw new Error('Result set is empty');
-                }
-                return first;
-            }
-        };
-    }
-    async refreshSchema() {
-        await this.baseDB.refreshSchema();
-    }
 }
 
 /**