appwrite-utils-cli 1.0.7 → 1.0.9

package/README.md

@@ -327,6 +327,122 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+### 1.0.9 - Enhanced User Transfer with Password Preservation
+
+**🔐 Complete Password Hash Preservation During User Transfers**
+
+#### Password Hash Support
+- **Universal Hash Support**: Support for all Appwrite password hash types:
+  - **Argon2**: Modern default hashing (preserved)
+  - **Bcrypt**: Industry standard (preserved)
+  - **Scrypt**: Memory-hard function with custom parameters (preserved)
+  - **Scrypt Modified**: Firebase-style with salt/separator/signer (preserved)
+  - **MD5**: Legacy support (preserved)
+  - **SHA variants**: SHA1, SHA256, SHA512 (preserved)
+  - **PHPass**: WordPress-style hashing (preserved)
+- **Dynamic Hash Detection**: Automatically detects and uses correct hash creation method
+- **Parameter Preservation**: Maintains hash-specific parameters (salt, iterations, memory cost, etc.)
+
+#### Enhanced User Transfer Logic
+- **Smart Password Recreation**: Uses appropriate `create*User` method based on detected hash type
+- **Fallback Mechanism**: Graceful fallback to temporary passwords if hash recreation fails
+- **Hash Options Support**: Preserves algorithm-specific configuration from `hashOptions`
+- **Detailed Logging**: Clear success/failure messages with hash type information
+
+#### User Experience Improvements
+- **Accurate Information**: Updated CLI messaging to reflect actual password preservation capabilities
+- **Clear Expectations**: Distinguishes between users who keep passwords vs. those who need reset
+- **Success Feedback**: Detailed reporting of password preservation success rate
+- **Risk Assessment**: Proper warnings only for users who will lose passwords
+
+#### Technical Implementation
+- **Hash Type Detection**: `user.hash` field determines creation method
+- **Configuration Parsing**: `user.hashOptions` provides algorithm parameters
+- **Error Resilience**: Comprehensive try-catch with fallback to temporary passwords
+- **Type Safety**: Proper handling of hash option types and parameters
+
+#### Migration Benefits
+- **Seamless Login**: Users with preserved hashes can immediately log in with original passwords
+- **Reduced Support**: Dramatically fewer password reset requests after migration
+- **Complete Fidelity**: Maintains original security posture and hash strength
+- **Production Ready**: Safe for live user base migrations
+
+#### Usage Examples
+```bash
+# Users will now preserve passwords during comprehensive transfer
+npx appwrite-utils-cli@latest appwrite-migrate --it
+# Select: 🚀 Comprehensive transfer (users → databases → buckets → functions)
+
+# Example output:
+# ✅ User 123 created with preserved argon2 password
+# ✅ User 456 created with preserved bcrypt password  
+# ⚠️  User 789 created with temporary password - password reset required
+```
+
+**Breaking Change**: None - fully backward compatible with enhanced capabilities.
+
+### 1.0.8 - Comprehensive Transfer System with Enhanced Rate Limiting
+
+**🚀 Complete Cross-Instance Transfer Solution**
+
+#### Comprehensive Transfer System
+- **New CLI Option**: `🚀 Comprehensive transfer (users → databases → buckets → functions)` in interactive mode
+- **Orchestrated Transfer Flow**: Proper execution order (users → databases → buckets → functions) for dependency management
+- **Cross-Instance Support**: Transfer entire Appwrite configurations between different instances/projects
+- **Selective Transfer**: Choose which components to transfer (users, databases, buckets, functions)
+- **Dry Run Mode**: Test transfers without making actual changes
+
+#### Enhanced Rate Limiting Strategy
+- **Configurable Limits**: 5 to 100 concurrent operations in steps of 5
+- **Differentiated Rates**: Smart rate limiting based on operation type:
+  - **General Operations**: Full rate (databases, functions)
+  - **User Operations**: Half rate (more sensitive operations)
+  - **File Operations**: Quarter rate (most bandwidth intensive)
+- **Visual Feedback**: Real-time rate limit display during transfers
+- **Intelligent Scaling**: Automatic calculation of optimal rates for different operations
+
+#### File Transfer Enhancements
+- **File Validation**: Comprehensive integrity checking (empty files, size limits)
+- **Retry Logic**: Exponential backoff for failed file transfers
+- **Error Handling**: Graceful handling of corrupt/invalid files
+- **Progress Tracking**: Real-time progress for large file transfers
+
+#### Function Transfer Integration
+- **Automated Function Migration**: Download from source, redeploy to target
+- **Temporary Management**: Automatic cleanup of downloaded function code
+- **Existing Code Integration**: Leverages existing deployment infrastructure
+- **Configuration Preservation**: Maintains function settings and variables
+
+#### User Experience Improvements
+- **Password Reset Warnings**: Clear notifications about Appwrite password limitations
+- **Interactive Configuration**: Step-by-step prompts for source/target setup
+- **Comprehensive Reporting**: Detailed transfer summaries with statistics
+- **Smart Confirmations**: Risk-based confirmations for destructive operations
+
+#### Technical Implementation
+- **Rate Limiting**: Uses p-limit for concurrent operation control
+- **Error Resilience**: Robust error handling with detailed user feedback
+- **Memory Management**: Efficient processing of large datasets
+- **Progress Tracking**: Real-time progress bars with ETA calculations
+
+#### Usage Examples
+```bash
+# Interactive mode - select comprehensive transfer
+npx appwrite-utils-cli@latest appwrite-migrate --it
+
+# Example rate limiting at 20 concurrent:
+# - General operations: 20 concurrent
+# - User operations: 10 concurrent  
+# - File operations: 5 concurrent
+```
+
+**Benefits**:
+- Complete Appwrite instance migration capability
+- Intelligent rate limiting prevents API throttling
+- Enhanced file transfer reliability
+- Comprehensive progress tracking and reporting
+- Maintains data integrity across transfers
+
 ### 1.0.7 - Forgot to remove debug logs
 
 ### 1.0.6 - Cross-Language Constants Generation

