@powersync/common 0.0.0-dev-20260504100448 → 0.0.0-dev-20260630141119

package/package.json

@@ -1,38 +1,17 @@
 {
   "name": "@powersync/common",
-  "version": "0.0.0-dev-20260504100448",
+  "version": "0.0.0-dev-20260630141119",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
   "description": "API definitions for PowerSync",
   "type": "module",
-  "main": "dist/bundle.mjs",
-  "module": "dist/bundle.mjs",
-  "types": "lib/index.d.ts",
+  "types": "./lib/index.d.ts",
   "exports": {
     ".": {
-      "node": {
-        "import": {
-          "types": "./lib/index.d.ts",
-          "default": "./dist/bundle.node.mjs"
-        },
-        "require": {
-          "types": "./dist/index.d.cts",
-          "require": "./dist/bundle.node.cjs"
-        }
-      },
-      "import": {
-        "types": "./lib/index.d.ts",
-        "default": "./dist/bundle.mjs"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "require": "./dist/bundle.cjs"
-      }
-    },
-    "./internal/sync_protocol": {
-      "types": "./legacy/sync_protocol.d.ts"
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
     }
   },
   "author": "PowerSync",
@@ -40,8 +19,7 @@
   "files": [
     "lib",
     "dist",
-    "src",
-    "legacy"
+    "src"
   ],
   "repository": {
     "type": "git",
@@ -51,31 +29,16 @@
     "url": "https://github.com/powersync-ja/powersync-js/issues"
   },
   "homepage": "https://docs.powersync.com",
-  "dependencies": {
-    "event-iterator": "^2.0.0"
-  },
   "devDependencies": {
-    "@rollup/plugin-commonjs": "^29.0.0",
-    "@rollup/plugin-inject": "^5.0.5",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^16.0.3",
     "@types/node": "^24.0.0",
     "@types/uuid": "^9.0.6",
-    "buffer": "^6.0.3",
-    "cross-fetch": "^4.1.0",
-    "estree-walker": "^3.0.3",
-    "js-logger": "^1.6.1",
-    "magic-string": "^0.30.21",
-    "rollup": "^4.52.5",
-    "rollup-plugin-dts": "^6.2.1",
-    "rsocket-core": "1.0.0-alpha.3",
-    "rsocket-websocket-client": "1.0.0-alpha.3"
+    "@microsoft/api-extractor": "^7.58.7"
   },
   "scripts": {
-    "build": "tsc -b && rollup -c rollup.config.mjs",
-    "build:prod": "tsc -b && rollup -c rollup.config.mjs",
+    "build": "tsc -b",
+    "build:prod": "tsc -b",
     "clean": "rm -rf lib dist tsconfig.tsbuildinfo",
     "test": "vitest",
-    "test:exports": "attw --pack . --exclude-entrypoints internal/sync_protocol"
+    "test:exports": "attw --pack . --ignore-rules no-resolution cjs-resolves-to-esm"
   }
 }

package/src/attachments/AttachmentContext.ts

@@ -1,7 +1,7 @@
-import { AbstractPowerSyncDatabase } from '../client/AbstractPowerSyncDatabase.js';
-import { ILogger } from '../utils/Logger.js';
+import { LogLevels, PowerSyncLogger } from '../utils/Logger.js';
 import { Transaction } from '../db/DBAdapter.js';
 import { AttachmentRecord, AttachmentState, attachmentFromSql } from './Schema.js';
