appwrite-utils-cli 1.0.8 → 1.1.0

package/dist/collections/methods.js

@@ -7,6 +7,7 @@ import { isNull, isUndefined, isNil, isPlainObject, isString, isJSONValue, chunk
 import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 import { ProgressManager } from "../shared/progressManager.js";
+import chalk from "chalk";
 export const documentExists = async (db, dbId, targetCollectionId, toCreateObject) => {
     const collection = await db.getCollection(dbId, targetCollectionId);
     const attributes = collection.attributes;
@@ -380,69 +381,120 @@ export const transferDocumentsBetweenDbsLocalToLocal = async (db, fromDbId, toDb
     }
     MessageFormatter.success(`Transferred ${totalDocumentsTransferred} documents from database ${fromDbId} to database ${toDbId} -- collection ${fromCollId} to collection ${toCollId}`, { prefix: "Transfer" });
 };
+/**
+ * Enhanced document transfer with fault tolerance and exponential backoff
+ */
+const transferDocumentWithRetry = async (db, dbId, collectionId, documentId, documentData, permissions, maxRetries = 3, retryCount = 0) => {
+    try {
+        await db.createDocument(dbId, collectionId, documentId, documentData, permissions);
+        return true;
+    }
+    catch (error) {
+        // Check if document already exists
+        if (error.code === 409 || error.message?.includes('already exists')) {
+            console.log(chalk.yellow(`Document ${documentId} already exists, skipping...`));
+            return true;
+        }
+        if (retryCount < maxRetries) {
+            // Calculate exponential backoff: 1s, 2s, 4s
+            const exponentialDelay = Math.min(1000 * Math.pow(2, retryCount), 8000);
+            console.log(chalk.yellow(`Retrying document ${documentId} (attempt ${retryCount + 1}/${maxRetries}, backoff: ${exponentialDelay}ms)`));
+            await delay(exponentialDelay);
+            return await transferDocumentWithRetry(db, dbId, collectionId, documentId, documentData, permissions, maxRetries, retryCount + 1);
+        }
+        console.log(chalk.red(`Failed to transfer document ${documentId} after ${maxRetries} retries: ${error.message}`));
+        return false;
+    }
+};
+/**
+ * Enhanced batch document transfer with fault tolerance
+ */
+const transferDocumentBatchWithRetry = async (db, dbId, collectionId, documents, batchSize = 10) => {
+    let successful = 0;
+    let failed = 0;
+    // Process documents in smaller batches to avoid overwhelming the server
+    const documentBatches = chunk(documents, batchSize);
+    for (const batch of documentBatches) {
+        console.log(chalk.blue(`Processing batch of ${batch.length} documents...`));
+        const batchPromises = batch.map(async (doc) => {
+            const toCreateObject = { ...doc };
+            delete toCreateObject.$databaseId;
+            delete toCreateObject.$collectionId;
+            delete toCreateObject.$createdAt;
+            delete toCreateObject.$updatedAt;
+            delete toCreateObject.$id;
+            delete toCreateObject.$permissions;
+            const result = await transferDocumentWithRetry(db, dbId, collectionId, doc.$id, toCreateObject, doc.$permissions || []);
+            return { docId: doc.$id, success: result };
+        });
+        const results = await Promise.allSettled(batchPromises);
+        results.forEach((result, index) => {
+            if (result.status === 'fulfilled') {
+                if (result.value.success) {
+                    successful++;
+                }
+                else {
+                    failed++;
+                }
+            }
+            else {
+                console.log(chalk.red(`Batch promise rejected for document ${batch[index].$id}: ${result.reason}`));
+                failed++;
+            }
+        });
+        // Add delay between batches to avoid rate limiting
+        if (documentBatches.indexOf(batch) < documentBatches.length - 1) {
+            await delay(500);
+        }
+    }
+    return { successful, failed };
+};
 export const transferDocumentsBetweenDbsLocalToRemote = async (localDb, endpoint, projectId, apiKey, fromDbId, toDbId, fromCollId, toCollId) => {
+    console.log(chalk.blue(`Starting enhanced document transfer from ${fromCollId} to ${toCollId}...`));
     const client = new Client()
         .setEndpoint(endpoint)
         .setProject(projectId)
         .setKey(apiKey);
-    let totalDocumentsTransferred = 0;
     const remoteDb = new Databases(client);
-    let fromCollDocs = await tryAwaitWithRetry(async () => localDb.listDocuments(fromDbId, fromCollId, [Query.limit(50)]));
-    if (fromCollDocs.documents.length === 0) {
+    let totalDocumentsProcessed = 0;
+    let totalSuccessful = 0;
+    let totalFailed = 0;
+    // Fetch documents in batches
+    let hasMoreDocuments = true;
+    let lastDocumentId;
+    while (hasMoreDocuments) {
+        const queries = [Query.limit(50)];
+        if (lastDocumentId) {
+            queries.push(Query.cursorAfter(lastDocumentId));
+        }
+        const fromCollDocs = await tryAwaitWithRetry(async () => localDb.listDocuments(fromDbId, fromCollId, queries));
+        if (fromCollDocs.documents.length === 0) {
+            hasMoreDocuments = false;
+            break;
+        }
+        console.log(chalk.blue(`Processing ${fromCollDocs.documents.length} documents...`));
+        const { successful, failed } = await transferDocumentBatchWithRetry(remoteDb, toDbId, toCollId, fromCollDocs.documents);
+        totalDocumentsProcessed += fromCollDocs.documents.length;
+        totalSuccessful += successful;
+        totalFailed += failed;
+        // Check if we have more documents to process
+        if (fromCollDocs.documents.length < 50) {
+            hasMoreDocuments = false;
+        }
+        else {
+            lastDocumentId = fromCollDocs.documents[fromCollDocs.documents.length - 1].$id;
+        }
+        console.log(chalk.gray(`Batch complete: ${successful} successful, ${failed} failed`));
+    }
+    if (totalDocumentsProcessed === 0) {
         MessageFormatter.info(`No documents found in collection ${fromCollId}`, { prefix: "Transfer" });
         return;
     }
-    else if (fromCollDocs.documents.length < 50) {
-        const batchedPromises = fromCollDocs.documents.map((doc) => {
-            const toCreateObject = {
-                ...doc,
-            };
-            delete toCreateObject.$databaseId;
-            delete toCreateObject.$collectionId;
-            delete toCreateObject.$createdAt;
-            delete toCreateObject.$updatedAt;
-            delete toCreateObject.$id;
-            delete toCreateObject.$permissions;
-            return tryAwaitWithRetry(async () => remoteDb.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
-        });
-        await Promise.all(batchedPromises);
-        totalDocumentsTransferred += fromCollDocs.documents.length;
+    const message = `Total documents processed: ${totalDocumentsProcessed}, successful: ${totalSuccessful}, failed: ${totalFailed}`;
+    if (totalFailed > 0) {
+        MessageFormatter.warning(message, { prefix: "Transfer" });
     }
     else {
-        const batchedPromises = fromCollDocs.documents.map((doc) => {
-            const toCreateObject = {
-                ...doc,
-            };
-            delete toCreateObject.$databaseId;
-            delete toCreateObject.$collectionId;
-            delete toCreateObject.$createdAt;
-            delete toCreateObject.$updatedAt;
-            delete toCreateObject.$id;
-            delete toCreateObject.$permissions;
-            return tryAwaitWithRetry(async () => remoteDb.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
-        });
-        await Promise.all(batchedPromises);
-        totalDocumentsTransferred += fromCollDocs.documents.length;
-        while (fromCollDocs.documents.length === 50) {
-            fromCollDocs = await tryAwaitWithRetry(async () => localDb.listDocuments(fromDbId, fromCollId, [
-                Query.limit(50),
-                Query.cursorAfter(fromCollDocs.documents[fromCollDocs.documents.length - 1].$id),
-            ]));
-            const batchedPromises = fromCollDocs.documents.map((doc) => {
-                const toCreateObject = {
-                    ...doc,
-                };
-                delete toCreateObject.$databaseId;
-                delete toCreateObject.$collectionId;
-                delete toCreateObject.$createdAt;
-                delete toCreateObject.$updatedAt;
-                delete toCreateObject.$id;
-                delete toCreateObject.$permissions;
-                return tryAwaitWithRetry(async () => remoteDb.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
-            });
-            await Promise.all(batchedPromises);
-            totalDocumentsTransferred += fromCollDocs.documents.length;
-        }
+        MessageFormatter.success(message, { prefix: "Transfer" });
     }
-    MessageFormatter.success(`Total documents transferred from database ${fromDbId} to database ${toDbId} -- collection ${fromCollId} to collection ${toCollId}: ${totalDocumentsTransferred}`, { prefix: "Transfer" });
 };

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",
-                },
-            ]);
+            // 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([
                 {
@@ -1620,16 +1712,18 @@ export class InteractiveCLI {
                 MessageFormatter.info("Transfer cancelled by user", { prefix: "Transfer" });
                 return;
             }
-            // Important password warning
+            // Password preservation information
             if (transferOptions.transferTypes.includes("users") && !transferOptions.dryRun) {
-                MessageFormatter.warning("IMPORTANT: User passwords cannot be transferred due to Appwrite security limitations.", { prefix: "Transfer" });
-                MessageFormatter.warning("Users will need to reset their passwords after transfer.", { prefix: "Transfer" });
+                MessageFormatter.info("User Password Transfer Information:", { prefix: "Transfer" });
+                MessageFormatter.info("✅ Users with hashed passwords (Argon2, Bcrypt, Scrypt, MD5, SHA, PHPass) will preserve their passwords", { prefix: "Transfer" });
+                MessageFormatter.info("⚠️  Users without hash information will receive temporary passwords and need to reset", { prefix: "Transfer" });
+                MessageFormatter.info("🔒 All user data (preferences, labels, verification status) will be preserved", { prefix: "Transfer" });
                 const { continueWithUsers } = await inquirer.prompt([
                     {
                         type: "confirm",
                         name: "continueWithUsers",
-                        message: "Continue with user transfer knowing passwords will be reset?",
-                        default: false,
+                        message: "Continue with user transfer?",
+                        default: true,
                     },
                 ]);
                 if (!continueWithUsers) {
@@ -1665,7 +1759,8 @@ export class InteractiveCLI {
             else {
                 MessageFormatter.success("Comprehensive transfer completed!", { prefix: "Transfer" });
                 if (transferOptions.transferTypes.includes("users") && results.users.transferred > 0) {
-                    MessageFormatter.info("Remember to notify users about password reset requirements", { prefix: "Transfer" });
+                    MessageFormatter.info("Users with preserved password hashes can log in with their original passwords", { prefix: "Transfer" });
+                    MessageFormatter.info("Users with temporary passwords will need to reset their passwords", { 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");
@@ -291,25 +280,94 @@ export const transferUsersLocalToRemote = async (localUsers, endpoint, projectId
                 const phone = user.phone
                     ? converterFunctions.convertPhoneStringToUSInternational(user.phone)
                     : undefined;
-                if (user.hash) {
-                    await tryAwaitWithRetry(async () => remoteUsers.createArgon2User(user.$id, user.email, user.password, // password - cannot transfer hashed passwords
-                    user.name // phone - optional
-                    ));
-                    if (phone) {
-                        await tryAwaitWithRetry(async () => remoteUsers.updatePhone(user.$id, phone));
+                // Handle user creation based on hash type
+                if (user.hash && user.password) {
+                    // User has a hashed password - recreate with proper hash method
+                    const hashType = user.hash.toLowerCase();
+                    const hashedPassword = user.password; // This is already hashed
+                    const hashOptions = user.hashOptions || {};
+                    try {
+                        switch (hashType) {
+                            case 'argon2':
+                                await tryAwaitWithRetry(async () => remoteUsers.createArgon2User(user.$id, user.email, hashedPassword, user.name));
+                                break;
+                            case 'bcrypt':
+                                await tryAwaitWithRetry(async () => remoteUsers.createBcryptUser(user.$id, user.email, hashedPassword, user.name));
+                                break;
+                            case 'scrypt':
+                                // Scrypt requires additional parameters from hashOptions
+                                const salt = typeof hashOptions.salt === 'string' ? hashOptions.salt : '';
+                                const costCpu = typeof hashOptions.costCpu === 'number' ? hashOptions.costCpu : 32768;
+                                const costMemory = typeof hashOptions.costMemory === 'number' ? hashOptions.costMemory : 14;
+                                const costParallel = typeof hashOptions.costParallel === 'number' ? hashOptions.costParallel : 1;
+                                const length = typeof hashOptions.length === 'number' ? hashOptions.length : 64;
+                                // Warn if using default values due to missing hash options
+                                if (!hashOptions.salt || typeof hashOptions.costCpu !== 'number') {
+                                    console.log(chalk.yellow(`User ${user.$id}: Using default Scrypt parameters due to missing hashOptions`));
+                                }
+                                await tryAwaitWithRetry(async () => remoteUsers.createScryptUser(user.$id, user.email, hashedPassword, salt, costCpu, costMemory, costParallel, length, user.name));
+                                break;
+                            case 'scryptmodified':
+                                // Scrypt Modified (Firebase) requires salt, separator, and signer key
+                                const modSalt = typeof hashOptions.salt === 'string' ? hashOptions.salt : '';
+                                const saltSeparator = typeof hashOptions.saltSeparator === 'string' ? hashOptions.saltSeparator : '';
+                                const signerKey = typeof hashOptions.signerKey === 'string' ? hashOptions.signerKey : '';
+                                // Warn if critical parameters are missing
+                                if (!hashOptions.salt || !hashOptions.saltSeparator || !hashOptions.signerKey) {
+                                    console.log(chalk.yellow(`User ${user.$id}: Missing critical Scrypt Modified parameters in hashOptions`));
+                                }
+                                await tryAwaitWithRetry(async () => remoteUsers.createScryptModifiedUser(user.$id, user.email, hashedPassword, modSalt, saltSeparator, signerKey, user.name));
+                                break;
+                            case 'md5':
+                                await tryAwaitWithRetry(async () => remoteUsers.createMD5User(user.$id, user.email, hashedPassword, user.name));
+                                break;
+                            case 'sha':
+                            case 'sha1':
+                            case 'sha256':
+                            case 'sha512':
+                                // SHA variants - determine version from hash type
+                                const getPasswordHashVersion = (hash) => {
+                                    switch (hash.toLowerCase()) {
+                                        case 'sha1': return 'sha1';
+                                        case 'sha256': return 'sha256';
+                                        case 'sha512': return 'sha512';
+                                        default: return 'sha256'; // Default to SHA256
+                                    }
+                                };
+                                await tryAwaitWithRetry(async () => remoteUsers.createSHAUser(user.$id, user.email, hashedPassword, getPasswordHashVersion(hashType), user.name));
+                                break;
+                            case 'phpass':
+                                await tryAwaitWithRetry(async () => remoteUsers.createPHPassUser(user.$id, user.email, hashedPassword, user.name));
+                                break;
+                            default:
+                                console.log(chalk.yellow(`Unknown hash type '${hashType}' for user ${user.$id}, falling back to Argon2`));
+                                await tryAwaitWithRetry(async () => remoteUsers.createArgon2User(user.$id, user.email, hashedPassword, user.name));
+                                break;
+                        }
+                        console.log(chalk.green(`User ${user.$id} created with preserved ${hashType} password`));
                     }
-                    if (user.labels && user.labels.length > 0) {
-                        await tryAwaitWithRetry(async () => remoteUsers.updateLabels(user.$id, user.labels));
+                    catch (error) {
+                        console.log(chalk.yellow(`Failed to create user ${user.$id} with ${hashType} hash, trying with temporary password`));
+                        // Fallback to creating user with temporary password
+                        await tryAwaitWithRetry(async () => remoteUsers.create(user.$id, user.email, phone, `changeMe${user.email}`, user.name));
+                        console.log(chalk.yellow(`User ${user.$id} created with temporary password - password reset required`));
                     }
                 }
                 else {
-                    await tryAwaitWithRetry(async () => remoteUsers.create(user.$id, user.email, phone, // phone - optional
-                    user.password, // password - cannot transfer hashed passwords
-                    user.name));
-                    if (user.labels && user.labels.length > 0) {
-                        await tryAwaitWithRetry(async () => remoteUsers.updateLabels(user.$id, user.labels));
+                    // No hash or password - create with temporary password
+                    const tempPassword = user.password || `changeMe${user.email}`;
+                    await tryAwaitWithRetry(async () => remoteUsers.create(user.$id, user.email, phone, tempPassword, user.name));
+                    if (!user.password) {
+                        console.log(chalk.yellow(`User ${user.$id} created with temporary password - password reset required`));
                     }
                 }
+                // Update phone, labels, and other attributes
+                if (phone) {
+                    await tryAwaitWithRetry(async () => remoteUsers.updatePhone(user.$id, phone));
+                }
+                if (user.labels && user.labels.length > 0) {
+                    await tryAwaitWithRetry(async () => remoteUsers.updateLabels(user.$id, user.labels));
+                }
                 // Update user preferences and status
                 await tryAwaitWithRetry(async () => remoteUsers.updatePrefs(user.$id, user.prefs));
                 if (!user.emailVerification) {

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