appwrite-utils-cli 1.0.9 → 1.1.1

package/dist/interactiveCLI.js

@@ -1516,48 +1516,140 @@ export class InteractiveCLI {
     async comprehensiveTransfer() {
         MessageFormatter.info("Starting comprehensive transfer configuration...", { prefix: "Transfer" });
         try {
-            // Get source configuration
-            const sourceConfig = await inquirer.prompt([
-                {
-                    type: "input",
-                    name: "sourceEndpoint",
-                    message: "Enter the source Appwrite endpoint:",
-                    validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
-                },
-                {
-                    type: "input",
-                    name: "sourceProject",
-                    message: "Enter the source project ID:",
-                    validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
-                },
-                {
-                    type: "password",
-                    name: "sourceKey",
-                    message: "Enter the source API key:",
-                    validate: (input) => input.trim() !== "" || "API key cannot be empty",
-                },
-            ]);
-            // Get target configuration
-            const targetConfig = await inquirer.prompt([
-                {
-                    type: "input",
-                    name: "targetEndpoint",
-                    message: "Enter the target Appwrite endpoint:",
-                    validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
-                },
-                {
-                    type: "input",
-                    name: "targetProject",
-                    message: "Enter the target project ID:",
-                    validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
-                },
-                {
-                    type: "password",
-                    name: "targetKey",
-                    message: "Enter the target API key:",
-                    validate: (input) => input.trim() !== "" || "API key cannot be empty",
-                },
-            ]);
+            // Initialize controller to optionally load config if available (supports both YAML and TypeScript configs)\n      await this.initControllerIfNeeded();\n      \n      // Check if user has an appwrite config for easier setup
+            const hasAppwriteConfig = this.controller?.config?.appwriteEndpoint &&
+                this.controller?.config?.appwriteProject &&
+                this.controller?.config?.appwriteKey;
+            let sourceConfig;
+            let targetConfig;
+            if (hasAppwriteConfig) {
+                // Offer to use existing config for source
+                const { useConfigForSource } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "useConfigForSource",
+                        message: "Use your current appwriteConfig as the source?",
+                        default: true,
+                    },
+                ]);
+                if (useConfigForSource) {
+                    sourceConfig = {
+                        sourceEndpoint: this.controller.config.appwriteEndpoint,
+                        sourceProject: this.controller.config.appwriteProject,
+                        sourceKey: this.controller.config.appwriteKey,
+                    };
+                    MessageFormatter.info(`Using config source: ${sourceConfig.sourceEndpoint}`, { prefix: "Transfer" });
+                }
+                else {
+                    // Get source configuration manually
+                    sourceConfig = await inquirer.prompt([
+                        {
+                            type: "input",
+                            name: "sourceEndpoint",
+                            message: "Enter the source Appwrite endpoint:",
+                            validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
+                        },
+                        {
+                            type: "input",
+                            name: "sourceProject",
+                            message: "Enter the source project ID:",
+                            validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
+                        },
+                        {
+                            type: "password",
+                            name: "sourceKey",
+                            message: "Enter the source API key:",
+                            validate: (input) => input.trim() !== "" || "API key cannot be empty",
+                        },
+                    ]);
+                }
+                // Offer to use existing config for target
+                const { useConfigForTarget } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "useConfigForTarget",
+                        message: "Use your current appwriteConfig as the target?",
+                        default: false,
+                    },
+                ]);
+                if (useConfigForTarget) {
+                    targetConfig = {
+                        targetEndpoint: this.controller.config.appwriteEndpoint,
+                        targetProject: this.controller.config.appwriteProject,
+                        targetKey: this.controller.config.appwriteKey,
+                    };
+                    MessageFormatter.info(`Using config target: ${targetConfig.targetEndpoint}`, { prefix: "Transfer" });
+                }
+                else {
+                    // Get target configuration manually
+                    targetConfig = await inquirer.prompt([
+                        {
+                            type: "input",
+                            name: "targetEndpoint",
+                            message: "Enter the target Appwrite endpoint:",
+                            validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
+                        },
+                        {
+                            type: "input",
+                            name: "targetProject",
+                            message: "Enter the target project ID:",
+                            validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
+                        },
+                        {
+                            type: "password",
+                            name: "targetKey",
+                            message: "Enter the target API key:",
+                            validate: (input) => input.trim() !== "" || "API key cannot be empty",
+                        },
+                    ]);
+                }
+            }
+            else {
+                // No appwrite config found, get both configurations manually
+                MessageFormatter.info("No appwriteConfig found, please enter source and target configurations manually", { prefix: "Transfer" });
+                // Get source configuration
+                sourceConfig = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "sourceEndpoint",
+                        message: "Enter the source Appwrite endpoint:",
+                        validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
+                    },
+                    {
+                        type: "input",
+                        name: "sourceProject",
+                        message: "Enter the source project ID:",
+                        validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
+                    },
+                    {
+                        type: "password",
+                        name: "sourceKey",
+                        message: "Enter the source API key:",
+                        validate: (input) => input.trim() !== "" || "API key cannot be empty",
+                    },
+                ]);
+                // Get target configuration
+                targetConfig = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "targetEndpoint",
+                        message: "Enter the target Appwrite endpoint:",
+                        validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
+                    },
+                    {
+                        type: "input",
+                        name: "targetProject",
+                        message: "Enter the target project ID:",
+                        validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
+                    },
+                    {
+                        type: "password",
+                        name: "targetKey",
+                        message: "Enter the target API key:",
+                        validate: (input) => input.trim() !== "" || "API key cannot be empty",
+                    },
+                ]);
+            }
             // Get transfer options
             const transferOptions = await inquirer.prompt([
                 {

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,130 @@ 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" });
+                        // Continue with the transfer even if some attributes failed
+                    }
+                    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" });
+                        // Continue with the transfer even if some indexes failed
+                    }
+                    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 +455,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/dist/migrations/transfer.js

@@ -2,13 +2,13 @@ import { converterFunctions, tryAwaitWithRetry } from "appwrite-utils";
 import { Client, Databases, IndexType, Query, Storage, Users, } from "node-appwrite";
 import { InputFile } from "node-appwrite/file";
 import { getAppwriteClient } from "../utils/helperFunctions.js";
-import { createOrUpdateAttribute, createUpdateCollectionAttributes, } from "../collections/attributes.js";
+import { createOrUpdateAttribute, createUpdateCollectionAttributes, createUpdateCollectionAttributesWithStatusCheck, } from "../collections/attributes.js";
 import { parseAttribute } from "appwrite-utils";
 import chalk from "chalk";
 import { fetchAllCollections } from "../collections/methods.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 import { ProgressManager } from "../shared/progressManager.js";
-import { createOrUpdateIndex, createOrUpdateIndexes, } from "../collections/indexes.js";
+import { createOrUpdateIndex, createOrUpdateIndexes, createOrUpdateIndexesWithStatusCheck, } from "../collections/indexes.js";
 import { getClient } from "../utils/getClientFromConfig.js";
 export const transferStorageLocalToLocal = async (storage, fromBucketId, toBucketId) => {
     MessageFormatter.info(`Transferring files from ${fromBucketId} to ${toBucketId}`, { prefix: "Transfer" });
@@ -161,20 +161,15 @@ export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId
                 console.log(chalk.yellow(`Creating collection ${collection.name} in target database...`));
                 targetCollection = await tryAwaitWithRetry(async () => localDb.createCollection(targetDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
             }
-            // Handle attributes
-            const existingAttributes = await tryAwaitWithRetry(async () => await localDb.listAttributes(targetDbId, targetCollection.$id));
-            for (const attribute of collection.attributes) {
-                const parsedAttribute = parseAttribute(attribute);
-                const existingAttribute = existingAttributes.attributes.find((attr) => attr.key === parsedAttribute.key);
-                if (!existingAttribute) {
-                    await tryAwaitWithRetry(async () => createOrUpdateAttribute(localDb, targetDbId, targetCollection, parsedAttribute));
-                    console.log(chalk.green(`Attribute ${parsedAttribute.key} created`));
-                }
-                else {
-                    console.log(chalk.blue(`Attribute ${parsedAttribute.key} exists, checking for updates...`));
-                    await tryAwaitWithRetry(async () => createOrUpdateAttribute(localDb, targetDbId, targetCollection, parsedAttribute));
-                }
+            // Handle attributes with enhanced status checking
+            console.log(chalk.blue(`Creating attributes for collection ${collection.name} with enhanced monitoring...`));
+            const allAttributes = collection.attributes.map(attr => parseAttribute(attr));
+            const attributeSuccess = await createUpdateCollectionAttributesWithStatusCheck(localDb, targetDbId, targetCollection, allAttributes);
+            if (!attributeSuccess) {
+                console.log(chalk.red(`❌ Failed to create all attributes for collection ${collection.name}, skipping to next collection`));
+                continue;
             }
+            console.log(chalk.green(`✅ All attributes created successfully for collection ${collection.name}`));
             // Handle indexes
             const existingIndexes = await tryAwaitWithRetry(async () => await localDb.listIndexes(targetDbId, targetCollection.$id));
             for (const index of collection.indexes) {
@@ -226,32 +221,26 @@ export const transferDatabaseLocalToRemote = async (localDb, endpoint, projectId
                 console.log(chalk.yellow(`Creating collection ${collection.name} in remote database...`));
                 targetCollection = await tryAwaitWithRetry(async () => remoteDb.createCollection(toDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
             }
-            // Handle attributes
-            const existingAttributes = await tryAwaitWithRetry(async () => await remoteDb.listAttributes(toDbId, targetCollection.$id));
-            for (const attribute of collection.attributes) {
-                const parsedAttribute = parseAttribute(attribute);
-                const existingAttribute = existingAttributes.attributes.find((attr) => attr.key === parsedAttribute.key);
-                if (!existingAttribute) {
-                    await tryAwaitWithRetry(async () => createOrUpdateAttribute(remoteDb, toDbId, targetCollection, parsedAttribute));
-                    console.log(chalk.green(`Attribute ${parsedAttribute.key} created`));
-                }
-                else {
-                    console.log(chalk.blue(`Attribute ${parsedAttribute.key} exists, checking for updates...`));
-                    await tryAwaitWithRetry(async () => createOrUpdateAttribute(remoteDb, toDbId, targetCollection, parsedAttribute));
-                }
+            // Handle attributes with enhanced status checking
+            console.log(chalk.blue(`Creating attributes for collection ${collection.name} with enhanced monitoring...`));
+            const attributesToCreate = collection.attributes.map(attr => parseAttribute(attr));
+            const attributesSuccess = await createUpdateCollectionAttributesWithStatusCheck(remoteDb, toDbId, targetCollection, attributesToCreate);
+            if (!attributesSuccess) {
+                console.log(chalk.red(`Failed to create some attributes for collection ${collection.name}`));
+                // Continue with the transfer even if some attributes failed
             }
-            // Handle indexes
-            const existingIndexes = await tryAwaitWithRetry(async () => await remoteDb.listIndexes(toDbId, targetCollection.$id));
-            for (const index of collection.indexes) {
-                const existingIndex = existingIndexes.indexes.find((idx) => idx.key === index.key);
-                if (!existingIndex) {
-                    await createOrUpdateIndex(toDbId, remoteDb, targetCollection.$id, index);
-                    console.log(chalk.green(`Index ${index.key} created`));
-                }
-                else {
-                    console.log(chalk.blue(`Index ${index.key} exists, checking for updates...`));
-                    await createOrUpdateIndex(toDbId, remoteDb, targetCollection.$id, index);
-                }
+            else {
+                console.log(chalk.green(`All attributes created successfully for collection ${collection.name}`));
+            }
+            // Handle indexes with enhanced status checking
+            console.log(chalk.blue(`Creating indexes for collection ${collection.name} with enhanced monitoring...`));
+            const indexesSuccess = await createOrUpdateIndexesWithStatusCheck(toDbId, remoteDb, targetCollection.$id, targetCollection, collection.indexes);
+            if (!indexesSuccess) {
+                console.log(chalk.red(`Failed to create some indexes for collection ${collection.name}`));
+                // Continue with the transfer even if some indexes failed
+            }
+            else {
+                console.log(chalk.green(`All indexes created successfully for collection ${collection.name}`));
             }
             // Transfer documents
             const { transferDocumentsBetweenDbsLocalToRemote } = await import("../collections/methods.js");

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.0.9",
+  "version": "1.1.1",
   "main": "src/main.ts",
   "type": "module",
   "repository": {