+import { CommonPowerSyncDatabase } from '../client/CommonPowerSyncDatabase.js';
 
 /**
  * AttachmentContext provides database operations for managing attachment records.
@@ -9,20 +9,21 @@ import { AttachmentRecord, AttachmentState, attachmentFromSql } from './Schema.j
  * Provides methods to query, insert, update, and delete attachment records with
  * proper transaction management through PowerSync.
  *
- * @internal
+ * @experimental
+ * @alpha
  */
 export class AttachmentContext {
   /** PowerSync database instance for executing queries */
-  db: AbstractPowerSyncDatabase;
+  readonly db: CommonPowerSyncDatabase;
 
   /** Name of the database table storing attachment records */
-  tableName: string;
+  readonly tableName: string;
 
   /** Logger instance for diagnostic information */
-  logger: ILogger;
+  readonly logger: PowerSyncLogger;
 
   /** Maximum number of archived attachments to keep before cleanup */
-  archivedCacheLimit: number = 100;
+  readonly archivedCacheLimit: number = 100;
 
   /**
    * Creates a new AttachmentContext instance.
@@ -32,9 +33,9 @@ export class AttachmentContext {
    * @param logger - Logger instance for diagnostic output
    */
   constructor(
-    db: AbstractPowerSyncDatabase,
+    db: CommonPowerSyncDatabase,
     tableName: string = 'attachments',
-    logger: ILogger,
+    logger: PowerSyncLogger,
     archivedCacheLimit: number
   ) {
     this.db = db;
@@ -233,9 +234,10 @@ export class AttachmentContext {
     if (archivedAttachments.length === 0) return false;
 
     await callback?.(archivedAttachments);
-    this.logger.info(
-      `Deleting ${archivedAttachments.length} archived attachments. Archived attachment exceeds cache archiveCacheLimit of ${this.archivedCacheLimit}.`
-    );
+    this.logger.log({
+      level: LogLevels.info,
+      message: `Deleting ${archivedAttachments.length} archived attachments. Archived attachment exceeds cache archiveCacheLimit of ${this.archivedCacheLimit}.`
+    });
 
     const ids = archivedAttachments.map((attachment) => attachment.id);
 
@@ -254,7 +256,7 @@ export class AttachmentContext {
       [JSON.stringify(ids)]
     );
 
-    this.logger.info(`Deleted ${archivedAttachments.length} archived attachments`);
+    this.logger.log({ level: LogLevels.info, message: `Deleted ${archivedAttachments.length} archived attachments` });
     return archivedAttachments.length < limit;
   }
 

package/src/attachments/AttachmentErrorHandler.ts

@@ -10,24 +10,24 @@ import { AttachmentRecord } from './Schema.js';
 export interface AttachmentErrorHandler {
   /**
    * Handles a download error for a specific attachment.
-   * @param attachment The attachment that failed to download
-   * @param error The error encountered during the download
+   * @param attachment - The attachment that failed to download
+   * @param error - The error encountered during the download
    * @returns `true` to retry the operation, `false` to archive the attachment
    */
   onDownloadError(attachment: AttachmentRecord, error: unknown): Promise<boolean>;
 
   /**
    * Handles an upload error for a specific attachment.
-   * @param attachment The attachment that failed to upload
-   * @param error The error encountered during the upload
+   * @param attachment - The attachment that failed to upload
+   * @param error - The error encountered during the upload
    * @returns `true` to retry the operation, `false` to archive the attachment
    */
   onUploadError(attachment: AttachmentRecord, error: unknown): Promise<boolean>;
 
   /**
    * Handles a delete error for a specific attachment.
-   * @param attachment The attachment that failed to delete
-   * @param error The error encountered during the delete
+   * @param attachment - The attachment that failed to delete
+   * @param error - The error encountered during the delete
    * @returns `true` to retry the operation, `false` to archive the attachment
    */
   onDeleteError(attachment: AttachmentRecord, error: unknown): Promise<boolean>;

package/src/attachments/AttachmentQueue.ts

@@ -1,15 +1,67 @@
-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 { ILogger } from '../utils/Logger.js';
+import { LogLevels, PowerSyncLogger } from '../utils/Logger.js';
 import { Transaction } from '../db/DBAdapter.js';
+import { AttachmentContext } from './AttachmentContext.js';
+import { AttachmentErrorHandler } from './AttachmentErrorHandler.js';
+import { AttachmentService } from './AttachmentService.js';
 import { AttachmentData, LocalStorageAdapter } 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 { AttachmentService } from './AttachmentService.js';
-import { AttachmentErrorHandler } from './AttachmentErrorHandler.js';
+import { CommonPowerSyncDatabase } from '../client/CommonPowerSyncDatabase.js';
+
+/**
+ * Configuration options for {@link AttachmentQueue}.
+ *
+ * @experimental
+ * @alpha This is currently experimental and may change without a major version bump.
+ */
+export interface AttachmentQueueOptions {
+  /**
+   * PowerSync database instance
+   */
+  db: CommonPowerSyncDatabase;
+  /**
+   * Remote storage adapter for upload/download operations
+   */
+  remoteStorage: RemoteStorageAdapter;
+  /**
+   * Local storage adapter for file persistence
+   */
+  localStorage: LocalStorageAdapter;
+  /**
+   * Callback for monitoring attachment changes in your data model
+   */
+  watchAttachments: (onUpdate: (attachment: WatchedAttachmentItem[]) => Promise<void>, signal: AbortSignal) => void;
+  /**
+   * Name of the table to store attachment records. Default: 'ps_attachment_queue'
+   */
+  tableName?: string;
+  /**
+   * Logger instance. Defaults to db.logger
+   */
+  logger?: PowerSyncLogger;
+  /**
+   * Periodic polling interval in milliseconds for retrying failed uploads/downloads. Default: 30000
+   */
+  syncIntervalMs?: number;
+  /**
+   * Throttle duration in milliseconds for the reactive watch query that detects attachment changes. Prevents rapid-fire syncs during bulk changes. Default: 30
+   */
+  syncThrottleDuration?: number;
+  /**
+   * Whether to automatically download remote attachments. Default: true
+   */
+  downloadAttachments?: boolean;
+  /**
+   * Maximum archived attachments before cleanup. Default: 100
+   */
+  archivedCacheLimit?: number;
+
+  /** Handler for upload, download and delete errors */
+  errorHandler?: AttachmentErrorHandler;
+}
 
 /**
  * AttachmentQueue manages the lifecycle and synchronization of attachments
@@ -49,7 +101,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) */
@@ -61,7 +113,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;
@@ -73,29 +125,19 @@ 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;
 
-  private watchActiveAttachments: DifferentialWatchedQuery<AttachmentRecord>;
+  private watchActiveAttachments!: DifferentialWatchedQuery<AttachmentRecord>;
 
-  private watchAttachmentsAbortController: AbortController;
+  private watchAttachmentsAbortController!: AbortController;
 
   /**
    * Creates a new AttachmentQueue instance.
    *
    * @param options - Configuration options
-   * @param options.db - PowerSync database instance
-   * @param options.remoteStorage - Remote storage adapter for upload/download operations
-   * @param options.localStorage - Local storage adapter for file persistence
-   * @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 - 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
    */
   constructor({
     db,
@@ -105,23 +147,11 @@ export class AttachmentQueue {
     logger,
     tableName = ATTACHMENT_TABLE,
     syncIntervalMs = 30 * 1000,
-    syncThrottleDuration = DEFAULT_WATCH_THROTTLE_MS,
+    syncThrottleDuration,
     downloadAttachments = true,
     archivedCacheLimit = 100,
     errorHandler
-  }: {
-    db: AbstractPowerSyncDatabase;
-    remoteStorage: RemoteStorageAdapter;
-    localStorage: LocalStorageAdapter;
-    watchAttachments: (onUpdate: (attachment: WatchedAttachmentItem[]) => Promise<void>, signal: AbortSignal) => void;
-    tableName?: string;
-    logger?: ILogger;
-    syncIntervalMs?: number;
-    syncThrottleDuration?: number;
-    downloadAttachments?: boolean;
-    archivedCacheLimit?: number;
-    errorHandler?: AttachmentErrorHandler;
-  }) {
+  }: AttachmentQueueOptions) {
     this.db = db;
     this.remoteStorage = remoteStorage;
     this.localStorage = localStorage;
@@ -190,7 +220,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 });
           });
         }
       }