package/dist/interactiveCLI.d.ts

@@ -34,4 +34,5 @@ export declare class InteractiveCLI {
     private detectConfigurationType;
     private buildChoicesList;
     private migrateTypeScriptConfig;
+    private comprehensiveTransfer;
 }

package/dist/interactiveCLI.js

@@ -6,6 +6,7 @@ import { fetchAllCollections } from "./collections/methods.js";
 import { listBuckets, createBucket } from "./storage/methods.js";
 import { Databases, Storage, Client, Compression, Query, Functions, } from "node-appwrite";
 import { getClient } from "./utils/getClientFromConfig.js";
+import { ComprehensiveTransfer } from "./migrations/comprehensiveTransfer.js";
 import { AppwriteFunctionSchema, parseAttribute, PermissionToAppwritePermission, RuntimeSchema, permissionSchema, } from "appwrite-utils";
 import { ulid } from "ulidx";
 import chalk from "chalk";
@@ -33,6 +34,7 @@ var CHOICES;
     CHOICES["SYNC_DB"] = "\u2B06\uFE0F Push local config to Appwrite";
     CHOICES["SYNCHRONIZE_CONFIGURATIONS"] = "\uD83D\uDD04 Synchronize configurations - Pull from Appwrite and write to local config";
     CHOICES["TRANSFER_DATA"] = "\uD83D\uDCE6 Transfer data";
+    CHOICES["COMPREHENSIVE_TRANSFER"] = "\uD83D\uDE80 Comprehensive transfer (users \u2192 databases \u2192 buckets \u2192 functions)";
     CHOICES["BACKUP_DATABASE"] = "\uD83D\uDCBE Backup database";
     CHOICES["WIPE_DATABASE"] = "\uD83E\uDDF9 Wipe database";
     CHOICES["WIPE_COLLECTIONS"] = "\uD83E\uDDF9 Wipe collections";
