appwrite-utils-cli 1.9.7 → 1.11.0

package/src/migrations/transfer.ts

@@ -1,339 +1,377 @@
-import { converterFunctions, tryAwaitWithRetry } from "appwrite-utils";
-import {
-  Client,
-  Databases,
-  IndexType,
-  Query,
-  Storage,
-  Users,
-  type Models,
-} from "node-appwrite";
-import { InputFile } from "node-appwrite/file";
-import { getAppwriteClient } from "../utils/helperFunctions.js";
+import { converterFunctions, tryAwaitWithRetry } from "appwrite-utils";
+import {
+  Client,
+  Databases,
+  IndexType,
+  Query,
+  Storage,
+  Users,
+  type Models,
+} from "node-appwrite";
+import { InputFile } from "node-appwrite/file";
+import { getAppwriteClient } from "appwrite-utils-helpers";
 // Legacy attribute helpers retained only for local-to-local flows if needed
-import { parseAttribute } from "appwrite-utils";
-import chalk from "chalk";
-import { fetchAllCollections } from "../collections/methods.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { LegacyAdapter } from "../adapters/LegacyAdapter.js";
-import { ProgressManager } from "../shared/progressManager.js";
-import { getClient, getAdapter } from "../utils/getClientFromConfig.js";
+import { parseAttribute } from "appwrite-utils";
+import chalk from "chalk";
+import { fetchAllCollections } from "../collections/methods.js";
+import { MessageFormatter, mapToCreateAttributeParams } from "appwrite-utils-helpers";
+import { ProgressManager } from "../shared/progressManager.js";
+import { getClient, getAdapter } from "appwrite-utils-helpers";
 import { diffTableColumns } from "../collections/tableOperations.js";
