appwrite-utils-cli 1.2.15 → 1.2.17

package/dist/migrations/comprehensiveTransfer.js

@@ -1,12 +1,12 @@
-import { converterFunctions, tryAwaitWithRetry, parseAttribute, objectNeedsUpdate } from "appwrite-utils";
-import { Client, Databases, Storage, Users, Functions, Teams, Query, } from "node-appwrite";
+import { converterFunctions, tryAwaitWithRetry, parseAttribute, objectNeedsUpdate, } from "appwrite-utils";
+import { Client, Databases, Storage, Users, Functions, Teams, 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, transferDatabaseLocalToRemote, transferStorageLocalToLocal, transferStorageLocalToRemote, transferUsersLocalToRemote } from "./transfer.js";
+import { transferDatabaseLocalToLocal, transferDatabaseLocalToRemote, transferStorageLocalToLocal, transferStorageLocalToRemote, transferUsersLocalToRemote, } from "./transfer.js";
 import { deployLocalFunction } from "../functions/deployments.js";
-import { listFunctions, downloadLatestFunctionDeployment } from "../functions/methods.js";
+import { listFunctions, downloadLatestFunctionDeployment, } from "../functions/methods.js";
 import pLimit from "p-limit";
 import chalk from "chalk";
 import { join } from "node:path";
@@ -66,9 +66,13 @@ export class ComprehensiveTransfer {
     }
     async execute() {
         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;
@@ -111,7 +115,9 @@ export class ComprehensiveTransfer {
         }
     }
     async transferAllUsers() {
-        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" });
@@ -125,7 +131,9 @@ export class ComprehensiveTransfer {
             // 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" });
@@ -133,7 +141,9 @@ export class ComprehensiveTransfer {
         }
     }
     async transferAllTeams() {
-        MessageFormatter.info("Starting team transfer phase", { prefix: "Transfer" });
+        MessageFormatter.info("Starting team transfer phase", {
+            prefix: "Transfer",
+        });
         try {
             // Fetch all teams from source with pagination
             const allSourceTeams = await this.fetchAllTeams(this.sourceTeams);
@@ -141,37 +151,41 @@ 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" });
                 return;
             }
-            const transferTasks = allSourceTeams.map(team => this.limit(async () => {
+            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" });
                         const memberships = await this.fetchAllMemberships(team.$id);
                         // Extract unique roles from all memberships
                         const allRoles = new Set();
-                        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);
-                        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" });
                         // 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",
+                            });
                         }
                     }
                     // Transfer team memberships
