appwrite-utils-cli 1.0.7 → 1.0.9

package/src/migrations/transfer.ts

@@ -609,41 +609,199 @@ export const transferUsersLocalToRemote = async (
           ? 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)
-            );
-          }
-          if (user.labels && user.labels.length > 0) {
+        // 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 as Record<string, any>) || {};
+          
+          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: string) => {
+                  switch (hash.toLowerCase()) {
+                    case 'sha1': return 'sha1' as any;
+                    case 'sha256': return 'sha256' as any;
+                    case 'sha512': return 'sha512' as any;
+                    default: return 'sha256' as any; // 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`));
+            
+          } 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.updateLabels(user.$id, user.labels)
+              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 {
+          // 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, // phone - optional
-              user.password, // password - cannot transfer hashed passwords
+              phone,
+              tempPassword,
               user.name
             )
           );
-          if (user.labels && user.labels.length > 0) {
-            await tryAwaitWithRetry(async () =>
-              remoteUsers.updateLabels(user.$id, user.labels)
-            );
+          
+          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 () =>