@powersync/common 1.57.1 → 2.0.0

package/src/attachments/AttachmentQueue.ts

@@ -1,9 +1,7 @@
-import { AbstractPowerSyncDatabase } from '../client/AbstractPowerSyncDatabase.js';
-import { DEFAULT_WATCH_THROTTLE_MS } from '../client/watched/WatchedQuery.js';
 import { DifferentialWatchedQuery } from '../client/watched/processors/DifferentialQueryProcessor.js';
 import { Mutex } from '../utils/mutex.js';
+import { LogLevels, PowerSyncLogger } from '../utils/Logger.js';
 import { Transaction } from '../db/DBAdapter.js';
-import { ILogger } from '../utils/Logger.js';
 import { AttachmentContext } from './AttachmentContext.js';
 import { AttachmentErrorHandler } from './AttachmentErrorHandler.js';
 import { AttachmentService } from './AttachmentService.js';
@@ -12,6 +10,7 @@ import { RemoteStorageAdapter } from './RemoteStorageAdapter.js';
 import { ATTACHMENT_TABLE, AttachmentRecord, AttachmentState } from './Schema.js';
 import { SyncingService } from './SyncingService.js';
 import { WatchedAttachmentItem } from './WatchedAttachmentItem.js';
+import { CommonPowerSyncDatabase } from '../client/CommonPowerSyncDatabase.js';
 
 /**
  * Configuration options for {@link AttachmentQueue}.
@@ -23,7 +22,7 @@ export interface AttachmentQueueOptions {
   /**
    * PowerSync database instance
    */
-  db: AbstractPowerSyncDatabase;
+  db: CommonPowerSyncDatabase;
   /**
    * Remote storage adapter for upload/download operations
    */
