appwrite-utils-cli 0.9.983 → 0.9.984

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.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,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) {

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.983",
+  "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);
+      }
     }
   }
 }

package/src/migrations/dataLoader.ts

@@ -1086,6 +1086,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,
@@ -1247,6 +1248,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,
@@ -1462,6 +1464,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,
@@ -1480,36 +1483,41 @@ export class DataLoader {
           transformedData
         );
         itemDataToUpdate.context = context;
-        
+
         // 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: [
-              ...(existingMapping?.postImportActions || []),
-              ...(newMapping.postImportActions || [])
-            ]
-          };
-        });
-      
+        const mergedAttributeMappings = newImportDef.attributeMappings.map(
+          (newMapping) => {
+            const existingMapping =
+              itemDataToUpdate.importDef?.attributeMappings.find(
+                (m) => m.targetKey === newMapping.targetKey
+              );
+
+            return {
+              ...newMapping,
+              postImportActions: [
+                ...(existingMapping?.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
@@ -1614,10 +1622,42 @@ export class DataLoader {
         );
         // 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: string): string | null => {
+              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 = {