@powersync/common 1.56.0 → 1.57.0

package/src/attachments/Schema.ts

@@ -1,5 +1,5 @@
 import { column } from '../db/schema/Column.js';
-import { Table } from '../db/schema/Table.js';
+import { RowType, Table } from '../db/schema/Table.js';
 import { TableV2Options } from '../db/schema/Table.js';
 
 /**
@@ -66,30 +66,39 @@ export enum AttachmentState {
  */
 export interface AttachmentTableOptions extends Omit<TableV2Options, 'name' | 'columns'> {}
 
+/**
+ * @alpha
+ */
+export 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.
  *
  * @alpha
  */
-export class AttachmentTable extends Table {
+export class AttachmentTable extends Table<typeof ATTACHMENT_TABLE_COLUMNS> {
   constructor(options?: AttachmentTableOptions) {
-    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
-      },
-      {
-        ...options,
-        viewName: options?.viewName ?? ATTACHMENT_TABLE,
-        localOnly: true,
-        insertOnly: false
-      }
-    );
+    super(ATTACHMENT_TABLE_COLUMNS, {
+      ...options,
+      viewName: options?.viewName ?? ATTACHMENT_TABLE,
+      localOnly: true,
+      insertOnly: false
+    });
   }
 }
+
+/**
+ * AttachmentTableRecord represents the row type of the attachment table.
+ *
+ * @alpha
+ */
+export type AttachmentTableRecord = RowType<AttachmentTable>;

package/src/attachments/SyncingService.ts

@@ -35,35 +35,58 @@ export 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
+   * @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: AttachmentRecord[], context: AttachmentContext): Promise<void> {
-    const updatedAttachments: AttachmentRecord[] = [];
+  async processAttachments(
+    attachments: AttachmentRecord[],
+    options?: {
+      signal?: AbortSignal;
+    }
+  ): Promise<void> {
+    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;
-
-        default:
-          break;
+      if (signal?.aborted) {
+        this.logger.info('Sync cancelled; stopping iteration early');
+        return;
       }
-    }
 
-    await context.saveAttachments(updatedAttachments);
+      try {
+        let updated: AttachmentRecord;
+        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);
+      }
+    }
   }
 
   /**