@powersync/web 1.38.5 → 1.38.6

package/dist/worker/SharedSyncImplementation.umd.js

@@ -1641,6 +1641,7 @@ class WorkerClient {
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   ATTACHMENT_TABLE: () => (/* binding */ ATTACHMENT_TABLE),
+/* harmony export */   ATTACHMENT_TABLE_COLUMNS: () => (/* binding */ ATTACHMENT_TABLE_COLUMNS),
 /* harmony export */   AbortOperation: () => (/* binding */ AbortOperation),
 /* harmony export */   AbstractPowerSyncDatabase: () => (/* binding */ AbstractPowerSyncDatabase),
 /* harmony export */   AbstractPowerSyncDatabaseOpenFactory: () => (/* binding */ AbstractPowerSyncDatabaseOpenFactory),
@@ -2122,6 +2123,19 @@ var AttachmentState;
     AttachmentState[AttachmentState["SYNCED"] = 3] = "SYNCED";
     AttachmentState[AttachmentState["ARCHIVED"] = 4] = "ARCHIVED"; // Attachment has been orphaned, i.e. the associated record has been deleted
 })(AttachmentState || (AttachmentState = {}));
+/**
+ * @alpha
+ */
+const ATTACHMENT_TABLE_COLUMNS = {
+    filename: column.text,
+    local_uri: column.text,
+    timestamp: column.integer,
+    size: column.integer,
+    media_type: column.text,
+    state: column.integer, // Corresponds to AttachmentState
+    has_synced: column.integer,
+    meta_data: column.text
+};
 /**
  * AttachmentTable defines the schema for the attachment queue table.
  *
@@ -2129,16 +2143,7 @@ var AttachmentState;
  */
 class AttachmentTable extends Table {
     constructor(options) {
-        super({
-            filename: column.text,
-            local_uri: column.text,
-            timestamp: column.integer,
-            size: column.integer,
-            media_type: column.text,
-            state: column.integer, // Corresponds to AttachmentState
-            has_synced: column.integer,
-            meta_data: column.text
-        }, {
+        super(ATTACHMENT_TABLE_COLUMNS, {
             ...options,
             viewName: options?.viewName ?? ATTACHMENT_TABLE,
             localOnly: true,
@@ -2670,31 +2675,51 @@ class SyncingService {
     }
     /**
      * Processes attachments based on their state (upload, download, or delete).
-     * All updates are saved in a single batch after processing.
+     *
+     * Each attachment's I/O runs outside the attachment-service mutex, and the row's
+     * state transition is persisted immediately after it completes. This keeps the
+     * mutex available to concurrent `saveFile` / `deleteFile` / watched-attachment
+     * processing while a batch is in flight, and means consumer queries against the
+     * attachments queue see incremental progress instead of one atomic commit at the
+     * end of the batch.
      *
      * @param attachments - Array of attachment records to process
-     * @param context - Attachment context for database operations
-     * @returns Promise that resolves when all attachments have been processed and saved
-     */
-    async processAttachments(attachments, context) {
-        const updatedAttachments = [];
+     * @param options - Optional controls. Pass `signal` (an `AbortSignal`) to interrupt
+     *                  the batch: it is checked between attachments and, once aborted, the
+     *                  loop exits early — letting `stopSync` stop a running batch within
+     *                  one attachment's processing time.
+     */
+    async processAttachments(attachments, options) {
+        const signal = options?.signal;
+        this.logger.info(`Starting processAttachments with ${attachments.length} attachments`);
         for (const attachment of attachments) {
-            switch (attachment.state) {
-                case AttachmentState.QUEUED_UPLOAD:
-                    const uploaded = await this.uploadAttachment(attachment);
-                    updatedAttachments.push(uploaded);
-                    break;
-                case AttachmentState.QUEUED_DOWNLOAD:
-                    const downloaded = await this.downloadAttachment(attachment);
-                    updatedAttachments.push(downloaded);
-                    break;
-                case AttachmentState.QUEUED_DELETE:
-                    const deleted = await this.deleteAttachment(attachment, context);
-                    updatedAttachments.push(deleted);
-                    break;
+            if (signal?.aborted) {
+                this.logger.info('Sync cancelled; stopping iteration early');
+                return;
+            }
+            try {
+                let updated;
+                switch (attachment.state) {
+                    case AttachmentState.QUEUED_UPLOAD:
+                        updated = await this.uploadAttachment(attachment);
+                        break;
+                    case AttachmentState.QUEUED_DOWNLOAD:
+                        updated = await this.downloadAttachment(attachment);
+                        break;
+                    case AttachmentState.QUEUED_DELETE:
+                        // `deleteAttachment` needs a context (it removes the row in a
+                        // transaction); briefly re-acquire the mutex for just this row.
+                        updated = await this.attachmentService.withContext((ctx) => this.deleteAttachment(attachment, ctx));
+                        break;
+                    default:
+                        continue;
+                }
+                await this.attachmentService.withContext((ctx) => ctx.saveAttachments([updated]));
+            }
+            catch (error) {
+                this.logger.warn(`Error during sync for ${attachment.id}`, error);
             }
         }
-        await context.saveAttachments(updatedAttachments);
     }
     /**
      * Uploads an attachment from local storage to remote storage.
@@ -2865,6 +2890,19 @@ class AttachmentQueue {
     statusListenerDispose;
     watchActiveAttachments;
     watchAttachmentsAbortController;
+    /**
+     * Serializes concurrent `syncStorage()` triggers (periodic timer, watch-onDiff,
+     * status-changed). Held across the whole batch, but only contended by other
+     * sync triggers — foreground `saveFile` / `deleteFile` / watched-attachment
+     * processing don't take this lock and proceed in parallel via the
+     * `AttachmentService` mutex, which is acquired only briefly per row.
+     */
+    syncLoopMutex = new Mutex();
+    /**
+     * Aborted by `stopSync()` to interrupt an in-flight batch within one
+     * attachment's processing time. Polled between rows by `SyncingService`.
+     */
+    syncAbortController;
     /**
      * Creates a new AttachmentQueue instance.
      *
@@ -2904,6 +2942,7 @@ class AttachmentQueue {
      */
     async startSync() {
         await this.stopSync();
+        this.syncAbortController = new AbortController();
         this.watchActiveAttachments = this.attachmentService.watchActiveAttachments({
             throttleMs: this.syncThrottleDuration
         });
@@ -3018,23 +3057,44 @@ class AttachmentQueue {
      *
      * This is called automatically at regular intervals when sync is started,
      * but can also be called manually to trigger an immediate sync.
+     *
+     * Concurrent invocations are serialized via `syncLoopMutex`.
      */
     async syncStorage() {
-        await this.attachmentService.withContext(async (ctx) => {
-            const activeAttachments = await ctx.getActiveAttachments();
-            await this.localStorage.initialize();
-            await this.syncingService.processAttachments(activeAttachments, ctx);
-            await this.syncingService.deleteArchivedAttachments(ctx);
-        });
+        const signal = this.syncAbortController?.signal;
+        if (signal?.aborted)
+            return;
+        try {
+            await this.syncLoopMutex.runExclusive(async () => {
+                const activeAttachments = await this.attachmentService.withContext((ctx) => ctx.getActiveAttachments());
+                await this.localStorage.initialize();
+                await this.syncingService.processAttachments(activeAttachments, { signal });
+                if (signal?.aborted)
+                    return;
+                await this.attachmentService.withContext((ctx) => this.syncingService.deleteArchivedAttachments(ctx));
+            }, signal);
+        }
+        catch (error) {
+            // A queued batch's acquire rejects when `stopSync` aborts — expected, not an error.
+            if (signal?.aborted)
+                return;
+            throw error;
+        }
     }
     /**
      * Stops the attachment synchronization process.
      *
-     * Clears the periodic sync timer and closes all active attachment watchers.
+     * Clears the periodic sync timer, closes all active attachment watchers, and
+     * aborts any in-flight `syncStorage()` call so it exits within one
+     * attachment's processing time instead of running the batch to completion.
      */
     async stopSync() {
         clearInterval(this.periodicSyncTimer);
         this.periodicSyncTimer = undefined;
+        if (this.syncAbortController) {
+            this.syncAbortController.abort();
+            this.syncAbortController = undefined;
+        }
         if (this.watchActiveAttachments)
             await this.watchActiveAttachments.close();
         if (this.watchAttachmentsAbortController) {
@@ -12649,7 +12709,7 @@ function requireDist () {
 
 var distExports = requireDist();
 
-var version = "1.56.0";
+var version = "1.57.0";
 var PACKAGE = {
 	version: version};