appwrite-utils-cli 0.9.983 → 0.9.990

package/README.md

@@ -125,6 +125,7 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+- 0.9.990: Fixed `transferFilesLocalToLocal` and `remote` if a document exists with that `$id`, also fixed wipe `"all"` option also wiping the associated buckets
 - 0.9.983: Fixed `afterImportActions` not resolving
 - 0.9.981: Try fixing `tryAwaitWithRetry` to catch `522` errors from Cloudflare, they were appearing for some users, also added a 1000ms delay to `tryAwaitWithRetry`
 - 0.9.98: Fixing some import errors reported by users

package/dist/main.js

@@ -141,7 +141,7 @@ async function main() {
             collections: parsedArgv.collectionIds?.split(","),
             doBackup: parsedArgv.backup,
             wipeDatabase: parsedArgv.wipe === "all" || parsedArgv.wipe === "docs",
-            wipeDocumentStorage: parsedArgv.wipe === "all",
+            wipeDocumentStorage: parsedArgv.wipe === "all" || parsedArgv.wipe === "storage",
             wipeUsers: parsedArgv.wipe === "all" || parsedArgv.wipe === "users",
             generateSchemas: parsedArgv.generate,
             importData: parsedArgv.import,
@@ -173,7 +173,7 @@ async function main() {
             options.wipeCollections) {
             if (options.wipeDatabase && options.databases) {
                 for (const db of options.databases) {
-                    await controller.wipeDatabase(db);
+                    await controller.wipeDatabase(db, options.wipeDocumentStorage);
                 }
             }
             if (options.wipeDocumentStorage && parsedArgv.bucketIds) {
@@ -217,52 +217,66 @@ async function main() {
             await controller.importData(options);
         }
         if (parsedArgv.transfer) {
-            const isRemote = !!parsedArgv.remoteEndpoint;
-            const fromDb = await controller.getDatabasesByIds([parsedArgv.fromDbId]);
-            let toDb;
-            let targetDatabases;
-            let targetStorage;
-            if (isRemote) {
-                if (!parsedArgv.remoteEndpoint ||
-                    !parsedArgv.remoteProjectId ||
-                    !parsedArgv.remoteApiKey) {
-                    throw new Error("Remote transfer details are missing");
+            if (parsedArgv.transfer) {
+                const isRemote = !!parsedArgv.remoteEndpoint;
+                let fromDb, toDb;
+                let targetDatabases;
+                let targetStorage;
+                // Only fetch databases if database IDs are provided
+                if (parsedArgv.fromDbId && parsedArgv.toDbId) {
+                    fromDb = (await controller.getDatabasesByIds([parsedArgv.fromDbId]))[0];
+                    if (isRemote) {
+                        if (!parsedArgv.remoteEndpoint ||
+                            !parsedArgv.remoteProjectId ||
+                            !parsedArgv.remoteApiKey) {
+                            throw new Error("Remote transfer details are missing");
+                        }
+                        const remoteClient = getClient(parsedArgv.remoteEndpoint, parsedArgv.remoteProjectId, parsedArgv.remoteApiKey);
+                        targetDatabases = new Databases(remoteClient);
+                        targetStorage = new Storage(remoteClient);
+                        const remoteDbs = await fetchAllDatabases(targetDatabases);
+                        toDb = remoteDbs.find((db) => db.$id === parsedArgv.toDbId);
+                    }
+                    else {
+                        toDb = (await controller.getDatabasesByIds([parsedArgv.toDbId]))[0];
+                    }
+                    if (!fromDb || !toDb) {
+                        throw new Error("Source or target database not found");
+                    }
                 }
-                const remoteClient = getClient(parsedArgv.remoteEndpoint, parsedArgv.remoteProjectId, parsedArgv.remoteApiKey);
-                targetDatabases = new Databases(remoteClient);
-                targetStorage = new Storage(remoteClient);
-                const remoteDbs = await fetchAllDatabases(targetDatabases);
-                toDb = remoteDbs.find((db) => db.$id === parsedArgv.toDbId);
-            }
-            else {
-                toDb = (await controller.getDatabasesByIds([parsedArgv.toDbId]))[0];
-            }
-            if (!fromDb[0] || !toDb) {
-                throw new Error("Source or target database not found");
-            }
-            let sourceBucket, targetBucket;
-            if (parsedArgv.fromBucketId) {
-                sourceBucket = await controller.storage?.getBucket(parsedArgv.fromBucketId);
-            }
-            if (parsedArgv.toBucketId) {
-                if (isRemote) {
-                    targetBucket = await targetStorage?.getBucket(parsedArgv.toBucketId);
+                // Handle storage setup
+                let sourceBucket, targetBucket;
+                if (parsedArgv.fromBucketId) {
+                    sourceBucket = await controller.storage?.getBucket(parsedArgv.fromBucketId);
+                }
+                if (parsedArgv.toBucketId) {
+                    if (isRemote) {
+                        if (!targetStorage) {
+                            const remoteClient = getClient(parsedArgv.remoteEndpoint, parsedArgv.remoteProjectId, parsedArgv.remoteApiKey);
+                            targetStorage = new Storage(remoteClient);
+                        }
+                        targetBucket = await targetStorage?.getBucket(parsedArgv.toBucketId);
+                    }
+                    else {
+                        targetBucket = await controller.storage?.getBucket(parsedArgv.toBucketId);
+                    }
                 }
-                else {
-                    targetBucket = await controller.storage?.getBucket(parsedArgv.toBucketId);
+                // Validate that at least one transfer type is specified
+                if (!fromDb && !sourceBucket) {
+                    throw new Error("No source database or bucket specified for transfer");
                 }
+                const transferOptions = {
+                    isRemote,
+                    fromDb,
+                    targetDb: toDb,
+                    transferEndpoint: parsedArgv.remoteEndpoint,
+                    transferProject: parsedArgv.remoteProjectId,
+                    transferKey: parsedArgv.remoteApiKey,
+                    sourceBucket: sourceBucket,
+                    targetBucket: targetBucket,
+                };
+                await controller.transferData(transferOptions);
             }
-            const transferOptions = {
-                isRemote,
-                fromDb: fromDb[0],
-                targetDb: toDb,
-                transferEndpoint: parsedArgv.remoteEndpoint,
-                transferProject: parsedArgv.remoteProjectId,
-                transferKey: parsedArgv.remoteApiKey,
-                sourceBucket: sourceBucket,
-                targetBucket: targetBucket,
-            };
-            await controller.transferData(transferOptions);
         }
     }
 }

package/dist/migrations/dataLoader.js

@@ -842,6 +842,7 @@ export class DataLoader {
                 }
             }
             // Update the attribute mappings with any actions that need to be performed post-import
+            // We added the basePath to get the folder from the filePath
             const mappingsWithActions = this.getAttributeMappingsWithActions(importDef.attributeMappings, context, transformedItem);
             // Update the import definition with the new attribute mappings
             const newImportDef = {
@@ -947,6 +948,7 @@ export class DataLoader {
                 continue;
             }
             // Update the attribute mappings with any actions that need to be performed post-import
+            // We added the basePath to get the folder from the filePath
             const mappingsWithActions = this.getAttributeMappingsWithActions(importDef.attributeMappings, context, transformedData);
             // Update the import definition with the new attribute mappings
             const newImportDef = {
@@ -1068,6 +1070,7 @@ export class DataLoader {
                 continue;
             }
             // Update the attribute mappings with any actions that need to be performed post-import
+            // We added the basePath to get the folder from the filePath
             const mappingsWithActions = this.getAttributeMappingsWithActions(importDef.attributeMappings, context, transformedData);
             // Update the import definition with the new attribute mappings
             const newImportDef = {
@@ -1084,21 +1087,21 @@ export class DataLoader {
                         ...newMapping,
                         postImportActions: [
                             ...(existingMapping?.postImportActions || []),
-                            ...(newMapping.postImportActions || [])
-                        ]
+                            ...(newMapping.postImportActions || []),
+                        ],
                     };
                 });
                 itemDataToUpdate.importDef = {
                     ...newImportDef,
-                    attributeMappings: mergedAttributeMappings
+                    attributeMappings: mergedAttributeMappings,
                 };
                 // Debug logging
-                if (mergedAttributeMappings.some(m => m.postImportActions?.length > 0)) {
+                if (mergedAttributeMappings.some((m) => m.postImportActions?.length > 0)) {
                     logger.info(`Post-import actions for ${collection.name}: ${JSON.stringify(mergedAttributeMappings
-                        .filter(m => m.postImportActions?.length > 0)
-                        .map(m => ({
+                        .filter((m) => m.postImportActions?.length > 0)
+                        .map((m) => ({
                         targetKey: m.targetKey,
-                        actions: m.postImportActions
+                        actions: m.postImportActions,
                     })), null, 2)}`);
                 }
             }
@@ -1174,7 +1177,40 @@ export class DataLoader {
                 let mappingFilePath = this.importDataActions.resolveTemplate(mapping.fileData.path, context, item);
                 // Ensure the file path is absolute if it doesn't start with "http"
                 if (!mappingFilePath.toLowerCase().startsWith("http")) {
-                    mappingFilePath = path.resolve(this.appwriteFolderPath, mappingFilePath);
+                    // First try the direct path
+                    let fullPath = path.resolve(this.appwriteFolderPath, mappingFilePath);
+                    // If file doesn't exist, search in subdirectories
+                    if (!fs.existsSync(fullPath)) {
+                        const findFileInDir = (dir) => {
+                            const files = fs.readdirSync(dir);
+                            for (const file of files) {
+                                const filePath = path.join(dir, file);
+                                const stat = fs.statSync(filePath);
+                                if (stat.isDirectory()) {
+                                    // Recursively search subdirectories
+                                    const found = findFileInDir(filePath);
+                                    if (found)
+                                        return found;
+                                }
+                                else if (file === path.basename(mappingFilePath)) {
+                                    return filePath;
+                                }
+                            }
+                            return null;
+                        };
+                        const foundPath = findFileInDir(this.appwriteFolderPath);
+                        if (foundPath) {
+                            mappingFilePath = foundPath;
+                        }
+                        else {
+                            logger.warn(`File not found in any subdirectory: ${mappingFilePath}`);
+                            // Keep the original resolved path as fallback
+                            mappingFilePath = fullPath;
+                        }
+                    }
+                    else {
+                        mappingFilePath = fullPath;
+                    }
                 }
                 // Define the after-import action to create a file and update the field
                 const afterImportAction = {

package/dist/migrations/importController.js

@@ -68,13 +68,36 @@ export class ImportController {
         }
     }
     async updateOthersToFinalData(updatedDb, targetDb) {
-        await transferDatabaseLocalToLocal(this.database, updatedDb.$id, targetDb.$id);
-        // Find the corresponding database configs
-        const updatedDbConfig = this.config.databases.find((db) => db.$id === updatedDb.$id);
-        const targetDbConfig = this.config.databases.find((db) => db.$id === targetDb.$id);
-        // Transfer database-specific bucket if both databases have a bucket defined
-        if (updatedDbConfig?.bucket && targetDbConfig?.bucket) {
-            await transferStorageLocalToLocal(this.storage, updatedDbConfig.bucket.$id, targetDbConfig.bucket.$id);
+        if (this.database) {
+            await transferDatabaseLocalToLocal(this.database, updatedDb.$id, targetDb.$id);
+        }
+        if (this.storage) {
+            // Find the corresponding database configs
+            const updatedDbConfig = this.config.databases.find((db) => db.$id === updatedDb.$id);
+            const targetDbConfig = this.config.databases.find((db) => db.$id === targetDb.$id);
+            const allBuckets = await this.storage.listBuckets([Query.limit(1000)]);
+            const bucketsWithDbIdInThem = allBuckets.buckets.filter(bucket => bucket.name.toLowerCase().includes(updatedDb.$id.toLowerCase()));
+            const configuredUpdatedBucketId = `${this.config.documentBucketId}_${updatedDb.$id.toLowerCase().trim().replace(" ", "")}`;
+            const configuredTargetBucketId = `${this.config.documentBucketId}_${targetDb.$id.toLowerCase().trim().replace(" ", "")}`;
+            let sourceBucketId;
+            let targetBucketId;
+            if (bucketsWithDbIdInThem.find(bucket => bucket.$id === configuredUpdatedBucketId)) {
+                sourceBucketId = configuredUpdatedBucketId;
+            }
+            else if (bucketsWithDbIdInThem.find(bucket => bucket.$id === configuredTargetBucketId)) {
+                targetBucketId = configuredTargetBucketId;
+            }
+            if (!sourceBucketId) {
+                sourceBucketId = updatedDbConfig?.bucket?.$id ||
+                    bucketsWithDbIdInThem[0]?.$id;
+            }
+            if (!targetBucketId) {
+                targetBucketId = targetDbConfig?.bucket?.$id ||
+                    bucketsWithDbIdInThem[0]?.$id;
+            }
+            if (sourceBucketId && targetBucketId) {
+                await transferStorageLocalToLocal(this.storage, sourceBucketId, targetBucketId);
+            }
         }
     }
     async importCollections(db, dataLoader, specificCollections) {

package/dist/migrations/transfer.d.ts

@@ -1,7 +1,7 @@
 import { Databases, Storage, type Models } from "node-appwrite";
 export interface TransferOptions {
-    fromDb: Models.Database;
-    targetDb: Models.Database;
+    fromDb: Models.Database | undefined;
+    targetDb: Models.Database | undefined;
     isRemote: boolean;
     collections?: string[];
     transferEndpoint?: string;

package/dist/migrations/transfer.js

@@ -33,7 +33,13 @@ export const transferStorageLocalToLocal = async (storage, fromBucketId, toBucke
             }
             const fileToCreate = InputFile.fromBuffer(new Uint8Array(fileData), file.name);
             console.log(`Creating file: ${file.name}`);
-            tryAwaitWithRetry(async () => await storage.createFile(toBucketId, file.$id, fileToCreate, file.$permissions));
+            try {
+                await tryAwaitWithRetry(async () => await storage.createFile(toBucketId, file.$id, fileToCreate, file.$permissions));
+            }
+            catch (error) {
+                // File already exists, so we can skip it
+                continue;
+            }
             numberOfFiles++;
         }
     }
@@ -90,7 +96,13 @@ export const transferStorageLocalToRemote = async (localStorage, endpoint, proje
     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);
-        await tryAwaitWithRetry(async () => await remoteStorage.createFile(toBucketId, file.$id, fileToCreate, file.$permissions));
+        try {
+            await tryAwaitWithRetry(async () => await remoteStorage.createFile(toBucketId, file.$id, fileToCreate, file.$permissions));
+        }
+        catch (error) {
+            // File already exists, so we can skip it
+            continue;
+        }
         numberOfFiles++;
     }
     console.log(`Transferred ${numberOfFiles} files from ${fromBucketId} to ${toBucketId}`);

package/dist/utilsController.d.ts

@@ -36,10 +36,8 @@ export declare class UtilsController {
     wipeOtherDatabases(databasesToKeep: Models.Database[]): Promise<void>;
     wipeUsers(): Promise<void>;
     backupDatabase(database: Models.Database): Promise<void>;
-    wipeDatabase(database: Models.Database): Promise<{
-        collectionId: string;
-        collectionName: string;
-    }[]>;
+    wipeDatabase(database: Models.Database, wipeBucket?: boolean): Promise<void>;
+    wipeBucketFromDatabase(database: Models.Database): Promise<void>;
     wipeCollection(database: Models.Database, collection: Models.Collection): Promise<void>;
     wipeDocumentStorage(bucketId: string): Promise<void>;
     createOrUpdateCollectionsForDatabases(databases: Models.Database[], collections?: Models.Collection[]): Promise<void>;

package/dist/utilsController.js

@@ -96,6 +96,8 @@ export class UtilsController {
         await this.init();
         if (!this.database)
             throw new Error("Database not initialized");
+        if (ids.length === 0)
+            return [];
         const dbs = await this.database.list([
             Query.limit(500),
             Query.equal("$id", ids),
@@ -121,11 +123,34 @@ export class UtilsController {
             throw new Error("Database, storage, or config not initialized");
         await backupDatabase(this.config, this.database, database.$id, this.storage);
     }
-    async wipeDatabase(database) {
+    async wipeDatabase(database, wipeBucket = false) {
         await this.init();
         if (!this.database)
             throw new Error("Database not initialized");
-        return await wipeDatabase(this.database, database.$id);
+        await wipeDatabase(this.database, database.$id);
+        if (wipeBucket) {
+            await this.wipeBucketFromDatabase(database);
+        }
+    }
+    async wipeBucketFromDatabase(database) {
+        // Check configured bucket in database config
+        const configuredBucket = this.config?.databases?.find(db => db.$id === database.$id)?.bucket;
+        if (configuredBucket?.$id) {
+            await this.wipeDocumentStorage(configuredBucket.$id);
+        }
+        // Also check for document bucket ID pattern
+        if (this.config?.documentBucketId) {
+            const documentBucketId = `${this.config.documentBucketId}_${database.$id.toLowerCase().trim().replace(/\s+/g, "")}`;
+            try {
+                await this.wipeDocumentStorage(documentBucketId);
+            }
+            catch (error) {
+                // Ignore if bucket doesn't exist
+                if (error?.type !== 'storage_bucket_not_found') {
+                    throw error;
+                }
+            }
+        }
     }
     async wipeCollection(database, collection) {
         await this.init();
@@ -199,13 +224,11 @@ export class UtilsController {
         return this.appwriteFolderPath;
     }
     async transferData(options) {
-        if (!this.database) {
-            throw new Error("Database is not initialized, is the config file correct & created?");
-        }
+        // Remove database requirement check
         let sourceClient = this.database;
         let targetClient;
-        let sourceDatabases;
-        let targetDatabases;
+        let sourceDatabases = [];
+        let targetDatabases = [];
         if (options.isRemote) {
             if (!options.transferEndpoint ||
                 !options.transferProject ||
@@ -213,34 +236,47 @@ export class UtilsController {
                 throw new Error("Remote transfer options are missing");
             }
             const remoteClient = getClient(options.transferEndpoint, options.transferProject, options.transferKey);
-            targetClient = new Databases(remoteClient);
-            sourceDatabases = await fetchAllDatabases(sourceClient);
-            targetDatabases = await fetchAllDatabases(targetClient);
+            if (this.database) {
+                targetClient = new Databases(remoteClient);
+                sourceDatabases = await fetchAllDatabases(sourceClient);
+                targetDatabases = await fetchAllDatabases(targetClient);
+            }
         }
-        else {
+        else if (this.database) {
             targetClient = sourceClient;
             sourceDatabases = targetDatabases = await fetchAllDatabases(sourceClient);
         }
-        // Validate that the provided databases exist in the fetched lists
-        const fromDb = sourceDatabases.find((db) => db.$id === options.fromDb.$id);
-        const targetDb = targetDatabases.find((db) => db.$id === options.targetDb.$id);
-        if (!fromDb || !targetDb) {
-            throw new Error("Source or target database not found");
-        }
-        if (options.isRemote) {
-            // Remote transfer
-            await transferDatabaseLocalToRemote(sourceClient, options.transferEndpoint, options.transferProject, options.transferKey, fromDb.$id, targetDb.$id);
-            if (this.storage && options.sourceBucket && options.targetBucket) {
-                await transferStorageLocalToRemote(this.storage, options.transferEndpoint, options.transferProject, options.transferKey, options.sourceBucket.$id, options.targetBucket.$id);
+        // Only validate databases if they're provided in options
+        if (options.fromDb && options.targetDb) {
+            const fromDb = sourceDatabases.find((db) => db.$id === options.fromDb.$id);
+            const targetDb = targetDatabases.find((db) => db.$id === options.targetDb.$id);
+            if (!fromDb || !targetDb) {
+                throw new Error("Source or target database not found");
+            }
+            if (options.isRemote && targetClient) {
+                await transferDatabaseLocalToRemote(sourceClient, options.transferEndpoint, options.transferProject, options.transferKey, fromDb.$id, targetDb.$id);
+            }
+            else if (targetClient) {
+                await transferDatabaseLocalToLocal(sourceClient, fromDb.$id, targetDb.$id);
             }
         }
-        else {
-            // Local transfer
-            await transferDatabaseLocalToLocal(sourceClient, fromDb.$id, targetDb.$id);
-            if (this.storage && options.sourceBucket && options.targetBucket) {
-                await transferStorageLocalToLocal(this.storage, options.sourceBucket.$id, options.targetBucket.$id);
+        // Handle storage transfer separately
+        if (this.storage && (options.sourceBucket || options.fromDb)) {
+            const sourceBucketId = options.sourceBucket?.$id ||
+                (options.fromDb && this.config?.documentBucketId &&
+                    `${this.config.documentBucketId}_${options.fromDb.$id.toLowerCase().trim().replace(" ", "")}`);
+            const targetBucketId = options.targetBucket?.$id ||
+                (options.targetDb && this.config?.documentBucketId &&
+                    `${this.config.documentBucketId}_${options.targetDb.$id.toLowerCase().trim().replace(" ", "")}`);
+            if (sourceBucketId && targetBucketId) {
+                if (options.isRemote) {
+                    await transferStorageLocalToRemote(this.storage, options.transferEndpoint, options.transferProject, options.transferKey, sourceBucketId, targetBucketId);
+                }
+                else {
+                    await transferStorageLocalToLocal(this.storage, sourceBucketId, targetBucketId);
+                }
             }
         }
-        console.log("Data transfer completed");
+        console.log("Transfer completed");
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "0.9.983",
+  "version": "0.9.990",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/main.ts

@@ -16,7 +16,7 @@ interface CliOptions {
   dbIds?: string;
   collectionIds?: string;
   bucketIds?: string;
-  wipe?: "all" | "docs" | "users";
+  wipe?: "all" | "storage" | "docs" | "users";
   wipeCollections?: boolean;
   generate?: boolean;
   import?: boolean;
@@ -181,7 +181,7 @@ async function main() {
       collections: parsedArgv.collectionIds?.split(","),
       doBackup: parsedArgv.backup,
       wipeDatabase: parsedArgv.wipe === "all" || parsedArgv.wipe === "docs",
-      wipeDocumentStorage: parsedArgv.wipe === "all",
+      wipeDocumentStorage: parsedArgv.wipe === "all" || parsedArgv.wipe === "storage",
       wipeUsers: parsedArgv.wipe === "all" || parsedArgv.wipe === "users",
       generateSchemas: parsedArgv.generate,
       importData: parsedArgv.import,
@@ -220,7 +220,7 @@ async function main() {
     ) {
       if (options.wipeDatabase && options.databases) {
         for (const db of options.databases) {
-          await controller.wipeDatabase(db);
+          await controller.wipeDatabase(db, options.wipeDocumentStorage);
         }
       }
       if (options.wipeDocumentStorage && parsedArgv.bucketIds) {
@@ -271,7 +271,6 @@ async function main() {
       }
     }
 
-
     if (options.generateSchemas) {
       await controller.generateSchemas();
     }
@@ -281,65 +280,91 @@ async function main() {
     }
 
     if (parsedArgv.transfer) {
-      const isRemote = !!parsedArgv.remoteEndpoint;
-      const fromDb = await controller.getDatabasesByIds([parsedArgv.fromDbId!]);
-      let toDb: Models.Database | undefined;
-      let targetDatabases: Databases | undefined;
-      let targetStorage: Storage | undefined;
+      if (parsedArgv.transfer) {
+        const isRemote = !!parsedArgv.remoteEndpoint;
+        let fromDb, toDb: Models.Database | undefined;
+        let targetDatabases: Databases | undefined;
+        let targetStorage: Storage | undefined;
+
+        // Only fetch databases if database IDs are provided
+        if (parsedArgv.fromDbId && parsedArgv.toDbId) {
+          fromDb = (
+            await controller.getDatabasesByIds([parsedArgv.fromDbId])
+          )[0];
+
+          if (isRemote) {
+            if (
+              !parsedArgv.remoteEndpoint ||
+              !parsedArgv.remoteProjectId ||
+              !parsedArgv.remoteApiKey
+            ) {
+              throw new Error("Remote transfer details are missing");
+            }
+            const remoteClient = getClient(
+              parsedArgv.remoteEndpoint,
+              parsedArgv.remoteProjectId,
+              parsedArgv.remoteApiKey
+            );
+            targetDatabases = new Databases(remoteClient);
+            targetStorage = new Storage(remoteClient);
+            const remoteDbs = await fetchAllDatabases(targetDatabases);
+            toDb = remoteDbs.find((db) => db.$id === parsedArgv.toDbId);
+          } else {
+            toDb = (await controller.getDatabasesByIds([parsedArgv.toDbId]))[0];
+          }
 
-      if (isRemote) {
-        if (
-          !parsedArgv.remoteEndpoint ||
-          !parsedArgv.remoteProjectId ||
-          !parsedArgv.remoteApiKey
-        ) {
-          throw new Error("Remote transfer details are missing");
+          if (!fromDb || !toDb) {
+            throw new Error("Source or target database not found");
+          }
         }
-        const remoteClient = getClient(
-          parsedArgv.remoteEndpoint,
-          parsedArgv.remoteProjectId,
-          parsedArgv.remoteApiKey
-        );
-        targetDatabases = new Databases(remoteClient);
-        targetStorage = new Storage(remoteClient);
-        const remoteDbs = await fetchAllDatabases(targetDatabases);
-        toDb = remoteDbs.find((db) => db.$id === parsedArgv.toDbId);
-      } else {
-        toDb = (await controller.getDatabasesByIds([parsedArgv.toDbId!]))[0];
-      }
 
-      if (!fromDb[0] || !toDb) {
-        throw new Error("Source or target database not found");
-      }
+        // Handle storage setup
+        let sourceBucket, targetBucket;
+        if (parsedArgv.fromBucketId) {
+          sourceBucket = await controller.storage?.getBucket(
+            parsedArgv.fromBucketId
+          );
+        }
+        if (parsedArgv.toBucketId) {
+          if (isRemote) {
+            if (!targetStorage) {
+              const remoteClient = getClient(
+                parsedArgv.remoteEndpoint!,
+                parsedArgv.remoteProjectId!,
+                parsedArgv.remoteApiKey!
+              );
+              targetStorage = new Storage(remoteClient);
+            }
+            targetBucket = await targetStorage?.getBucket(
+              parsedArgv.toBucketId
+            );
+          } else {
+            targetBucket = await controller.storage?.getBucket(
+              parsedArgv.toBucketId
+            );
+          }
+        }
 
-      let sourceBucket, targetBucket;
-      if (parsedArgv.fromBucketId) {
-        sourceBucket = await controller.storage?.getBucket(
-          parsedArgv.fromBucketId
-        );
-      }
-      if (parsedArgv.toBucketId) {
-        if (isRemote) {
-          targetBucket = await targetStorage?.getBucket(parsedArgv.toBucketId);
-        } else {
-          targetBucket = await controller.storage?.getBucket(
-            parsedArgv.toBucketId
+        // Validate that at least one transfer type is specified
+        if (!fromDb && !sourceBucket) {
+          throw new Error(
+            "No source database or bucket specified for transfer"
           );
         }
-      }
 
-      const transferOptions: TransferOptions = {
-        isRemote,
-        fromDb: fromDb[0],
-        targetDb: toDb,
-        transferEndpoint: parsedArgv.remoteEndpoint,
-        transferProject: parsedArgv.remoteProjectId,
-        transferKey: parsedArgv.remoteApiKey,
-        sourceBucket: sourceBucket,
-        targetBucket: targetBucket,
-      };
+        const transferOptions: TransferOptions = {
+          isRemote,
+          fromDb,
+          targetDb: toDb,
+          transferEndpoint: parsedArgv.remoteEndpoint,
+          transferProject: parsedArgv.remoteProjectId,
+          transferKey: parsedArgv.remoteApiKey,
+          sourceBucket: sourceBucket,
+          targetBucket: targetBucket,
+        };
 
-      await controller.transferData(transferOptions);
+        await controller.transferData(transferOptions);
+      }
     }
   }
 }