@@ -109,6 +111,9 @@ export class InteractiveCLI {
                     await this.initControllerIfNeeded();
                     await this.transferData();
                     break;
+                case CHOICES.COMPREHENSIVE_TRANSFER:
+                    await this.comprehensiveTransfer();
+                    break;
                 case CHOICES.BACKUP_DATABASE:
                     await this.initControllerIfNeeded();
                     await this.backupDatabase();
@@ -1396,13 +1401,13 @@ export class InteractiveCLI {
         }));
     }
     async reloadConfig() {
-        console.log(chalk.yellow("Reloading configuration files..."));
+        MessageFormatter.progress("Reloading configuration files...", { prefix: "Config" });
         try {
             await this.controller.reloadConfig();
-            console.log(chalk.green("Configuration files reloaded successfully."));
+            MessageFormatter.success("Configuration files reloaded successfully", { prefix: "Config" });
         }
         catch (error) {
-            console.error(chalk.red("Error reloading configuration files:"), error);
+            MessageFormatter.error("Failed to reload configuration files", error instanceof Error ? error : new Error(String(error)), { prefix: "Config" });
         }
     }
     async updateFunctionSpec() {
@@ -1452,7 +1457,6 @@ export class InteractiveCLI {
         try {
             // Check for YAML config first
             const yamlConfigPath = findYamlConfig(this.currentDir);
-            console.log(`DEBUG: YAML config search from ${this.currentDir}, found: ${yamlConfigPath}`);
             if (yamlConfigPath) {
                 this.isUsingTypeScriptConfig = false;
                 MessageFormatter.info("Using YAML configuration", { prefix: "Config" });
@@ -1509,4 +1513,167 @@ export class InteractiveCLI {
             MessageFormatter.error("Migration failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
         }
     }
+    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",
+                },
+            ]);
+            // Get transfer options
+            const transferOptions = await inquirer.prompt([
+                {
+                    type: "checkbox",
+                    name: "transferTypes",
+                    message: "Select what to transfer:",
+                    choices: [
+                        { name: "👥 Users", value: "users", checked: true },
+                        { name: "🗄️ Databases", value: "databases", checked: true },
+                        { name: "📦 Storage Buckets", value: "buckets", checked: true },
+                        { name: "⚡ Functions", value: "functions", checked: true },
+                    ],
+                    validate: (input) => input.length > 0 || "Select at least one transfer type",
+                },
+                {
+                    type: "list",
+                    name: "concurrencyLimit",
+                    message: "Select concurrency limit:",
+                    choices: [
+                        { name: "5 (Conservative) - Users: 2, Files: 1", value: 5 },
+                        { name: "10 (Balanced) - Users: 5, Files: 2", value: 10 },
+                        { name: "15 - Users: 7, Files: 3", value: 15 },
+                        { name: "20 - Users: 10, Files: 5", value: 20 },
+                        { name: "25 - Users: 12, Files: 6", value: 25 },
+                        { name: "30 - Users: 15, Files: 7", value: 30 },
+                        { name: "35 - Users: 17, Files: 8", value: 35 },
+                        { name: "40 - Users: 20, Files: 10", value: 40 },
+                        { name: "45 - Users: 22, Files: 11", value: 45 },
+                        { name: "50 - Users: 25, Files: 12", value: 50 },
+                        { name: "55 - Users: 27, Files: 13", value: 55 },
+                        { name: "60 - Users: 30, Files: 15", value: 60 },
+                        { name: "65 - Users: 32, Files: 16", value: 65 },
+                        { name: "70 - Users: 35, Files: 17", value: 70 },
+                        { name: "75 - Users: 37, Files: 18", value: 75 },
+                        { name: "80 - Users: 40, Files: 20", value: 80 },
+                        { name: "85 - Users: 42, Files: 21", value: 85 },
+                        { name: "90 - Users: 45, Files: 22", value: 90 },
+                        { name: "95 - Users: 47, Files: 23", value: 95 },
+                        { name: "100 (Aggressive) - Users: 50, Files: 25", value: 100 },
+                    ],
+                    default: 10,
+                },
+                {
+                    type: "confirm",
+                    name: "dryRun",
+                    message: "Run in dry-run mode (no actual changes)?",
+                    default: false,
+                },
+            ]);
+            // Confirmation
+            const { confirmed } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirmed",
+                    message: `Are you sure you want to ${transferOptions.dryRun ? "dry-run" : "perform"} comprehensive transfer from ${sourceConfig.sourceEndpoint} to ${targetConfig.targetEndpoint}?`,
+                    default: false,
+                },
+            ]);
+            if (!confirmed) {
+                MessageFormatter.info("Transfer cancelled by user", { prefix: "Transfer" });
+                return;
+            }
+            // Password preservation information
+            if (transferOptions.transferTypes.includes("users") && !transferOptions.dryRun) {
+                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?",
+                        default: true,
+                    },
+                ]);
+                if (!continueWithUsers) {
+                    // Remove users from transfer types
+                    transferOptions.transferTypes = transferOptions.transferTypes.filter((type) => type !== "users");
+                    if (transferOptions.transferTypes.length === 0) {
+                        MessageFormatter.info("No transfer types selected, cancelling", { prefix: "Transfer" });
+                        return;
+                    }
+                }
+            }
+            // Execute comprehensive transfer
+            const comprehensiveTransferOptions = {
+                sourceEndpoint: sourceConfig.sourceEndpoint,
+                sourceProject: sourceConfig.sourceProject,
+                sourceKey: sourceConfig.sourceKey,
+                targetEndpoint: targetConfig.targetEndpoint,
+                targetProject: targetConfig.targetProject,
+                targetKey: targetConfig.targetKey,
+                transferUsers: transferOptions.transferTypes.includes("users"),
+                transferDatabases: transferOptions.transferTypes.includes("databases"),
+                transferBuckets: transferOptions.transferTypes.includes("buckets"),
+                transferFunctions: transferOptions.transferTypes.includes("functions"),
+                concurrencyLimit: transferOptions.concurrencyLimit,
+                dryRun: transferOptions.dryRun,
+            };
+            const transfer = new ComprehensiveTransfer(comprehensiveTransferOptions);
+            const results = await transfer.execute();
+            // Display results
+            if (transferOptions.dryRun) {
+                MessageFormatter.success("Dry run completed successfully!", { prefix: "Transfer" });
+            }
+            else {
+                MessageFormatter.success("Comprehensive transfer completed!", { prefix: "Transfer" });
+                if (transferOptions.transferTypes.includes("users") && results.users.transferred > 0) {
+                    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" });
+                }
+            }
+        }
+        catch (error) {
+            MessageFormatter.error("Comprehensive transfer failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+        }
+    }
 }

