tests: fixed SyncService to rely on LocalStorage and be agnostic to file saving.

Author: Amine

.gitignore

@@ -9,5 +9,5 @@ dist
 # Useful if running repository in VSCode dev container
 .pnpm-store
 __screenshots__
-**/tests/temp/**/*
-**/tests/temp/**/.*
+testing.db
+testing.db-*

packages/attachments/src/AttachmentContext.ts

@@ -117,20 +117,9 @@ export class AttachmentContext {
    * @param attachment - The attachment record to upsert
    * @param context - Active database transaction context
    */
-  upsertAttachment(attachment: AttachmentRecord, context: Transaction): void {
-    console.debug('[ATTACHMENT CONTEXT] Upserting attachment:', [
-      attachment.id,
-      attachment.filename,
-      attachment.localUri || null,
-      attachment.size || null,
-      attachment.mediaType || null,
-      attachment.timestamp,
-      attachment.state,
-      attachment.hasSynced ? 1 : 0,
-      attachment.metaData || null
-    ]);
+  async upsertAttachment(attachment: AttachmentRecord, context: Transaction): Promise<void> {    
     try {
-      context.execute(
+      const result = await context.execute(
         /* sql */
         `
           INSERT
@@ -161,7 +150,6 @@ export class AttachmentContext {
         ]
       );
     } catch (error) {
-      console.error('[ATTACHMENT CONTEXT] Error upserting attachment:', attachment.id?.substring(0,8), attachment.state, error);
       throw error;
     }
   }
@@ -198,9 +186,7 @@ export class AttachmentContext {
    * @param attachments - Array of attachment records to save
    */
   async saveAttachments(attachments: AttachmentRecord[]): Promise<void> {
-    console.debug('[ATTACHMENT CONTEXT] Saving attachments:', attachments.map(a => ({ id: a.id?.substring(0,8), state: a.state })));
     if (attachments.length === 0) {
-      console.debug('[ATTACHMENT CONTEXT] No attachments to save');
       return;
     }
     await this.db.writeTransaction(async (tx) => {

packages/attachments/src/AttachmentQueue.ts

@@ -1,14 +1,12 @@
 import { AbstractPowerSyncDatabase, DifferentialWatchedQuery, ILogger, Transaction } from '@powersync/common';
 import { AttachmentContext } from './AttachmentContext.js';
-import { LocalStorageAdapter } from './LocalStorageAdapter.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';
 
-export type AttachmentData = ArrayBuffer | Blob | string;
-
 /**
  * AttachmentQueue manages the lifecycle and synchronization of attachments
  * between local and remote storage.
@@ -96,7 +94,6 @@ export class AttachmentQueue {
     downloadAttachments?: boolean;
     archivedCacheLimit?: number;
   }) {
-    console.debug('AttachmentQueue constructor')
     this.context = new AttachmentContext(db, tableName, logger ?? db.logger);
     this.remoteStorage = remoteStorage;
     this.localStorage = localStorage;
@@ -136,7 +133,6 @@ export class AttachmentQueue {
    * - Handles state transitions for archived and new attachments
    */
   async startSync(): Promise<void> {
-    console.debug('[QUEUE] AttachmentQueue startSync')
     if (this.attachmentService.watchActiveAttachments) {
       await this.stopSync();
       // re-create the watch after it was stopped
@@ -151,14 +147,12 @@ export class AttachmentQueue {
     // Sync storage when there is a change in active attachments
     this.watchActiveAttachments.registerListener({
       onDiff: async () => {
-        console.debug('[QUEUE] watchActiveAttachments: diff detected, syncing storage');
         await this.syncStorage();
       }
     });
 
     // Process attachments when there is a change in watched attachments
     this.watchAttachments(async (watchedAttachments) => {
-      console.debug('[QUEUE] watchAttachments callback:', watchedAttachments.length, 'items');
       // Need to get all the attachments which are tracked in the DB.
       // We might need to restore an archived attachment.
       const currentAttachments = await this.context.getAttachments();
@@ -234,7 +228,6 @@ export class AttachmentQueue {
       }
 
       if (attachmentUpdates.length > 0) {
-        console.debug('[QUEUE] Saving attachments:', attachmentUpdates);
         await this.context.saveAttachments(attachmentUpdates);
       }
     });
@@ -248,7 +241,6 @@ export class AttachmentQueue {
    */
   async syncStorage(): Promise<void> {
     const activeAttachments = await this.context.getActiveAttachments();
-    console.debug('[QUEUE] syncStorage: processing', activeAttachments.length, 'active attachments');
     await this.localStorage.initialize();
     await this.syncingService.processAttachments(activeAttachments);
     await this.syncingService.deleteArchivedAttachments();

packages/attachments/src/LocalStorageAdapter.ts

@@ -1,8 +1,11 @@
+export type AttachmentData = ArrayBuffer | string;
+
 export enum EncodingType {
   UTF8 = 'utf8',
   Base64 = 'base64'
 }
 
+
 /**
  * LocalStorageAdapter defines the interface for local file storage operations.
  * Implementations handle file I/O, directory management, and storage initialization.
@@ -14,7 +17,7 @@ export interface LocalStorageAdapter {
    * @param data Data to store (ArrayBuffer, Blob, or string)
    * @returns Number of bytes written
    */
-  saveFile(filePath: string, data: ArrayBuffer | Blob | string): Promise<number>;
+  saveFile(filePath: string, data: AttachmentData): Promise<number>;
 
   /**
    * Retrieves file data as an ArrayBuffer.

packages/attachments/src/SyncingService.ts

@@ -107,22 +107,11 @@ export class SyncingService {
    * @returns Updated attachment record with local URI and new state
    */
   async downloadAttachment(attachment: AttachmentRecord): Promise<AttachmentRecord> {
-    console.debug('[SYNC] Downloading:', attachment.id);
     try {
-      const file = await this.remoteStorage.downloadFile(attachment);
-      console.debug('[SYNC] Downloaded, converting to base64');
-      const base64Data = await new Promise<string>((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onloadend = () => {
-          // remove the header from the result: 'data:*/*;base64,'
-          resolve(reader.result?.toString().replace(/^data:.+;base64,/, '') || '');
-        };
-        reader.onerror = reject;
-        reader.readAsDataURL(new File([file], attachment.filename));
-      });
+      const fileData = await this.remoteStorage.downloadFile(attachment);
 
       const localUri = this.localStorage.getLocalUri(attachment.filename);
-      await this.localStorage.saveFile(localUri, base64Data);
+      await this.localStorage.saveFile(localUri, fileData);
 
       return {
         ...attachment,

packages/attachments/src/storageAdapters/IndexDBFileSystemAdapter.ts

@@ -1,4 +1,4 @@
-import { EncodingType, LocalStorageAdapter } from '../LocalStorageAdapter.js';
+import { AttachmentData, EncodingType, LocalStorageAdapter } from '../LocalStorageAdapter.js';
 
 /**
  * IndexDBFileSystemStorageAdapter implements LocalStorageAdapter using IndexedDB.
@@ -41,11 +41,28 @@ export class IndexDBFileSystemStorageAdapter implements LocalStorageAdapter {
     return tx.objectStore('files');
   }
 
-  async saveFile(filePath: string, data: string): Promise<number> {
+  async saveFile(filePath: string, data: AttachmentData): Promise<number> {
     const store = await this.getStore('readwrite');
+
+    let dataToStore: ArrayBuffer;
+    let size: number;
+
+    if (typeof data === 'string') {
+      const binaryString = atob(data);
+      const bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+      dataToStore = bytes.buffer;
+      size = bytes.byteLength;
+    } else {
+      dataToStore = data;
+      size = dataToStore.byteLength;
+    }
+
     return await new Promise<number>((resolve, reject) => {
-      const req = store.put(data, filePath);
-      req.onsuccess = () => resolve(data.length);
+      const req = store.put(dataToStore, filePath);
+      req.onsuccess = () => resolve(size);
       req.onerror = () => reject(req.error);
     });
   }

packages/attachments/src/storageAdapters/NodeFileSystemAdapter.ts

@@ -1,6 +1,6 @@
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import { EncodingType, LocalStorageAdapter } from '../LocalStorageAdapter.js';
+import { AttachmentData, EncodingType, LocalStorageAdapter } from '../LocalStorageAdapter.js';
 
 /**
  * NodeFileSystemAdapter implements LocalStorageAdapter using Node.js filesystem.
@@ -40,13 +40,17 @@ export class NodeFileSystemAdapter implements LocalStorageAdapter {
 
   async saveFile(
     filePath: string,
-    data: string,
+    data: AttachmentData,
     options?: { encoding?: EncodingType; mediaType?: string }
   ): Promise<number> {
-    const buffer = options?.encoding === EncodingType.Base64 ? Buffer.from(data, 'base64') : Buffer.from(data, 'utf8');
-    await fs.writeFile(filePath, buffer, {
-      encoding: options?.encoding
-    });
+    let buffer: Buffer;
+
+    if (typeof data === 'string') {
+      buffer = Buffer.from(data, options?.encoding ?? EncodingType.Base64);
+    } else {
+      buffer = Buffer.from(data);
+    }
+    await fs.writeFile(filePath, buffer);
     return buffer.length;
   }
 

packages/attachments/tests/attachments.test.ts

@@ -56,7 +56,6 @@ beforeAll(async () => {
     }),
     database: {
       dbFilename: 'testing.db',
-      dbLocation: './tests/temp'
     }
   });
 
@@ -101,7 +100,6 @@ const watchAttachments = (onUpdate: (attachments: WatchedAttachmentItem[]) => vo
 
 // Helper to watch the attachments table
 async function* watchAttachmentsTable(): AsyncGenerator<AttachmentRecord[]> {
-  console.debug('[TEST] watchAttachmentsTable: watching attachments table');
   const watcher = db.watch(
     `
         SELECT
@@ -113,10 +111,7 @@ async function* watchAttachmentsTable(): AsyncGenerator<AttachmentRecord[]> {
   );
 
   for await (const result of watcher) {
-    console.debug('[TEST] watchAttachmentsTable: result', result);
     const attachments = result.rows?._array.map((r: any) => attachmentFromSql(r)) ?? [];
-    console.debug('[TEST] watchAttachmentsTable: attachments', attachments);
-    console.debug('[TEST] Mapped attachments:', attachments.map(a => ({ id: a.id?.substring(0,8), state: a.state, hasSynced: a.hasSynced })));
     yield attachments;
   }
 }
@@ -126,7 +121,6 @@ async function waitForMatchCondition(
   predicate: (attachments: AttachmentRecord[]) => boolean,
   timeoutSeconds: number = 5
 ): Promise<AttachmentRecord[]> {
-  console.debug('[TEST] waitForMatchCondition: waiting for condition');
   const timeoutMs = timeoutSeconds * 1000;
   const abortController = new AbortController();
   const startTime = Date.now();
@@ -135,21 +129,16 @@ async function waitForMatchCondition(
 
   try {
     for await (const value of generator) {
-      console.debug('[TEST] waitForMatchCondition: generator value', value);
       if (Date.now() - startTime > timeoutMs) {
-        console.debug('[TEST] waitForMatchCondition: timeout');
         throw new Error(`Timeout waiting for condition after ${timeoutSeconds}s`);
       }
 
       if (predicate(value)) {
-        console.debug('[TEST] waitForMatchCondition: match found!');
         return value;
       }
     }
-    console.debug('[TEST] waitForMatchCondition: for await loop ended without match');
     throw new Error('Stream ended without match');
   } finally {
-    console.debug('[TEST] waitForMatchCondition: finally finaling');
     await generator.return?.(undefined);
     abortController.abort();
   }
@@ -188,7 +177,6 @@ describe('attachment queue', () => {
       const attachments = await waitForMatchCondition(
         () => watchAttachmentsTable(),
         (results) => {
-          console.debug('[TEST] Predicate checking:', results.map(r => ({ id: r.id?.substring(0,8), state: r.state })));
           return results.some((r) => r.state === AttachmentState.SYNCED)
         },
         5
@@ -204,7 +192,7 @@ describe('attachment queue', () => {
 
     // Verify local file exists
     const localData = await queue.localStorage.readFile(attachmentRecord.localUri!);
-    expect(localData).toEqual(MOCK_JPEG_U8A);
+    expect(Array.from(new Uint8Array(localData))).toEqual(MOCK_JPEG_U8A);
 
     await queue.stopSync();
   });