appwrite-utils-cli 1.2.15 → 1.2.16

package/src/migrations/comprehensiveTransfer.ts

@@ -1,4 +1,9 @@
-import { converterFunctions, tryAwaitWithRetry, parseAttribute, objectNeedsUpdate } from "appwrite-utils";
+import {
+  converterFunctions,
+  tryAwaitWithRetry,
+  parseAttribute,
+  objectNeedsUpdate,
+} from "appwrite-utils";
 import {
   Client,
   Databases,
@@ -8,22 +13,24 @@ import {
   Teams,
   type Models,
   Query,
+  AppwriteException,
 } from "node-appwrite";
 import { InputFile } from "node-appwrite/file";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 import { ProgressManager } from "../shared/progressManager.js";
 import { getClient } from "../utils/getClientFromConfig.js";
-import { 
-  transferDatabaseLocalToLocal, 
+import {
+  transferDatabaseLocalToLocal,
   transferDatabaseLocalToRemote,
   transferStorageLocalToLocal,
   transferStorageLocalToRemote,
-  transferUsersLocalToRemote
+  transferUsersLocalToRemote,
 } from "./transfer.js";
-import { 
-  deployLocalFunction 
-} from "../functions/deployments.js";
-import { listFunctions, downloadLatestFunctionDeployment } from "../functions/methods.js";
+import { deployLocalFunction } from "../functions/deployments.js";
+import {
+  listFunctions,
+  downloadLatestFunctionDeployment,
+} from "../functions/methods.js";
 import pLimit from "p-limit";
 import chalk from "chalk";
 import { join } from "node:path";
@@ -100,7 +107,7 @@ export class ComprehensiveTransfer {
 
     const baseLimit = options.concurrencyLimit || 10;
     this.limit = pLimit(baseLimit);
-    
+
     // Different rate limits for different operations to prevent API throttling
     // Users: Half speed (more sensitive operations)
     // Files: Quarter speed (most bandwidth intensive)
@@ -120,18 +127,25 @@ export class ComprehensiveTransfer {
 
   async execute(): Promise<TransferResults> {
     try {
-      MessageFormatter.info("Starting comprehensive transfer", { prefix: "Transfer" });
-      
+      MessageFormatter.info("Starting comprehensive transfer", {
+        prefix: "Transfer",
+      });
+
       if (this.options.dryRun) {
-        MessageFormatter.info("DRY RUN MODE - No actual changes will be made", { prefix: "Transfer" });
+        MessageFormatter.info("DRY RUN MODE - No actual changes will be made", {
+          prefix: "Transfer",
+        });
       }
 
       // Show rate limiting configuration
       const baseLimit = this.options.concurrencyLimit || 10;
       const userLimit = Math.max(1, Math.floor(baseLimit / 2));
       const fileLimit = Math.max(1, Math.floor(baseLimit / 4));
-      
-      MessageFormatter.info(`Rate limits: General=${baseLimit}, Users=${userLimit}, Files=${fileLimit}`, { prefix: "Transfer" });
+
+      MessageFormatter.info(
+        `Rate limits: General=${baseLimit}, Users=${userLimit}, Files=${fileLimit}`,
+        { prefix: "Transfer" }
+      );
 
       // Ensure temp directory exists
       if (!fs.existsSync(this.tempDir)) {
@@ -164,7 +178,11 @@ export class ComprehensiveTransfer {
 
       return this.results;
     } catch (error) {
-      MessageFormatter.error("Comprehensive transfer failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+      MessageFormatter.error(
+        "Comprehensive transfer failed",
+        error instanceof Error ? error : new Error(String(error)),
+        { prefix: "Transfer" }
+      );
       throw error;
     } finally {
       // Clean up temp directory
@@ -175,11 +193,16 @@ export class ComprehensiveTransfer {
   }
 
   private async transferAllUsers(): Promise<void> {
-    MessageFormatter.info("Starting user transfer phase", { prefix: "Transfer" });
+    MessageFormatter.info("Starting user transfer phase", {
+      prefix: "Transfer",
+    });
 
     if (this.options.dryRun) {
       const usersList = await this.sourceUsers.list([Query.limit(1)]);
-      MessageFormatter.info(`DRY RUN: Would transfer ${usersList.total} users`, { prefix: "Transfer" });
+      MessageFormatter.info(
+        `DRY RUN: Would transfer ${usersList.total} users`,
+        { prefix: "Transfer" }
+      );
       return;
     }
 
@@ -193,20 +216,28 @@ export class ComprehensiveTransfer {
         this.options.targetProject,
         this.options.targetKey
       );
-      
+
       // Get actual count for results
       const usersList = await this.sourceUsers.list([Query.limit(1)]);
       this.results.users.transferred = usersList.total;
-      
-      MessageFormatter.success(`User transfer completed`, { prefix: "Transfer" });
+
+      MessageFormatter.success(`User transfer completed`, {
+        prefix: "Transfer",
+      });
     } catch (error) {
-      MessageFormatter.error("User transfer failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+      MessageFormatter.error(
+        "User transfer failed",
+        error instanceof Error ? error : new Error(String(error)),
+        { prefix: "Transfer" }
+      );
       this.results.users.failed = 1;
     }
   }
 
   private async transferAllTeams(): Promise<void> {
-    MessageFormatter.info("Starting team transfer phase", { prefix: "Transfer" });
+    MessageFormatter.info("Starting team transfer phase", {
+      prefix: "Transfer",
+    });
 
     try {
       // Fetch all teams from source with pagination
@@ -216,47 +247,68 @@ export class ComprehensiveTransfer {
       if (this.options.dryRun) {
         let totalMemberships = 0;
         for (const team of allSourceTeams) {
-          const memberships = await this.sourceTeams.listMemberships(team.$id, [Query.limit(1)]);
+          const memberships = await this.sourceTeams.listMemberships(team.$id, [
+            Query.limit(1),
+          ]);
           totalMemberships += memberships.total;
         }
-        MessageFormatter.info(`DRY RUN: Would transfer ${allSourceTeams.length} teams with ${totalMemberships} memberships`, { prefix: "Transfer" });
+        MessageFormatter.info(
+          `DRY RUN: Would transfer ${allSourceTeams.length} teams with ${totalMemberships} memberships`,
+          { prefix: "Transfer" }
+        );
         return;
       }
 
-      const transferTasks = allSourceTeams.map(team => 
+      const transferTasks = allSourceTeams.map((team) =>
         this.limit(async () => {
           try {
             // Check if team exists in target
-            const existingTeam = allTargetTeams.find(tt => tt.$id === team.$id);
-            
+            const existingTeam = allTargetTeams.find(
+              (tt) => tt.$id === team.$id
+            );
+
             if (!existingTeam) {
               // Fetch all memberships to extract unique roles before creating team
-              MessageFormatter.info(`Fetching memberships for team ${team.name} to extract roles`, { prefix: "Transfer" });
+              MessageFormatter.info(
+                `Fetching memberships for team ${team.name} to extract roles`,
+                { prefix: "Transfer" }
+              );
               const memberships = await this.fetchAllMemberships(team.$id);
-              
+
               // Extract unique roles from all memberships
               const allRoles = new Set<string>();
-              memberships.forEach(membership => {
-                membership.roles.forEach(role => allRoles.add(role));
+              memberships.forEach((membership) => {
+                membership.roles.forEach((role) => allRoles.add(role));
               });
               const uniqueRoles = Array.from(allRoles);
-              
-              MessageFormatter.info(`Found ${uniqueRoles.length} unique roles for team ${team.name}: ${uniqueRoles.join(', ')}`, { prefix: "Transfer" });
-              
+
+              MessageFormatter.info(
+                `Found ${uniqueRoles.length} unique roles for team ${
+                  team.name
+                }: ${uniqueRoles.join(", ")}`,
+                { prefix: "Transfer" }
+              );
+
               // Create team in target with the collected roles
-              await this.targetTeams.create(
-                team.$id,
-                team.name,
-                uniqueRoles
+              await this.targetTeams.create(team.$id, team.name, uniqueRoles);
+              MessageFormatter.success(
+                `Created team: ${team.name} with roles: ${uniqueRoles.join(
+                  ", "
+                )}`,
+                { prefix: "Transfer" }
               );
-              MessageFormatter.success(`Created team: ${team.name} with roles: ${uniqueRoles.join(', ')}`, { prefix: "Transfer" });
             } else {
-              MessageFormatter.info(`Team ${team.name} already exists, updating if needed`, { prefix: "Transfer" });
-              
+              MessageFormatter.info(
+                `Team ${team.name} already exists, updating if needed`,
+                { prefix: "Transfer" }
+              );
+
               // Update team if needed
               if (existingTeam.name !== team.name) {
                 await this.targetTeams.updateName(team.$id, team.name);
-                MessageFormatter.success(`Updated team name: ${team.name}`, { prefix: "Transfer" });
+                MessageFormatter.success(`Updated team name: ${team.name}`, {
+                  prefix: "Transfer",
+                });
               }
             }
 
@@ -264,54 +316,85 @@ export class ComprehensiveTransfer {
             await this.transferTeamMemberships(team.$id);
 
             this.results.teams.transferred++;
-            MessageFormatter.success(`Team ${team.name} transferred successfully`, { prefix: "Transfer" });
+            MessageFormatter.success(
+              `Team ${team.name} transferred successfully`,
+              { prefix: "Transfer" }
+            );
           } catch (error) {
-            MessageFormatter.error(`Team ${team.name} transfer failed`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            MessageFormatter.error(
+              `Team ${team.name} transfer failed`,
+              error instanceof Error ? error : new Error(String(error)),
+              { prefix: "Transfer" }
+            );
             this.results.teams.failed++;
           }
         })
       );
 
       await Promise.all(transferTasks);
-      MessageFormatter.success("Team transfer phase completed", { prefix: "Transfer" });
+      MessageFormatter.success("Team transfer phase completed", {
+        prefix: "Transfer",
+      });
     } catch (error) {
-      MessageFormatter.error("Team transfer phase failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+      MessageFormatter.error(
+        "Team transfer phase failed",
+        error instanceof Error ? error : new Error(String(error)),
+        { prefix: "Transfer" }
+      );
     }
   }
 
   private async transferAllDatabases(): Promise<void> {
-    MessageFormatter.info("Starting database transfer phase", { prefix: "Transfer" });
+    MessageFormatter.info("Starting database transfer phase", {
+      prefix: "Transfer",
+    });
 
     try {
       const sourceDatabases = await this.sourceDatabases.list();
       const targetDatabases = await this.targetDatabases.list();
 
       if (this.options.dryRun) {
-        MessageFormatter.info(`DRY RUN: Would transfer ${sourceDatabases.databases.length} databases`, { prefix: "Transfer" });
+        MessageFormatter.info(
+          `DRY RUN: Would transfer ${sourceDatabases.databases.length} databases`,
+          { prefix: "Transfer" }
+        );
         return;
       }
 
       // Phase 1: Create all databases and collections (structure only)
-      MessageFormatter.info("Phase 1: Creating database structures (databases, collections, attributes, indexes)", { prefix: "Transfer" });
-      
-      const structureCreationTasks = sourceDatabases.databases.map(db => 
+      MessageFormatter.info(
+        "Phase 1: Creating database structures (databases, collections, attributes, indexes)",
+        { prefix: "Transfer" }
+      );
+
+      const structureCreationTasks = sourceDatabases.databases.map((db) =>
         this.limit(async () => {
           try {
             // Check if database exists in target
-            const existingDb = targetDatabases.databases.find(tdb => tdb.$id === db.$id);
-            
+            const existingDb = targetDatabases.databases.find(
+              (tdb) => tdb.$id === db.$id
+            );
+
             if (!existingDb) {
               // Create database in target
               await this.targetDatabases.create(db.$id, db.name, db.enabled);
-              MessageFormatter.success(`Created database: ${db.name}`, { prefix: "Transfer" });
+              MessageFormatter.success(`Created database: ${db.name}`, {
+                prefix: "Transfer",
+              });
             }
 
             // Create collections, attributes, and indexes WITHOUT transferring documents
             await this.createDatabaseStructure(db.$id);
 
-            MessageFormatter.success(`Database structure created: ${db.name}`, { prefix: "Transfer" });
+            MessageFormatter.success(`Database structure created: ${db.name}`, {
+              prefix: "Transfer",
+            });
           } catch (error) {
-            MessageFormatter.error(`Database structure creation failed for ${db.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            MessageFormatter.error(
+              `Database structure creation failed for ${db.name}`,
+              error instanceof Error ? error : new Error(String(error)),
+              { prefix: "Transfer" }
+            );
             this.results.databases.failed++;
           }
         })
@@ -320,27 +403,43 @@ export class ComprehensiveTransfer {
       await Promise.all(structureCreationTasks);
 
       // Phase 2: Transfer all documents after all structures are created
-      MessageFormatter.info("Phase 2: Transferring documents to all collections", { prefix: "Transfer" });
-      
-      const documentTransferTasks = sourceDatabases.databases.map(db => 
+      MessageFormatter.info(
+        "Phase 2: Transferring documents to all collections",
+        { prefix: "Transfer" }
+      );
+
+      const documentTransferTasks = sourceDatabases.databases.map((db) =>
         this.limit(async () => {
           try {
             // Transfer documents for this database
             await this.transferDatabaseDocuments(db.$id);
 
             this.results.databases.transferred++;
-            MessageFormatter.success(`Database documents transferred: ${db.name}`, { prefix: "Transfer" });
+            MessageFormatter.success(
+              `Database documents transferred: ${db.name}`,
+              { prefix: "Transfer" }
+            );
           } catch (error) {
-            MessageFormatter.error(`Document transfer failed for ${db.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            MessageFormatter.error(
+              `Document transfer failed for ${db.name}`,
+              error instanceof Error ? error : new Error(String(error)),
+              { prefix: "Transfer" }
+            );
             this.results.databases.failed++;
           }
         })
       );
 
       await Promise.all(documentTransferTasks);
-      MessageFormatter.success("Database transfer phase completed", { prefix: "Transfer" });
+      MessageFormatter.success("Database transfer phase completed", {
+        prefix: "Transfer",
+      });
     } catch (error) {
-      MessageFormatter.error("Database transfer phase failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+      MessageFormatter.error(
+        "Database transfer phase failed",
+        error instanceof Error ? error : new Error(String(error)),
+        { prefix: "Transfer" }
+      );
     }
   }
 
@@ -348,33 +447,51 @@ export class ComprehensiveTransfer {
    * Phase 1: Create database structure (collections, attributes, indexes) without transferring documents
    */
   private async createDatabaseStructure(dbId: string): Promise<void> {
-    MessageFormatter.info(`Creating database structure for ${dbId}`, { prefix: "Transfer" });
+    MessageFormatter.info(`Creating database structure for ${dbId}`, {
+      prefix: "Transfer",
+    });
 
     try {
       // Get all collections from source database
-      const sourceCollections = await this.fetchAllCollections(dbId, this.sourceDatabases);
-      MessageFormatter.info(`Found ${sourceCollections.length} collections in source database ${dbId}`, { prefix: "Transfer" });
+      const sourceCollections = await this.fetchAllCollections(
+        dbId,
+        this.sourceDatabases
+      );
+      MessageFormatter.info(
+        `Found ${sourceCollections.length} collections in source database ${dbId}`,
+        { prefix: "Transfer" }
+      );
 
       // Process each collection
       for (const collection of sourceCollections) {
-        MessageFormatter.info(`Processing collection: ${collection.name} (${collection.$id})`, { prefix: "Transfer" });
+        MessageFormatter.info(
+          `Processing collection: ${collection.name} (${collection.$id})`,
+          { prefix: "Transfer" }
+        );
 
         try {
           // Create or update collection in target
           let targetCollection: Models.Collection;
           const existingCollection = await tryAwaitWithRetry(async () =>
-            this.targetDatabases.listCollections(dbId, [Query.equal("$id", collection.$id)])
+            this.targetDatabases.listCollections(dbId, [
+              Query.equal("$id", collection.$id),
+            ])
           );
 
           if (existingCollection.collections.length > 0) {
             targetCollection = existingCollection.collections[0];
-            MessageFormatter.info(`Collection ${collection.name} exists in target database`, { prefix: "Transfer" });
+            MessageFormatter.info(
+              `Collection ${collection.name} exists in target database`,
+              { prefix: "Transfer" }
+            );
 
             // Update collection if needed
             if (
               targetCollection.name !== collection.name ||
-              JSON.stringify(targetCollection.$permissions) !== JSON.stringify(collection.$permissions) ||
-              targetCollection.documentSecurity !== collection.documentSecurity ||
+              JSON.stringify(targetCollection.$permissions) !==
+                JSON.stringify(collection.$permissions) ||
+              targetCollection.documentSecurity !==
+                collection.documentSecurity ||
               targetCollection.enabled !== collection.enabled
             ) {
               targetCollection = await tryAwaitWithRetry(async () =>
@@ -387,10 +504,16 @@ export class ComprehensiveTransfer {
                   collection.enabled
                 )
               );
-              MessageFormatter.success(`Collection ${collection.name} updated`, { prefix: "Transfer" });
+              MessageFormatter.success(
+                `Collection ${collection.name} updated`,
+                { prefix: "Transfer" }
+              );
             }
           } else {
-            MessageFormatter.info(`Creating collection ${collection.name} in target database...`, { prefix: "Transfer" });
+            MessageFormatter.info(
+              `Creating collection ${collection.name} in target database...`,
+              { prefix: "Transfer" }
+            );
             targetCollection = await tryAwaitWithRetry(async () =>
               this.targetDatabases.createCollection(
                 dbId,
@@ -401,55 +524,99 @@ export class ComprehensiveTransfer {
                 collection.enabled
               )
             );
-            MessageFormatter.success(`Collection ${collection.name} created`, { prefix: "Transfer" });
+            MessageFormatter.success(`Collection ${collection.name} created`, {
+              prefix: "Transfer",
+            });
           }
 
           // Handle attributes with enhanced status checking
-          MessageFormatter.info(`Creating attributes for collection ${collection.name} with enhanced monitoring...`, { prefix: "Transfer" });
-          
-          const attributesToCreate = collection.attributes.map(attr => parseAttribute(attr as any));
-          
-          const attributesSuccess = await this.createCollectionAttributesWithStatusCheck(
-            this.targetDatabases,
-            dbId,
-            targetCollection,
-            attributesToCreate
+          MessageFormatter.info(
+            `Creating attributes for collection ${collection.name} with enhanced monitoring...`,
+            { prefix: "Transfer" }
+          );
+
+          const attributesToCreate = collection.attributes.map((attr) =>
+            parseAttribute(attr as any)
           );
-          
+
+          const attributesSuccess =
+            await this.createCollectionAttributesWithStatusCheck(
+              this.targetDatabases,
+              dbId,
+              targetCollection,
+              attributesToCreate
+            );
+
           if (!attributesSuccess) {
-            MessageFormatter.error(`Failed to create some attributes for collection ${collection.name}`, undefined, { prefix: "Transfer" });
-            MessageFormatter.error(`Skipping index creation and document transfer for collection ${collection.name} due to attribute failures`, undefined, { prefix: "Transfer" });
+            MessageFormatter.error(
+              `Failed to create some attributes for collection ${collection.name}`,
+              undefined,
+              { prefix: "Transfer" }
+            );
+            MessageFormatter.error(
+              `Skipping index creation and document transfer for collection ${collection.name} due to attribute failures`,
+              undefined,
+              { prefix: "Transfer" }
+            );
             // Skip indexes and document transfer if attributes failed
             continue;
           } else {
-            MessageFormatter.success(`All attributes created successfully for collection ${collection.name}`, { prefix: "Transfer" });
+            MessageFormatter.success(
+              `All attributes created successfully for collection ${collection.name}`,
+              { prefix: "Transfer" }
+            );
           }
 
           // Handle indexes with enhanced status checking
-          MessageFormatter.info(`Creating indexes for collection ${collection.name} with enhanced monitoring...`, { prefix: "Transfer" });
-          
-          const indexesSuccess = await this.createCollectionIndexesWithStatusCheck(
-            dbId,
-            this.targetDatabases,
-            targetCollection.$id,
-            targetCollection,
-            collection.indexes as any
+          MessageFormatter.info(
+            `Creating indexes for collection ${collection.name} with enhanced monitoring...`,
+            { prefix: "Transfer" }
           );
-          
+
+          const indexesSuccess =
+            await this.createCollectionIndexesWithStatusCheck(
+              dbId,
+              this.targetDatabases,
+              targetCollection.$id,
+              targetCollection,
+              collection.indexes as any
+            );
+
           if (!indexesSuccess) {
-            MessageFormatter.error(`Failed to create some indexes for collection ${collection.name}`, undefined, { prefix: "Transfer" });
-            MessageFormatter.warning(`Proceeding with document transfer despite index failures for collection ${collection.name}`, { prefix: "Transfer" });
+            MessageFormatter.error(
+              `Failed to create some indexes for collection ${collection.name}`,
+              undefined,
+              { prefix: "Transfer" }
+            );
+            MessageFormatter.warning(
+              `Proceeding with document transfer despite index failures for collection ${collection.name}`,
+              { prefix: "Transfer" }
+            );
           } else {
-            MessageFormatter.success(`All indexes created successfully for collection ${collection.name}`, { prefix: "Transfer" });
+            MessageFormatter.success(
+              `All indexes created successfully for collection ${collection.name}`,
+              { prefix: "Transfer" }
+            );
           }
 
-          MessageFormatter.success(`Structure complete for collection ${collection.name}`, { prefix: "Transfer" });
+          MessageFormatter.success(
+            `Structure complete for collection ${collection.name}`,
+            { prefix: "Transfer" }
+          );
         } catch (error) {
-          MessageFormatter.error(`Error processing collection ${collection.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+          MessageFormatter.error(
+            `Error processing collection ${collection.name}`,
+            error instanceof Error ? error : new Error(String(error)),
+            { prefix: "Transfer" }
+          );
         }
       }
     } catch (error) {
-      MessageFormatter.error(`Failed to create database structure for ${dbId}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+      MessageFormatter.error(
+        `Failed to create database structure for ${dbId}`,
+        error instanceof Error ? error : new Error(String(error)),
+        { prefix: "Transfer" }
+      );
       throw error;
     }
   }
@@ -458,16 +625,27 @@ export class ComprehensiveTransfer {
    * Phase 2: Transfer documents to all collections in the database
    */
   private async transferDatabaseDocuments(dbId: string): Promise<void> {
-    MessageFormatter.info(`Transferring documents for database ${dbId}`, { prefix: "Transfer" });
+    MessageFormatter.info(`Transferring documents for database ${dbId}`, {
+      prefix: "Transfer",
+    });
 
     try {
       // Get all collections from source database
-      const sourceCollections = await this.fetchAllCollections(dbId, this.sourceDatabases);
-      MessageFormatter.info(`Transferring documents for ${sourceCollections.length} collections in database ${dbId}`, { prefix: "Transfer" });
+      const sourceCollections = await this.fetchAllCollections(
+        dbId,
+        this.sourceDatabases
+      );
+      MessageFormatter.info(
+        `Transferring documents for ${sourceCollections.length} collections in database ${dbId}`,
+        { prefix: "Transfer" }
+      );
 
       // Process each collection
       for (const collection of sourceCollections) {
-        MessageFormatter.info(`Transferring documents for collection: ${collection.name} (${collection.$id})`, { prefix: "Transfer" });
+        MessageFormatter.info(
+          `Transferring documents for collection: ${collection.name} (${collection.$id})`,
+          { prefix: "Transfer" }
+        );
 
         try {
           // Transfer documents
@@ -479,20 +657,33 @@ export class ComprehensiveTransfer {
             collection.$id,
             collection.$id
           );
-          
-          MessageFormatter.success(`Documents transferred for collection ${collection.name}`, { prefix: "Transfer" });
+
+          MessageFormatter.success(
+            `Documents transferred for collection ${collection.name}`,
+            { prefix: "Transfer" }
+          );
         } catch (error) {
-          MessageFormatter.error(`Error transferring documents for collection ${collection.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+          MessageFormatter.error(
+            `Error transferring documents for collection ${collection.name}`,
+            error instanceof Error ? error : new Error(String(error)),
+            { prefix: "Transfer" }
+          );
         }
       }
     } catch (error) {
-      MessageFormatter.error(`Failed to transfer documents for database ${dbId}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+      MessageFormatter.error(
+        `Failed to transfer documents for database ${dbId}`,
+        error instanceof Error ? error : new Error(String(error)),
+        { prefix: "Transfer" }
+      );
       throw error;
     }
   }
 
   private async transferAllBuckets(): Promise<void> {
-    MessageFormatter.info("Starting bucket transfer phase", { prefix: "Transfer" });
+    MessageFormatter.info("Starting bucket transfer phase", {
+      prefix: "Transfer",
+    });
 
     try {
       // Get all buckets from source with pagination
@@ -502,38 +693,52 @@ export class ComprehensiveTransfer {
       if (this.options.dryRun) {
         let totalFiles = 0;
         for (const bucket of allSourceBuckets) {
-          const files = await this.sourceStorage.listFiles(bucket.$id, [Query.limit(1)]);
+          const files = await this.sourceStorage.listFiles(bucket.$id, [
+            Query.limit(1),
+          ]);
           totalFiles += files.total;
         }
-        MessageFormatter.info(`DRY RUN: Would transfer ${allSourceBuckets.length} buckets with ${totalFiles} files`, { prefix: "Transfer" });
+        MessageFormatter.info(
+          `DRY RUN: Would transfer ${allSourceBuckets.length} buckets with ${totalFiles} files`,
+          { prefix: "Transfer" }
+        );
         return;
       }
 
-      const transferTasks = allSourceBuckets.map(bucket => 
+      const transferTasks = allSourceBuckets.map((bucket) =>
         this.limit(async () => {
           try {
             // Check if bucket exists in target
-            const existingBucket = allTargetBuckets.find(tb => tb.$id === bucket.$id);
-            
+            const existingBucket = allTargetBuckets.find(
+              (tb) => tb.$id === bucket.$id
+            );
+
             if (!existingBucket) {
               // Create bucket with fallback strategy for maximumFileSize
               await this.createBucketWithFallback(bucket);
-              MessageFormatter.success(`Created bucket: ${bucket.name}`, { prefix: "Transfer" });
+              MessageFormatter.success(`Created bucket: ${bucket.name}`, {
+                prefix: "Transfer",
+              });
             } else {
               // Compare bucket permissions and update if needed
-              const sourcePermissions = JSON.stringify(bucket.$permissions?.sort() || []);
-              const targetPermissions = JSON.stringify(existingBucket.$permissions?.sort() || []);
-              
-              if (sourcePermissions !== targetPermissions ||
-                  existingBucket.name !== bucket.name ||
-                  existingBucket.fileSecurity !== bucket.fileSecurity ||
-                  existingBucket.enabled !== bucket.enabled) {
-                
+              const sourcePermissions = JSON.stringify(
+                bucket.$permissions?.sort() || []
+              );
+              const targetPermissions = JSON.stringify(
+                existingBucket.$permissions?.sort() || []
+              );
+
+              if (
+                sourcePermissions !== targetPermissions ||
+                existingBucket.name !== bucket.name ||
+                existingBucket.fileSecurity !== bucket.fileSecurity ||
+                existingBucket.enabled !== bucket.enabled
+              ) {
                 MessageFormatter.warning(
-                  `Bucket ${bucket.name} exists but has different settings. Updating to match source.`, 
+                  `Bucket ${bucket.name} exists but has different settings. Updating to match source.`,
                   { prefix: "Transfer" }
                 );
-                
+
                 try {
                   await this.targetStorage.updateBucket(
                     bucket.$id,
@@ -547,16 +752,24 @@ export class ComprehensiveTransfer {
                     bucket.encryption,
                     bucket.antivirus
                   );
-                  MessageFormatter.success(`Updated bucket ${bucket.name} to match source`, { prefix: "Transfer" });
+                  MessageFormatter.success(
+                    `Updated bucket ${bucket.name} to match source`,
+                    { prefix: "Transfer" }
+                  );
                 } catch (updateError) {
                   MessageFormatter.error(
-                    `Failed to update bucket ${bucket.name}`, 
-                    updateError instanceof Error ? updateError : new Error(String(updateError)), 
+                    `Failed to update bucket ${bucket.name}`,
+                    updateError instanceof Error
+                      ? updateError
+                      : new Error(String(updateError)),
                     { prefix: "Transfer" }
                   );
                 }
               } else {
-                MessageFormatter.info(`Bucket ${bucket.name} already exists with matching settings`, { prefix: "Transfer" });
+                MessageFormatter.info(
+                  `Bucket ${bucket.name} already exists with matching settings`,
+                  { prefix: "Transfer" }
+                );
               }
             }
 
@@ -564,31 +777,46 @@ export class ComprehensiveTransfer {
             await this.transferBucketFiles(bucket.$id, bucket.$id);
 
             this.results.buckets.transferred++;
-            MessageFormatter.success(`Bucket ${bucket.name} transferred successfully`, { prefix: "Transfer" });
+            MessageFormatter.success(
+              `Bucket ${bucket.name} transferred successfully`,
+              { prefix: "Transfer" }
+            );
           } catch (error) {
-            MessageFormatter.error(`Bucket ${bucket.name} transfer failed`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            MessageFormatter.error(
+              `Bucket ${bucket.name} transfer failed`,
+              error instanceof Error ? error : new Error(String(error)),
+              { prefix: "Transfer" }
+            );
             this.results.buckets.failed++;
           }
         })
       );
 
       await Promise.all(transferTasks);
-      MessageFormatter.success("Bucket transfer phase completed", { prefix: "Transfer" });
+      MessageFormatter.success("Bucket transfer phase completed", {
+        prefix: "Transfer",
+      });
     } catch (error) {
-      MessageFormatter.error("Bucket transfer phase failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+      MessageFormatter.error(
+        "Bucket transfer phase failed",
+        error instanceof Error ? error : new Error(String(error)),
+        { prefix: "Transfer" }
+      );
     }
   }
 
   private async createBucketWithFallback(bucket: Models.Bucket): Promise<void> {
     // Determine the optimal size to try first
     let sizeToTry: number;
-    
+
     if (this.cachedMaxFileSize) {
       // Use cached size if it's smaller than or equal to the bucket's original size
       if (bucket.maximumFileSize >= this.cachedMaxFileSize) {
         sizeToTry = this.cachedMaxFileSize;
         MessageFormatter.info(
-          `Bucket ${bucket.name}: Using cached maximumFileSize ${sizeToTry} (${(sizeToTry / 1_000_000_000).toFixed(1)}GB)`,
+          `Bucket ${bucket.name}: Using cached maximumFileSize ${sizeToTry} (${(
+            sizeToTry / 1_000_000_000
+          ).toFixed(1)}GB)`,
           { prefix: "Transfer" }
         );
       } else {
@@ -614,30 +842,41 @@ export class ComprehensiveTransfer {
         bucket.encryption,
         bucket.antivirus
       );
-      
+
       // Success - cache this size if it's not already cached or is smaller than cached
       if (!this.cachedMaxFileSize || sizeToTry < this.cachedMaxFileSize) {
         this.cachedMaxFileSize = sizeToTry;
         MessageFormatter.info(
-          `Bucket ${bucket.name}: Cached successful maximumFileSize ${sizeToTry} (${(sizeToTry / 1_000_000_000).toFixed(1)}GB)`,
+          `Bucket ${
+            bucket.name
+          }: Cached successful maximumFileSize ${sizeToTry} (${(
+            sizeToTry / 1_000_000_000
+          ).toFixed(1)}GB)`,
           { prefix: "Transfer" }
         );
       }
-      
+
       // Log if we used a different size than original
       if (sizeToTry !== bucket.maximumFileSize) {
         MessageFormatter.warning(
-          `Bucket ${bucket.name}: maximumFileSize used ${sizeToTry} instead of original ${bucket.maximumFileSize} (${(sizeToTry / 1_000_000_000).toFixed(1)}GB)`,
+          `Bucket ${
+            bucket.name
+          }: maximumFileSize used ${sizeToTry} instead of original ${
+            bucket.maximumFileSize
+          } (${(sizeToTry / 1_000_000_000).toFixed(1)}GB)`,
           { prefix: "Transfer" }
         );
       }
-      
+
       return; // Success, exit the function
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
-      
+
       // Check if the error is related to maximumFileSize validation
-      if (err.message.includes('maximumFileSize') || err.message.includes('valid range')) {
+      if (
+        err.message.includes("maximumFileSize") ||
+        err.message.includes("valid range")
+      ) {
         MessageFormatter.warning(
           `Bucket ${bucket.name}: Failed with maximumFileSize ${sizeToTry}, falling back to smaller sizes...`,
           { prefix: "Transfer" }
@@ -655,17 +894,17 @@ export class ComprehensiveTransfer {
       2_500_000_000, // 2.5GB
       2_000_000_000, // 2GB
       1_000_000_000, // 1GB
-      500_000_000,   // 500MB
-      100_000_000    // 100MB
+      500_000_000, // 500MB
+      100_000_000, // 100MB
     ];
 
     // Remove sizes that are larger than or equal to the already-tried size
     const validSizes = fallbackSizes
-      .filter(size => size < sizeToTry)
+      .filter((size) => size < sizeToTry)
       .sort((a, b) => b - a); // Sort descending
 
     let lastError: Error | null = null;
-    
+
     for (const fileSize of validSizes) {
       try {
         await this.targetStorage.createBucket(
@@ -680,30 +919,39 @@ export class ComprehensiveTransfer {
           bucket.encryption,
           bucket.antivirus
         );
-        
+
         // Success - cache this size if it's not already cached or is smaller than cached
         if (!this.cachedMaxFileSize || fileSize < this.cachedMaxFileSize) {
           this.cachedMaxFileSize = fileSize;
           MessageFormatter.info(
-            `Bucket ${bucket.name}: Cached successful maximumFileSize ${fileSize} (${(fileSize / 1_000_000_000).toFixed(1)}GB)`,
+            `Bucket ${
+              bucket.name
+            }: Cached successful maximumFileSize ${fileSize} (${(
+              fileSize / 1_000_000_000
+            ).toFixed(1)}GB)`,
             { prefix: "Transfer" }
           );
         }
-        
+
         // Log if we had to reduce the file size
         if (fileSize !== bucket.maximumFileSize) {
           MessageFormatter.warning(
-            `Bucket ${bucket.name}: maximumFileSize reduced from ${bucket.maximumFileSize} to ${fileSize} (${(fileSize / 1_000_000_000).toFixed(1)}GB)`,
+            `Bucket ${bucket.name}: maximumFileSize reduced from ${
+              bucket.maximumFileSize
+            } to ${fileSize} (${(fileSize / 1_000_000_000).toFixed(1)}GB)`,
             { prefix: "Transfer" }
           );
         }
-        
+
         return; // Success, exit the function
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
-        
+
         // Check if the error is related to maximumFileSize validation
-        if (lastError.message.includes('maximumFileSize') || lastError.message.includes('valid range')) {
+        if (
+          lastError.message.includes("maximumFileSize") ||
+          lastError.message.includes("valid range")
+        ) {
           MessageFormatter.warning(
             `Bucket ${bucket.name}: Failed with maximumFileSize ${fileSize}, trying smaller size...`,
             { prefix: "Transfer" }
@@ -715,17 +963,20 @@ export class ComprehensiveTransfer {
         }
       }
     }
-    
+
     // If we get here, all fallback sizes failed
     MessageFormatter.error(
       `Bucket ${bucket.name}: All fallback file sizes failed. Last error: ${lastError?.message}`,
       lastError || undefined,
       { prefix: "Transfer" }
     );
-    throw lastError || new Error('All fallback file sizes failed');
+    throw lastError || new Error("All fallback file sizes failed");
   }
 
-  private async transferBucketFiles(sourceBucketId: string, targetBucketId: string): Promise<void> {
+  private async transferBucketFiles(
+    sourceBucketId: string,
+    targetBucketId: string
+  ): Promise<void> {
     let lastFileId: string | undefined;
     let transferredFiles = 0;
 
@@ -739,24 +990,31 @@ export class ComprehensiveTransfer {
       if (files.files.length === 0) break;
 
       // Process files with rate limiting
-      const fileTasks = files.files.map(file => 
+      const fileTasks = files.files.map((file) =>
         this.fileLimit(async () => {
           try {
             // Check if file already exists and compare permissions
             let existingFile: Models.File | null = null;
             try {
-              existingFile = await this.targetStorage.getFile(targetBucketId, file.$id);
-              
+              existingFile = await this.targetStorage.getFile(
+                targetBucketId,
+                file.$id
+              );
+
               // Compare permissions between source and target file
-              const sourcePermissions = JSON.stringify(file.$permissions?.sort() || []);
-              const targetPermissions = JSON.stringify(existingFile.$permissions?.sort() || []);
-              
+              const sourcePermissions = JSON.stringify(
+                file.$permissions?.sort() || []
+              );
+              const targetPermissions = JSON.stringify(
+                existingFile.$permissions?.sort() || []
+              );
+
               if (sourcePermissions !== targetPermissions) {
                 MessageFormatter.warning(
-                  `File ${file.name} (${file.$id}) exists but has different permissions. Source: ${sourcePermissions}, Target: ${targetPermissions}`, 
+                  `File ${file.name} (${file.$id}) exists but has different permissions. Source: ${sourcePermissions}, Target: ${targetPermissions}`,
                   { prefix: "Transfer" }
                 );
-                
+
                 // Update file permissions to match source
                 try {
                   await this.targetStorage.updateFile(
@@ -765,16 +1023,24 @@ export class ComprehensiveTransfer {
                     file.name,
                     file.$permissions
                   );
-                  MessageFormatter.success(`Updated file ${file.name} permissions to match source`, { prefix: "Transfer" });
+                  MessageFormatter.success(
+                    `Updated file ${file.name} permissions to match source`,
+                    { prefix: "Transfer" }
+                  );
                 } catch (updateError) {
                   MessageFormatter.error(
-                    `Failed to update permissions for file ${file.name}`, 
-                    updateError instanceof Error ? updateError : new Error(String(updateError)), 
+                    `Failed to update permissions for file ${file.name}`,
+                    updateError instanceof Error
+                      ? updateError
+                      : new Error(String(updateError)),
                     { prefix: "Transfer" }
                   );
                 }
               } else {
-                MessageFormatter.info(`File ${file.name} already exists with matching permissions, skipping`, { prefix: "Transfer" });
+                MessageFormatter.info(
+                  `File ${file.name} already exists with matching permissions, skipping`,
+                  { prefix: "Transfer" }
+                );
               }
               return;
             } catch (error) {
@@ -782,9 +1048,15 @@ export class ComprehensiveTransfer {
             }
 
             // Download file with validation
-            const fileData = await this.validateAndDownloadFile(sourceBucketId, file.$id);
+            const fileData = await this.validateAndDownloadFile(
+              sourceBucketId,
+              file.$id
+            );
             if (!fileData) {
-              MessageFormatter.warning(`File ${file.name} failed validation, skipping`, { prefix: "Transfer" });
+              MessageFormatter.warning(
+                `File ${file.name} failed validation, skipping`,
+                { prefix: "Transfer" }
+              );
               return;
             }
 
@@ -802,9 +1074,15 @@ export class ComprehensiveTransfer {
             );
 
             transferredFiles++;
-            MessageFormatter.success(`Transferred file: ${file.name}`, { prefix: "Transfer" });
+            MessageFormatter.success(`Transferred file: ${file.name}`, {
+              prefix: "Transfer",
+            });
           } catch (error) {
-            MessageFormatter.error(`Failed to transfer file ${file.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            MessageFormatter.error(
+              `Failed to transfer file ${file.name}`,
+              error instanceof Error ? error : new Error(String(error)),
+              { prefix: "Transfer" }
+            );
           }
         })
       );
@@ -815,61 +1093,99 @@ export class ComprehensiveTransfer {
       lastFileId = files.files[files.files.length - 1].$id;
     }
 
-    MessageFormatter.info(`Transferred ${transferredFiles} files from bucket ${sourceBucketId}`, { prefix: "Transfer" });
+    MessageFormatter.info(
+      `Transferred ${transferredFiles} files from bucket ${sourceBucketId}`,
+      { prefix: "Transfer" }
+    );
   }
 
-  private async validateAndDownloadFile(bucketId: string, fileId: string): Promise<ArrayBuffer | null> {
+  private async validateAndDownloadFile(
+    bucketId: string,
+    fileId: string
+  ): Promise<ArrayBuffer | null> {
     let attempts = 3;
     while (attempts > 0) {
       try {
-        const fileData = await this.sourceStorage.getFileDownload(bucketId, fileId);
-        
+        const fileData = await this.sourceStorage.getFileDownload(
+          bucketId,
+          fileId
+        );
+
         // Basic validation - ensure file is not empty and not too large
         if (fileData.byteLength === 0) {
-          MessageFormatter.warning(`File ${fileId} is empty`, { prefix: "Transfer" });
+          MessageFormatter.warning(`File ${fileId} is empty`, {
+            prefix: "Transfer",
+          });
           return null;
         }
 
-        if (fileData.byteLength > 50 * 1024 * 1024) { // 50MB limit
-          MessageFormatter.warning(`File ${fileId} is too large (${fileData.byteLength} bytes)`, { prefix: "Transfer" });
+        if (fileData.byteLength > 50 * 1024 * 1024) {
+          // 50MB limit
+          MessageFormatter.warning(
+            `File ${fileId} is too large (${fileData.byteLength} bytes)`,
+            { prefix: "Transfer" }
+          );
           return null;
         }
 
         return fileData;
       } catch (error) {
         attempts--;
-        MessageFormatter.warning(`Error downloading file ${fileId}, attempts left: ${attempts}`, { prefix: "Transfer" });
+        MessageFormatter.warning(
+          `Error downloading file ${fileId}, attempts left: ${attempts}`,
+          { prefix: "Transfer" }
+        );
         if (attempts === 0) {
-          MessageFormatter.error(`Failed to download file ${fileId} after all attempts`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+          MessageFormatter.error(
+            `Failed to download file ${fileId} after all attempts`,
+            error instanceof Error ? error : new Error(String(error)),
+            { prefix: "Transfer" }
+          );
           return null;
         }
         // Wait before retry
-        await new Promise(resolve => setTimeout(resolve, 1000 * (4 - attempts)));
+        await new Promise((resolve) =>
+          setTimeout(resolve, 1000 * (4 - attempts))
+        );
       }
     }
     return null;
   }
 
   private async transferAllFunctions(): Promise<void> {
-    MessageFormatter.info("Starting function transfer phase", { prefix: "Transfer" });
+    MessageFormatter.info("Starting function transfer phase", {
+      prefix: "Transfer",
+    });
 
     try {
-      const sourceFunctions = await listFunctions(this.sourceClient, [Query.limit(1000)]);
-      const targetFunctions = await listFunctions(this.targetClient, [Query.limit(1000)]);
+      const sourceFunctions = await listFunctions(this.sourceClient, [
+        Query.limit(1000),
+      ]);
+      const targetFunctions = await listFunctions(this.targetClient, [
+        Query.limit(1000),
+      ]);
 
       if (this.options.dryRun) {
-        MessageFormatter.info(`DRY RUN: Would transfer ${sourceFunctions.functions.length} functions`, { prefix: "Transfer" });
+        MessageFormatter.info(
+          `DRY RUN: Would transfer ${sourceFunctions.functions.length} functions`,
+          { prefix: "Transfer" }
+        );
         return;
       }
 
-      const transferTasks = sourceFunctions.functions.map(func => 
+      const transferTasks = sourceFunctions.functions.map((func) =>
         this.limit(async () => {
           try {
             // Check if function exists in target
-            const existingFunc = targetFunctions.functions.find(tf => tf.$id === func.$id);
-            
+            const existingFunc = targetFunctions.functions.find(
+              (tf) => tf.$id === func.$id
+            );
+
             if (existingFunc) {
-              MessageFormatter.info(`Function ${func.name} already exists, skipping creation`, { prefix: "Transfer" });
+              MessageFormatter.info(
+                `Function ${func.name} already exists, skipping creation`,
+                { prefix: "Transfer" }
+              );
               this.results.functions.skipped++;
               return;
             }
@@ -877,7 +1193,11 @@ export class ComprehensiveTransfer {
             // Download function from source
             const functionPath = await this.downloadFunction(func);
             if (!functionPath) {
-              MessageFormatter.error(`Failed to download function ${func.name}`, undefined, { prefix: "Transfer" });
+              MessageFormatter.error(
+                `Failed to download function ${func.name}`,
+                undefined,
+                { prefix: "Transfer" }
+              );
               this.results.functions.failed++;
               return;
             }
@@ -904,26 +1224,45 @@ export class ComprehensiveTransfer {
               specification: func.specification as any,
               dirPath: functionPath,
             };
-            
-            await deployLocalFunction(this.targetClient, func.name, functionConfig);
+
+            await deployLocalFunction(
+              this.targetClient,
+              func.name,
+              functionConfig
+            );
 
             this.results.functions.transferred++;
-            MessageFormatter.success(`Function ${func.name} transferred successfully`, { prefix: "Transfer" });
+            MessageFormatter.success(
+              `Function ${func.name} transferred successfully`,
+              { prefix: "Transfer" }
+            );
           } catch (error) {
-            MessageFormatter.error(`Function ${func.name} transfer failed`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            MessageFormatter.error(
+              `Function ${func.name} transfer failed`,
+              error instanceof Error ? error : new Error(String(error)),
+              { prefix: "Transfer" }
+            );
             this.results.functions.failed++;
           }
         })
       );
 
       await Promise.all(transferTasks);
-      MessageFormatter.success("Function transfer phase completed", { prefix: "Transfer" });
+      MessageFormatter.success("Function transfer phase completed", {
+        prefix: "Transfer",
+      });
     } catch (error) {
-      MessageFormatter.error("Function transfer phase failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+      MessageFormatter.error(
+        "Function transfer phase failed",
+        error instanceof Error ? error : new Error(String(error)),
+        { prefix: "Transfer" }
+      );
     }
   }
 
-  private async downloadFunction(func: Models.Function): Promise<string | null> {
+  private async downloadFunction(
+    func: Models.Function
+  ): Promise<string | null> {
     try {
       const { path } = await downloadLatestFunctionDeployment(
         this.sourceClient,
@@ -932,7 +1271,11 @@ export class ComprehensiveTransfer {
       );
       return path;
     } catch (error) {
-      MessageFormatter.error(`Failed to download function ${func.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+      MessageFormatter.error(
+        `Failed to download function ${func.name}`,
+        error instanceof Error ? error : new Error(String(error)),
+        { prefix: "Transfer" }
+      );
       return null;
     }
   }
@@ -940,7 +1283,10 @@ export class ComprehensiveTransfer {
   /**
    * Helper method to fetch all collections from a database
    */
-  private async fetchAllCollections(dbId: string, databases: Databases): Promise<Models.Collection[]> {
+  private async fetchAllCollections(
+    dbId: string,
+    databases: Databases
+  ): Promise<Models.Collection[]> {
     const collections: Models.Collection[] = [];
     let lastId: string | undefined;
 
@@ -950,18 +1296,20 @@ export class ComprehensiveTransfer {
         queries.push(Query.cursorAfter(lastId));
       }
 
-      const result = await tryAwaitWithRetry(async () => databases.listCollections(dbId, queries));
-      
+      const result = await tryAwaitWithRetry(async () =>
+        databases.listCollections(dbId, queries)
+      );
+
       if (result.collections.length === 0) {
         break;
       }
 
       collections.push(...result.collections);
-      
+
       if (result.collections.length < 100) {
         break;
       }
-      
+
       lastId = result.collections[result.collections.length - 1].$id;
     }
 
@@ -981,18 +1329,20 @@ export class ComprehensiveTransfer {
         queries.push(Query.cursorAfter(lastId));
       }
 
-      const result = await tryAwaitWithRetry(async () => storage.listBuckets(queries));
-      
+      const result = await tryAwaitWithRetry(async () =>
+        storage.listBuckets(queries)
+      );
+
       if (result.buckets.length === 0) {
         break;
       }
 
       buckets.push(...result.buckets);
-      
+
       if (result.buckets.length < 100) {
         break;
       }
-      
+
       lastId = result.buckets[result.buckets.length - 1].$id;
     }
 
@@ -1020,7 +1370,7 @@ export class ComprehensiveTransfer {
       twoWay: attr.twoWay,
       twoWayKey: attr.twoWayKey,
       onDelete: attr.onDelete,
-      side: attr.side
+      side: attr.side,
     };
   }
 
@@ -1034,8 +1384,10 @@ export class ComprehensiveTransfer {
     attributes: any[]
   ): Promise<boolean> {
     // Import the enhanced attribute creation function
-    const { createUpdateCollectionAttributesWithStatusCheck } = await import("../collections/attributes.js");
-    
+    const { createUpdateCollectionAttributesWithStatusCheck } = await import(
+      "../collections/attributes.js"
+    );
+
     return await createUpdateCollectionAttributesWithStatusCheck(
       databases,
       dbId,
@@ -1055,8 +1407,10 @@ export class ComprehensiveTransfer {
     indexes: any[]
   ): Promise<boolean> {
     // Import the enhanced index creation function
-    const { createOrUpdateIndexesWithStatusCheck } = await import("../collections/indexes.js");
-    
+    const { createOrUpdateIndexesWithStatusCheck } = await import(
+      "../collections/indexes.js"
+    );
+
     return await createOrUpdateIndexesWithStatusCheck(
       dbId,
       databases,
@@ -1077,7 +1431,10 @@ export class ComprehensiveTransfer {
     sourceCollectionId: string,
     targetCollectionId: string
   ): Promise<void> {
-    MessageFormatter.info(`Transferring documents from ${sourceCollectionId} to ${targetCollectionId} with bulk operations, content comparison, and permission filtering`, { prefix: "Transfer" });
+    MessageFormatter.info(
+      `Transferring documents from ${sourceCollectionId} to ${targetCollectionId} with bulk operations, content comparison, and permission filtering`,
+      { prefix: "Transfer" }
+    );
 
     let lastId: string | undefined;
     let totalTransferred = 0;
@@ -1085,11 +1442,14 @@ export class ComprehensiveTransfer {
     let totalUpdated = 0;
 
     // Check if bulk operations are supported
-    const supportsBulk = this.options.sourceEndpoint.includes('cloud.appwrite.io') || 
-                        this.options.targetEndpoint.includes('cloud.appwrite.io');
-    
+    const supportsBulk =
+      this.options.sourceEndpoint.includes("cloud.appwrite.io") ||
+      this.options.targetEndpoint.includes("cloud.appwrite.io");
+
     if (supportsBulk) {
-      MessageFormatter.info(`Using bulk operations for enhanced performance`, { prefix: "Transfer" });
+      MessageFormatter.info(`Using bulk operations for enhanced performance`, {
+        prefix: "Transfer",
+      });
     }
 
     while (true) {
@@ -1099,7 +1459,7 @@ export class ComprehensiveTransfer {
         queries.push(Query.cursorAfter(lastId));
       }
 
-      const sourceDocuments = await tryAwaitWithRetry(async () => 
+      const sourceDocuments = await tryAwaitWithRetry(async () =>
         sourceDb.listDocuments(sourceDbId, sourceCollectionId, queries)
       );
 
@@ -1107,87 +1467,90 @@ export class ComprehensiveTransfer {
         break;
       }
 
-      MessageFormatter.info(`Processing batch of ${sourceDocuments.documents.length} source documents`, { prefix: "Transfer" });
+      MessageFormatter.info(
+        `Processing batch of ${sourceDocuments.documents.length} source documents`,
+        { prefix: "Transfer" }
+      );
 
       // Extract document IDs from the current batch
-      const sourceDocIds = sourceDocuments.documents.map(doc => doc.$id);
-      
+      const sourceDocIds = sourceDocuments.documents.map((doc) => doc.$id);
+
       // Fetch existing documents from target in a single query
       const existingTargetDocs = await this.fetchTargetDocumentsBatch(
-        targetDb, 
-        targetDbId, 
-        targetCollectionId, 
+        targetDb,
+        targetDbId,
+        targetCollectionId,
         sourceDocIds
       );
 
       // Create a map for quick lookup of existing documents
       const existingDocsMap = new Map<string, Models.Document>();
-      existingTargetDocs.forEach(doc => {
+      existingTargetDocs.forEach((doc) => {
         existingDocsMap.set(doc.$id, doc);
       });
 
       // Filter documents based on existence, content comparison, and permission comparison
       const documentsToTransfer: Models.Document[] = [];
-      const documentsToUpdate: { doc: Models.Document; targetDoc: Models.Document; reason: string }[] = [];
+      const documentsToUpdate: {
+        doc: Models.Document;
+        targetDoc: Models.Document;
+        reason: string;
+      }[] = [];
 
       for (const sourceDoc of sourceDocuments.documents) {
         const existingTargetDoc = existingDocsMap.get(sourceDoc.$id);
-        
+
         if (!existingTargetDoc) {
           // Document doesn't exist in target, needs to be transferred
           documentsToTransfer.push(sourceDoc);
         } else {
           // Document exists, compare both content and permissions
-          const sourcePermissions = JSON.stringify((sourceDoc.$permissions || []).sort());
-          const targetPermissions = JSON.stringify((existingTargetDoc.$permissions || []).sort());
-          const permissionsDiffer = sourcePermissions !== targetPermissions;
-          
+          const sourcePermissions = Array.from(
+            new Set(sourceDoc.$permissions || [])
+          ).sort();
+          const targetPermissions = Array.from(
+            new Set(existingTargetDoc.$permissions || [])
+          ).sort();
+          const permissionsDiffer =
+            sourcePermissions.join(",") !== targetPermissions.join(",") ||
+            sourcePermissions.length !== targetPermissions.length;
+
           // Use objectNeedsUpdate to compare document content (excluding system fields)
-          const contentDiffers = objectNeedsUpdate(existingTargetDoc, sourceDoc);
-          
+          const contentDiffers = objectNeedsUpdate(
+            existingTargetDoc,
+            sourceDoc
+          );
+
           if (contentDiffers && permissionsDiffer) {
             // Both content and permissions differ
-            documentsToUpdate.push({ 
-              doc: sourceDoc, 
-              targetDoc: existingTargetDoc, 
-              reason: "content and permissions differ"
+            documentsToUpdate.push({
+              doc: sourceDoc,
+              targetDoc: existingTargetDoc,
+              reason: "content and permissions differ",
             });
-            MessageFormatter.info(
-              `Document ${sourceDoc.$id} exists but content and permissions differ - will update`, 
-              { prefix: "Transfer" }
-            );
           } else if (contentDiffers) {
             // Only content differs
-            documentsToUpdate.push({ 
-              doc: sourceDoc, 
-              targetDoc: existingTargetDoc, 
-              reason: "content differs"
+            documentsToUpdate.push({
+              doc: sourceDoc,
+              targetDoc: existingTargetDoc,
+              reason: "content differs",
             });
-            MessageFormatter.info(
-              `Document ${sourceDoc.$id} exists but content differs - will update`, 
-              { prefix: "Transfer" }
-            );
           } else if (permissionsDiffer) {
             // Only permissions differ
-            documentsToUpdate.push({ 
-              doc: sourceDoc, 
-              targetDoc: existingTargetDoc, 
-              reason: "permissions differ"
+            documentsToUpdate.push({
+              doc: sourceDoc,
+              targetDoc: existingTargetDoc,
+              reason: "permissions differ",
             });
-            MessageFormatter.info(
-              `Document ${sourceDoc.$id} exists but permissions differ - will update`, 
-              { prefix: "Transfer" }
-            );
           } else {
             // Document exists with identical content AND permissions, skip
             totalSkipped++;
-            MessageFormatter.info(`Document ${sourceDoc.$id} exists with matching content and permissions - skipping`, { prefix: "Transfer" });
           }
         }
       }
 
       MessageFormatter.info(
-        `Batch analysis: ${documentsToTransfer.length} to create, ${documentsToUpdate.length} to update, ${totalSkipped} skipped so far`, 
+        `Batch analysis: ${documentsToTransfer.length} to create, ${documentsToUpdate.length} to update, ${totalSkipped} skipped so far`,
         { prefix: "Transfer" }
       );
 
@@ -1202,7 +1565,6 @@ export class ComprehensiveTransfer {
             documentsToTransfer
           );
           totalTransferred += documentsToTransfer.length;
-          MessageFormatter.success(`Bulk transferred ${documentsToTransfer.length} new documents`, { prefix: "Transfer" });
         } else {
           // Use individual transfers for smaller batches or non-bulk endpoints
           const transferCount = await this.transferDocumentsIndividual(
@@ -1230,11 +1592,12 @@ export class ComprehensiveTransfer {
         break;
       }
 
-      lastId = sourceDocuments.documents[sourceDocuments.documents.length - 1].$id;
+      lastId =
+        sourceDocuments.documents[sourceDocuments.documents.length - 1].$id;
     }
 
     MessageFormatter.info(
-      `Transfer complete: ${totalTransferred} new, ${totalUpdated} updated, ${totalSkipped} skipped from ${sourceCollectionId} to ${targetCollectionId}`, 
+      `Transfer complete: ${totalTransferred} new, ${totalUpdated} updated, ${totalSkipped} skipped from ${sourceCollectionId} to ${targetCollectionId}`,
       { prefix: "Transfer" }
     );
   }
@@ -1249,29 +1612,33 @@ export class ComprehensiveTransfer {
     docIds: string[]
   ): Promise<Models.Document[]> {
     const documents: Models.Document[] = [];
-    
+
     // Split IDs into chunks of 100 for Query.equal limitations
     const idChunks = this.chunkArray(docIds, 100);
-    
+
     for (const chunk of idChunks) {
       try {
-        const result = await tryAwaitWithRetry(async () => 
+        const result = await tryAwaitWithRetry(async () =>
           targetDb.listDocuments(targetDbId, targetCollectionId, [
-            Query.equal('$id', chunk),
-            Query.limit(100)
+            Query.equal("$id", chunk),
+            Query.limit(100),
           ])
         );
         documents.push(...result.documents);
       } catch (error) {
         // If query fails, fall back to individual gets (less efficient but more reliable)
         MessageFormatter.warning(
-          `Batch query failed for ${chunk.length} documents, falling back to individual checks`, 
+          `Batch query failed for ${chunk.length} documents, falling back to individual checks`,
           { prefix: "Transfer" }
         );
-        
+
         for (const docId of chunk) {
           try {
-            const doc = await targetDb.getDocument(targetDbId, targetCollectionId, docId);
+            const doc = await targetDb.getDocument(
+              targetDbId,
+              targetCollectionId,
+              docId
+            );
             documents.push(doc);
           } catch (getError) {
             // Document doesn't exist, which is fine
@@ -1279,7 +1646,7 @@ export class ComprehensiveTransfer {
         }
       }
     }
-    
+
     return documents;
   }
 
@@ -1293,12 +1660,20 @@ export class ComprehensiveTransfer {
     documents: Models.Document[]
   ): Promise<void> {
     // Prepare documents for bulk upsert
-    const preparedDocs = documents.map(doc => {
-      const { $id, $createdAt, $updatedAt, $permissions, $databaseId, $collectionId, ...docData } = doc;
-      return {
+    const preparedDocs = documents.map((doc) => {
+      const {
         $id,
+        $createdAt,
+        $updatedAt,
         $permissions,
+        $databaseId,
+        $collectionId,
         ...docData
+      } = doc;
+      return {
+        $id,
+        $permissions,
+        ...docData,
       };
     });
 
@@ -1308,31 +1683,27 @@ export class ComprehensiveTransfer {
 
     for (const maxBatchSize of batchSizes) {
       const documentBatches = this.chunkArray(preparedDocs, maxBatchSize);
-      
+
       try {
         for (const batch of documentBatches) {
-          MessageFormatter.info(`Bulk upserting ${batch.length} documents...`, { prefix: "Transfer" });
-          
           await this.bulkUpsertDocuments(
             this.targetClient,
             targetDbId,
             targetCollectionId,
             batch
           );
-          
-          MessageFormatter.success(`✅ Bulk upserted ${batch.length} documents`, { prefix: "Transfer" });
-          
-          // Add delay between batches to respect rate limits
-          if (documentBatches.indexOf(batch) < documentBatches.length - 1) {
-            await new Promise(resolve => setTimeout(resolve, 200));
-          }
+
+          MessageFormatter.success(
+            `✅ Bulk upserted ${batch.length} documents`,
+            { prefix: "Transfer" }
+          );
         }
-        
+
         processed = true;
         break; // Success, exit batch size loop
       } catch (error) {
         MessageFormatter.warning(
-          `Bulk upsert with batch size ${maxBatchSize} failed, trying smaller size...`, 
+          `Bulk upsert with batch size ${maxBatchSize} failed, trying smaller size...`,
           { prefix: "Transfer" }
         );
         continue; // Try next smaller batch size
@@ -1341,12 +1712,17 @@ export class ComprehensiveTransfer {
 
     if (!processed) {
       MessageFormatter.warning(
-        `All bulk operations failed, falling back to individual transfers`, 
+        `All bulk operations failed, falling back to individual transfers`,
         { prefix: "Transfer" }
       );
-      
+
       // Fall back to individual transfers
-      await this.transferDocumentsIndividual(targetDb, targetDbId, targetCollectionId, documents);
+      await this.transferDocumentsIndividual(
+        targetDb,
+        targetDbId,
+        targetCollectionId,
+        documents
+      );
     }
   }
 
@@ -1361,24 +1737,30 @@ export class ComprehensiveTransfer {
   ): Promise<any> {
     const apiPath = `/databases/${dbId}/collections/${collectionId}/documents`;
     const url = new URL(client.config.endpoint + apiPath);
-    
+
     const headers = {
-      'Content-Type': 'application/json',
-      'X-Appwrite-Project': client.config.project,
-      'X-Appwrite-Key': client.config.key
+      "Content-Type": "application/json",
+      "X-Appwrite-Project": client.config.project,
+      "X-Appwrite-Key": client.config.key,
     };
-    
+
     const response = await fetch(url.toString(), {
-      method: 'PUT',
+      method: "PUT",
       headers,
-      body: JSON.stringify({ documents })
+      body: JSON.stringify({ documents }),
     });
-    
+
     if (!response.ok) {
-      const errorData: any = await response.json().catch(() => ({ message: 'Unknown error' }));
-      throw new Error(`Bulk upsert failed: ${response.status} - ${errorData.message || 'Unknown error'}`);
+      const errorData: any = await response
+        .json()
+        .catch(() => ({ message: "Unknown error" }));
+      throw new Error(
+        `Bulk upsert failed: ${response.status} - ${
+          errorData.message || "Unknown error"
+        }`
+      );
     }
-    
+
     return await response.json();
   }
 
@@ -1393,11 +1775,19 @@ export class ComprehensiveTransfer {
   ): Promise<number> {
     let successCount = 0;
 
-    const transferTasks = documents.map(doc => 
+    const transferTasks = documents.map((doc) =>
       this.limit(async () => {
         try {
-          const { $id, $createdAt, $updatedAt, $permissions, $databaseId, $collectionId, ...docData } = doc;
-          
+          const {
+            $id,
+            $createdAt,
+            $updatedAt,
+            $permissions,
+            $databaseId,
+            $collectionId,
+            ...docData
+          } = doc;
+
           await tryAwaitWithRetry(async () =>
             targetDb.createDocument(
               targetDbId,
@@ -1409,11 +1799,47 @@ export class ComprehensiveTransfer {
           );
 
           successCount++;
-          MessageFormatter.success(`Transferred document ${doc.$id}`, { prefix: "Transfer" });
         } catch (error) {
+          if (
+            error instanceof AppwriteException &&
+            error.message.includes("already exists")
+          ) {
+            try {
+              // Update it! It's here because it needs an update or a create
+              const {
+                $id,
+                $createdAt,
+                $updatedAt,
+                $permissions,
+                $databaseId,
+                $collectionId,
+                ...docData
+              } = doc;
+              await tryAwaitWithRetry(async () =>
+                targetDb.updateDocument(
+                  targetDbId,
+                  targetCollectionId,
+                  doc.$id,
+                  docData,
+                  doc.$permissions
+                )
+              );
+              successCount++;
+            } catch (updateError) {
+              // just send the error to the formatter
+              MessageFormatter.error(
+                `Failed to transfer document ${doc.$id}`,
+                updateError instanceof Error
+                  ? updateError
+                  : new Error(String(updateError)),
+                { prefix: "Transfer" }
+              );
+            }
+          }
+
           MessageFormatter.error(
-            `Failed to transfer document ${doc.$id}`, 
-            error instanceof Error ? error : new Error(String(error)), 
+            `Failed to transfer document ${doc.$id}`,
+            error instanceof Error ? error : new Error(String(error)),
             { prefix: "Transfer" }
           );
         }
@@ -1431,15 +1857,27 @@ export class ComprehensiveTransfer {
     targetDb: Databases,
     targetDbId: string,
     targetCollectionId: string,
-    documentPairs: { doc: Models.Document; targetDoc: Models.Document; reason: string }[]
+    documentPairs: {
+      doc: Models.Document;
+      targetDoc: Models.Document;
+      reason: string;
+    }[]
   ): Promise<number> {
     let successCount = 0;
 
-    const updateTasks = documentPairs.map(({ doc, targetDoc, reason }) => 
+    const updateTasks = documentPairs.map(({ doc, targetDoc, reason }) =>
       this.limit(async () => {
         try {
-          const { $id, $createdAt, $updatedAt, $permissions, $databaseId, $collectionId, ...docData } = doc;
-          
+          const {
+            $id,
+            $createdAt,
+            $updatedAt,
+            $permissions,
+            $databaseId,
+            $collectionId,
+            ...docData
+          } = doc;
+
           await tryAwaitWithRetry(async () =>
             targetDb.updateDocument(
               targetDbId,
@@ -1451,14 +1889,10 @@ export class ComprehensiveTransfer {
           );
 
           successCount++;
-          MessageFormatter.success(
-            `Updated document ${doc.$id} (${reason}) - permissions: [${targetDoc.$permissions?.join(', ')}] → [${doc.$permissions?.join(', ')}]`, 
-            { prefix: "Transfer" }
-          );
         } catch (error) {
           MessageFormatter.error(
-            `Failed to update document ${doc.$id} (${reason})`, 
-            error instanceof Error ? error : new Error(String(error)), 
+            `Failed to update document ${doc.$id} (${reason})`,
+            error instanceof Error ? error : new Error(String(error)),
             { prefix: "Transfer" }
           );
         }
@@ -1483,7 +1917,9 @@ export class ComprehensiveTransfer {
   /**
    * Helper method to fetch all teams with pagination
    */
-  private async fetchAllTeams(teams: Teams): Promise<Models.Team<Models.Preferences>[]> {
+  private async fetchAllTeams(
+    teams: Teams
+  ): Promise<Models.Team<Models.Preferences>[]> {
     const teamsList: Models.Team<Models.Preferences>[] = [];
     let lastId: string | undefined;
 
@@ -1494,17 +1930,17 @@ export class ComprehensiveTransfer {
       }
 
       const result = await tryAwaitWithRetry(async () => teams.list(queries));
-      
+
       if (result.teams.length === 0) {
         break;
       }
 
       teamsList.push(...result.teams);
-      
+
       if (result.teams.length < 100) {
         break;
       }
-      
+
       lastId = result.teams[result.teams.length - 1].$id;
     }
 
@@ -1514,7 +1950,9 @@ export class ComprehensiveTransfer {
   /**
    * Helper method to fetch all memberships for a team with pagination
    */
-  private async fetchAllMemberships(teamId: string): Promise<Models.Membership[]> {
+  private async fetchAllMemberships(
+    teamId: string
+  ): Promise<Models.Membership[]> {
     const membershipsList: Models.Membership[] = [];
     let lastId: string | undefined;
 
@@ -1524,20 +1962,20 @@ export class ComprehensiveTransfer {
         queries.push(Query.cursorAfter(lastId));
       }
 
-      const result = await tryAwaitWithRetry(async () => 
+      const result = await tryAwaitWithRetry(async () =>
         this.sourceTeams.listMemberships(teamId, queries)
       );
-      
+
       if (result.memberships.length === 0) {
         break;
       }
 
       membershipsList.push(...result.memberships);
-      
+
       if (result.memberships.length < 100) {
         break;
       }
-      
+
       lastId = result.memberships[result.memberships.length - 1].$id;
     }
 
@@ -1548,40 +1986,55 @@ export class ComprehensiveTransfer {
    * Helper method to transfer team memberships
    */
   private async transferTeamMemberships(teamId: string): Promise<void> {
-    MessageFormatter.info(`Transferring memberships for team ${teamId}`, { prefix: "Transfer" });
+    MessageFormatter.info(`Transferring memberships for team ${teamId}`, {
+      prefix: "Transfer",
+    });
 
     try {
       // Fetch all memberships for this team
       const memberships = await this.fetchAllMemberships(teamId);
-      
+
       if (memberships.length === 0) {
-        MessageFormatter.info(`No memberships found for team ${teamId}`, { prefix: "Transfer" });
+        MessageFormatter.info(`No memberships found for team ${teamId}`, {
+          prefix: "Transfer",
+        });
         return;
       }
 
-      MessageFormatter.info(`Found ${memberships.length} memberships for team ${teamId}`, { prefix: "Transfer" });
+      MessageFormatter.info(
+        `Found ${memberships.length} memberships for team ${teamId}`,
+        { prefix: "Transfer" }
+      );
 
       let totalTransferred = 0;
 
       // Transfer memberships with rate limiting
-      const transferTasks = memberships.map(membership => 
-        this.userLimit(async () => { // Use userLimit for team operations (more sensitive)
+      const transferTasks = memberships.map((membership) =>
+        this.userLimit(async () => {
+          // Use userLimit for team operations (more sensitive)
           try {
             // Check if membership already exists and compare roles
             let existingMembership: Models.Membership | null = null;
             try {
-              existingMembership = await this.targetTeams.getMembership(teamId, membership.$id);
-              
+              existingMembership = await this.targetTeams.getMembership(
+                teamId,
+                membership.$id
+              );
+
               // Compare roles between source and target membership
-              const sourceRoles = JSON.stringify(membership.roles?.sort() || []);
-              const targetRoles = JSON.stringify(existingMembership.roles?.sort() || []);
-              
+              const sourceRoles = JSON.stringify(
+                membership.roles?.sort() || []
+              );
+              const targetRoles = JSON.stringify(
+                existingMembership.roles?.sort() || []
+              );
+
               if (sourceRoles !== targetRoles) {
                 MessageFormatter.warning(
-                  `Membership ${membership.$id} exists but has different roles. Source: ${sourceRoles}, Target: ${targetRoles}`, 
+                  `Membership ${membership.$id} exists but has different roles. Source: ${sourceRoles}, Target: ${targetRoles}`,
                   { prefix: "Transfer" }
                 );
-                
+
                 // Update membership roles to match source
                 try {
                   await this.targetTeams.updateMembership(
@@ -1589,16 +2042,24 @@ export class ComprehensiveTransfer {
                     membership.$id,
                     membership.roles
                   );
-                  MessageFormatter.success(`Updated membership ${membership.$id} roles to match source`, { prefix: "Transfer" });
+                  MessageFormatter.success(
+                    `Updated membership ${membership.$id} roles to match source`,
+                    { prefix: "Transfer" }
+                  );
                 } catch (updateError) {
                   MessageFormatter.error(
-                    `Failed to update roles for membership ${membership.$id}`, 
-                    updateError instanceof Error ? updateError : new Error(String(updateError)), 
+                    `Failed to update roles for membership ${membership.$id}`,
+                    updateError instanceof Error
+                      ? updateError
+                      : new Error(String(updateError)),
                     { prefix: "Transfer" }
                   );
                 }
               } else {
-                MessageFormatter.info(`Membership ${membership.$id} already exists with matching roles, skipping`, { prefix: "Transfer" });
+                MessageFormatter.info(
+                  `Membership ${membership.$id} already exists with matching roles, skipping`,
+                  { prefix: "Transfer" }
+                );
               }
               return;
             } catch (error) {
@@ -1610,7 +2071,10 @@ export class ComprehensiveTransfer {
             try {
               userData = await this.targetUsers.get(membership.userId);
             } catch (error) {
-              MessageFormatter.warning(`User ${membership.userId} not found in target, membership ${membership.$id} may fail`, { prefix: "Transfer" });
+              MessageFormatter.warning(
+                `User ${membership.userId} not found in target, membership ${membership.$id} may fail`,
+                { prefix: "Transfer" }
+              );
             }
 
             // Create membership using the comprehensive user data
@@ -1627,38 +2091,87 @@ export class ComprehensiveTransfer {
             );
 
             totalTransferred++;
-            MessageFormatter.success(`Transferred membership ${membership.$id} for user ${userData?.name || membership.userName}`, { prefix: "Transfer" });
+            MessageFormatter.success(
+              `Transferred membership ${membership.$id} for user ${
+                userData?.name || membership.userName
+              }`,
+              { prefix: "Transfer" }
+            );
           } catch (error) {
-            MessageFormatter.error(`Failed to transfer membership ${membership.$id}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            MessageFormatter.error(
+              `Failed to transfer membership ${membership.$id}`,
+              error instanceof Error ? error : new Error(String(error)),
+              { prefix: "Transfer" }
+            );
           }
         })
       );
 
       await Promise.all(transferTasks);
-      MessageFormatter.info(`Transferred ${totalTransferred} memberships for team ${teamId}`, { prefix: "Transfer" });
+      MessageFormatter.info(
+        `Transferred ${totalTransferred} memberships for team ${teamId}`,
+        { prefix: "Transfer" }
+      );
     } catch (error) {
-      MessageFormatter.error(`Failed to transfer memberships for team ${teamId}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+      MessageFormatter.error(
+        `Failed to transfer memberships for team ${teamId}`,
+        error instanceof Error ? error : new Error(String(error)),
+        { prefix: "Transfer" }
+      );
     }
   }
 
   private printSummary(): void {
     const duration = Math.round((Date.now() - this.startTime) / 1000);
-    
-    MessageFormatter.info("=== COMPREHENSIVE TRANSFER SUMMARY ===", { prefix: "Transfer" });
+
+    MessageFormatter.info("=== COMPREHENSIVE TRANSFER SUMMARY ===", {
+      prefix: "Transfer",
+    });
     MessageFormatter.info(`Total Time: ${duration}s`, { prefix: "Transfer" });
-    MessageFormatter.info(`Users: ${this.results.users.transferred} transferred, ${this.results.users.skipped} skipped, ${this.results.users.failed} failed`, { prefix: "Transfer" });
-    MessageFormatter.info(`Teams: ${this.results.teams.transferred} transferred, ${this.results.teams.skipped} skipped, ${this.results.teams.failed} failed`, { prefix: "Transfer" });
-    MessageFormatter.info(`Databases: ${this.results.databases.transferred} transferred, ${this.results.databases.skipped} skipped, ${this.results.databases.failed} failed`, { prefix: "Transfer" });
-    MessageFormatter.info(`Buckets: ${this.results.buckets.transferred} transferred, ${this.results.buckets.skipped} skipped, ${this.results.buckets.failed} failed`, { prefix: "Transfer" });
-    MessageFormatter.info(`Functions: ${this.results.functions.transferred} transferred, ${this.results.functions.skipped} skipped, ${this.results.functions.failed} failed`, { prefix: "Transfer" });
-    
-    const totalTransferred = this.results.users.transferred + this.results.teams.transferred + this.results.databases.transferred + this.results.buckets.transferred + this.results.functions.transferred;
-    const totalFailed = this.results.users.failed + this.results.teams.failed + this.results.databases.failed + this.results.buckets.failed + this.results.functions.failed;
-    
+    MessageFormatter.info(
+      `Users: ${this.results.users.transferred} transferred, ${this.results.users.skipped} skipped, ${this.results.users.failed} failed`,
+      { prefix: "Transfer" }
+    );
+    MessageFormatter.info(
+      `Teams: ${this.results.teams.transferred} transferred, ${this.results.teams.skipped} skipped, ${this.results.teams.failed} failed`,
+      { prefix: "Transfer" }
+    );
+    MessageFormatter.info(
+      `Databases: ${this.results.databases.transferred} transferred, ${this.results.databases.skipped} skipped, ${this.results.databases.failed} failed`,
+      { prefix: "Transfer" }
+    );
+    MessageFormatter.info(
+      `Buckets: ${this.results.buckets.transferred} transferred, ${this.results.buckets.skipped} skipped, ${this.results.buckets.failed} failed`,
+      { prefix: "Transfer" }
+    );
+    MessageFormatter.info(
+      `Functions: ${this.results.functions.transferred} transferred, ${this.results.functions.skipped} skipped, ${this.results.functions.failed} failed`,
+      { prefix: "Transfer" }
+    );
+
+    const totalTransferred =
+      this.results.users.transferred +
+      this.results.teams.transferred +
+      this.results.databases.transferred +
+      this.results.buckets.transferred +
+      this.results.functions.transferred;
+    const totalFailed =
+      this.results.users.failed +
+      this.results.teams.failed +
+      this.results.databases.failed +
+      this.results.buckets.failed +
+      this.results.functions.failed;
+
     if (totalFailed === 0) {
-      MessageFormatter.success(`All ${totalTransferred} items transferred successfully!`, { prefix: "Transfer" });
+      MessageFormatter.success(
+        `All ${totalTransferred} items transferred successfully!`,
+        { prefix: "Transfer" }
+      );
     } else {
-      MessageFormatter.warning(`${totalTransferred} items transferred, ${totalFailed} failed`, { prefix: "Transfer" });
+      MessageFormatter.warning(
+        `${totalTransferred} items transferred, ${totalFailed} failed`,
+        { prefix: "Transfer" }
+      );
     }
   }
-}
+}