appwrite-utils-cli 0.9.983 → 0.9.990

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 = {

package/src/migrations/importController.ts

@@ -119,27 +119,54 @@ 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 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: string | undefined;
+      let targetBucketId: string | undefined;
+
+      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
+        );
+      }
     }
   }
 

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;
@@ -64,15 +64,20 @@ export const transferStorageLocalToLocal = async (
         file.name
       );
       console.log(`Creating file: ${file.name}`);
-      tryAwaitWithRetry(
-        async () =>
+      try {
+        await tryAwaitWithRetry(
+          async () =>
           await storage.createFile(
             toBucketId,
             file.$id,
             fileToCreate,
             file.$permissions
           )
-      );
+        );
+      } catch (error: any) {
+        // File already exists, so we can skip it
+        continue;
+      }
       numberOfFiles++;
     }
   } else {
@@ -167,15 +172,20 @@ export const transferStorageLocalToRemote = async (
       new Uint8Array(fileData),
       file.name
     );
-    await tryAwaitWithRetry(
-      async () =>
+    try {
+      await tryAwaitWithRetry(
+        async () =>
         await remoteStorage.createFile(
           toBucketId,
           file.$id,
           fileToCreate,
           file.$permissions
         )
-    );
+      );
+    } catch (error: any) {
+      // File already exists, so we can skip it
+      continue;
+    }
     numberOfFiles++;
   }
   console.log(

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),
@@ -178,10 +179,34 @@ export class UtilsController {
     );
   }
 
-  async wipeDatabase(database: Models.Database) {
+  async wipeDatabase(database: Models.Database, wipeBucket: boolean = 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: Models.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: any) {
+        // Ignore if bucket doesn't exist
+        if (error?.type !== 'storage_bucket_not_found') {
+          throw error;
+        }
+      }
+    }
   }
 
   async wipeCollection(database: Models.Database, collection: Models.Collection) {
@@ -289,16 +314,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 +334,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);
+      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
+    // 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": []
-}