@@ -228,6 +258,7 @@ export class AttachmentQueue {
               state: AttachmentState.QUEUED_DOWNLOAD,
               hasSynced: false,
               metaData: watchedAttachment.metaData,
+              mediaType: watchedAttachment.mediaType,
               timestamp: new Date().getTime()
             });
             continue;
@@ -321,17 +352,24 @@ export class AttachmentQueue {
     }
   }
 
+  /**
+   * Provides an {@link AttachmentContext} to a callback.
+   *
+   * The callback runs while the attachment queue mutex is held. Do not call
+   * other {@link AttachmentQueue} methods from within the callback, as they may
+   * attempt to acquire the same mutex and block indefinitely.
+   */
+  withAttachmentContext<T>(callback: (context: AttachmentContext) => Promise<T>): Promise<T> {
+    /**
+     * AttachmentService is internal and private in this class.
+     * We only need to expose its locking and context functionality for extending classes.
+     */
+    return this.attachmentService.withContext(callback);
+  }
   /**
    * Saves a file to local storage and queues it for upload to remote storage.
    *
    * @param options - File save options
-   * @param options.data - The file data as ArrayBuffer, Blob, or base64 string
-   * @param options.fileExtension - File extension (e.g., 'jpg', 'pdf')
-   * @param options.mediaType - MIME type of the file (e.g., 'image/jpeg')
-   * @param options.metaData - Optional metadata to associate with the attachment
-   * @param options.id - Optional custom ID. If not provided, a UUID will be generated
-   * @param options.updateHook - Optional callback to execute additional database operations
-   *                             within the same transaction as the attachment creation
    * @returns Promise resolving to the created attachment record
    */
   async saveFile({
@@ -342,11 +380,30 @@ export class AttachmentQueue {
     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> {
     const resolvedId = id ?? (await this.generateAttachmentId());

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

@@ -1,5 +1,11 @@
+/**
+ * @alpha
+ */
 export type AttachmentData = ArrayBuffer | string;
 
+/**
+ * @alpha
+ */
 export enum EncodingType {
   UTF8 = 'utf8',
   Base64 = 'base64'
@@ -15,41 +21,41 @@ export enum EncodingType {
 export interface LocalStorageAdapter {
   /**
    * Saves data to a local file.
-   * @param filePath Path where the file will be stored
-   * @param data Data to store (ArrayBuffer, Blob, or string)
+   * @param filePath - Path where the file will be stored
+   * @param data - Data to store (ArrayBuffer, Blob, or string)
    * @returns Number of bytes written
    */
   saveFile(filePath: string, data: AttachmentData): Promise<number>;
 
   /**
    * Retrieves file data as an ArrayBuffer.
-   * @param filePath Path where the file is stored
+   * @param filePath - Path where the file is stored
    * @returns ArrayBuffer containing the file data
    */
   readFile(filePath: string): Promise<ArrayBuffer>;
 
   /**
    * Deletes the file at the given path.
-   * @param filePath Path where the file is stored
+   * @param filePath - Path where the file is stored
    */
   deleteFile(filePath: string): Promise<void>;
 
   /**
    * Checks if a file exists at the given path.
-   * @param filePath Path where the file is stored
+   * @param filePath - Path where the file is stored
    * @returns True if the file exists, false otherwise
    */
   fileExists(filePath: string): Promise<boolean>;
 
   /**
    * Creates a directory at the specified path.
-   * @param path The full path to the directory
+   * @param path - The full path to the directory
    */
   makeDir(path: string): Promise<void>;
 
   /**
    * Removes a directory at the specified path.
-   * @param path The full path to the directory
+   * @param path - The full path to the directory
    */
   rmDir(path: string): Promise<void>;
 
@@ -65,7 +71,7 @@ export interface LocalStorageAdapter {
 
   /**
    * Returns the file path for the provided filename in the storage directory.
-   * @param filename The filename to get the path for
+   * @param filename - The filename to get the path for
    * @returns The full file path
    */
   getLocalUri(filename: string): string;

package/src/attachments/README.md

@@ -427,10 +427,12 @@ type WatchedAttachmentItem = {
   id: string;
   fileExtension: string;  // e.g., 'jpg', 'pdf'
   metaData?: string;
+  mediaType?: string;     // e.g., 'image/jpeg'
 } | {
   id: string;
   filename: string;       // e.g., 'document.pdf'
   metaData?: string;
+  mediaType?: string;     // e.g., 'application/pdf'
 };
 ```
 

package/src/attachments/RemoteStorageAdapter.ts

@@ -10,21 +10,21 @@ import { AttachmentRecord } from './Schema.js';
 export interface RemoteStorageAdapter {
   /**
    * Uploads a file to remote storage.
-   * @param fileData The binary content of the file to upload
-   * @param attachment The associated attachment metadata
+   * @param fileData - The binary content of the file to upload
+   * @param attachment - The associated attachment metadata
    */
   uploadFile(fileData: ArrayBuffer, attachment: AttachmentRecord): Promise<void>;
 
   /**
    * Downloads a file from remote storage.
-   * @param attachment The attachment describing the file to download
+   * @param attachment - The attachment describing the file to download
    * @returns The binary data of the downloaded file
    */
   downloadFile(attachment: AttachmentRecord): Promise<ArrayBuffer>;
 
   /**
    * Deletes a file from remote storage.
-   * @param attachment The attachment describing the file to delete
+   * @param attachment - The attachment describing the file to delete
    */
   deleteFile(attachment: AttachmentRecord): Promise<void>;
 }

package/src/attachments/Schema.ts

@@ -1,13 +1,18 @@
 import { column } from '../db/schema/Column.js';
 import { 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.
+ *
+ * @alpha
+ */
 export const ATTACHMENT_TABLE = 'attachments';
 
 /**
  * AttachmentRecord represents an attachment in the local database.
  *
- * @experimental
+ * @alpha
  */
 export interface AttachmentRecord {
   id: string;
@@ -27,7 +32,7 @@ export interface AttachmentRecord {
  * @param row - The database row object
  * @returns The corresponding AttachmentRecord
  *
- * @experimental
+ * @alpha
  */
 export function attachmentFromSql(row: any): AttachmentRecord {
   return {
@@ -46,7 +51,7 @@ export function attachmentFromSql(row: any): AttachmentRecord {
 /**
  * AttachmentState represents the current synchronization state of an attachment.
  *
- * @experimental
+ * @alpha
  */
 export enum AttachmentState {
   QUEUED_UPLOAD = 0, // Attachment to be uploaded
@@ -56,12 +61,15 @@ export enum AttachmentState {
   ARCHIVED = 4 // Attachment has been orphaned, i.e. the associated record has been deleted
 }
 
-export interface AttachmentTableOptions extends Omit<TableV2Options, 'name' | 'columns'> {}
+/**
+ * @alpha
+ */
+export interface AttachmentTableOptions extends Omit<TableOptions, 'name' | 'columns'> {}
 
 /**
  * AttachmentTable defines the schema for the attachment queue table.
  *
- * @internal
+ * @alpha
  */
 export class AttachmentTable extends Table {
   constructor(options?: AttachmentTableOptions) {

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;
@@ -75,7 +75,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}`);
@@ -111,7 +111,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);
 
@@ -183,7 +183,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
+            });
           }
         }
       }