package/dist/migrations/comprehensiveTransfer.d.ts

@@ -0,0 +1,66 @@
+export interface ComprehensiveTransferOptions {
+    sourceEndpoint: string;
+    sourceProject: string;
+    sourceKey: string;
+    targetEndpoint: string;
+    targetProject: string;
+    targetKey: string;
+    transferUsers?: boolean;
+    transferDatabases?: boolean;
+    transferBuckets?: boolean;
+    transferFunctions?: boolean;
+    concurrencyLimit?: number;
+    dryRun?: boolean;
+}
+export interface TransferResults {
+    users: {
+        transferred: number;
+        skipped: number;
+        failed: number;
+    };
+    databases: {
+        transferred: number;
+        skipped: number;
+        failed: number;
+    };
+    buckets: {
+        transferred: number;
+        skipped: number;
+        failed: number;
+    };
+    functions: {
+        transferred: number;
+        skipped: number;
+        failed: number;
+    };
+    totalTime: number;
+}
+export declare class ComprehensiveTransfer {
+    private options;
+    private sourceClient;
+    private targetClient;
+    private sourceUsers;
+    private targetUsers;
+    private sourceDatabases;
+    private targetDatabases;
+    private sourceStorage;
+    private targetStorage;
+    private sourceFunctions;
+    private targetFunctions;
+    private limit;
+    private userLimit;
+    private fileLimit;
+    private results;
+    private startTime;
+    private tempDir;
+    constructor(options: ComprehensiveTransferOptions);
+    execute(): Promise<TransferResults>;
+    private transferAllUsers;
+    private transferAllDatabases;
+    private transferAllBuckets;
+    private transferBucketFiles;
+    private validateAndDownloadFile;
+    private transferAllFunctions;
+    private downloadFunction;
+    private printSummary;
+}