@powersync/common 1.57.3 → 2.1.0

package/src/attachments/AttachmentQueue.ts

@@ -1,37 +1,36 @@
-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';
-import { AttachmentData, LocalStorageAdapter } from './LocalStorageAdapter.js';
+import { AttachmentTransportAdapter } from './AttachmentTransportAdapter.js';
+import { BufferedAttachmentTransport } from './BufferedAttachmentTransport.js';
+import { AttachmentData, LocalStorageAdapter, StreamingLocalStorageAdapter } from './LocalStorageAdapter.js';
 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}.
+ * Fields common to every {@link AttachmentQueueOptions} variant.
  *
  * @experimental
  * @alpha This is currently experimental and may change without a major version bump.
  */
-export interface AttachmentQueueOptions {
+export interface BaseAttachmentQueueOptions<TLocal extends LocalStorageAdapter = LocalStorageAdapter> {
   /**
    * PowerSync database instance
    */
-  db: AbstractPowerSyncDatabase;
-  /**
-   * Remote storage adapter for upload/download operations
-   */
-  remoteStorage: RemoteStorageAdapter;
+  db: CommonPowerSyncDatabase;
   /**
-   * Local storage adapter for file persistence
+   * Local storage adapter for file persistence. Its type determines whether
+   * {@link AttachmentQueue.saveFileFromUri} is available (a
+   * {@link StreamingLocalStorageAdapter} enables it).
    */
-  localStorage: LocalStorageAdapter;
+  localStorage: TLocal;
   /**
    * Callback for monitoring attachment changes in your data model
    */
@@ -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
    */
@@ -65,6 +64,52 @@ export interface AttachmentQueueOptions {
   errorHandler?: AttachmentErrorHandler;
 }
 
+/**
+ * Configuration options for {@link AttachmentQueue}.
+ *
+ * Provide **exactly one** remote mechanism:
+ * - `remoteStorage` — a {@link RemoteStorageAdapter}, wrapped in the default
+ *   default buffered transport that delegates upload/download/delete to it.
+ * - `transportAdapter` — an {@link AttachmentTransportAdapter} that owns all remote
+ *   operations directly (e.g. a native file-URI implementation for buffer-free
+ *   transfer of large files). No `remoteStorage` is needed in this case.
+ *
+ * Supplying both, or neither, is a type error.
+ *
+ * @experimental
+ * @alpha This is currently experimental and may change without a major version bump.
+ */
+export type AttachmentQueueOptions<TLocal extends LocalStorageAdapter = LocalStorageAdapter> =
+  BaseAttachmentQueueOptions<TLocal> &
+    (
+      | { remoteStorage: RemoteStorageAdapter; transportAdapter?: never }
+      | { transportAdapter: AttachmentTransportAdapter; remoteStorage?: never }
+    );
+
+/**
+ * Fields shared by {@link AttachmentQueue.saveFile} and {@link AttachmentQueue.saveFileFromUri}.
+ *
+ * @alpha
+ */
+export interface SaveAttachmentOptions {
+  /** File extension (e.g., 'jpg', 'pdf') */
+  fileExtension: string;
+  /** MIME type of the file (e.g., 'image/jpeg') */
+  mediaType?: string;
+  /** Optional metadata to associate with the attachment */
+  metaData?: string;
+  /** Optional custom ID. If not provided, a UUID will be generated */
+  id?: string;
+  /**
+   * Optional callback to execute additional database operations within the same transaction as the
+   * attachment creation.
+   */
+  updateHook?: (transaction: Transaction, attachment: AttachmentRecord) => Promise<void>;
+}
+
+/** How the file bytes reach managed storage when creating an upload attachment. */
+type AttachmentSource = { kind: 'data'; data: AttachmentData } | { kind: 'uri'; localUri: string };
+
 /**
  * AttachmentQueue manages the lifecycle and synchronization of attachments
  * between local and remote storage.
@@ -74,7 +119,7 @@ export interface AttachmentQueueOptions {
  * @experimental
  * @alpha This is currently experimental and may change without a major version bump.
  */
-export class AttachmentQueue {
+export class AttachmentQueue<TLocal extends LocalStorageAdapter = LocalStorageAdapter> {
   /** Timer for periodic synchronization operations */
   private periodicSyncTimer?: ReturnType<typeof setInterval>;
 
@@ -82,10 +127,7 @@ export class AttachmentQueue {
   private readonly syncingService: SyncingService;
 
   /** Adapter for local file storage operations */
-  readonly localStorage: LocalStorageAdapter;
-
-  /** Adapter for remote file storage operations */
-  readonly remoteStorage: RemoteStorageAdapter;
+  readonly localStorage: TLocal;
 
   /**
    * Callback function to watch for changes in attachment references in your data model.
@@ -103,7 +145,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 +157,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 +169,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 +185,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
@@ -160,17 +202,18 @@ export class AttachmentQueue {
     db,
     localStorage,
     remoteStorage,
+    transportAdapter,
     watchAttachments,
     logger,
     tableName = ATTACHMENT_TABLE,
     syncIntervalMs = 30 * 1000,
-    syncThrottleDuration = DEFAULT_WATCH_THROTTLE_MS,
+    syncThrottleDuration,
     downloadAttachments = true,
     archivedCacheLimit = 100,
     errorHandler
-  }: AttachmentQueueOptions) {
+  }: AttachmentQueueOptions<TLocal>) {
     this.db = db;
-    this.remoteStorage = remoteStorage;
+    this.syncLoopMutex = db.createMutex();
     this.localStorage = localStorage;
     this.watchAttachments = watchAttachments;
     this.tableName = tableName;
@@ -180,10 +223,13 @@ export class AttachmentQueue {
     this.downloadAttachments = downloadAttachments;
     this.logger = logger ?? db.logger;
     this.attachmentService = new AttachmentService(db, this.logger, tableName, archivedCacheLimit);
+
+    const transport = transportAdapter ?? new BufferedAttachmentTransport(localStorage, remoteStorage!);
+
     this.syncingService = new SyncingService(
       this.attachmentService,
       localStorage,
-      remoteStorage,
+      transport,
       this.logger,
       errorHandler
     );
@@ -239,7 +285,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 +394,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 +404,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;
     }
   }
@@ -407,49 +454,30 @@ export class AttachmentQueue {
     return this.attachmentService.withContext(callback);
   }
   /**
-   * Saves a file to local storage and queues it for upload to remote storage.
-   *
-   * @param options - File save options
-   * @returns Promise resolving to the created attachment record
+   * Creates a `QUEUED_UPLOAD` attachment record, placing the file at the managed
+   * `localUri` from the given `source`, and persists the record
+   * alongside the caller's `updateHook` in a single transaction.
    */
-  async saveFile({
-    data,
-    fileExtension,
-    mediaType,
-    metaData,
-    id,
-    updateHook
-  }: {
-    /**
-     * The file data as ArrayBuffer, Blob, or base64 string
-     */
-    data: AttachmentData;
-    /**
-     * File extension (e.g., 'jpg', 'pdf')
-     */
-    fileExtension: string;
-    /**
-     * MIME type of the file (e.g., 'image/jpeg')
-     */
-    mediaType?: string;
-    /**
-     * Optional metadata to associate with the attachment
-     */
-    metaData?: string;
-    /**
-     * Optional custom ID. If not provided, a UUID will be generated
-     */
-    id?: string;
-    /**
-     * Optional callback to execute additional database operations within the same transaction as the attachment
-     * creation.
-     */
-    updateHook?: (transaction: Transaction, attachment: AttachmentRecord) => Promise<void>;
-  }): Promise<AttachmentRecord> {
+  private async createUploadAttachment(
+    { fileExtension, mediaType, metaData, id, updateHook }: SaveAttachmentOptions,
+    source: AttachmentSource
+  ): Promise<AttachmentRecord> {
     const resolvedId = id ?? (await this.generateAttachmentId());
     const filename = `${resolvedId}.${fileExtension}`;
     const localUri = this.localStorage.getLocalUri(filename);
-    const size = await this.localStorage.saveFile(localUri, data);
+
+    let size: number;
+    if (source.kind === 'data') {
+      size = await this.localStorage.saveFile(localUri, source.data);
+    } else {
+      // saveFileFromUri is only exposed for streaming-capable local adapters; guard at
+      // runtime too for plain-JS callers.
+      const localStorage = this.localStorage as Partial<StreamingLocalStorageAdapter>;
+      if (!localStorage.moveFile) {
+        throw new Error('The configured local storage adapter does not support moveFile, required by saveFileFromUri.');
+      }
+      size = await localStorage.moveFile(source.localUri, localUri);
+    }
 
     const attachment: AttachmentRecord = {
       id: resolvedId,
@@ -473,6 +501,37 @@ export class AttachmentQueue {
     return attachment;
   }
 
+  /**
+   * Saves in-memory file data to local storage and queues it for upload.
+   *
+   * @param options - File data plus {@link SaveAttachmentOptions}
+   * @returns Promise resolving to the created attachment record
+   */
+  async saveFile(options: SaveAttachmentOptions & { data: AttachmentData }): Promise<AttachmentRecord> {
+    return this.createUploadAttachment(options, { kind: 'data', data: options.data });
+  }
+
+  /**
+   * Registers a file that already exists on disk and queues it for upload, moving it
+   * into managed storage without loading it into memory.
+   *
+   * Prefer this over {@link AttachmentQueue.saveFile} for large, app-originated files
+   * (recordings, videos): it avoids reading the file into an `ArrayBuffer` just to write
+   * it back to disk. Requires the local storage adapter to implement `moveFile`.
+   *
+   * Only available when the queue is configured with a {@link StreamingLocalStorageAdapter}
+   * (one that implements `moveFile`).
+   *
+   * @param options - The existing file's `localUri` plus {@link SaveAttachmentOptions}
+   * @returns Promise resolving to the created attachment record
+   */
+  async saveFileFromUri(
+    this: AttachmentQueue<StreamingLocalStorageAdapter>,
+    options: SaveAttachmentOptions & { localUri: string }
+  ): Promise<AttachmentRecord> {
+    return this.createUploadAttachment(options, { kind: 'uri', localUri: options.localUri });
+  }
+
   async deleteFile({
     id,
     updateHook

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/AttachmentTransportAdapter.ts

@@ -0,0 +1,49 @@
+import { AttachmentRecord } from './Schema.js';
+
+/**
+ * An {@link AttachmentRecord} that is guaranteed to have a `localUri`.
+ *
+ * The syncing service assigns `localUri` before invoking a transport download,
+ * so implementations always receive both the metadata and the destination path.
+ *
+ * @alpha
+ */
+export type LocatedAttachmentRecord = AttachmentRecord & { localUri: string };
+
+/**
+ * AttachmentTransportAdapter owns all remote-side operations for an attachment —
+ * transfer (upload/download) and delete — as single operations.
+ *
+ * A transport owns the entire transfer, letting implementations pick the most
+ * efficient mechanism available (buffer, stream, or a platform-native file-URI
+ * upload/download API). On platforms like React Native this allows large files to
+ * be transferred without ever materializing them in the JS heap.
+ *
+ * The default transport composes the local and remote storage adapters. Provide a custom transport (via
+ * `AttachmentQueue`'s `transportAdapter` option) to own the whole remote side; in
+ * that case a separate `remoteStorage` is not required.
+ *
+ * @experimental
+ * @alpha This is currently experimental and may change without a major version bump.
+ */
+export interface AttachmentTransportAdapter {
+  /**
+   * Uploads the attachment's local file to remote storage.
+   * @param attachment - The attachment to upload. `localUri` points at the source file.
+   */
+  upload(attachment: LocatedAttachmentRecord): Promise<void>;
+
+  /**
+   * Downloads the remote file into `attachment.localUri`.
+   * @param attachment - The attachment to download. `localUri` is the destination path,
+   *                      assigned by the syncing service before this call.
+   */
+  download(attachment: LocatedAttachmentRecord): Promise<void>;
+
+  /**
+   * Deletes the attachment's file from remote storage. Local file removal is handled
+   * separately by the syncing service.
+   * @param attachment - The attachment to delete.
+   */
+  delete(attachment: AttachmentRecord): Promise<void>;
+}

package/src/attachments/BufferedAttachmentTransport.ts

@@ -0,0 +1,37 @@
+import { AttachmentTransportAdapter, LocatedAttachmentRecord } from './AttachmentTransportAdapter.js';
+import { LocalStorageAdapter } from './LocalStorageAdapter.js';
+import { RemoteStorageAdapter } from './RemoteStorageAdapter.js';
+import { AttachmentRecord } from './Schema.js';
+
+/**
+ * Default {@link AttachmentTransportAdapter}, composing the local and remote
+ * storage adapters.
+ *
+ * The full file body is materialized as an `ArrayBuffer` in JS memory between the
+ * two adapter calls. This is fine for small files but can cause memory pressure on
+ * large ones — environments that support native transfer should provide a custom
+ * transport instead.
+ *
+ * @experimental
+ * @alpha This is currently experimental and may change without a major version bump.
+ */
+export class BufferedAttachmentTransport implements AttachmentTransportAdapter {
+  constructor(
+    private localStorage: LocalStorageAdapter,
+    private remoteStorage: RemoteStorageAdapter
+  ) {}
+
+  async upload(attachment: LocatedAttachmentRecord): Promise<void> {
+    const fileData = await this.localStorage.readFile(attachment.localUri);
+    await this.remoteStorage.uploadFile(fileData, attachment);
+  }
+
+  async download(attachment: LocatedAttachmentRecord): Promise<void> {
+    const fileData = await this.remoteStorage.downloadFile(attachment);
+    await this.localStorage.saveFile(attachment.localUri, fileData);
+  }
+
+  async delete(attachment: AttachmentRecord): Promise<void> {
+    await this.remoteStorage.deleteFile(attachment);
+  }
+}

package/src/attachments/LocalStorageAdapter.ts

@@ -76,3 +76,23 @@ export interface LocalStorageAdapter {
    */
   getLocalUri(filename: string): string;
 }
+
+/**
+ * A {@link LocalStorageAdapter} that can relocate a file into managed storage without
+ * loading it into memory. Required for {@link AttachmentQueue.saveFileFromUri}; only
+ * queues configured with a streaming-capable local adapter expose that method.
+ *
+ * @experimental
+ * @alpha This is currently experimental and may change without a major version bump.
+ */
+export interface StreamingLocalStorageAdapter extends LocalStorageAdapter {
+  /**
+   * Moves a file into managed storage without loading it into memory.
+   * Overwrites any existing file at the target. When source and target are the same
+   * path, this is a no-op that just reports the size.
+   * @param sourceUri - Path of the existing file
+   * @param targetUri - Destination path within managed storage
+   * @returns Number of bytes in the moved file
+   */
+  moveFile(sourceUri: string, targetUri: string): Promise<number>;
+}

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,7 +1,7 @@
-import { ILogger } from '../utils/Logger.js';
+import { LogLevels, PowerSyncLogger } from '../utils/Logger.js';
 import { AttachmentService } from './AttachmentService.js';
+import { AttachmentTransportAdapter } from './AttachmentTransportAdapter.js';
 import { LocalStorageAdapter } from './LocalStorageAdapter.js';
-import { RemoteStorageAdapter } from './RemoteStorageAdapter.js';
 import { AttachmentRecord, AttachmentState } from './Schema.js';
 import { AttachmentErrorHandler } from './AttachmentErrorHandler.js';
 import { AttachmentContext } from './AttachmentContext.js';
@@ -10,25 +10,28 @@ import { AttachmentContext } from './AttachmentContext.js';
  * Orchestrates attachment synchronization between local and remote storage.
  * Handles uploads, downloads, deletions, and state transitions.
  *
+ * Remote operations (upload/download/delete) go through the {@link AttachmentTransportAdapter};
+ * local file operations use the {@link LocalStorageAdapter}.
+ *
  * @internal
  */
 export class SyncingService {
   private attachmentService: AttachmentService;
   private localStorage: LocalStorageAdapter;
-  private remoteStorage: RemoteStorageAdapter;
-  private logger: ILogger;
+  private transport: AttachmentTransportAdapter;
+  private logger: PowerSyncLogger;
   private errorHandler?: AttachmentErrorHandler;
 
   constructor(
     attachmentService: AttachmentService,
     localStorage: LocalStorageAdapter,
-    remoteStorage: RemoteStorageAdapter,
-    logger: ILogger,
+    transport: AttachmentTransportAdapter,
+    logger: PowerSyncLogger,
     errorHandler?: AttachmentErrorHandler
   ) {
     this.attachmentService = attachmentService;
     this.localStorage = localStorage;
-    this.remoteStorage = remoteStorage;
+    this.transport = transport;
     this.logger = logger;
     this.errorHandler = errorHandler;
   }
@@ -56,11 +59,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 +93,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,14 +111,13 @@ 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}`);
       }
 
-      const fileBlob = await this.localStorage.readFile(attachment.localUri);
-      await this.remoteStorage.uploadFile(fileBlob, attachment);
+      await this.transport.upload({ ...attachment, localUri: attachment.localUri });
 
       return {
         ...attachment,
@@ -127,19 +139,17 @@ export class SyncingService {
 
   /**
    * Downloads an attachment from remote storage to local storage.
-   * Retrieves the file, converts to base64, and saves locally.
+   * The destination `localUri` is assigned here and the transport writes the file to it.
    * On success, marks as SYNCED. On failure, defers to error handler or archives.
    *
    * @param attachment - The attachment record to download
    * @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);
-
       const localUri = this.localStorage.getLocalUri(attachment.filename);
-      await this.localStorage.saveFile(localUri, fileData);
+      await this.transport.download({ ...attachment, localUri });
 
       return {
         ...attachment,
@@ -171,7 +181,7 @@ export class SyncingService {
    */
   async deleteAttachment(attachment: AttachmentRecord, context: AttachmentContext): Promise<AttachmentRecord> {
     try {
-      await this.remoteStorage.deleteFile(attachment);
+      await this.transport.delete(attachment);
       if (attachment.localUri) {
         await this.localStorage.deleteFile(attachment.localUri);
       }
@@ -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
+            });
           }
         }
       }