appwrite-utils-cli 1.1.0 → 1.1.2

package/dist/collections/attributes.js

@@ -164,16 +164,38 @@ export const createOrUpdateAttributeWithStatusCheck = async (db, dbId, collectio
         if (success) {
             return true;
         }
-        // If not successful and we have retries left, delete collection and try again
+        // If not successful and we have retries left, delete specific attribute and try again
         if (retryCount < maxRetries) {
-            console.log(chalk.yellow(`Attribute '${attribute.key}' failed/stuck, retrying...`));
-            // Get fresh collection data
-            const freshCollection = await db.getCollection(dbId, collection.$id);
-            // Delete and recreate collection
-            const newCollection = await deleteAndRecreateCollection(db, dbId, freshCollection, retryCount + 1);
-            if (newCollection) {
-                // Retry with the new collection
-                return await createOrUpdateAttributeWithStatusCheck(db, dbId, newCollection, attribute, retryCount + 1, maxRetries);
+            console.log(chalk.yellow(`Attribute '${attribute.key}' failed/stuck, deleting and retrying...`));
+            // Try to delete the specific stuck attribute instead of the entire collection
+            try {
+                await db.deleteAttribute(dbId, collection.$id, attribute.key);
+                console.log(chalk.yellow(`Deleted stuck attribute '${attribute.key}', will retry creation`));
+                // Wait a bit before retry
+                await delay(3000);
+                // Get fresh collection data
+                const freshCollection = await db.getCollection(dbId, collection.$id);
+                // Retry with the same collection (attribute should be gone now)
+                return await createOrUpdateAttributeWithStatusCheck(db, dbId, freshCollection, attribute, retryCount + 1, maxRetries);
+            }
+            catch (deleteError) {
+                console.log(chalk.red(`Failed to delete stuck attribute '${attribute.key}': ${deleteError}`));
+                // If attribute deletion fails, only then try collection recreation as last resort
+                if (retryCount >= maxRetries - 1) {
+                    console.log(chalk.yellow(`Last resort: Recreating collection for attribute '${attribute.key}'`));
+                    // Get fresh collection data
+                    const freshCollection = await db.getCollection(dbId, collection.$id);
+                    // Delete and recreate collection
+                    const newCollection = await deleteAndRecreateCollection(db, dbId, freshCollection, retryCount + 1);
+                    if (newCollection) {
+                        // Retry with the new collection
+                        return await createOrUpdateAttributeWithStatusCheck(db, dbId, newCollection, attribute, retryCount + 1, maxRetries);
+                    }
+                }
+                else {
+                    // Continue to next retry without collection recreation
+                    return await createOrUpdateAttributeWithStatusCheck(db, dbId, collection, attribute, retryCount + 1, maxRetries);
+                }
             }
         }
         console.log(chalk.red(`❌ Failed to create attribute '${attribute.key}' after ${maxRetries + 1} attempts`));
@@ -437,32 +459,58 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
             await delay(500); // Longer delay for deletions
         }
     }
-    // Create attributes ONE BY ONE with proper status checking
+    // Create attributes ONE BY ONE with proper status checking and persistent retry logic
     console.log(chalk.blue(`Creating ${attributes.length} attributes sequentially with status monitoring...`));
     let currentCollection = collection;