@@ -185,14 +199,18 @@ export class ComprehensiveTransfer {
                 }
             }));
             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" });
         }
     }
     async transferAllDatabases() {
-        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();
@@ -202,18 +220,22 @@ export class ComprehensiveTransfer {
             }
             // 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 => this.limit(async () => {
+            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" });
@@ -223,7 +245,7 @@ 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 => this.limit(async () => {
+            const documentTransferTasks = sourceDatabases.databases.map((db) => this.limit(async () => {
                 try {
                     // Transfer documents for this database
                     await this.transferDatabaseDocuments(db.$id);
@@ -236,7 +258,9 @@ export class ComprehensiveTransfer {
                 }
             }));
             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" });
@@ -246,7 +270,9 @@ export class ComprehensiveTransfer {
      * Phase 1: Create database structure (collections, attributes, indexes) without transferring documents
      */
     async createDatabaseStructure(dbId) {
-        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);
@@ -257,14 +283,18 @@ export class ComprehensiveTransfer {
                 try {
                     // Create or update collection in target
                     let targetCollection;
-                    const existingCollection = await tryAwaitWithRetry(async () => this.targetDatabases.listCollections(dbId, [Query.equal("$id", collection.$id)]));
+                    const existingCollection = await tryAwaitWithRetry(async () => 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" });
                         // 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 () => this.targetDatabases.updateCollection(dbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
                             MessageFormatter.success(`Collection ${collection.name} updated`, { prefix: "Transfer" });
@@ -273,11 +303,13 @@ export class ComprehensiveTransfer {
                     else {
                         MessageFormatter.info(`Creating collection ${collection.name} in target database...`, { prefix: "Transfer" });
                         targetCollection = await tryAwaitWithRetry(async () => this.targetDatabases.createCollection(dbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, 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));
+                    const attributesToCreate = collection.attributes.map((attr) => parseAttribute(attr));
                     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" });
@@ -290,7 +322,14 @@ export class ComprehensiveTransfer {
                     }
                     // 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);
+                    let indexesSuccess = true;
+                    // Check if indexes need to be created ahead of time
+                    if (collection.indexes.some((index) => !targetCollection.indexes.some((ti) => ti.key === index.key ||
+                        ti.attributes.sort().join(",") ===
+                            index.attributes.sort().join(","))) ||
+                        collection.indexes.length !== targetCollection.indexes.length) {
+                        indexesSuccess = await this.createCollectionIndexesWithStatusCheck(dbId, this.targetDatabases, targetCollection.$id, targetCollection, collection.indexes);
+                    }
                     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" });
@@ -314,7 +353,9 @@ export class ComprehensiveTransfer {
      * Phase 2: Transfer documents to all collections in the database
      */
     async transferDatabaseDocuments(dbId) {
-        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);
@@ -338,7 +379,9 @@ export class ComprehensiveTransfer {
         }
     }
     async transferAllBuckets() {
-        MessageFormatter.info("Starting bucket transfer phase", { prefix: "Transfer" });
+        MessageFormatter.info("Starting bucket transfer phase", {
+            prefix: "Transfer",
+        });
         try {
             // Get all buckets from source with pagination
             const allSourceBuckets = await this.fetchAllBuckets(this.sourceStorage);
@@ -346,20 +389,24 @@ 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" });
                 return;
             }
-            const transferTasks = allSourceBuckets.map(bucket => this.limit(async () => {
+            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
@@ -375,7 +422,9 @@ export class ComprehensiveTransfer {
                                 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)), { prefix: "Transfer" });
+                                MessageFormatter.error(`Failed to update bucket ${bucket.name}`, updateError instanceof Error
+                                    ? updateError
+                                    : new Error(String(updateError)), { prefix: "Transfer" });
                             }
                         }
                         else {
@@ -393,7 +442,9 @@ export class ComprehensiveTransfer {
                 }
             }));
             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" });
@@ -434,7 +485,8 @@ export class ComprehensiveTransfer {
         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" });
                 // Continue to fallback logic below
             }
@@ -450,11 +502,11 @@ export class ComprehensiveTransfer {
             2_000_000_000, // 2GB
             1_000_000_000, // 1GB
             500_000_000, // 500MB
-            100_000_000 // 100MB
+            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 = null;
         for (const fileSize of validSizes) {
@@ -474,7 +526,8 @@ export class ComprehensiveTransfer {
             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" });
                     continue; // Try next smaller size
                 }
@@ -486,7 +539,7 @@ 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");
     }
     async transferBucketFiles(sourceBucketId, targetBucketId) {
         let lastFileId;
@@ -500,7 +553,7 @@ export class ComprehensiveTransfer {
             if (files.files.length === 0)
                 break;
             // Process files with rate limiting
-            const fileTasks = files.files.map(file => this.fileLimit(async () => {
+            const fileTasks = files.files.map((file) => this.fileLimit(async () => {
                 try {
                     // Check if file already exists and compare permissions
                     let existingFile = null;
@@ -517,7 +570,9 @@ export class ComprehensiveTransfer {
                                 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)), { prefix: "Transfer" });
+                                MessageFormatter.error(`Failed to update permissions for file ${file.name}`, updateError instanceof Error
+                                    ? updateError
+                                    : new Error(String(updateError)), { prefix: "Transfer" });
                             }
                         }
                         else {
@@ -538,7 +593,9 @@ export class ComprehensiveTransfer {
                     const fileToCreate = InputFile.fromBuffer(new Uint8Array(fileData), file.name);
                     await this.targetStorage.createFile(targetBucketId, file.$id, fileToCreate, file.$permissions);
                     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" });
@@ -558,10 +615,13 @@ export class ComprehensiveTransfer {
                 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
+                if (fileData.byteLength > 50 * 1024 * 1024) {
+                    // 50MB limit
                     MessageFormatter.warning(`File ${fileId} is too large (${fileData.byteLength} bytes)`, { prefix: "Transfer" });
                     return null;
                 }
@@ -575,24 +635,30 @@ export class ComprehensiveTransfer {
                     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;
     }
     async transferAllFunctions() {
-        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" });
                 return;
             }
-            const transferTasks = sourceFunctions.functions.map(func => this.limit(async () => {
+            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" });
                         this.results.functions.skipped++;
@@ -637,7 +703,9 @@ export class ComprehensiveTransfer {
                 }
             }));
             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" });
@@ -720,7 +788,7 @@ export class ComprehensiveTransfer {
             twoWay: attr.twoWay,
             twoWayKey: attr.twoWayKey,
             onDelete: attr.onDelete,
-            side: attr.side
+            side: attr.side,
         };
     }
     /**
@@ -749,10 +817,13 @@ export class ComprehensiveTransfer {
         let totalSkipped = 0;
         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 bulkEnabled = false;
+        // Temporarily disable to see if it fixes my permissions issues
+        const supportsBulk = bulkEnabled ? this.options.targetEndpoint.includes("cloud.appwrite.io") : false;
         if (supportsBulk) {
-            MessageFormatter.info(`Using bulk operations for enhanced performance`, { prefix: "Transfer" });
+            MessageFormatter.info(`Using bulk operations for enhanced performance`, {
+                prefix: "Transfer",
+            });
         }
         while (true) {
             // Fetch source documents in larger batches (1000 instead of 50)
@@ -766,12 +837,12 @@ export class ComprehensiveTransfer {
             }
             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, sourceDocIds);
             // Create a map for quick lookup of existing documents
             const existingDocsMap = new Map();
-            existingTargetDocs.forEach(doc => {
+            existingTargetDocs.forEach((doc) => {
                 existingDocsMap.set(doc.$id, doc);
             });
             // Filter documents based on existence, content comparison, and permission comparison
@@ -785,9 +856,10 @@ export class ComprehensiveTransfer {
                 }
                 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);
                     if (contentDiffers && permissionsDiffer) {
@@ -795,32 +867,28 @@ export class ComprehensiveTransfer {
                         documentsToUpdate.push({
                             doc: sourceDoc,
                             targetDoc: existingTargetDoc,
-                            reason: "content and permissions differ"
+                            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"
+                            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"
+                            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" });
                     }
                 }
             }
@@ -831,7 +899,6 @@ export class ComprehensiveTransfer {
                     // Use bulk operations for large batches
                     await this.transferDocumentsBulk(targetDb, targetDbId, targetCollectionId, 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
@@ -847,7 +914,8 @@ export class ComprehensiveTransfer {
             if (sourceDocuments.documents.length < 1000) {
                 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}`, { prefix: "Transfer" });
     }
@@ -861,8 +929,8 @@ export class ComprehensiveTransfer {
         for (const chunk of idChunks) {
             try {
                 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);
             }
@@ -887,12 +955,12 @@ export class ComprehensiveTransfer {
      */
     async transferDocumentsBulk(targetDb, targetDbId, targetCollectionId, documents) {
         // Prepare documents for bulk upsert
-        const preparedDocs = documents.map(doc => {
+        const preparedDocs = documents.map((doc) => {
             const { $id, $createdAt, $updatedAt, $permissions, $databaseId, $collectionId, ...docData } = doc;
             return {
                 $id,
                 $permissions,
-                ...docData
+                ...docData,
             };
         });
         // Process in smaller chunks for bulk operations (1000 for Pro, 100 for Free tier)
@@ -902,13 +970,8 @@ export class ComprehensiveTransfer {
             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));
-                    }
                 }
                 processed = true;
                 break; // Success, exit batch size loop
@@ -931,18 +994,20 @@ export class ComprehensiveTransfer {
         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 = await response.json().catch(() => ({ message: 'Unknown error' }));
-            throw new Error(`Bulk upsert failed: ${response.status} - ${errorData.message || 'Unknown error'}`);
+            const errorData = await response
+                .json()
+                .catch(() => ({ message: "Unknown error" }));
+            throw new Error(`Bulk upsert failed: ${response.status} - ${errorData.message || "Unknown error"}`);
         }
         return await response.json();
     }
@@ -951,14 +1016,28 @@ export class ComprehensiveTransfer {
      */
     async transferDocumentsIndividual(targetDb, targetDbId, targetCollectionId, documents) {
         let successCount = 0;
-        const transferTasks = documents.map(doc => this.limit(async () => {
+        const transferTasks = documents.map((doc) => this.limit(async () => {
             try {
                 const { $id, $createdAt, $updatedAt, $permissions, $databaseId, $collectionId, ...docData } = doc;
                 await tryAwaitWithRetry(async () => targetDb.createDocument(targetDbId, targetCollectionId, doc.$id, docData, doc.$permissions));
                 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)), { prefix: "Transfer" });
             }
         }));
@@ -975,7 +1054,6 @@ export class ComprehensiveTransfer {
                 const { $id, $createdAt, $updatedAt, $permissions, $databaseId, $collectionId, ...docData } = doc;
                 await tryAwaitWithRetry(async () => targetDb.updateDocument(targetDbId, targetCollectionId, doc.$id, docData, doc.$permissions));
                 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)), { prefix: "Transfer" });
@@ -1044,18 +1122,23 @@ export class ComprehensiveTransfer {
      * Helper method to transfer team memberships
      */
     async transferTeamMemberships(teamId) {
-        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" });
             let totalTransferred = 0;
             // Transfer memberships with rate limiting
-            const transferTasks = memberships.map(membership => this.userLimit(async () => {
+            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 = null;
@@ -1072,7 +1155,9 @@ export class ComprehensiveTransfer {
                                 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)), { prefix: "Transfer" });
+                                MessageFormatter.error(`Failed to update roles for membership ${membership.$id}`, updateError instanceof Error
+                                    ? updateError
+                                    : new Error(String(updateError)), { prefix: "Transfer" });
                             }
                         }
                         else {
@@ -1114,15 +1199,25 @@ export class ComprehensiveTransfer {
     }
     printSummary() {
         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;
+        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" });
         }