@powersync/common 1.49.0 → 1.50.0

package/lib/utils/mutex.js

@@ -1,29 +1,105 @@
 /**
- * Wrapper for async-mutex runExclusive, which allows for a timeout on each exclusive lock.
+ * An asynchronous mutex implementation.
+ *
+ * @internal This class is meant to be used in PowerSync SDKs only, and is not part of the public API.
  */
-export async function mutexRunExclusive(mutex, callback, options) {
-    return new Promise((resolve, reject) => {
-        const timeout = options?.timeoutMs;
-        let timedOut = false;
-        const timeoutId = timeout
-            ? setTimeout(() => {
-                timedOut = true;
-                reject(new Error('Timeout waiting for lock'));
-            }, timeout)
-            : undefined;
-        mutex.runExclusive(async () => {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
+export class Mutex {
+    inCriticalSection = false;
+    // Linked list of waiters. We don't expect the wait list to become particularly large, and this allows removing
+    // aborted waiters from the middle of the list efficiently.
+    firstWaiter;
+    lastWaiter;
+    addWaiter(onAcquire) {
+        const node = {
+            isActive: true,
+            onAcquire,
+            prev: this.lastWaiter
+        };
+        if (this.lastWaiter) {
+            this.lastWaiter.next = node;
+            this.lastWaiter = node;
+        }
+        else {
+            // First waiter
+            this.lastWaiter = this.firstWaiter = node;
+        }
+        return node;
+    }
+    deactivateWaiter(waiter) {
+        const { prev, next } = waiter;
+        waiter.isActive = false;
+        if (prev)
+            prev.next = next;
+        if (next)
+            next.prev = prev;
+        if (waiter == this.firstWaiter)
+            this.firstWaiter = next;
+        if (waiter == this.lastWaiter)
+            this.lastWaiter = prev;
+    }
+    acquire(abort) {
+        return new Promise((resolve, reject) => {
+            function rejectAborted() {
+                reject(abort?.reason ?? new Error('Mutex acquire aborted'));
             }
-            if (timedOut)
-                return;
-            try {
-                resolve(await callback());
+            if (abort?.aborted) {
+                return rejectAborted();
             }
-            catch (ex) {
-                reject(ex);
+            let holdsMutex = false;
+            const markCompleted = () => {
+                if (!holdsMutex)
+                    return;
+                holdsMutex = false;
+                const waiter = this.firstWaiter;
+                if (waiter) {
+                    this.deactivateWaiter(waiter);
+                    // Still in critical section, but owned by next waiter now.
+                    waiter.onAcquire();
+                }
+                else {
+                    this.inCriticalSection = false;
+                }
+            };
+            if (!this.inCriticalSection) {
+                this.inCriticalSection = true;
+                holdsMutex = true;
+                return resolve(markCompleted);
+            }
+            else {
+                let node;
+                const onAbort = () => {
+                    abort?.removeEventListener('abort', onAbort);
+                    if (node.isActive) {
+                        this.deactivateWaiter(node);
+                        rejectAborted();
+                    }
+                };
+                node = this.addWaiter(() => {
+                    abort?.removeEventListener('abort', onAbort);
+                    holdsMutex = true;
+                    resolve(markCompleted);
+                });
+                abort?.addEventListener('abort', onAbort);
             }
         });
-    });
+    }
+    async runExclusive(fn, abort) {
+        const returnMutex = await this.acquire(abort);
+        try {
+            return await fn();
+        }
+        finally {
+            returnMutex();
+        }
+    }
+}
+export function timeoutSignal(timeout) {
+    if (timeout == null)
+        return;
+    if ('timeout' in AbortSignal)
+        return AbortSignal.timeout(timeout);
+    const controller = new AbortController();
+    setTimeout(() => controller.abort(new Error('Timeout waiting for lock')), timeout);
+    return controller.signal;
 }
 //# sourceMappingURL=mutex.js.map

package/lib/utils/mutex.js.map

@@ -1 +1 @@
-{"version":3,"file":"mutex.js","sourceRoot":"","sources":["../../src/utils/mutex.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,KAAY,EACZ,QAA0B,EAC1B,OAAgC;IAEhC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,MAAM,OAAO,GAAG,OAAO,EAAE,SAAS,CAAC;QACnC,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,MAAM,SAAS,GAAG,OAAO;YACvB,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE;gBACd,QAAQ,GAAG,IAAI,CAAC;gBAChB,MAAM,CAAC,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC,CAAC;YAChD,CAAC,EAAE,OAAO,CAAC;YACb,CAAC,CAAC,SAAS,CAAC;QAEd,KAAK,CAAC,YAAY,CAAC,KAAK,IAAI,EAAE;YAC5B,IAAI,SAAS,EAAE,CAAC;gBACd,YAAY,CAAC,SAAS,CAAC,CAAC;YAC1B,CAAC;YACD,IAAI,QAAQ;gBAAE,OAAO;YAErB,IAAI,CAAC;gBACH,OAAO,CAAC,MAAM,QAAQ,EAAE,CAAC,CAAC;YAC5B,CAAC;YAAC,OAAO,EAAE,EAAE,CAAC;gBACZ,MAAM,CAAC,EAAE,CAAC,CAAC;YACb,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"mutex.js","sourceRoot":"","sources":["../../src/utils/mutex.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powersync/common",
-  "version": "1.49.0",
+  "version": "1.50.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -48,7 +48,6 @@
   },
   "homepage": "https://docs.powersync.com",
   "dependencies": {
-    "async-mutex": "^0.5.0",
     "event-iterator": "^2.0.0"
   },
   "devDependencies": {

package/src/attachments/AttachmentQueue.ts

@@ -51,10 +51,16 @@ export class AttachmentQueue {
   /** Logger instance for diagnostic information */
   readonly logger: ILogger;
 
-  /** Interval in milliseconds between periodic sync operations. Default: 30000 (30 seconds) */
+  /** Interval in milliseconds between periodic sync operations. Acts as a polling timer to retry
+   *  failed uploads/downloads, especially after the app goes offline. Default: 30000 (30 seconds) */
   readonly syncIntervalMs: number = 30 * 1000;
 
-  /** Duration in milliseconds to throttle sync operations */
+  /** Throttle duration in milliseconds for the reactive watch query on the attachments table.
+   *  When attachment records change, a watch query detects the change and triggers a sync.
+   *  This throttle prevents the sync from firing too rapidly when many changes happen in
+   *  quick succession (e.g., bulk inserts). This is distinct from syncIntervalMs — it controls
+   *  how quickly the queue reacts to changes, while syncIntervalMs controls how often it polls
+   *  for retries. Default: 30 (from DEFAULT_WATCH_THROTTLE_MS) */
   readonly syncThrottleDuration: number;
 
   /** Whether to automatically download remote attachments. Default: true */
@@ -86,8 +92,8 @@ export class AttachmentQueue {
    * @param options.watchAttachments - Callback for monitoring attachment changes in your data model
    * @param options.tableName - Name of the table to store attachment records. Default: 'ps_attachment_queue'
    * @param options.logger - Logger instance. Defaults to db.logger
-   * @param options.syncIntervalMs - Interval between automatic syncs in milliseconds. Default: 30000
-   * @param options.syncThrottleDuration - Throttle duration for sync operations in milliseconds. Default: 1000
+   * @param options.syncIntervalMs - Periodic polling interval in milliseconds for retrying failed uploads/downloads. Default: 30000
+   * @param options.syncThrottleDuration - Throttle duration in milliseconds for the reactive watch query that detects attachment changes. Prevents rapid-fire syncs during bulk changes. Default: 30
    * @param options.downloadAttachments - Whether to automatically download remote attachments. Default: true
    * @param options.archivedCacheLimit - Maximum archived attachments before cleanup. Default: 100
    */

package/src/attachments/AttachmentService.ts

@@ -1,8 +1,7 @@
-import { Mutex } from 'async-mutex';
 import { AbstractPowerSyncDatabase } from '../client/AbstractPowerSyncDatabase.js';
 import { DifferentialWatchedQuery } from '../client/watched/processors/DifferentialQueryProcessor.js';
 import { ILogger } from '../utils/Logger.js';
-import { mutexRunExclusive } from '../utils/mutex.js';
+import { Mutex } from '../utils/mutex.js';
 import { AttachmentContext } from './AttachmentContext.js';
 import { AttachmentRecord, AttachmentState } from './Schema.js';
 
@@ -55,7 +54,7 @@ export class AttachmentService {
    * Executes a callback with exclusive access to the attachment context.
    */
   async withContext<T>(callback: (context: AttachmentContext) => Promise<T>): Promise<T> {
-    return mutexRunExclusive(this.mutex, async () => {
+    return this.mutex.runExclusive(async () => {
       return callback(this.context);
     });
   }

package/src/attachments/README.md

@@ -289,8 +289,8 @@ new AttachmentQueue(options: AttachmentQueueOptions)
 | `watchAttachments` | `(onUpdate: (attachments: WatchedAttachmentItem[]) => Promise<void>) => void` | Yes | - | Callback to determine which attachments to handle by the queue from your user defined query |
 | `tableName` | `string` | No | `'attachments'` | Name of the attachments table |
 | `logger` | `ILogger` | No | `db.logger` | Logger instance for diagnostic output |
-| `syncIntervalMs` | `number` | No | `30000` | Interval between automatic syncs in milliseconds |
-| `syncThrottleDuration` | `number` | No | `30` | Throttle duration for sync operations in milliseconds |
+| `syncIntervalMs` | `number` | No | `30000` | Periodic polling interval (in milliseconds) for retrying failed uploads/downloads. A `setInterval` timer that calls `syncStorage()` on this cadence, ensuring operations are retried even if no database changes occur (e.g., after coming back online). |
+| `syncThrottleDuration` | `number` | No | `30` | Throttle duration (in milliseconds) for the reactive watch query on the attachments table. When attachment records change (e.g., a new file is queued), a watch query detects the change and triggers a sync. This throttle prevents the sync from firing too rapidly when many changes happen in quick succession (e.g., bulk inserts). This is distinct from `syncIntervalMs` — it controls how quickly the queue *reacts* to changes, while `syncIntervalMs` controls how often it *polls* for retries. |
 | `downloadAttachments` | `boolean` | No | `true` | Whether to automatically download remote attachments |
 | `archivedCacheLimit` | `number` | No | `100` | Maximum number of archived attachments before cleanup |
 | `errorHandler` | `AttachmentErrorHandler` | No | `undefined` | Custom error handler for upload/download/delete operations |
@@ -676,11 +676,13 @@ Adjust sync frequency based on your needs:
 ```typescript
 const queue = new AttachmentQueue({
   // ... other options
-  syncIntervalMs: 60000, // Sync every 60 seconds instead of 30
+  syncIntervalMs: 60000, // Poll for retries every 60 seconds instead of 30
+  syncThrottleDuration: 100, // React to attachment changes within 100ms (default: 30ms)
 });
 ```
 
-Set to `0` to disable periodic syncing (manual `syncStorage()` calls only).
+- **`syncIntervalMs`** controls the periodic polling timer — how often the queue retries failed operations.
+- **`syncThrottleDuration`** controls how quickly the queue reacts to attachment table changes. The default (30ms) is fast enough for most use cases. Increase it if you see performance issues during bulk attachment operations.
 
 ### Archive and Cache Management
 

package/src/attachments/SyncingService.ts

@@ -54,7 +54,7 @@ export class SyncingService {
           updatedAttachments.push(downloaded);
           break;
         case AttachmentState.QUEUED_DELETE:
-          const deleted = await this.deleteAttachment(attachment);
+          const deleted = await this.deleteAttachment(attachment, context);
           updatedAttachments.push(deleted);
           break;
 
@@ -143,18 +143,17 @@ export class SyncingService {
    * On failure, defers to error handler or archives.
    *
    * @param attachment - The attachment record to delete
+   * @param context - Attachment context for database operations
    * @returns Updated attachment record
    */
-  async deleteAttachment(attachment: AttachmentRecord): Promise<AttachmentRecord> {
+  async deleteAttachment(attachment: AttachmentRecord, context: AttachmentContext): Promise<AttachmentRecord> {
     try {
       await this.remoteStorage.deleteFile(attachment);
       if (attachment.localUri) {
         await this.localStorage.deleteFile(attachment.localUri);
       }
 
-      await this.attachmentService.withContext(async (ctx) => {
-        await ctx.deleteAttachment(attachment.id);
-      });
+      await context.deleteAttachment(attachment.id);
 
       return {
         ...attachment,

package/src/client/AbstractPowerSyncDatabase.ts

@@ -1,4 +1,3 @@
-import { Mutex } from 'async-mutex';
 import { EventIterator } from 'event-iterator';
 import Logger, { ILogger } from 'js-logger';
 import {
@@ -46,6 +45,7 @@ import { TriggerManagerImpl } from './triggers/TriggerManagerImpl.js';
 import { DEFAULT_WATCH_THROTTLE_MS, WatchCompatibleQuery } from './watched/WatchedQuery.js';
 import { OnChangeQueryProcessor } from './watched/processors/OnChangeQueryProcessor.js';
 import { WatchedQueryComparator } from './watched/processors/comparators.js';
+import { Mutex } from '../utils/mutex.js';
 
 export interface DisconnectAndClearOptions {
   /** When set to false, data in local-only tables is preserved. */
@@ -813,6 +813,10 @@ SELECT * FROM crud_entries;
    * Execute a SQL write (INSERT/UPDATE/DELETE) query
    * and optionally return results.
    *
+   * When using the default client-side [JSON-based view system](https://docs.powersync.com/architecture/client-architecture#client-side-schema-and-sqlite-database-structure),
+   * the returned result's `rowsAffected` may be `0` for successful `UPDATE` and `DELETE` statements.
+   * Use a `RETURNING` clause and inspect `result.rows` when you need to confirm which rows changed.
+   *
    * @param sql The SQL query to execute
    * @param parameters Optional array of parameters to bind to the query
    * @returns The query result as an object with structured key-value pairs
@@ -921,7 +925,7 @@ SELECT * FROM crud_entries;
     await this.waitForReady();
     return this.database.readTransaction(
       async (tx) => {
-        const res = await callback({ ...tx });
+        const res = await callback(tx);
         await tx.rollback();
         return res;
       },

package/src/db/DBAdapter.ts

@@ -16,7 +16,13 @@ import { BaseListener, BaseObserverInterface } from '../utils/BaseObserver.js';
 export type QueryResult = {
   /** Represents the auto-generated row id if applicable. */
   insertId?: number;
-  /** Number of affected rows if result of a update query. */
+  /**
+   * Number of affected rows reported by SQLite for a write query.
+   *
+   * When using the default client-side [JSON-based view system](https://docs.powersync.com/architecture/client-architecture#client-side-schema-and-sqlite-database-structure),
+   * `rowsAffected` may be `0` for successful `UPDATE` and `DELETE` statements.
+   * Use a `RETURNING` clause and inspect `rows` when you need to confirm which rows changed.
+   */
   rowsAffected: number;
   /** if status is undefined or 0 this object will contain the query results */
   rows?: {

package/src/utils/mutex.ts

@@ -1,34 +1,129 @@
-import { Mutex } from 'async-mutex';
+export type UnlockFn = () => void;
 
 /**
- * Wrapper for async-mutex runExclusive, which allows for a timeout on each exclusive lock.
+ * An asynchronous mutex implementation.
+ *
+ * @internal This class is meant to be used in PowerSync SDKs only, and is not part of the public API.
  */
-export async function mutexRunExclusive<T>(
-  mutex: Mutex,
-  callback: () => Promise<T>,
-  options?: { timeoutMs?: number }
-): Promise<T> {
-  return new Promise((resolve, reject) => {
-    const timeout = options?.timeoutMs;
-    let timedOut = false;
-    const timeoutId = timeout
-      ? setTimeout(() => {
-          timedOut = true;
-          reject(new Error('Timeout waiting for lock'));
-        }, timeout)
-      : undefined;
-
-    mutex.runExclusive(async () => {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
+export class Mutex {
+  private inCriticalSection = false;
+
+  // Linked list of waiters. We don't expect the wait list to become particularly large, and this allows removing
+  // aborted waiters from the middle of the list efficiently.
+  private firstWaiter?: MutexWaitNode;
+  private lastWaiter?: MutexWaitNode;
+
+  private addWaiter(onAcquire: () => void): MutexWaitNode {
+    const node: MutexWaitNode = {
+      isActive: true,
+      onAcquire,
+      prev: this.lastWaiter
+    };
+    if (this.lastWaiter) {
+      this.lastWaiter.next = node;
+      this.lastWaiter = node;
+    } else {
+      // First waiter
+      this.lastWaiter = this.firstWaiter = node;
+    }
+
+    return node;
+  }
+
+  private deactivateWaiter(waiter: MutexWaitNode) {
+    const { prev, next } = waiter;
+    waiter.isActive = false;
+
+    if (prev) prev.next = next;
+    if (next) next.prev = prev;
+    if (waiter == this.firstWaiter) this.firstWaiter = next;
+    if (waiter == this.lastWaiter) this.lastWaiter = prev;
+  }
+
+  acquire(abort?: AbortSignal): Promise<UnlockFn> {
+    return new Promise((resolve, reject) => {
+      function rejectAborted() {
+        reject(abort?.reason ?? new Error('Mutex acquire aborted'));
       }
-      if (timedOut) return;
+      if (abort?.aborted) {
+        return rejectAborted();
+      }
+
+      let holdsMutex = false;
+
+      const markCompleted = () => {
+        if (!holdsMutex) return;
+        holdsMutex = false;
+
+        const waiter = this.firstWaiter;
+        if (waiter) {
+          this.deactivateWaiter(waiter);
+          // Still in critical section, but owned by next waiter now.
+          waiter.onAcquire();
+        } else {
+          this.inCriticalSection = false;
+        }
+      };
+
+      if (!this.inCriticalSection) {
+        this.inCriticalSection = true;
+        holdsMutex = true;
+        return resolve(markCompleted);
+      } else {
+        let node: MutexWaitNode;
+
+        const onAbort = () => {
+          abort?.removeEventListener('abort', onAbort);
 
-      try {
-        resolve(await callback());
-      } catch (ex) {
-        reject(ex);
+          if (node.isActive) {
+            this.deactivateWaiter(node);
+            rejectAborted();
+          }
+        };
+
+        node = this.addWaiter(() => {
+          abort?.removeEventListener('abort', onAbort);
+          holdsMutex = true;
+          resolve(markCompleted);
+        });
+
+        abort?.addEventListener('abort', onAbort);
       }
     });
-  });
+  }
+
+  async runExclusive<T>(fn: () => PromiseLike<T> | T, abort?: AbortSignal): Promise<T> {
+    const returnMutex = await this.acquire(abort);
+
+    try {
+      return await fn();
+    } finally {
+      returnMutex();
+    }
+  }
+}
+
+interface MutexWaitNode {
+  /**
+   * Whether the waiter is currently active (not aborted and not fullfilled).
+   */
+  isActive: boolean;
+  onAcquire: () => void;
+  prev?: MutexWaitNode;
+  next?: MutexWaitNode;
+}
+
+/**
+ * Creates a signal aborting after the set timeout.
+ */
+export function timeoutSignal(timeout: number): AbortSignal;
+export function timeoutSignal(timeout?: number): AbortSignal | undefined;
+
+export function timeoutSignal(timeout?: number): AbortSignal | undefined {
+  if (timeout == null) return;
+  if ('timeout' in AbortSignal) return AbortSignal.timeout(timeout);
+
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(new Error('Timeout waiting for lock')), timeout);
+  return controller.signal;
 }