-import { mapToCreateAttributeParams } from "../shared/attributeMapper.js";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
-
-export interface TransferOptions {
-  fromDb: Models.Database | undefined;
-  targetDb: Models.Database | undefined;
-  isRemote: boolean;
-  collections?: string[];
-  transferEndpoint?: string;
-  transferProject?: string;
-  transferKey?: string;
-  sourceBucket?: Models.Bucket;
-  targetBucket?: Models.Bucket;
-  transferUsers?: boolean;
-}
-
-export const transferStorageLocalToLocal = async (
-  storage: Storage,
-  fromBucketId: string,
-  toBucketId: string
-) => {
-  MessageFormatter.info(
-    `Transferring files from ${fromBucketId} to ${toBucketId}`,
-    { prefix: "Transfer" }
-  );
-  let lastFileId: string | undefined;
-  let fromFiles = await tryAwaitWithRetry(
-    async () => await storage.listFiles(fromBucketId, [Query.limit(100)])
-  );
-  const allFromFiles = fromFiles.files;
-  let numberOfFiles = 0;
-
-  const downloadFileWithRetry = async (bucketId: string, fileId: string) => {
-    let attempts = 3;
-    while (attempts > 0) {
-      try {
-        return await storage.getFileDownload(bucketId, fileId);
-      } catch (error) {
-        MessageFormatter.error(
-          `Error downloading file ${fileId}`,
-          error instanceof Error ? error : new Error(String(error)),
-          { prefix: "Transfer" }
-        );
-        attempts--;
-        if (attempts === 0) throw error;
-      }
-    }
-  };
-
-  if (fromFiles.files.length < 100) {
-    for (const file of allFromFiles) {
-      const fileData = await tryAwaitWithRetry(
-        async () => await downloadFileWithRetry(file.bucketId, file.$id)
-      );
-      if (!fileData) {
-        MessageFormatter.error(
-          `Error downloading file ${file.$id}`,
-          undefined,
-          { prefix: "Transfer" }
-        );
-        continue;
-      }
-      const fileToCreate = InputFile.fromBuffer(
-        new Uint8Array(fileData),
-        file.name
-      );
-      MessageFormatter.progress(`Creating file: ${file.name}`, {
-        prefix: "Transfer",
-      });
-      try {
-        await tryAwaitWithRetry(
-          async () =>
-            await storage.createFile(
-              toBucketId,
-              file.$id,
-              fileToCreate,
-              file.$permissions
-            )
-        );
-      } catch (error: any) {
-        // File already exists, so we can skip it
-        continue;
-      }
-      numberOfFiles++;
-    }
-  } else {
-    lastFileId = fromFiles.files[fromFiles.files.length - 1].$id;
-    while (lastFileId) {
-      const files = await tryAwaitWithRetry(
-        async () =>
-          await storage.listFiles(fromBucketId, [
-            Query.limit(100),
-            Query.cursorAfter(lastFileId!),
-          ])
-      );
-      allFromFiles.push(...files.files);
-      if (files.files.length < 100) {
-        lastFileId = undefined;
-      } else {
-        lastFileId = files.files[files.files.length - 1].$id;
-      }
-    }
-    for (const file of allFromFiles) {
-      const fileData = await tryAwaitWithRetry(
-        async () => await downloadFileWithRetry(file.bucketId, file.$id)
-      );
-      if (!fileData) {
-        MessageFormatter.error(
-          `Error downloading file ${file.$id}`,
-          undefined,
-          { prefix: "Transfer" }
-        );
-        continue;
-      }
-      const fileToCreate = InputFile.fromBuffer(
-        new Uint8Array(fileData),
-        file.name
-      );
-      try {
-        await tryAwaitWithRetry(
-          async () =>
-            await storage.createFile(
-              toBucketId,
-              file.$id,
-              fileToCreate,
-              file.$permissions
-            )
-        );
-      } catch (error: any) {
-        // File already exists, so we can skip it
-        MessageFormatter.warning(
-          `File ${file.$id} already exists, skipping...`,
-          { prefix: "Transfer" }
-        );
-        continue;
-      }
-      numberOfFiles++;
-    }
-  }
-
-  MessageFormatter.success(
-    `Transferred ${numberOfFiles} files from ${fromBucketId} to ${toBucketId}`,
-    { prefix: "Transfer" }
-  );
-};
-
-export const transferStorageLocalToRemote = async (
-  localStorage: Storage,
-  endpoint: string,
-  projectId: string,
-  apiKey: string,
-  fromBucketId: string,
-  toBucketId: string
-) => {
-  MessageFormatter.info(
-    `Transferring files from current storage ${fromBucketId} to ${endpoint} bucket ${toBucketId}`,
-    { prefix: "Transfer" }
-  );
-  const client = getAppwriteClient(endpoint, projectId, apiKey);
-  const remoteStorage = new Storage(client);
-  let numberOfFiles = 0;
-  let lastFileId: string | undefined;
-  let fromFiles = await tryAwaitWithRetry(
-    async () => await localStorage.listFiles(fromBucketId, [Query.limit(100)])
-  );
-  const allFromFiles = fromFiles.files;
-  if (fromFiles.files.length === 100) {
-    lastFileId = fromFiles.files[fromFiles.files.length - 1].$id;
-    while (lastFileId) {
-      const files = await tryAwaitWithRetry(
-        async () =>
-          await localStorage.listFiles(fromBucketId, [
-            Query.limit(100),
-            Query.cursorAfter(lastFileId!),
-          ])
-      );
-      allFromFiles.push(...files.files);
-      if (files.files.length < 100) {
-        break;
-      }
-      lastFileId = files.files[files.files.length - 1].$id;
-    }
-  }
-
-  for (const file of allFromFiles) {
-    const fileData = await tryAwaitWithRetry(
-      async () => await localStorage.getFileDownload(file.bucketId, file.$id)
-    );
-    const fileToCreate = InputFile.fromBuffer(
-      new Uint8Array(fileData),
-      file.name
-    );
-    try {
-      await tryAwaitWithRetry(
-        async () =>
-          await remoteStorage.createFile(
-            toBucketId,
-            file.$id,
-            fileToCreate,
-            file.$permissions
-          )
-      );
-    } catch (error: any) {
-      // File already exists, so we can skip it
-      MessageFormatter.warning(`File ${file.$id} already exists, skipping...`, {
-        prefix: "Transfer",
-      });
-      continue;
-    }
-    numberOfFiles++;
-  }
-  MessageFormatter.success(
-    `Transferred ${numberOfFiles} files from ${fromBucketId} to ${toBucketId}`,
-    { prefix: "Transfer" }
-  );
-};
-
-// Document transfer functions moved to collections/methods.ts with enhanced UX
-
-// Remote document transfer functions moved to collections/methods.ts with enhanced UX
-
-/**
- * Transfers all collections and documents from one local database to another local database.
- *
- * @param {Databases} localDb - The local database instance.
- * @param {string} fromDbId - The ID of the source database.
- * @param {string} targetDbId - The ID of the target database.
- * @return {Promise<void>} A promise that resolves when the transfer is complete.
- */
-export const transferDatabaseLocalToLocal = async (
-  localDb: Databases,
-  fromDbId: string,
-  targetDbId: string
-) => {
-  MessageFormatter.info(
-    `Starting database transfer from ${fromDbId} to ${targetDbId}`,
-    { prefix: "Transfer" }
-  );
-  // Get all collections from source database
-  const sourceCollections = await fetchAllCollections(fromDbId, localDb);
-  MessageFormatter.info(
-    `Found ${sourceCollections.length} collections in source database`,
-    { prefix: "Transfer" }
-  );
-
-  // Process each collection
-  for (const collection of sourceCollections) {
-    MessageFormatter.processing(
-      `Processing collection: ${collection.name} (${collection.$id})`,
-      { prefix: "Transfer" }
-    );
-
-    try {
-      // Create or update collection in target
-      let targetCollection: Models.Collection;
-      const existingCollection = await tryAwaitWithRetry(async () =>
-        localDb.listCollections(targetDbId, [
-          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 ||
-          targetCollection.$permissions !== collection.$permissions ||
-          targetCollection.documentSecurity !== collection.documentSecurity ||
-          targetCollection.enabled !== collection.enabled
-        ) {
-          targetCollection = await tryAwaitWithRetry(async () =>
-            localDb.updateCollection(
-              targetDbId,
-              collection.$id,
-              collection.name,
-              collection.$permissions,
-              collection.documentSecurity,
-              collection.enabled
-            )
-          );
-          MessageFormatter.success(
-            `Collection ${collection.name} updated`,
-            { prefix: "Transfer" }
-          );
-        }
-      } else {
-        MessageFormatter.progress(
-          `Creating collection ${collection.name} in target database...`,
-          { prefix: "Transfer" }
-        );
-        targetCollection = await tryAwaitWithRetry(async () =>
-          localDb.createCollection(
-            targetDbId,
-            collection.$id,
-            collection.name,
-            collection.$permissions,
-            collection.documentSecurity,
-            collection.enabled
-          )
-        );
-      }
-
-      // Create attributes via local adapter (wrap the existing client)
-      const localAdapter: DatabaseAdapter = new LegacyAdapter((localDb as any).client);
-      MessageFormatter.info(`Creating attributes for ${collection.name} via adapter...`, { prefix: 'Transfer' });
-      const uniformAttrs = collection.attributes.map((attr) => parseAttribute(attr as any));
+import { type DatabaseAdapter } from "appwrite-utils-helpers";
+
+export interface TransferOptions {
+  fromDb: Models.Database | undefined;
+  targetDb: Models.Database | undefined;
+  isRemote: boolean;
+  collections?: string[];
+  transferEndpoint?: string;
+  transferProject?: string;
+  transferKey?: string;
+  sourceBucket?: Models.Bucket;
+  targetBucket?: Models.Bucket;
+  transferUsers?: boolean;
+}
+
+export const transferStorageLocalToLocal = async (
+  storage: Storage,
+  fromBucketId: string,
+  toBucketId: string
+) => {
+  MessageFormatter.info(
+    `Transferring files from ${fromBucketId} to ${toBucketId}`,
+    { prefix: "Transfer" }
+  );
+  let lastFileId: string | undefined;
+  let fromFiles = await tryAwaitWithRetry(
+    async () => await storage.listFiles(fromBucketId, [Query.limit(100)])
+  );
+  const allFromFiles = fromFiles.files;
+  let numberOfFiles = 0;
+
+  const downloadFileWithRetry = async (bucketId: string, fileId: string) => {
+    let attempts = 3;
+    while (attempts > 0) {
+      try {
+        return await storage.getFileDownload(bucketId, fileId);
+      } catch (error) {
+        MessageFormatter.error(
+          `Error downloading file ${fileId}`,
+          error instanceof Error ? error : new Error(String(error)),
+          { prefix: "Transfer" }
+        );
+        attempts--;
+        if (attempts === 0) throw error;
+      }
+    }
+  };
+
+  if (fromFiles.files.length < 100) {
+    for (const file of allFromFiles) {
+      const fileData = await tryAwaitWithRetry(
+        async () => await downloadFileWithRetry(file.bucketId, file.$id)
+      );
+      if (!fileData) {
+        MessageFormatter.error(
+          `Error downloading file ${file.$id}`,
+          undefined,
+          { prefix: "Transfer" }
+        );
+        continue;
+      }
+      const fileToCreate = InputFile.fromBuffer(
+        new Uint8Array(fileData),
+        file.name
+      );
+      MessageFormatter.progress(`Creating file: ${file.name}`, {
+        prefix: "Transfer",
+      });
+      try {
+        await tryAwaitWithRetry(
+          async () =>
+            await storage.createFile(
+              toBucketId,
+              file.$id,
+              fileToCreate,
+              file.$permissions
+            )
+        );
+      } catch (error: any) {
+        // File already exists, so we can skip it
+        continue;
+      }
+      numberOfFiles++;
+    }
+  } else {
+    lastFileId = fromFiles.files[fromFiles.files.length - 1].$id;
+    while (lastFileId) {
+      const files = await tryAwaitWithRetry(
+        async () =>
+          await storage.listFiles(fromBucketId, [
+            Query.limit(100),
+            Query.cursorAfter(lastFileId!),
+          ])
+      );
+      allFromFiles.push(...files.files);
+      if (files.files.length < 100) {
+        lastFileId = undefined;
+      } else {
+        lastFileId = files.files[files.files.length - 1].$id;
+      }
+    }
+    for (const file of allFromFiles) {
+      const fileData = await tryAwaitWithRetry(
+        async () => await downloadFileWithRetry(file.bucketId, file.$id)
+      );
+      if (!fileData) {
+        MessageFormatter.error(
+          `Error downloading file ${file.$id}`,
+          undefined,
+          { prefix: "Transfer" }
+        );
+        continue;
+      }
+      const fileToCreate = InputFile.fromBuffer(
+        new Uint8Array(fileData),
+        file.name
+      );
+      try {
+        await tryAwaitWithRetry(
+          async () =>
+            await storage.createFile(
+              toBucketId,
+              file.$id,
+              fileToCreate,
+              file.$permissions
+            )
+        );
+      } catch (error: any) {
+        // File already exists, so we can skip it
+        MessageFormatter.warning(
+          `File ${file.$id} already exists, skipping...`,
+          { prefix: "Transfer" }
+        );
+        continue;
+      }
+      numberOfFiles++;
+    }
+  }
+
+  MessageFormatter.success(
+    `Transferred ${numberOfFiles} files from ${fromBucketId} to ${toBucketId}`,
+    { prefix: "Transfer" }
+  );
+};
+
+export const transferStorageLocalToRemote = async (
+  localStorage: Storage,
+  endpoint: string,
+  projectId: string,
+  apiKey: string,
+  fromBucketId: string,
+  toBucketId: string
+) => {
+  MessageFormatter.info(
+    `Transferring files from current storage ${fromBucketId} to ${endpoint} bucket ${toBucketId}`,
+    { prefix: "Transfer" }
+  );
+  const client = getAppwriteClient(endpoint, projectId, apiKey);
+  const remoteStorage = new Storage(client);
+  let numberOfFiles = 0;
+  let lastFileId: string | undefined;
+  let fromFiles = await tryAwaitWithRetry(
+    async () => await localStorage.listFiles(fromBucketId, [Query.limit(100)])
+  );
+  const allFromFiles = fromFiles.files;
+  if (fromFiles.files.length === 100) {
+    lastFileId = fromFiles.files[fromFiles.files.length - 1].$id;
+    while (lastFileId) {
+      const files = await tryAwaitWithRetry(
+        async () =>
+          await localStorage.listFiles(fromBucketId, [
+            Query.limit(100),
+            Query.cursorAfter(lastFileId!),
+          ])
+      );
+      allFromFiles.push(...files.files);
+      if (files.files.length < 100) {
+        break;
+      }
+      lastFileId = files.files[files.files.length - 1].$id;
+    }
+  }
+
+  for (const file of allFromFiles) {
+    const fileData = await tryAwaitWithRetry(
+      async () => await localStorage.getFileDownload(file.bucketId, file.$id)
+    );
+    const fileToCreate = InputFile.fromBuffer(
+      new Uint8Array(fileData),
+      file.name
+    );
+    try {
+      await tryAwaitWithRetry(
+        async () =>
+          await remoteStorage.createFile(
+            toBucketId,
+            file.$id,
+            fileToCreate,
+            file.$permissions
+          )
+      );
+    } catch (error: any) {
+      // File already exists, so we can skip it
+      MessageFormatter.warning(`File ${file.$id} already exists, skipping...`, {
+        prefix: "Transfer",
+      });
+      continue;
+    }
+    numberOfFiles++;
+  }
+  MessageFormatter.success(
+    `Transferred ${numberOfFiles} files from ${fromBucketId} to ${toBucketId}`,
+    { prefix: "Transfer" }
+  );
+};
+
+// Document transfer functions moved to collections/methods.ts with enhanced UX
+
+// Remote document transfer functions moved to collections/methods.ts with enhanced UX
+
+/**
+ * Transfers all tables/collections and documents from one local database to another local database.
+ * Uses the DatabaseAdapter for unified TablesDB / legacy support.
+ *
+ * @param {Databases} localDb - The local database instance (kept for signature compat).
+ * @param {string} fromDbId - The ID of the source database.
+ * @param {string} targetDbId - The ID of the target database.
+ * @param {string[]} collectionIds - Optional filter: specific table/collection IDs to transfer. undefined = all, empty array = none.
+ * @param {DatabaseAdapter} adapter - The database adapter (TablesDB or Legacy).
+ * @return {Promise<void>} A promise that resolves when the transfer is complete.
+ */
+export const transferDatabaseLocalToLocal = async (
+  localDb: Databases,
+  fromDbId: string,
+  targetDbId: string,
+  collectionIds?: string[],
+  adapter?: DatabaseAdapter
+) => {
+  if (!adapter) {
+    throw new Error("DatabaseAdapter is required for transferDatabaseLocalToLocal");
+  }
+  const dbAdapter: DatabaseAdapter = adapter;
+
+  MessageFormatter.info(
+    `Starting database transfer from ${fromDbId} to ${targetDbId} (mode: ${dbAdapter.getApiMode()})`,
+    { prefix: "Transfer" }
+  );
+
+  // Get all tables/collections from source database via adapter
+  const sourceListRes = await dbAdapter.listTables({ databaseId: fromDbId, queries: [Query.limit(500)] });
+  let sourceTables: any[] = sourceListRes.tables || sourceListRes.collections || sourceListRes.data || [];
+
+  // Filter by collectionIds if provided (match by $id or by name)
+  if (collectionIds !== undefined) {
+    if (collectionIds.length === 0) {
+      MessageFormatter.info("No tables/collections selected for transfer, skipping.", { prefix: "Transfer" });
+      return;
+    }
+    const idSet = new Set(collectionIds);
+    sourceTables = sourceTables.filter((c: any) => idSet.has(c.$id) || idSet.has(c.name));
+  }
+
+  MessageFormatter.info(
+    `Found ${sourceTables.length} tables/collections in source database`,
+    { prefix: "Transfer" }
+  );
+
+  // Process each table/collection
+  for (const table of sourceTables) {
+    MessageFormatter.processing(
+      `Processing table: ${table.name} (${table.$id})`,
+      { prefix: "Transfer" }
+    );
+
+    try {
+      // Check if table exists in target via adapter
+      let targetTableId = table.$id;
+      let targetTableData: any;
+
+      try {
+        const existingRes = await dbAdapter.getTable({ databaseId: targetDbId, tableId: table.$id });
+        targetTableData = existingRes.data || (existingRes.tables && existingRes.tables[0]);
+
+        if (targetTableData) {
+          MessageFormatter.info(
+            `Table ${table.name} exists in target database`,
+            { prefix: "Transfer" }
+          );
+
+          // Update table if needed
+          const securityField = table.rowSecurity ?? table.documentSecurity ?? false;
+          const targetSecurity = targetTableData.rowSecurity ?? targetTableData.documentSecurity ?? false;
+          if (
+            targetTableData.name !== table.name ||
+            JSON.stringify(targetTableData.$permissions) !== JSON.stringify(table.$permissions) ||
+            targetSecurity !== securityField ||
+            targetTableData.enabled !== table.enabled
+          ) {
+            await tryAwaitWithRetry(async () =>
+              dbAdapter.updateTable({
+                databaseId: targetDbId,
+                id: table.$id,
+                name: table.name,
+                permissions: table.$permissions,
+                documentSecurity: table.documentSecurity,
+                rowSecurity: table.rowSecurity,
+                enabled: table.enabled,
+              })
+            );
+            MessageFormatter.success(
+              `Table ${table.name} updated`,
+              { prefix: "Transfer" }
+            );
+          }
+        }
+      } catch {
+        // Table does not exist in target, create it
+        targetTableData = null;
+      }
+
+      if (!targetTableData) {
+        MessageFormatter.progress(
+          `Creating table ${table.name} in target database...`,
+          { prefix: "Transfer" }
+        );
+        const createRes = await tryAwaitWithRetry(async () =>
+          dbAdapter.createTable({
+            databaseId: targetDbId,
+            id: table.$id,
+            name: table.name,
+            permissions: table.$permissions,
+            documentSecurity: table.documentSecurity,
+            rowSecurity: table.rowSecurity,
+            enabled: table.enabled,
+          })
+        );
+        targetTableData = createRes.data || (createRes.tables && createRes.tables[0]);
+      }
+
+      // Create attributes via adapter
+      MessageFormatter.info(`Creating attributes for ${table.name} via adapter...`, { prefix: 'Transfer' });
+
+      // Fetch existing attributes in target to skip already-created ones
+      const targetTableRes = await dbAdapter.getTable({ databaseId: targetDbId, tableId: targetTableId });
+      const targetInfo = targetTableRes.data || (targetTableRes.tables && targetTableRes.tables[0]);
+      const existingAttrs = targetInfo?.attributes || targetInfo?.columns || [];
+      const existingKeys = new Set(existingAttrs.map((a: any) => a.key || a.$id));
+
+      const uniformAttrs = (table.attributes || []).map((attr: any) => parseAttribute(attr as any));
       const nonRel = uniformAttrs.filter((a: any) => a.type !== 'relationship');
       for (const attr of nonRel) {
-        const params = mapToCreateAttributeParams(attr as any, { databaseId: targetDbId, tableId: targetCollection.$id });
-        await localAdapter.createAttribute(params);
+        if (existingKeys.has(attr.key)) continue;
+        const params = mapToCreateAttributeParams(attr as any, { databaseId: targetDbId, tableId: targetTableId });
+        await dbAdapter.createAttribute(params);
         await new Promise((r) => setTimeout(r, 150));
       }
 
@@ -343,8 +381,9 @@ export const transferDatabaseLocalToLocal = async (
         let lastStatus = '';
         while (Date.now() - start < maxWait) {
           try {
-            const tableRes = await localAdapter.getTable({ databaseId: targetDbId, tableId: targetCollection.$id });
-            const attrs = (tableRes as any).attributes || (tableRes as any).columns || [];
+            const tableRes = await dbAdapter.getTable({ databaseId: targetDbId, tableId: targetTableId });
+            const tInfo = tableRes.data || (tableRes.tables && tableRes.tables[0]);
+            const attrs = tInfo?.attributes || tInfo?.columns || [];
             const found = attrs.find((a: any) => a.key === attr.key);
             if (found) {
               if (found.status === 'available') break;
@@ -366,17 +405,18 @@ export const transferDatabaseLocalToLocal = async (
       // Relationship attributes
       const rels = uniformAttrs.filter((a: any) => a.type === 'relationship');
       for (const attr of rels) {
-        const params = mapToCreateAttributeParams(attr as any, { databaseId: targetDbId, tableId: targetCollection.$id });
-        await localAdapter.createAttribute(params);
+        if (existingKeys.has(attr.key)) continue;
+        const params = mapToCreateAttributeParams(attr as any, { databaseId: targetDbId, tableId: targetTableId });
+        await dbAdapter.createAttribute(params);
         await new Promise((r) => setTimeout(r, 150));
       }
-
+
       // Handle indexes via adapter (create or update)
-      for (const idx of collection.indexes) {
+      for (const idx of (table.indexes || [])) {
         try {
-          await localAdapter.createIndex({
+          await dbAdapter.createIndex({
             databaseId: targetDbId,
-            tableId: targetCollection.$id,
+            tableId: targetTableId,
             key: (idx as any).key,
             type: (idx as any).type,
             attributes: (idx as any).attributes,
@@ -387,10 +427,10 @@ export const transferDatabaseLocalToLocal = async (
         } catch (e) {
           // Try update path by deleting and recreating if necessary
           try {
-            await localAdapter.deleteIndex({ databaseId: targetDbId, tableId: targetCollection.$id, key: (idx as any).key });
-            await localAdapter.createIndex({
+            await dbAdapter.deleteIndex({ databaseId: targetDbId, tableId: targetTableId, key: (idx as any).key });
+            await dbAdapter.createIndex({
               databaseId: targetDbId,
-              tableId: targetCollection.$id,
+              tableId: targetTableId,
               key: (idx as any).key,
               type: (idx as any).type,
               attributes: (idx as any).attributes,
@@ -403,106 +443,111 @@ export const transferDatabaseLocalToLocal = async (
           }
         }
       }
-
-      // Transfer documents
-      const { transferDocumentsBetweenDbsLocalToLocal } = await import(
-        "../collections/methods.js"
-      );
-      await transferDocumentsBetweenDbsLocalToLocal(
-        localDb,
-        fromDbId,
-        targetDbId,
-        collection.$id,
-        targetCollection.$id
-      );
-    } catch (error) {
-      MessageFormatter.error(
-        `Error processing collection ${collection.name}`,
-        error instanceof Error ? error : new Error(String(error)),
-        { prefix: "Transfer" }
-      );
-    }
-  }
-};
-
-export const transferDatabaseLocalToRemote = async (
-  localDb: Databases,
-  endpoint: string,
-  projectId: string,
-  apiKey: string,
-  fromDbId: string,
-  toDbId: string
-) => {
-  const client = getAppwriteClient(endpoint, projectId, apiKey);
-  const remoteDb = new Databases(client);
-
-  // Get all collections from source database
-  const sourceCollections = await fetchAllCollections(fromDbId, localDb);
-  MessageFormatter.info(
-    `Found ${sourceCollections.length} collections in source database`,
-    { prefix: "Transfer" }
-  );
-
-  // Process each collection
-  for (const collection of sourceCollections) {
-    MessageFormatter.processing(
-      `Processing collection: ${collection.name} (${collection.$id})`,
-      { prefix: "Transfer" }
-    );
-
-    try {
-      // Create or update collection in target
-      let targetCollection: Models.Collection;
-      const existingCollection = await tryAwaitWithRetry(async () =>
-        remoteDb.listCollections(toDbId, [Query.equal("$id", collection.$id)])
-      );
-
-      if (existingCollection.collections.length > 0) {
-        targetCollection = existingCollection.collections[0];
-        MessageFormatter.info(
-          `Collection ${collection.name} exists in remote database`,
-          { prefix: "Transfer" }
-        );
-
-        // Update collection if needed
-        if (
-          targetCollection.name !== collection.name ||
-          targetCollection.$permissions !== collection.$permissions ||
-          targetCollection.documentSecurity !== collection.documentSecurity ||
-          targetCollection.enabled !== collection.enabled
-        ) {
-          targetCollection = await tryAwaitWithRetry(async () =>
-            remoteDb.updateCollection(
-              toDbId,
-              collection.$id,
-              collection.name,
-              collection.$permissions,
-              collection.documentSecurity,
-              collection.enabled
-            )
-          );
-          MessageFormatter.success(
-            `Collection ${collection.name} updated`,
-            { prefix: "Transfer" }
-          );
-        }
-      } else {
-        MessageFormatter.progress(
-          `Creating collection ${collection.name} in remote database...`,
-          { prefix: "Transfer" }
-        );
-        targetCollection = await tryAwaitWithRetry(async () =>
-          remoteDb.createCollection(
-            toDbId,
-            collection.$id,
-            collection.name,
-            collection.$permissions,
-            collection.documentSecurity,
-            collection.enabled
-          )
-        );
-      }
-
+
+      // Transfer documents/rows via adapter
+      const { transferDocumentsBetweenDbsLocalToLocal } = await import(
+        "../collections/transferOperations.js"
+      );
+      await transferDocumentsBetweenDbsLocalToLocal(
+        dbAdapter,
+        fromDbId,
+        targetDbId,
+        table.$id,
+        targetTableId
+      );
+    } catch (error) {
+      MessageFormatter.error(
+        `Error processing table ${table.name}`,
+        error instanceof Error ? error : new Error(String(error)),
+        { prefix: "Transfer" }
+      );
+    }
+  }
+};
+
+export const transferDatabaseLocalToRemote = async (
+  localDb: Databases,
+  endpoint: string,
+  projectId: string,
+  apiKey: string,
+  fromDbId: string,
+  toDbId: string,
+  collectionIds?: string[]
+) => {
+  const client = getAppwriteClient(endpoint, projectId, apiKey);
+  const remoteDb = new Databases(client);
+
+  // Get all collections from source database
+  let sourceCollections = await fetchAllCollections(fromDbId, localDb);
+  if (collectionIds && collectionIds.length > 0) {
+    const idSet = new Set(collectionIds);
+    sourceCollections = sourceCollections.filter((c) => idSet.has(c.$id));
+  }
+  MessageFormatter.info(
+    `Found ${sourceCollections.length} collections in source database`,
+    { prefix: "Transfer" }
+  );
+
+  // Process each collection
+  for (const collection of sourceCollections) {
+    MessageFormatter.processing(
+      `Processing collection: ${collection.name} (${collection.$id})`,
+      { prefix: "Transfer" }
+    );
+
+    try {
+      // Create or update collection in target
+      let targetCollection: Models.Collection;
+      const existingCollection = await tryAwaitWithRetry(async () =>
+        remoteDb.listCollections(toDbId, [Query.equal("$id", collection.$id)])
+      );
+
+      if (existingCollection.collections.length > 0) {
+        targetCollection = existingCollection.collections[0];
+        MessageFormatter.info(
+          `Collection ${collection.name} exists in remote database`,
+          { prefix: "Transfer" }
+        );
+
+        // Update collection if needed
+        if (
+          targetCollection.name !== collection.name ||
+          targetCollection.$permissions !== collection.$permissions ||
+          targetCollection.documentSecurity !== collection.documentSecurity ||
+          targetCollection.enabled !== collection.enabled
+        ) {
+          targetCollection = await tryAwaitWithRetry(async () =>
+            remoteDb.updateCollection(
+              toDbId,
+              collection.$id,
+              collection.name,
+              collection.$permissions,
+              collection.documentSecurity,
+              collection.enabled
+            )
+          );
+          MessageFormatter.success(
+            `Collection ${collection.name} updated`,
+            { prefix: "Transfer" }
+          );
+        }
+      } else {
+        MessageFormatter.progress(
+          `Creating collection ${collection.name} in remote database...`,
+          { prefix: "Transfer" }
+        );
+        targetCollection = await tryAwaitWithRetry(async () =>
+          remoteDb.createCollection(
+            toDbId,
+            collection.$id,
+            collection.name,
+            collection.$permissions,
+            collection.documentSecurity,
+            collection.enabled
+          )
+        );
+      }
+
       // Create/Update attributes via adapter (prefer adapter for remote)
       const { adapter: remoteAdapter } = await getAdapter(endpoint, projectId, apiKey, 'auto');
       MessageFormatter.info(`Creating attributes for ${collection.name} via adapter...`, { prefix: 'Transfer' });
@@ -551,13 +596,13 @@ export const transferDatabaseLocalToRemote = async (
         for (const a of rUpdate) { const p = mapToCreateAttributeParams(a as any, { databaseId: toDbId, tableId: collection.$id }); await (remoteAdapter as DatabaseAdapter).updateAttribute(p as any); await new Promise((r)=>setTimeout(r,150)); }
         for (const a of rCreate) { const p = mapToCreateAttributeParams(a as any, { databaseId: toDbId, tableId: collection.$id }); await (remoteAdapter as DatabaseAdapter).createAttribute(p); await new Promise((r)=>setTimeout(r,150)); }
       }
-
-      // Handle indexes with enhanced status checking
-      MessageFormatter.info(
-        `Creating indexes for collection ${collection.name} with enhanced monitoring...`,
-        { prefix: "Transfer" }
-      );
-
+
+      // Handle indexes with enhanced status checking
+      MessageFormatter.info(
+        `Creating indexes for collection ${collection.name} with enhanced monitoring...`,
+        { prefix: "Transfer" }
+      );
+
       // Create indexes via adapter
       for (const idx of (collection.indexes as any[]) || []) {
         try {
@@ -574,495 +619,495 @@ export const transferDatabaseLocalToRemote = async (
           MessageFormatter.error(`Failed to create index ${idx.key}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Transfer' });
         }
       }
-
-      // Transfer documents
-      const { transferDocumentsBetweenDbsLocalToRemote } = await import(
-        "../collections/methods.js"
-      );
-      await transferDocumentsBetweenDbsLocalToRemote(
-        localDb,
-        endpoint,
-        projectId,
-        apiKey,
-        fromDbId,
-        toDbId,
-        collection.$id,
-        targetCollection.$id
-      );
-    } catch (error) {
-      MessageFormatter.error(
-        `Error processing collection ${collection.name}`,
-        error instanceof Error ? error : new Error(String(error)),
-        { prefix: "Transfer" }
-      );
-    }
-  }
-};
-
-export const transferUsersLocalToRemote = async (
-  localUsers: Users,
-  endpoint: string,
-  projectId: string,
-  apiKey: string
-) => {
-  MessageFormatter.info(
-    "Starting user transfer to remote instance...",
-    { prefix: "Transfer" }
-  );
-
-  const client = getClient(endpoint, projectId, apiKey);
-  const remoteUsers = new Users(client);
-
-  let totalTransferred = 0;
-  let lastId: string | undefined;
-
-  while (true) {
-    const queries = [Query.limit(100)];
-    if (lastId) {
-      queries.push(Query.cursorAfter(lastId));
-    }
-
-    const usersList = await tryAwaitWithRetry(async () =>
-      localUsers.list(queries)
-    );
-
-    if (usersList.users.length === 0) {
-      break;
-    }
-
-    for (const user of usersList.users) {
-      try {
-        // Check if user already exists in remote
-        let remoteUser: Models.User<Models.Preferences> | undefined;
-        try {
-          remoteUser = await tryAwaitWithRetry(async () =>
-            remoteUsers.get(user.$id)
-          );
-          
-          // If user exists, update only the differences
-          if (remoteUser) {
-            MessageFormatter.info(
-              `User ${user.$id} exists, checking for updates...`,
-              { prefix: "Transfer" }
-            );
-            let hasUpdates = false;
-
-            // Update name if different
-            if (remoteUser.name !== user.name) {
-              await tryAwaitWithRetry(async () =>
-                remoteUsers.updateName(user.$id, user.name)
-              );
-              MessageFormatter.success(
-                `Updated name for user ${user.$id}`,
-                { prefix: "Transfer" }
-              );
-              hasUpdates = true;
-            }
-
-            // Update email if different
-            if (remoteUser.email !== user.email) {
-              await tryAwaitWithRetry(async () =>
-                remoteUsers.updateEmail(user.$id, user.email)
-              );
-              MessageFormatter.success(
-                `Updated email for user ${user.$id}`,
-                { prefix: "Transfer" }
-              );
-              hasUpdates = true;
-            }
-
-            // Update phone if different
-            const normalizedLocalPhone = user.phone 
-              ? converterFunctions.convertPhoneStringToUSInternational(user.phone)
-              : undefined;
-            if (remoteUser.phone !== normalizedLocalPhone) {
-              if (normalizedLocalPhone) {
-                await tryAwaitWithRetry(async () =>
-                  remoteUsers.updatePhone(user.$id, normalizedLocalPhone)
-                );
-              }
-              MessageFormatter.success(
-                `Updated phone for user ${user.$id}`,
-                { prefix: "Transfer" }
-              );
-              hasUpdates = true;
-            }
-
-            // Update preferences if different
-            if (JSON.stringify(remoteUser.prefs) !== JSON.stringify(user.prefs)) {
-              await tryAwaitWithRetry(async () =>
-                remoteUsers.updatePrefs(user.$id, user.prefs)
-              );
-              MessageFormatter.success(
-                `Updated preferences for user ${user.$id}`,
-                { prefix: "Transfer" }
-              );
-              hasUpdates = true;
-            }
-
-            // Update labels if different
-            if (JSON.stringify(remoteUser.labels) !== JSON.stringify(user.labels)) {
-              await tryAwaitWithRetry(async () =>
-                remoteUsers.updateLabels(user.$id, user.labels)
-              );
-              MessageFormatter.success(
-                `Updated labels for user ${user.$id}`,
-                { prefix: "Transfer" }
-              );
-              hasUpdates = true;
-            }
-
-            // Update email verification if different
-            if (remoteUser.emailVerification !== user.emailVerification) {
-              await tryAwaitWithRetry(async () =>
-                remoteUsers.updateEmailVerification(user.$id, user.emailVerification)
-              );
-              MessageFormatter.success(
-                `Updated email verification for user ${user.$id}`,
-                { prefix: "Transfer" }
-              );
-              hasUpdates = true;
-            }
-
-            // Update phone verification if different
-            if (remoteUser.phoneVerification !== user.phoneVerification) {
-              await tryAwaitWithRetry(async () =>
-                remoteUsers.updatePhoneVerification(user.$id, user.phoneVerification)
-              );
-              MessageFormatter.success(
-                `Updated phone verification for user ${user.$id}`,
-                { prefix: "Transfer" }
-              );
-              hasUpdates = true;
-            }
-
-            // Update status if different
-            if (remoteUser.status !== user.status) {
-              await tryAwaitWithRetry(async () =>
-                remoteUsers.updateStatus(user.$id, user.status)
-              );
-              MessageFormatter.success(
-                `Updated status for user ${user.$id}`,
-                { prefix: "Transfer" }
-              );
-              hasUpdates = true;
-            }
-
-            if (!hasUpdates) {
-              MessageFormatter.info(
-                `User ${user.$id} is already up to date, skipping...`,
-                { prefix: "Transfer" }
-              );
-            } else {
-              totalTransferred++;
-              MessageFormatter.success(
-                `Updated user ${user.$id}`,
-                { prefix: "Transfer" }
-              );
-            }
-            continue;
-          }
-        } catch (error: any) {
-          // User doesn't exist, proceed with creation
-        }
-
-        const phone = user.phone
-          ? converterFunctions.convertPhoneStringToUSInternational(user.phone)
-          : undefined;
-
-        // 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"
-                ) {
-                  MessageFormatter.warning(
-                    `User ${user.$id}: Using default Scrypt parameters due to missing hashOptions`,
-                    { prefix: "Transfer" }
-                  );
-                }
-
-                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
-                ) {
-                  MessageFormatter.warning(
-                    `User ${user.$id}: Missing critical Scrypt Modified parameters in hashOptions`,
-                    { prefix: "Transfer" }
-                  );
-                }
-
-                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:
-                MessageFormatter.warning(
-                  `Unknown hash type '${hashType}' for user ${user.$id}, falling back to Argon2`,
-                  { prefix: "Transfer" }
-                );
-                await tryAwaitWithRetry(async () =>
-                  remoteUsers.createArgon2User(
-                    user.$id,
-                    user.email,
-                    hashedPassword,
-                    user.name
-                  )
-                );
-                break;
-            }
-
-            MessageFormatter.success(
-              `User ${user.$id} created with preserved ${hashType} password`,
-              { prefix: "Transfer" }
-            );
-          } catch (error) {
-            MessageFormatter.warning(
-              `Failed to create user ${user.$id} with ${hashType} hash, trying with temporary password`,
-              { prefix: "Transfer" }
-            );
-
-            // Fallback to creating user with temporary password
-            await tryAwaitWithRetry(async () =>
-              remoteUsers.create(
-                user.$id,
-                user.email,
-                phone,
-                `changeMe${user.email}`,
-                user.name
-              )
-            );
-
-            MessageFormatter.warning(
-              `User ${user.$id} created with temporary password - password reset required`,
-              { prefix: "Transfer" }
-            );
-          }
-        } 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,
-              tempPassword,
-              user.name
-            )
-          );
-
-          if (!user.password) {
-            MessageFormatter.warning(
-              `User ${user.$id} created with temporary password - password reset required`,
-              { prefix: "Transfer" }
-            );
-          }
-        }
-
-        // Update phone, labels, and other attributes for newly created users
-        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 for newly created users
-        await tryAwaitWithRetry(async () =>
-          remoteUsers.updatePrefs(user.$id, user.prefs)
-        );
-
-        if (user.emailVerification) {
-          await tryAwaitWithRetry(async () =>
-            remoteUsers.updateEmailVerification(user.$id, true)
-          );
-        } else {
-          await tryAwaitWithRetry(async () =>
-            remoteUsers.updateEmailVerification(user.$id, false)
-          );
-        }
-
-        if (user.phoneVerification) {
-          await tryAwaitWithRetry(async () =>
-            remoteUsers.updatePhoneVerification(user.$id, true)
-          );
-        }
-
-        if (user.status === false) {
-          await tryAwaitWithRetry(async () =>
-            remoteUsers.updateStatus(user.$id, false)
-          );
-        }
-
-        totalTransferred++;
-        MessageFormatter.success(
-          `Transferred user ${user.$id}`,
-          { prefix: "Transfer" }
-        );
-      } catch (error) {
-        MessageFormatter.error(
-          `Failed to transfer user ${user.$id}`,
-          error instanceof Error ? error : new Error(String(error)),
-          { prefix: "Transfer" }
-        );
-      }
-    }
-
-    if (usersList.users.length < 100) {
-      break;
-    }
-    lastId = usersList.users[usersList.users.length - 1].$id;
-  }
-
-  MessageFormatter.success(
-    `Successfully transferred ${totalTransferred} users`,
-    { prefix: "Transfer" }
-  );
-};
+
+      // Transfer documents
+      const { transferDocumentsBetweenDbsLocalToRemote } = await import(
+        "../collections/methods.js"
+      );
+      await transferDocumentsBetweenDbsLocalToRemote(
+        localDb,
+        endpoint,
+        projectId,
+        apiKey,
+        fromDbId,
+        toDbId,
+        collection.$id,
+        targetCollection.$id
+      );
+    } catch (error) {
+      MessageFormatter.error(
+        `Error processing collection ${collection.name}`,
+        error instanceof Error ? error : new Error(String(error)),
+        { prefix: "Transfer" }
+      );
+    }
+  }
+};
+
+export const transferUsersLocalToRemote = async (
+  localUsers: Users,
+  endpoint: string,
+  projectId: string,
+  apiKey: string
+) => {
+  MessageFormatter.info(
+    "Starting user transfer to remote instance...",
+    { prefix: "Transfer" }
+  );
+
+  const client = getClient(endpoint, projectId, apiKey);
+  const remoteUsers = new Users(client);
+
+  let totalTransferred = 0;
+  let lastId: string | undefined;
+
+  while (true) {
+    const queries = [Query.limit(100)];
+    if (lastId) {
+      queries.push(Query.cursorAfter(lastId));
+    }
+
+    const usersList = await tryAwaitWithRetry(async () =>
+      localUsers.list(queries)
+    );
+
+    if (usersList.users.length === 0) {
+      break;
+    }
+
+    for (const user of usersList.users) {
+      try {
+        // Check if user already exists in remote
+        let remoteUser: Models.User<Models.Preferences> | undefined;
+        try {
+          remoteUser = await tryAwaitWithRetry(async () =>
+            remoteUsers.get(user.$id)
+          );
+          
+          // If user exists, update only the differences
+          if (remoteUser) {
+            MessageFormatter.info(
+              `User ${user.$id} exists, checking for updates...`,
+              { prefix: "Transfer" }
+            );
+            let hasUpdates = false;
+
+            // Update name if different
+            if (remoteUser.name !== user.name) {
+              await tryAwaitWithRetry(async () =>
+                remoteUsers.updateName(user.$id, user.name)
+              );
+              MessageFormatter.success(
+                `Updated name for user ${user.$id}`,
+                { prefix: "Transfer" }
+              );
+              hasUpdates = true;
+            }
+
+            // Update email if different
+            if (remoteUser.email !== user.email) {
+              await tryAwaitWithRetry(async () =>
+                remoteUsers.updateEmail(user.$id, user.email)
+              );
+              MessageFormatter.success(
+                `Updated email for user ${user.$id}`,
+                { prefix: "Transfer" }
+              );
+              hasUpdates = true;
+            }
+
+            // Update phone if different
+            const normalizedLocalPhone = user.phone 
+              ? converterFunctions.convertPhoneStringToUSInternational(user.phone)
+              : undefined;
+            if (remoteUser.phone !== normalizedLocalPhone) {
+              if (normalizedLocalPhone) {
+                await tryAwaitWithRetry(async () =>
+                  remoteUsers.updatePhone(user.$id, normalizedLocalPhone)
+                );
+              }
+              MessageFormatter.success(
+                `Updated phone for user ${user.$id}`,
+                { prefix: "Transfer" }
+              );
+              hasUpdates = true;
+            }
+
+            // Update preferences if different
+            if (JSON.stringify(remoteUser.prefs) !== JSON.stringify(user.prefs)) {
+              await tryAwaitWithRetry(async () =>
+                remoteUsers.updatePrefs(user.$id, user.prefs)
+              );
+              MessageFormatter.success(
+                `Updated preferences for user ${user.$id}`,
+                { prefix: "Transfer" }
+              );
+              hasUpdates = true;
+            }
+
+            // Update labels if different
+            if (JSON.stringify(remoteUser.labels) !== JSON.stringify(user.labels)) {
+              await tryAwaitWithRetry(async () =>
+                remoteUsers.updateLabels(user.$id, user.labels)
+              );
+              MessageFormatter.success(
+                `Updated labels for user ${user.$id}`,
+                { prefix: "Transfer" }
+              );
+              hasUpdates = true;
+            }
+
+            // Update email verification if different
+            if (remoteUser.emailVerification !== user.emailVerification) {
+              await tryAwaitWithRetry(async () =>
+                remoteUsers.updateEmailVerification(user.$id, user.emailVerification)
+              );
+              MessageFormatter.success(
+                `Updated email verification for user ${user.$id}`,
+                { prefix: "Transfer" }
+              );
+              hasUpdates = true;
+            }
+
+            // Update phone verification if different
+            if (remoteUser.phoneVerification !== user.phoneVerification) {
+              await tryAwaitWithRetry(async () =>
+                remoteUsers.updatePhoneVerification(user.$id, user.phoneVerification)
+              );
+              MessageFormatter.success(
+                `Updated phone verification for user ${user.$id}`,
+                { prefix: "Transfer" }
+              );
+              hasUpdates = true;
+            }
+
+            // Update status if different
+            if (remoteUser.status !== user.status) {
+              await tryAwaitWithRetry(async () =>
+                remoteUsers.updateStatus(user.$id, user.status)
+              );
+              MessageFormatter.success(
+                `Updated status for user ${user.$id}`,
+                { prefix: "Transfer" }
+              );
+              hasUpdates = true;
+            }
+
+            if (!hasUpdates) {
+              MessageFormatter.info(
+                `User ${user.$id} is already up to date, skipping...`,
+                { prefix: "Transfer" }
+              );
+            } else {
+              totalTransferred++;
+              MessageFormatter.success(
+                `Updated user ${user.$id}`,
+                { prefix: "Transfer" }
+              );
+            }
+            continue;
+          }
+        } catch (error: any) {
+          // User doesn't exist, proceed with creation
+        }
+
+        const phone = user.phone
+          ? converterFunctions.convertPhoneStringToUSInternational(user.phone)
+          : undefined;
+
+        // 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"
+                ) {
+                  MessageFormatter.warning(
+                    `User ${user.$id}: Using default Scrypt parameters due to missing hashOptions`,
+                    { prefix: "Transfer" }
+                  );
+                }
+
+                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
+                ) {
+                  MessageFormatter.warning(
+                    `User ${user.$id}: Missing critical Scrypt Modified parameters in hashOptions`,
+                    { prefix: "Transfer" }
+                  );
+                }
+
+                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:
+                MessageFormatter.warning(
+                  `Unknown hash type '${hashType}' for user ${user.$id}, falling back to Argon2`,
+                  { prefix: "Transfer" }
+                );
+                await tryAwaitWithRetry(async () =>
+                  remoteUsers.createArgon2User(
+                    user.$id,
+                    user.email,
+                    hashedPassword,
+                    user.name
+                  )
+                );
+                break;
+            }
+
+            MessageFormatter.success(
+              `User ${user.$id} created with preserved ${hashType} password`,
+              { prefix: "Transfer" }
+            );
+          } catch (error) {
+            MessageFormatter.warning(
+              `Failed to create user ${user.$id} with ${hashType} hash, trying with temporary password`,
+              { prefix: "Transfer" }
+            );
+
+            // Fallback to creating user with temporary password
+            await tryAwaitWithRetry(async () =>
+              remoteUsers.create(
+                user.$id,
+                user.email,
+                phone,
+                `changeMe${user.email}`,
+                user.name
+              )
+            );
+
+            MessageFormatter.warning(
+              `User ${user.$id} created with temporary password - password reset required`,
+              { prefix: "Transfer" }
+            );
+          }
+        } 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,
+              tempPassword,
+              user.name
+            )
+          );
+
+          if (!user.password) {
+            MessageFormatter.warning(
+              `User ${user.$id} created with temporary password - password reset required`,
+              { prefix: "Transfer" }
+            );
+          }
+        }
+
+        // Update phone, labels, and other attributes for newly created users
+        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 for newly created users
+        await tryAwaitWithRetry(async () =>
+          remoteUsers.updatePrefs(user.$id, user.prefs)
+        );
+
+        if (user.emailVerification) {
+          await tryAwaitWithRetry(async () =>
+            remoteUsers.updateEmailVerification(user.$id, true)
+          );
+        } else {
+          await tryAwaitWithRetry(async () =>
+            remoteUsers.updateEmailVerification(user.$id, false)
+          );
+        }
+
+        if (user.phoneVerification) {
+          await tryAwaitWithRetry(async () =>
+            remoteUsers.updatePhoneVerification(user.$id, true)
+          );
+        }
+
+        if (user.status === false) {
+          await tryAwaitWithRetry(async () =>
+            remoteUsers.updateStatus(user.$id, false)
+          );
+        }
+
+        totalTransferred++;
+        MessageFormatter.success(
+          `Transferred user ${user.$id}`,
+          { prefix: "Transfer" }
+        );
+      } catch (error) {
+        MessageFormatter.error(
+          `Failed to transfer user ${user.$id}`,
+          error instanceof Error ? error : new Error(String(error)),
+          { prefix: "Transfer" }
+        );
+      }
+    }
+
+    if (usersList.users.length < 100) {
+      break;
+    }
+    lastId = usersList.users[usersList.users.length - 1].$id;
+  }
+
+  MessageFormatter.success(
+    `Successfully transferred ${totalTransferred} users`,
+    { prefix: "Transfer" }
+  );
+};