appwrite-utils-cli 0.9.982 → 0.9.984

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,26 +1483,42 @@ export class DataLoader {
           transformedData
         );
         itemDataToUpdate.context = context;
-        // Merge existing importDef with new importDef, focusing only on postImportActions
+
+        // 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 || []),
+              ],
+            };
+          }
+        );
+
         itemDataToUpdate.importDef = {
-          ...itemDataToUpdate.importDef,
-          attributeMappings:
-            itemDataToUpdate.importDef?.attributeMappings.map(
-              (attrMapping, index) => ({
-                ...attrMapping,
-                postImportActions: [
-                  ...(attrMapping.postImportActions || []),
-                  ...(newImportDef.attributeMappings[index]
-                    ?.postImportActions || []),
-                ],
-              })
-            ) || [],
-        } as ImportDef;
-
-        if (collection.name.toLowerCase() === "councils") {
-          console.log(
-            `Mappings in update councils: ${JSON.stringify(
-              itemDataToUpdate.importDef.attributeMappings,
+          ...newImportDef,
+          attributeMappings: mergedAttributeMappings,
+        };
+
+        // 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
             )}`
@@ -1603,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 = {

package/src/migrations/importController.ts

@@ -119,27 +119,38 @@ export class ImportController {
     updatedDb: Models.Database,
     targetDb: Models.Database
   ) {
-    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
-    );
+    if (this.database) {
+      await transferDatabaseLocalToLocal(
+        this.database,
+        updatedDb.$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.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
+        );
+      }
     }
   }
 
@@ -298,11 +309,13 @@ export class ImportController {
   }
 
   async executePostImportActions(dbId: string, dataLoader: DataLoader, specificCollections?: string[]) {
-    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}`
         );
@@ -330,6 +343,8 @@ export class ImportController {
             }
           }
         }
+      } else {
+        console.log(`Skipping collection: ${collectionKey} because it's not valid for post-import actions`);
       }
     }
   }

package/src/migrations/transfer.ts

@@ -13,8 +13,8 @@ import { createOrUpdateAttribute } from "../collections/attributes.js";
 import { parseAttribute } from "appwrite-utils";
 
 export interface TransferOptions {
-  fromDb: Models.Database;
-  targetDb: Models.Database;
+  fromDb: Models.Database | undefined;
+  targetDb: Models.Database | undefined;
   isRemote: boolean;
   collections?: string[];
   transferEndpoint?: string;

package/src/utilsController.ts

@@ -145,6 +145,7 @@ export class UtilsController {
   async getDatabasesByIds(ids: string[]) {
     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),
@@ -289,16 +290,11 @@ export class UtilsController {
   }
 
   async transferData(options: TransferOptions): Promise<void> {
-    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: Databases;
-    let sourceDatabases: Models.Database[];
-    let targetDatabases: Models.Database[];
+    let targetClient: Databases | undefined;
+    let sourceDatabases: Models.Database[] = [];
+    let targetDatabases: Models.Database[] = [];
 
     if (options.isRemote) {
       if (
@@ -314,63 +310,76 @@ export class UtilsController {
         options.transferProject,
         options.transferKey
       );
-      targetClient = new Databases(remoteClient);
-
-      sourceDatabases = await fetchAllDatabases(sourceClient);
-      targetDatabases = await fetchAllDatabases(targetClient);
-    } else {
+      
+      if (this.database) {
+        targetClient = new Databases(remoteClient);
+        sourceDatabases = await fetchAllDatabases(sourceClient!);
+        targetDatabases = await fetchAllDatabases(targetClient);
+      }
+    } 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");
+      sourceDatabases = targetDatabases = await fetchAllDatabases(sourceClient!);
     }
 
-    if (options.isRemote) {
-      // Remote transfer
-      await transferDatabaseLocalToRemote(
-        sourceClient,
-        options.transferEndpoint!,
-        options.transferProject!,
-        options.transferKey!,
-        fromDb.$id,
-        targetDb.$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 (this.storage && options.sourceBucket && options.targetBucket) {
-        await transferStorageLocalToRemote(
-          this.storage,
+      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!,
-          options.sourceBucket.$id,
-          options.targetBucket.$id
+          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/zlogs/album.json

@@ -1,4 +0,0 @@
-{
-  "collection": "album",
-  "data": []
-}