-    const failedAttributes = [];
-    for (const attribute of attributes) {
-        console.log(chalk.blue(`\n--- Processing attribute: ${attribute.key} ---`));
-        const success = await createOrUpdateAttributeWithStatusCheck(db, dbId, currentCollection, attribute);
-        if (success) {
-            console.log(chalk.green(`✅ Successfully created attribute: ${attribute.key}`));
-            // Get updated collection data for next iteration
+    let attributesToProcess = [...attributes];
+    let overallRetryCount = 0;
+    const maxOverallRetries = 3;
+    while (attributesToProcess.length > 0 && overallRetryCount < maxOverallRetries) {
+        const remainingAttributes = [...attributesToProcess];
+        attributesToProcess = []; // Reset for next iteration
+        console.log(chalk.blue(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${remainingAttributes.length} attributes ===`));
+        for (const attribute of remainingAttributes) {
+            console.log(chalk.blue(`\n--- Processing attribute: ${attribute.key} ---`));
+            const success = await createOrUpdateAttributeWithStatusCheck(db, dbId, currentCollection, attribute);
+            if (success) {
+                console.log(chalk.green(`✅ Successfully created attribute: ${attribute.key}`));
+                // Get updated collection data for next iteration
+                try {
+                    currentCollection = await db.getCollection(dbId, collection.$id);
+                }
+                catch (error) {
+                    console.log(chalk.yellow(`Warning: Could not refresh collection data: ${error}`));
+                }
+                // Add delay between successful attributes
+                await delay(1000);
+            }
+            else {
+                console.log(chalk.red(`❌ Failed to create attribute: ${attribute.key}, will retry in next round`));
+                attributesToProcess.push(attribute); // Add back to retry list
+            }
+        }
+        if (attributesToProcess.length === 0) {
+            console.log(chalk.green(`\n✅ Successfully created all ${attributes.length} attributes for collection: ${collection.name}`));
+            return true;
+        }
+        overallRetryCount++;
+        if (overallRetryCount < maxOverallRetries) {
+            console.log(chalk.yellow(`\n⏳ Waiting 5 seconds before retrying ${attributesToProcess.length} failed attributes...`));
+            await delay(5000);
+            // Refresh collection data before retry
             try {
                 currentCollection = await db.getCollection(dbId, collection.$id);
+                console.log(chalk.blue(`Refreshed collection data for retry`));
             }
             catch (error) {
-                console.log(chalk.yellow(`Warning: Could not refresh collection data: ${error}`));
+                console.log(chalk.yellow(`Warning: Could not refresh collection data for retry: ${error}`));
             }
-            // Add delay between successful attributes
-            await delay(1000);
-        }
-        else {
-            console.log(chalk.red(`❌ Failed to create attribute: ${attribute.key}`));
-            failedAttributes.push(attribute.key);
         }
     }
-    if (failedAttributes.length > 0) {
-        console.log(chalk.red(`\n❌ Failed to create ${failedAttributes.length} attributes: ${failedAttributes.join(', ')}`));
+    // If we get here, some attributes still failed after all retries
+    if (attributesToProcess.length > 0) {
+        console.log(chalk.red(`\n❌ Failed to create ${attributesToProcess.length} attributes after ${maxOverallRetries} attempts: ${attributesToProcess.map(a => a.key).join(', ')}`));
+        console.log(chalk.red(`This may indicate a fundamental issue with the attribute definitions or Appwrite instance`));
         return false;
     }
     console.log(chalk.green(`\n✅ Successfully created all ${attributes.length} attributes for collection: ${collection.name}`));

package/dist/collections/indexes.js

@@ -130,22 +130,40 @@ export const createOrUpdateIndexWithStatusCheck = async (dbId, db, collectionId,
  */
 export const createOrUpdateIndexesWithStatusCheck = async (dbId, db, collectionId, collection, indexes) => {
     console.log(chalk.blue(`Creating/updating ${indexes.length} indexes with status monitoring...`));
-    const failedIndexes = [];
-    for (const index of indexes) {
-        console.log(chalk.blue(`\n--- Processing index: ${index.key} ---`));
-        const success = await createOrUpdateIndexWithStatusCheck(dbId, db, collectionId, collection, index);
-        if (success) {
-            console.log(chalk.green(`✅ Successfully created index: ${index.key}`));
-            // Add delay between successful indexes
-            await delay(1000);
+    let indexesToProcess = [...indexes];
+    let overallRetryCount = 0;
+    const maxOverallRetries = 3;
+    while (indexesToProcess.length > 0 && overallRetryCount < maxOverallRetries) {
+        const remainingIndexes = [...indexesToProcess];
+        indexesToProcess = []; // Reset for next iteration
+        console.log(chalk.blue(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${remainingIndexes.length} indexes ===`));
+        for (const index of remainingIndexes) {
+            console.log(chalk.blue(`\n--- Processing index: ${index.key} ---`));
+            const success = await createOrUpdateIndexWithStatusCheck(dbId, db, collectionId, collection, index);
+            if (success) {
+                console.log(chalk.green(`✅ Successfully created index: ${index.key}`));
+                // Add delay between successful indexes
+                await delay(1000);
+            }
+            else {
+                console.log(chalk.red(`❌ Failed to create index: ${index.key}, will retry in next round`));
+                indexesToProcess.push(index); // Add back to retry list
+            }
+        }
+        if (indexesToProcess.length === 0) {
+            console.log(chalk.green(`\n✅ Successfully created all ${indexes.length} indexes`));
+            return true;
         }
-        else {
-            console.log(chalk.red(`❌ Failed to create index: ${index.key}`));
-            failedIndexes.push(index.key);
+        overallRetryCount++;
+        if (overallRetryCount < maxOverallRetries) {
+            console.log(chalk.yellow(`\n⏳ Waiting 5 seconds before retrying ${indexesToProcess.length} failed indexes...`));
+            await delay(5000);
         }
     }
-    if (failedIndexes.length > 0) {
-        console.log(chalk.red(`\n❌ Failed to create ${failedIndexes.length} indexes: ${failedIndexes.join(', ')}`));
+    // If we get here, some indexes still failed after all retries
+    if (indexesToProcess.length > 0) {
+        console.log(chalk.red(`\n❌ Failed to create ${indexesToProcess.length} indexes after ${maxOverallRetries} attempts: ${indexesToProcess.map(i => i.key).join(', ')}`));
+        console.log(chalk.red(`This may indicate a fundamental issue with the index definitions or Appwrite instance`));
         return false;
     }
     console.log(chalk.green(`\n✅ Successfully created all ${indexes.length} indexes`));

package/dist/interactiveCLI.js

@@ -1516,6 +1516,8 @@ export class InteractiveCLI {
     async comprehensiveTransfer() {
         MessageFormatter.info("Starting comprehensive transfer configuration...", { prefix: "Transfer" });
         try {
+            // Initialize controller to optionally load config if available (supports both YAML and TypeScript configs)
+            await this.initControllerIfNeeded();
             // Check if user has an appwrite config for easier setup
             const hasAppwriteConfig = this.controller?.config?.appwriteEndpoint &&
                 this.controller?.config?.appwriteProject &&

package/dist/migrations/comprehensiveTransfer.d.ts

@@ -57,10 +57,38 @@ export declare class ComprehensiveTransfer {
     execute(): Promise<TransferResults>;
     private transferAllUsers;
     private transferAllDatabases;
+    /**
+     * Phase 1: Create database structure (collections, attributes, indexes) without transferring documents
+     */
+    private createDatabaseStructure;
+    /**
+     * Phase 2: Transfer documents to all collections in the database
+     */
+    private transferDatabaseDocuments;
     private transferAllBuckets;
     private transferBucketFiles;
     private validateAndDownloadFile;
     private transferAllFunctions;
     private downloadFunction;
+    /**
+     * Helper method to fetch all collections from a database
+     */
+    private fetchAllCollections;
+    /**
+     * Helper method to parse attribute objects (simplified version of parseAttribute)
+     */
+    private parseAttribute;
+    /**
+     * Helper method to create collection attributes with status checking
+     */
+    private createCollectionAttributesWithStatusCheck;
+    /**
+     * Helper method to create collection indexes with status checking
+     */
+    private createCollectionIndexesWithStatusCheck;
+    /**
+     * Helper method to transfer documents between databases
+     */
+    private transferDocumentsBetweenDatabases;
     private printSummary;
 }

package/dist/migrations/comprehensiveTransfer.js

@@ -1,4 +1,4 @@
-import { converterFunctions, tryAwaitWithRetry } from "appwrite-utils";
+import { converterFunctions, tryAwaitWithRetry, parseAttribute } from "appwrite-utils";
 import { Client, Databases, Storage, Users, Functions, Query, } from "node-appwrite";
 import { InputFile } from "node-appwrite/file";
 import { MessageFormatter } from "../shared/messageFormatter.js";
@@ -132,7 +132,9 @@ export class ComprehensiveTransfer {
                 MessageFormatter.info(`DRY RUN: Would transfer ${sourceDatabases.databases.length} databases`, { prefix: "Transfer" });
                 return;
             }
-            const transferTasks = sourceDatabases.databases.map(db => this.limit(async () => {
+            // 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 () => {
                 try {
                     // Check if database exists in target
                     const existingDb = targetDatabases.databases.find(tdb => tdb.$id === db.$id);
@@ -141,23 +143,132 @@ export class ComprehensiveTransfer {
                         await this.targetDatabases.create(db.$id, db.name, db.enabled);
                         MessageFormatter.success(`Created database: ${db.name}`, { prefix: "Transfer" });
                     }
-                    // Transfer database content
-                    await transferDatabaseLocalToRemote(this.sourceDatabases, this.options.targetEndpoint, this.options.targetProject, this.options.targetKey, db.$id, db.$id);
+                    // Create collections, attributes, and indexes WITHOUT transferring documents
+                    await this.createDatabaseStructure(db.$id);
+                    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" });
+                    this.results.databases.failed++;
+                }
+            }));
+            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 () => {
+                try {
+                    // Transfer documents for this database
+                    await this.transferDatabaseDocuments(db.$id);
                     this.results.databases.transferred++;
-                    MessageFormatter.success(`Database ${db.name} transferred successfully`, { prefix: "Transfer" });
+                    MessageFormatter.success(`Database documents transferred: ${db.name}`, { prefix: "Transfer" });
                 }
                 catch (error) {
-                    MessageFormatter.error(`Database ${db.name} transfer failed`, 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(transferTasks);
+            await Promise.all(documentTransferTasks);
             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" });
         }
     }
+    /**
+     * Phase 1: Create database structure (collections, attributes, indexes) without transferring documents
+     */
+    async createDatabaseStructure(dbId) {
+        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" });
+            // Process each collection
+            for (const collection of sourceCollections) {
+                MessageFormatter.info(`Processing collection: ${collection.name} (${collection.$id})`, { prefix: "Transfer" });
+                try {
+                    // Create or update collection in target
+                    let targetCollection;
+                    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 ||
+                            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" });
+                        }
+                    }
+                    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" });
+                    }
+                    // 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 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" });
+                        // Skip indexes and document transfer if attributes failed
+                        continue;
+                    }
+                    else {
+                        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);
+                    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" });
+                    }
+                    else {
+                        MessageFormatter.success(`All indexes created successfully 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" });
+                }
+            }
+        }
+        catch (error) {
+            MessageFormatter.error(`Failed to create database structure for ${dbId}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            throw error;
+        }
+    }
+    /**
+     * Phase 2: Transfer documents to all collections in the database
+     */
+    async transferDatabaseDocuments(dbId) {
+        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" });
+            // Process each collection
+            for (const collection of sourceCollections) {
+                MessageFormatter.info(`Transferring documents for collection: ${collection.name} (${collection.$id})`, { prefix: "Transfer" });
+                try {
+                    // Transfer documents
+                    await this.transferDocumentsBetweenDatabases(this.sourceDatabases, this.targetDatabases, dbId, dbId, collection.$id, collection.$id);
+                    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" });
+                }
+            }
+        }
+        catch (error) {
+            MessageFormatter.error(`Failed to transfer documents for database ${dbId}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            throw error;
+        }
+    }
     async transferAllBuckets() {
         MessageFormatter.info("Starting bucket transfer phase", { prefix: "Transfer" });
         try {
@@ -346,6 +457,115 @@ export class ComprehensiveTransfer {
             return null;
         }
     }
+    /**
+     * Helper method to fetch all collections from a database
+     */
+    async fetchAllCollections(dbId, databases) {
+        const collections = [];
+        let lastId;
+        while (true) {
+            const queries = [Query.limit(100)];
+            if (lastId) {
+                queries.push(Query.cursorAfter(lastId));
+            }
+            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;
+        }
+        return collections;
+    }
+    /**
+     * Helper method to parse attribute objects (simplified version of parseAttribute)
+     */
+    parseAttribute(attr) {
+        // This is a simplified version - in production you'd use the actual parseAttribute from appwrite-utils
+        return {
+            key: attr.key,
+            type: attr.type,
+            size: attr.size,
+            required: attr.required,
+            array: attr.array,
+            default: attr.default,
+            format: attr.format,
+            elements: attr.elements,
+            min: attr.min,
+            max: attr.max,
+            relatedCollection: attr.relatedCollection,
+            relationType: attr.relationType,
+            twoWay: attr.twoWay,
+            twoWayKey: attr.twoWayKey,
+            onDelete: attr.onDelete,
+            side: attr.side
+        };
+    }
+    /**
+     * Helper method to create collection attributes with status checking
+     */
+    async createCollectionAttributesWithStatusCheck(databases, dbId, collection, attributes) {
+        // Import the enhanced attribute creation function
+        const { createUpdateCollectionAttributesWithStatusCheck } = await import("../collections/attributes.js");
+        return await createUpdateCollectionAttributesWithStatusCheck(databases, dbId, collection, attributes);
+    }
+    /**
+     * Helper method to create collection indexes with status checking
+     */
+    async createCollectionIndexesWithStatusCheck(dbId, databases, collectionId, collection, indexes) {
+        // Import the enhanced index creation function
+        const { createOrUpdateIndexesWithStatusCheck } = await import("../collections/indexes.js");
+        return await createOrUpdateIndexesWithStatusCheck(dbId, databases, collectionId, collection, indexes);
+    }
+    /**
+     * Helper method to transfer documents between databases
+     */
+    async transferDocumentsBetweenDatabases(sourceDb, targetDb, sourceDbId, targetDbId, sourceCollectionId, targetCollectionId) {
+        MessageFormatter.info(`Transferring documents from ${sourceCollectionId} to ${targetCollectionId}`, { prefix: "Transfer" });
+        let lastId;
+        let totalTransferred = 0;
+        while (true) {
+            const queries = [Query.limit(50)]; // Smaller batch size for better performance
+            if (lastId) {
+                queries.push(Query.cursorAfter(lastId));
+            }
+            const documents = await tryAwaitWithRetry(async () => sourceDb.listDocuments(sourceDbId, sourceCollectionId, queries));
+            if (documents.documents.length === 0) {
+                break;
+            }
+            // Transfer documents with rate limiting
+            const transferTasks = documents.documents.map(doc => this.limit(async () => {
+                try {
+                    // Check if document already exists
+                    try {
+                        await targetDb.getDocument(targetDbId, targetCollectionId, doc.$id);
+                        MessageFormatter.info(`Document ${doc.$id} already exists, skipping`, { prefix: "Transfer" });
+                        return;
+                    }
+                    catch (error) {
+                        // Document doesn't exist, proceed with creation
+                    }
+                    // Create document in target
+                    const { $id, $createdAt, $updatedAt, $permissions, $databaseId, $collectionId, ...docData } = doc;
+                    await tryAwaitWithRetry(async () => targetDb.createDocument(targetDbId, targetCollectionId, doc.$id, docData, doc.$permissions));
+                    totalTransferred++;
+                    MessageFormatter.success(`Transferred document ${doc.$id}`, { prefix: "Transfer" });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Failed to transfer document ${doc.$id}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+                }
+            }));
+            await Promise.all(transferTasks);
+            if (documents.documents.length < 50) {
+                break;
+            }
+            lastId = documents.documents[documents.documents.length - 1].$id;
+        }
+        MessageFormatter.info(`Transferred ${totalTransferred} documents from ${sourceCollectionId} to ${targetCollectionId}`, { prefix: "Transfer" });
+    }
     printSummary() {
         const duration = Math.round((Date.now() - this.startTime) / 1000);
         MessageFormatter.info("=== COMPREHENSIVE TRANSFER SUMMARY ===", { prefix: "Transfer" });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/collections/attributes.ts

@@ -263,26 +263,65 @@ export const createOrUpdateAttributeWithStatusCheck = async (
       return true;
     }
     
-    // If not successful and we have retries left, delete collection and try again
+    // If not successful and we have retries left, delete specific attribute and try again
     if (retryCount < maxRetries) {
-      console.log(chalk.yellow(`Attribute '${attribute.key}' failed/stuck, retrying...`));
+      console.log(chalk.yellow(`Attribute '${attribute.key}' failed/stuck, deleting and retrying...`));
       
-      // Get fresh collection data
-      const freshCollection = await db.getCollection(dbId, collection.$id);
-      
-      // Delete and recreate collection
-      const newCollection = await deleteAndRecreateCollection(db, dbId, freshCollection, retryCount + 1);
-      
-      if (newCollection) {
-        // Retry with the new collection
+      // Try to delete the specific stuck attribute instead of the entire collection
+      try {
+        await db.deleteAttribute(dbId, collection.$id, attribute.key);
+        console.log(chalk.yellow(`Deleted stuck attribute '${attribute.key}', will retry creation`));
+        
+        // Wait a bit before retry
+        await delay(3000);
+        
+        // Get fresh collection data
+        const freshCollection = await db.getCollection(dbId, collection.$id);
+        
+        // Retry with the same collection (attribute should be gone now)
         return await createOrUpdateAttributeWithStatusCheck(
           db, 
           dbId, 
-          newCollection, 
+          freshCollection, 
           attribute, 
           retryCount + 1, 
           maxRetries
         );
+      } catch (deleteError) {
+        console.log(chalk.red(`Failed to delete stuck attribute '${attribute.key}': ${deleteError}`));
+        
+        // If attribute deletion fails, only then try collection recreation as last resort
+        if (retryCount >= maxRetries - 1) {
+          console.log(chalk.yellow(`Last resort: Recreating collection for attribute '${attribute.key}'`));
+          
+          // Get fresh collection data
+          const freshCollection = await db.getCollection(dbId, collection.$id);
+          
+          // Delete and recreate collection
+          const newCollection = await deleteAndRecreateCollection(db, dbId, freshCollection, retryCount + 1);
+          
+          if (newCollection) {
+            // Retry with the new collection
+            return await createOrUpdateAttributeWithStatusCheck(
+              db, 
+              dbId, 
+              newCollection, 
+              attribute, 
+              retryCount + 1, 
+              maxRetries
+            );
+          }
+        } else {
+          // Continue to next retry without collection recreation
+          return await createOrUpdateAttributeWithStatusCheck(
+            db, 
+            dbId, 
+            collection, 
+            attribute, 
+            retryCount + 1, 
+            maxRetries
+          );
+        }
       }
     }
     
@@ -810,42 +849,73 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
     }
   }
 
-  // Create attributes ONE BY ONE with proper status checking
+  // Create attributes ONE BY ONE with proper status checking and persistent retry logic
   console.log(chalk.blue(`Creating ${attributes.length} attributes sequentially with status monitoring...`));
   
   let currentCollection = collection;
-  const failedAttributes: string[] = [];
+  let attributesToProcess = [...attributes];
+  let overallRetryCount = 0;
+  const maxOverallRetries = 3;
   
-  for (const attribute of attributes) {
-    console.log(chalk.blue(`\n--- Processing attribute: ${attribute.key} ---`));
+  while (attributesToProcess.length > 0 && overallRetryCount < maxOverallRetries) {
+    const remainingAttributes = [...attributesToProcess];
+    attributesToProcess = []; // Reset for next iteration
     
-    const success = await createOrUpdateAttributeWithStatusCheck(
-      db, 
-      dbId, 
-      currentCollection, 
-      attribute
-    );
+    console.log(chalk.blue(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${remainingAttributes.length} attributes ===`));
     
-    if (success) {
-      console.log(chalk.green(`✅ Successfully created attribute: ${attribute.key}`));
+    for (const attribute of remainingAttributes) {
+      console.log(chalk.blue(`\n--- Processing attribute: ${attribute.key} ---`));
+      
+      const success = await createOrUpdateAttributeWithStatusCheck(
+        db, 
+        dbId, 
+        currentCollection, 
+        attribute
+      );
+      
+      if (success) {
+        console.log(chalk.green(`✅ Successfully created attribute: ${attribute.key}`));
+        
+        // Get updated collection data for next iteration
+        try {
+          currentCollection = await db.getCollection(dbId, collection.$id);
+        } catch (error) {
+          console.log(chalk.yellow(`Warning: Could not refresh collection data: ${error}`));
+        }
+        
+        // Add delay between successful attributes
+        await delay(1000);
+      } else {
+        console.log(chalk.red(`❌ Failed to create attribute: ${attribute.key}, will retry in next round`));
+        attributesToProcess.push(attribute); // Add back to retry list
+      }
+    }
+    
+    if (attributesToProcess.length === 0) {
+      console.log(chalk.green(`\n✅ Successfully created all ${attributes.length} attributes for collection: ${collection.name}`));
+      return true;
+    }
+    
+    overallRetryCount++;
+    
+    if (overallRetryCount < maxOverallRetries) {
+      console.log(chalk.yellow(`\n⏳ Waiting 5 seconds before retrying ${attributesToProcess.length} failed attributes...`));
+      await delay(5000);
       
-      // Get updated collection data for next iteration
+      // Refresh collection data before retry
       try {
         currentCollection = await db.getCollection(dbId, collection.$id);
+        console.log(chalk.blue(`Refreshed collection data for retry`));
       } catch (error) {
-        console.log(chalk.yellow(`Warning: Could not refresh collection data: ${error}`));
+        console.log(chalk.yellow(`Warning: Could not refresh collection data for retry: ${error}`));
       }
-      
-      // Add delay between successful attributes
-      await delay(1000);
-    } else {
-      console.log(chalk.red(`❌ Failed to create attribute: ${attribute.key}`));
-      failedAttributes.push(attribute.key);
     }
   }
   
-  if (failedAttributes.length > 0) {
-    console.log(chalk.red(`\n❌ Failed to create ${failedAttributes.length} attributes: ${failedAttributes.join(', ')}`));
+  // If we get here, some attributes still failed after all retries
+  if (attributesToProcess.length > 0) {
+    console.log(chalk.red(`\n❌ Failed to create ${attributesToProcess.length} attributes after ${maxOverallRetries} attempts: ${attributesToProcess.map(a => a.key).join(', ')}`));
+    console.log(chalk.red(`This may indicate a fundamental issue with the attribute definitions or Appwrite instance`));
     return false;
   }
   

package/src/collections/indexes.ts

@@ -233,32 +233,55 @@ export const createOrUpdateIndexesWithStatusCheck = async (
 ): Promise<boolean> => {
   console.log(chalk.blue(`Creating/updating ${indexes.length} indexes with status monitoring...`));
   
-  const failedIndexes: string[] = [];
+  let indexesToProcess = [...indexes];
+  let overallRetryCount = 0;
+  const maxOverallRetries = 3;
   
-  for (const index of indexes) {
-    console.log(chalk.blue(`\n--- Processing index: ${index.key} ---`));
+  while (indexesToProcess.length > 0 && overallRetryCount < maxOverallRetries) {
+    const remainingIndexes = [...indexesToProcess];
+    indexesToProcess = []; // Reset for next iteration
     
-    const success = await createOrUpdateIndexWithStatusCheck(
-      dbId, 
-      db, 
-      collectionId, 
-      collection, 
-      index
-    );
+    console.log(chalk.blue(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${remainingIndexes.length} indexes ===`));
     
-    if (success) {
-      console.log(chalk.green(`✅ Successfully created index: ${index.key}`));
+    for (const index of remainingIndexes) {
+      console.log(chalk.blue(`\n--- Processing index: ${index.key} ---`));
       
-      // Add delay between successful indexes
-      await delay(1000);
-    } else {
-      console.log(chalk.red(`❌ Failed to create index: ${index.key}`));
-      failedIndexes.push(index.key);
+      const success = await createOrUpdateIndexWithStatusCheck(
+        dbId, 
+        db, 
+        collectionId, 
+        collection, 
+        index
+      );
+      
+      if (success) {
+        console.log(chalk.green(`✅ Successfully created index: ${index.key}`));
+        
+        // Add delay between successful indexes
+        await delay(1000);
+      } else {
+        console.log(chalk.red(`❌ Failed to create index: ${index.key}, will retry in next round`));
+        indexesToProcess.push(index); // Add back to retry list
+      }
+    }
+    
+    if (indexesToProcess.length === 0) {
+      console.log(chalk.green(`\n✅ Successfully created all ${indexes.length} indexes`));
+      return true;
+    }
+    
+    overallRetryCount++;
+    
+    if (overallRetryCount < maxOverallRetries) {
+      console.log(chalk.yellow(`\n⏳ Waiting 5 seconds before retrying ${indexesToProcess.length} failed indexes...`));
+      await delay(5000);
     }
   }
   
-  if (failedIndexes.length > 0) {
-    console.log(chalk.red(`\n❌ Failed to create ${failedIndexes.length} indexes: ${failedIndexes.join(', ')}`));
+  // If we get here, some indexes still failed after all retries
+  if (indexesToProcess.length > 0) {
+    console.log(chalk.red(`\n❌ Failed to create ${indexesToProcess.length} indexes after ${maxOverallRetries} attempts: ${indexesToProcess.map(i => i.key).join(', ')}`));
+    console.log(chalk.red(`This may indicate a fundamental issue with the index definitions or Appwrite instance`));
     return false;
   }
   

package/src/interactiveCLI.ts

@@ -2052,6 +2052,9 @@ export class InteractiveCLI {
     MessageFormatter.info("Starting comprehensive transfer configuration...", { prefix: "Transfer" });
 
     try {
+      // Initialize controller to optionally load config if available (supports both YAML and TypeScript configs)
+      await this.initControllerIfNeeded();
+      
       // Check if user has an appwrite config for easier setup
       const hasAppwriteConfig = this.controller?.config?.appwriteEndpoint && 
                                this.controller?.config?.appwriteProject && 

package/src/migrations/comprehensiveTransfer.ts

@@ -1,4 +1,4 @@
-import { converterFunctions, tryAwaitWithRetry } from "appwrite-utils";
+import { converterFunctions, tryAwaitWithRetry, parseAttribute } from "appwrite-utils";
 import {
   Client,
   Databases,
@@ -204,7 +204,10 @@ export class ComprehensiveTransfer {
         return;
       }
 
-      const transferTasks = sourceDatabases.databases.map(db => 
+      // 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 () => {
           try {
             // Check if database exists in target
@@ -216,32 +219,191 @@ export class ComprehensiveTransfer {
               MessageFormatter.success(`Created database: ${db.name}`, { prefix: "Transfer" });
             }
 
-            // Transfer database content
-            await transferDatabaseLocalToRemote(
-              this.sourceDatabases,
-              this.options.targetEndpoint,
-              this.options.targetProject,
-              this.options.targetKey,
-              db.$id,
-              db.$id
-            );
+            // Create collections, attributes, and indexes WITHOUT transferring documents
+            await this.createDatabaseStructure(db.$id);
+
+            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" });
+            this.results.databases.failed++;
+          }
+        })
+      );
+
+      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 () => {
+          try {
+            // Transfer documents for this database
+            await this.transferDatabaseDocuments(db.$id);
 
             this.results.databases.transferred++;
-            MessageFormatter.success(`Database ${db.name} transferred successfully`, { prefix: "Transfer" });
+            MessageFormatter.success(`Database documents transferred: ${db.name}`, { prefix: "Transfer" });
           } catch (error) {
-            MessageFormatter.error(`Database ${db.name} transfer failed`, 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(transferTasks);
+      await Promise.all(documentTransferTasks);
       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" });
     }
   }
 
+  /**
+   * 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" });
+
+    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" });
+
+      // Process each collection
+      for (const collection of sourceCollections) {
+        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)])
+          );
+
+          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 ||
+              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" });
+            }
+          } 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" });
+          }
+
+          // 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
+          );
+          
+          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" });
+            // Skip indexes and document transfer if attributes failed
+            continue;
+          } else {
+            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
+          );
+          
+          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" });
+          } else {
+            MessageFormatter.success(`All indexes created successfully 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" });
+        }
+      }
+    } catch (error) {
+      MessageFormatter.error(`Failed to create database structure for ${dbId}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+      throw error;
+    }
+  }
+
+  /**
+   * 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" });
+
+    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" });
+
+      // Process each collection
+      for (const collection of sourceCollections) {
+        MessageFormatter.info(`Transferring documents for collection: ${collection.name} (${collection.$id})`, { prefix: "Transfer" });
+
+        try {
+          // Transfer documents
+          await this.transferDocumentsBetweenDatabases(
+            this.sourceDatabases,
+            this.targetDatabases,
+            dbId,
+            dbId,
+            collection.$id,
+            collection.$id
+          );
+          
+          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" });
+        }
+      }
+    } catch (error) {
+      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" });
 
@@ -483,6 +645,180 @@ export class ComprehensiveTransfer {
     }
   }
 
+  /**
+   * Helper method to fetch all collections from a database
+   */
+  private async fetchAllCollections(dbId: string, databases: Databases): Promise<Models.Collection[]> {
+    const collections: Models.Collection[] = [];
+    let lastId: string | undefined;
+
+    while (true) {
+      const queries = [Query.limit(100)];
+      if (lastId) {
+        queries.push(Query.cursorAfter(lastId));
+      }
+
+      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;
+    }
+
+    return collections;
+  }
+
+  /**
+   * Helper method to parse attribute objects (simplified version of parseAttribute)
+   */
+  private parseAttribute(attr: any): any {
+    // This is a simplified version - in production you'd use the actual parseAttribute from appwrite-utils
+    return {
+      key: attr.key,
+      type: attr.type,
+      size: attr.size,
+      required: attr.required,
+      array: attr.array,
+      default: attr.default,
+      format: attr.format,
+      elements: attr.elements,
+      min: attr.min,
+      max: attr.max,
+      relatedCollection: attr.relatedCollection,
+      relationType: attr.relationType,
+      twoWay: attr.twoWay,
+      twoWayKey: attr.twoWayKey,
+      onDelete: attr.onDelete,
+      side: attr.side
+    };
+  }
+
+  /**
+   * Helper method to create collection attributes with status checking
+   */
+  private async createCollectionAttributesWithStatusCheck(
+    databases: Databases,
+    dbId: string,
+    collection: Models.Collection,
+    attributes: any[]
+  ): Promise<boolean> {
+    // Import the enhanced attribute creation function
+    const { createUpdateCollectionAttributesWithStatusCheck } = await import("../collections/attributes.js");
+    
+    return await createUpdateCollectionAttributesWithStatusCheck(
+      databases,
+      dbId,
+      collection,
+      attributes
+    );
+  }
+
+  /**
+   * Helper method to create collection indexes with status checking
+   */
+  private async createCollectionIndexesWithStatusCheck(
+    dbId: string,
+    databases: Databases,
+    collectionId: string,
+    collection: Models.Collection,
+    indexes: any[]
+  ): Promise<boolean> {
+    // Import the enhanced index creation function
+    const { createOrUpdateIndexesWithStatusCheck } = await import("../collections/indexes.js");
+    
+    return await createOrUpdateIndexesWithStatusCheck(
+      dbId,
+      databases,
+      collectionId,
+      collection,
+      indexes
+    );
+  }
+
+  /**
+   * Helper method to transfer documents between databases
+   */
+  private async transferDocumentsBetweenDatabases(
+    sourceDb: Databases,
+    targetDb: Databases,
+    sourceDbId: string,
+    targetDbId: string,
+    sourceCollectionId: string,
+    targetCollectionId: string
+  ): Promise<void> {
+    MessageFormatter.info(`Transferring documents from ${sourceCollectionId} to ${targetCollectionId}`, { prefix: "Transfer" });
+
+    let lastId: string | undefined;
+    let totalTransferred = 0;
+
+    while (true) {
+      const queries = [Query.limit(50)]; // Smaller batch size for better performance
+      if (lastId) {
+        queries.push(Query.cursorAfter(lastId));
+      }
+
+      const documents = await tryAwaitWithRetry(async () => 
+        sourceDb.listDocuments(sourceDbId, sourceCollectionId, queries)
+      );
+
+      if (documents.documents.length === 0) {
+        break;
+      }
+
+      // Transfer documents with rate limiting
+      const transferTasks = documents.documents.map(doc => 
+        this.limit(async () => {
+          try {
+            // Check if document already exists
+            try {
+              await targetDb.getDocument(targetDbId, targetCollectionId, doc.$id);
+              MessageFormatter.info(`Document ${doc.$id} already exists, skipping`, { prefix: "Transfer" });
+              return;
+            } catch (error) {
+              // Document doesn't exist, proceed with creation
+            }
+
+            // Create document in target
+            const { $id, $createdAt, $updatedAt, $permissions, $databaseId, $collectionId, ...docData } = doc;
+            
+            await tryAwaitWithRetry(async () =>
+              targetDb.createDocument(
+                targetDbId,
+                targetCollectionId,
+                doc.$id,
+                docData,
+                doc.$permissions
+              )
+            );
+
+            totalTransferred++;
+            MessageFormatter.success(`Transferred document ${doc.$id}`, { prefix: "Transfer" });
+          } catch (error) {
+            MessageFormatter.error(`Failed to transfer document ${doc.$id}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+          }
+        })
+      );
+
+      await Promise.all(transferTasks);
+
+      if (documents.documents.length < 50) {
+        break;
+      }
+
+      lastId = documents.documents[documents.documents.length - 1].$id;
+    }
+
+    MessageFormatter.info(`Transferred ${totalTransferred} documents from ${sourceCollectionId} to ${targetCollectionId}`, { prefix: "Transfer" });
+  }
+
   private printSummary(): void {
     const duration = Math.round((Date.now() - this.startTime) / 1000);