appwrite-utils-cli 0.9.982 → 0.9.984

package/README.md

@@ -125,6 +125,7 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+- 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
 - 0.9.95: Updated to include new version of `appwrite-utils`

package/dist/main.js

@@ -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.d.ts

@@ -708,27 +708,7 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
         attributes?: ({
             key: string;
             type?: "string" | undefined;
-            format
-            /**
-             * Generates attribute mappings with post-import actions based on the provided attribute mappings.
-             * This method checks each mapping for a fileData attribute and adds a post-import action to create a file
-             * and update the field with the file's ID if necessary.
-             *
-             * @param attributeMappings - The attribute mappings from the import definition.
-             * @param context - The context object containing information about the database, collection, and document.
-             * @param item - The item being imported, used for resolving template paths in fileData mappings.
-             * @returns The attribute mappings updated with any necessary post-import actions.
-             */
-            ? /**
-             * Generates attribute mappings with post-import actions based on the provided attribute mappings.
-             * This method checks each mapping for a fileData attribute and adds a post-import action to create a file
-             * and update the field with the file's ID if necessary.
-             *
-             * @param attributeMappings - The attribute mappings from the import definition.
-             * @param context - The context object containing information about the database, collection, and document.
-             * @param item - The item being imported, used for resolving template paths in fileData mappings.
-             * @returns The attribute mappings updated with any necessary post-import actions.
-             */: string | null | undefined;
+            format?: string | null | undefined;
             description?: string | Record<string, string> | undefined;
             required?: boolean | undefined;
             array?: boolean | undefined;
@@ -1392,27 +1372,7 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
         attributes?: ({
             key: string;
             type?: "string" | undefined;
-            format
-            /**
-             * Generates attribute mappings with post-import actions based on the provided attribute mappings.
-             * This method checks each mapping for a fileData attribute and adds a post-import action to create a file
-             * and update the field with the file's ID if necessary.
-             *
-             * @param attributeMappings - The attribute mappings from the import definition.
-             * @param context - The context object containing information about the database, collection, and document.
-             * @param item - The item being imported, used for resolving template paths in fileData mappings.
-             * @returns The attribute mappings updated with any necessary post-import actions.
-             */
-            ? /**
-             * Generates attribute mappings with post-import actions based on the provided attribute mappings.
-             * This method checks each mapping for a fileData attribute and adds a post-import action to create a file
-             * and update the field with the file's ID if necessary.
-             *
-             * @param attributeMappings - The attribute mappings from the import definition.
-             * @param context - The context object containing information about the database, collection, and document.
-             * @param item - The item being imported, used for resolving template paths in fileData mappings.
-             * @returns The attribute mappings updated with any necessary post-import actions.
-             */: string | null | undefined;
+            format?: string | null | undefined;
             description?: string | Record<string, string> | undefined;
             required?: boolean | undefined;
             array?: boolean | undefined;

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 = {
@@ -1077,20 +1080,29 @@ export class DataLoader {
             if (itemDataToUpdate) {
                 itemDataToUpdate.finalData = this.mergeObjects(itemDataToUpdate.finalData, transformedData);
                 itemDataToUpdate.context = context;
-                // Merge existing importDef with new importDef, focusing only on postImportActions
-                itemDataToUpdate.importDef = {
-                    ...itemDataToUpdate.importDef,
-                    attributeMappings: itemDataToUpdate.importDef?.attributeMappings.map((attrMapping, index) => ({
-                        ...attrMapping,
+                // Fix: Ensure we properly merge the attribute mappings and their actions
+                const mergedAttributeMappings = newImportDef.attributeMappings.map((newMapping) => {
+                    const existingMapping = itemDataToUpdate.importDef?.attributeMappings.find((m) => m.targetKey === newMapping.targetKey);
+                    return {
+                        ...newMapping,
                         postImportActions: [
-                            ...(attrMapping.postImportActions || []),
-                            ...(newImportDef.attributeMappings[index]
-                                ?.postImportActions || []),
+                            ...(existingMapping?.postImportActions || []),
+                            ...(newMapping.postImportActions || []),
                         ],
-                    })) || [],
+                    };
+                });
+                itemDataToUpdate.importDef = {
+                    ...newImportDef,
+                    attributeMappings: mergedAttributeMappings,
                 };
-                if (collection.name.toLowerCase() === "councils") {
-                    console.log(`Mappings in update councils: ${JSON.stringify(itemDataToUpdate.importDef.attributeMappings, null, 2)}`);
+                // Debug logging
+                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) => ({
+                        targetKey: m.targetKey,
+                        actions: m.postImportActions,
+                    })), null, 2)}`);
                 }
             }
             else {
@@ -1165,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,22 @@ 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 sourceBucketId = updatedDbConfig?.bucket?.$id ||
+                (this.config.documentBucketId &&
+                    `${this.config.documentBucketId}_${updatedDb.$id.toLowerCase().trim().replace(" ", "")}`);
+            const targetBucketId = targetDbConfig?.bucket?.$id ||
+                (this.config.documentBucketId &&
+                    `${this.config.documentBucketId}_${targetDb.$id.toLowerCase().trim().replace(" ", "")}`);
+            if (sourceBucketId && targetBucketId) {
+                await transferStorageLocalToLocal(this.storage, sourceBucketId, targetBucketId);
+            }
         }
     }
     async importCollections(db, dataLoader, specificCollections) {
@@ -198,10 +207,13 @@ export class ImportController {
         }
     }
     async executePostImportActions(dbId, dataLoader, specificCollections) {
-        const collectionsToProcess = specificCollections || Array.from(dataLoader.importMap.keys());
+        console.log("Executing post-import actions...");
+        const collectionsToProcess = specificCollections && specificCollections.length > 0 ? specificCollections : (this.config.collections ? this.config.collections.map(c => c.name) : Array.from(dataLoader.importMap.keys()));
+        console.log("Collections to process:", collectionsToProcess);
         // Iterate over each collection in the importMap
         for (const [collectionKey, collectionData] of dataLoader.importMap.entries()) {
-            if (collectionsToProcess.includes(collectionKey)) {
+            const allCollectionKeys = collectionsToProcess.map(c => dataLoader.getCollectionKey(c));
+            if (allCollectionKeys.includes(collectionKey)) {
                 console.log(`Processing post-import actions for collection: ${collectionKey}`);
                 // Iterate over each item in the collectionData.data
                 for (const item of collectionData.data) {
@@ -221,6 +233,9 @@ export class ImportController {
                     }
                 }
             }
+            else {
+                console.log(`Skipping collection: ${collectionKey} because it's not valid for post-import actions`);
+            }
         }
     }
 }

package/dist/migrations/migrationHelper.d.ts

@@ -91,7 +91,6 @@ export declare const ContextObject: z.ZodObject<{
     context: z.ZodAny;
 }, "strip", z.ZodTypeAny, {
     collectionId: string;
-    dbId: string;
     attributeMappings: {
         targetKey: string;
         oldKey?: string | undefined;
@@ -111,11 +110,11 @@ export declare const ContextObject: z.ZodObject<{
             action: string;
         }[] | undefined;
     }[];
+    dbId: string;
     context?: any;
     finalItem?: any;
 }, {
     collectionId: string;
-    dbId: string;
     attributeMappings: {
         targetKey: string;
         oldKey?: string | undefined;
@@ -135,6 +134,7 @@ export declare const ContextObject: z.ZodObject<{
             action: string;
         }[] | undefined;
     }[];
+    dbId: string;
     context?: any;
     finalItem?: any;
 }>;

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/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),
@@ -199,13 +201,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 +213,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.982",
+  "version": "0.9.984",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/main.ts

@@ -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);
+      }
     }
   }
 }