@@ -43,7 +42,7 @@ export interface AttachmentQueueOptions {
   /**
    * Logger instance. Defaults to db.logger
    */
-  logger?: ILogger;
+  logger?: PowerSyncLogger;
   /**
    * Periodic polling interval in milliseconds for retrying failed uploads/downloads. Default: 30000
    */
@@ -103,7 +102,7 @@ export class AttachmentQueue {
   readonly tableName: string;
 
   /** Logger instance for diagnostic information */
-  readonly logger: ILogger;
+  readonly logger: PowerSyncLogger;
 
   /** 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) */
@@ -115,7 +114,7 @@ export class AttachmentQueue {
    *  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;
+  readonly syncThrottleDuration?: number;
 
   /** Whether to automatically download remote attachments. Default: true */
   readonly downloadAttachments: boolean = true;
@@ -127,7 +126,7 @@ export class AttachmentQueue {
   private readonly attachmentService: AttachmentService;
 
   /** PowerSync database instance */
-  private readonly db: AbstractPowerSyncDatabase;
+  private readonly db: CommonPowerSyncDatabase;
 
   /** Cleanup function for status change listener */
   private statusListenerDispose?: () => void;
@@ -143,7 +142,7 @@ export class AttachmentQueue {
    * processing don't take this lock and proceed in parallel via the
    * `AttachmentService` mutex, which is acquired only briefly per row.
    */
-  private syncLoopMutex = new Mutex();
+  private syncLoopMutex: Mutex;
 
   /**
    * Aborted by `stopSync()` to interrupt an in-flight batch within one
@@ -164,12 +163,13 @@ export class AttachmentQueue {
     logger,
     tableName = ATTACHMENT_TABLE,
     syncIntervalMs = 30 * 1000,
-    syncThrottleDuration = DEFAULT_WATCH_THROTTLE_MS,
+    syncThrottleDuration,
     downloadAttachments = true,
     archivedCacheLimit = 100,
     errorHandler
   }: AttachmentQueueOptions) {
     this.db = db;
+    this.syncLoopMutex = db.createMutex();
     this.remoteStorage = remoteStorage;
     this.localStorage = localStorage;
     this.watchAttachments = watchAttachments;
@@ -239,7 +239,7 @@ export class AttachmentQueue {
         if (status.connected) {
           // Device came online, process attachments immediately
           this.syncStorage().catch((error) => {
-            this.logger.error('Error syncing storage on connection:', error);
+            this.logger.log({ level: LogLevels.error, message: 'Error syncing storage on connection', error });
           });
         }
       }
@@ -348,7 +348,8 @@ export class AttachmentQueue {
    */
   async syncStorage(): Promise<void> {
     const signal = this.syncAbortController?.signal;
-    if (signal?.aborted) return;
+    // We have a signal from startSync() to stopSync(), so treat the absence of one like an aborted sync.
+    if (signal == null || signal?.aborted) return;
 
     try {
       await this.syncLoopMutex.runExclusive(async () => {
@@ -357,13 +358,13 @@ export class AttachmentQueue {
 
         await this.syncingService.processAttachments(activeAttachments, { signal });
 
-        if (signal?.aborted) return;
+        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;
+      if (signal.aborted) return;
       throw error;
     }
   }

package/src/attachments/AttachmentService.ts

@@ -1,6 +1,6 @@
-import { AbstractPowerSyncDatabase } from '../client/AbstractPowerSyncDatabase.js';
+import { CommonPowerSyncDatabase } from '../client/CommonPowerSyncDatabase.js';
 import { DifferentialWatchedQuery } from '../client/watched/processors/DifferentialQueryProcessor.js';
-import { ILogger } from '../utils/Logger.js';
+import { PowerSyncLogger, LogLevels } from '../utils/Logger.js';
 import { Mutex } from '../utils/mutex.js';
 import { AttachmentContext } from './AttachmentContext.js';
 import { AttachmentRecord, AttachmentState } from './Schema.js';
@@ -11,15 +11,16 @@ import { AttachmentRecord, AttachmentState } from './Schema.js';
  * @internal
  */
 export class AttachmentService {
-  private mutex = new Mutex();
+  private mutex: Mutex;
   private context: AttachmentContext;
 
   constructor(
-    private db: AbstractPowerSyncDatabase,
-    private logger: ILogger,
+    private db: CommonPowerSyncDatabase,
+    private logger: PowerSyncLogger,
     private tableName: string = 'attachments',
     archivedCacheLimit: number = 100
   ) {
+    this.mutex = db.createMutex();
     this.context = new AttachmentContext(db, tableName, logger, archivedCacheLimit);
   }
 
@@ -28,7 +29,7 @@ export class AttachmentService {
    * @returns Watch query that emits changes for queued uploads, downloads, and deletes
    */
   watchActiveAttachments({ throttleMs }: { throttleMs?: number } = {}): DifferentialWatchedQuery<AttachmentRecord> {
-    this.logger.info('Watching active attachments...');
+    this.logger.log({ level: LogLevels.info, message: 'Watching active attachments...' });
     const watch = this.db
       .query<AttachmentRecord>({
         sql: /* sql */ `

package/src/attachments/Schema.ts

@@ -1,6 +1,6 @@
 import { column } from '../db/schema/Column.js';
 import { RowType, Table } from '../db/schema/Table.js';
-import { TableV2Options } from '../db/schema/Table.js';
+import { TableOptions } from '../db/schema/Table.js';
 
 /**
  * The default name of the local table storing attachment data.
@@ -64,7 +64,7 @@ export enum AttachmentState {
 /**
  * @alpha
  */
-export interface AttachmentTableOptions extends Omit<TableV2Options, 'name' | 'columns'> {}
+export interface AttachmentTableOptions extends Omit<TableOptions, 'name' | 'columns'> {}
 
 /**
  * @alpha

package/src/attachments/SyncingService.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../utils/Logger.js';
+import { LogLevels, PowerSyncLogger } from '../utils/Logger.js';
 import { AttachmentService } from './AttachmentService.js';
 import { LocalStorageAdapter } from './LocalStorageAdapter.js';
 import { RemoteStorageAdapter } from './RemoteStorageAdapter.js';
@@ -16,14 +16,14 @@ export class SyncingService {
   private attachmentService: AttachmentService;
   private localStorage: LocalStorageAdapter;
   private remoteStorage: RemoteStorageAdapter;
-  private logger: ILogger;
+  private logger: PowerSyncLogger;
   private errorHandler?: AttachmentErrorHandler;
 
   constructor(
     attachmentService: AttachmentService,
     localStorage: LocalStorageAdapter,
     remoteStorage: RemoteStorageAdapter,
-    logger: ILogger,
+    logger: PowerSyncLogger,
     errorHandler?: AttachmentErrorHandler
   ) {
     this.attachmentService = attachmentService;
@@ -56,11 +56,17 @@ export class SyncingService {
     }
   ): Promise<void> {
     const signal = options?.signal;
-    this.logger.info(`Starting processAttachments with ${attachments.length} attachments`);
+    this.logger.log({
+      level: LogLevels.info,
+      message: `Starting processAttachments with ${attachments.length} attachments`
+    });
 
     for (const attachment of attachments) {
       if (signal?.aborted) {
-        this.logger.info('Sync cancelled; stopping iteration early');
+        this.logger.log({
+          level: LogLevels.info,
+          message: 'Sync cancelled; stopping iteration early'
+        });
         return;
       }
 
@@ -84,7 +90,11 @@ export class SyncingService {
 
         await this.attachmentService.withContext((ctx) => ctx.saveAttachments([updated]));
       } catch (error) {
-        this.logger.warn(`Error during sync for ${attachment.id}`, error);
+        this.logger.log({
+          level: LogLevels.warn,
+          message: `Error during sync for ${attachment.id}`,
+          error
+        });
       }
     }
   }
@@ -98,7 +108,7 @@ export class SyncingService {
    * @throws Error if the attachment has no localUri
    */
   async uploadAttachment(attachment: AttachmentRecord): Promise<AttachmentRecord> {
-    this.logger.info(`Uploading attachment ${attachment.filename}`);
+    this.logger.log({ level: LogLevels.info, message: `Uploading attachment ${attachment.filename}` });
     try {
       if (attachment.localUri == null) {
         throw new Error(`No localUri for attachment ${attachment.id}`);
@@ -134,7 +144,7 @@ export class SyncingService {
    * @returns Updated attachment record with local URI and new state
    */
   async downloadAttachment(attachment: AttachmentRecord): Promise<AttachmentRecord> {
-    this.logger.info(`Downloading attachment ${attachment.filename}`);
+    this.logger.log({ level: LogLevels.info, message: `Downloading attachment ${attachment.filename}` });
     try {
       const fileData = await this.remoteStorage.downloadFile(attachment);
 
@@ -206,7 +216,11 @@ export class SyncingService {
           try {
             await this.localStorage.deleteFile(attachment.localUri);
           } catch (error) {
-            this.logger.error('Error deleting local file for archived attachment', error);
+            this.logger.log({
+              level: LogLevels.error,
+              message: 'Error deleting local file for archived attachment',
+              error
+            });
           }
         }
       }