appwrite-utils-cli 1.5.1 → 1.6.0

package/src/migrations/importController.ts

@@ -19,6 +19,7 @@ import { resolveAndUpdateRelationships } from "./relationships.js";
 import { UsersController } from "../users/methods.js";
 import { logger } from "../shared/logging.js";
 import { updateOperation } from "../shared/migrationHelpers.js";
+import { LegacyAdapter } from "../adapters/LegacyAdapter.js";
 import {
   BatchSchema,
   OperationCreateSchema,
@@ -84,10 +85,6 @@ export class ImportController {
     let databaseRan: Models.Database | undefined;
 
     for (let db of databasesToProcess) {
-      if (!this.config.useMigrations && db.name.toLowerCase().trim().replace(" ", "") === "migrations") {
-        continue;
-      }
-
       MessageFormatter.banner(`Starting import data for database: ${db.name}`, "Database Import");
 
       if (!databaseRan) {
@@ -112,9 +109,9 @@ export class ImportController {
         await this.updateOthersToFinalData(databaseRan, db);
       }
 
-      console.log(`---------------------------------`);
-      console.log(`Finished import data for database: ${db.name}`);
-      console.log(`---------------------------------`);
+      MessageFormatter.divider();
+      MessageFormatter.success(`Finished import data for database: ${db.name}`, { prefix: "Import" });
+      MessageFormatter.divider();
     }
   }
 
@@ -274,10 +271,10 @@ export class ImportController {
                   );
                 }
               }
-              console.log("Finished importing users batch");
+              MessageFormatter.success("Finished importing users batch", { prefix: "Import" });
             }
             this.hasImportedUsers = true;
-            console.log("Finished importing users");
+            MessageFormatter.success("Finished importing users", { prefix: "Import" });
           }
         }
 
@@ -287,23 +284,22 @@ export class ImportController {
         }
 
         let importOperation: any = null;
-        if (this.config.useMigrations) {
-          importOperation = await this.database.getDocument(
-            "migrations",
-            "currentOperations",
-            importOperationId
-          );
-          await updateOperation(this.database, importOperation.$id, {
-            status: "in_progress",
-          }, this.config.useMigrations);
-        }
+        importOperation = await this.database.getDocument(
+          "migrations",
+          "currentOperations",
+          importOperationId
+        );
+        const adapter = new LegacyAdapter(this.database);
+        await updateOperation(adapter, db.$id, importOperation.$id, {
+          status: "in_progress",
+        });
         
         const collectionData = dataLoader.importMap.get(
           dataLoader.getCollectionKey(collection.name)
         );
-        console.log(`Processing collection: ${collection.name}...`);
+        MessageFormatter.processing(`Processing collection: ${collection.name}...`, { prefix: "Import" });
         if (!collectionData) {
-          console.log("No collection data for ", collection.name);
+          MessageFormatter.warning(`No collection data for ${collection.name}`, { prefix: "Import" });
           continue;
         }
 
@@ -311,7 +307,7 @@ export class ImportController {
         let processedItems = 0;
         for (let i = 0; i < dataSplit.length; i++) {
           const batches = dataSplit[i];
-          console.log(`Processing batch ${i + 1} of ${dataSplit.length}`);
+          MessageFormatter.progress(`Processing batch ${i + 1} of ${dataSplit.length}`, { prefix: "Import" });
 
           const batchPromises = batches.map((item, index) => {
             try {
@@ -340,25 +336,31 @@ export class ImportController {
                   )
               );
             } catch (error) {
-              console.error(error);
+              MessageFormatter.error(
+                "Error creating document",
+                error instanceof Error ? error : new Error(String(error)),
+                { prefix: "Import" }
+              );
               return Promise.resolve();
             }
           });
 
           // Wait for all promises in the current batch to resolve
           await Promise.all(batchPromises);
-          console.log(`Completed batch ${i + 1} of ${dataSplit.length}`);
-          if (this.config.useMigrations && importOperation) {
-            await updateOperation(this.database, importOperation.$id, {
+          MessageFormatter.success(`Completed batch ${i + 1} of ${dataSplit.length}`, { prefix: "Import" });
+          if (importOperation) {
+            const adapter = new LegacyAdapter(this.database);
+            await updateOperation(adapter, db.$id, importOperation.$id, {
               progress: processedItems,
-            }, this.config.useMigrations);
+            });
           }
         }
         // After all batches are processed, update the operation status to completed
-        if (this.config.useMigrations && importOperation) {
-          await updateOperation(this.database, importOperation.$id, {
+        if (importOperation) {
+          const adapter = new LegacyAdapter(this.database);
+          await updateOperation(adapter, db.$id, importOperation.$id, {
             status: "completed",
-          }, this.config.useMigrations);
+          });
         }
       }
     }
@@ -369,14 +371,14 @@ export class ImportController {
     dataLoader: DataLoader,
     specificCollections?: string[]
   ) {
-    console.log("Executing post-import actions...");
+    MessageFormatter.info("Executing post-import actions...", { prefix: "Import" });
     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);
+    MessageFormatter.info(`Collections to process: ${collectionsToProcess.join(", ")}`, { prefix: "Import" });
     // Iterate over each collection in the importMap
     for (const [
       collectionKey,
@@ -386,8 +388,9 @@ export class ImportController {
         dataLoader.getCollectionKey(c)
       );
       if (allCollectionKeys.includes(collectionKey)) {
-        console.log(
-          `Processing post-import actions for collection: ${collectionKey}`
+        MessageFormatter.processing(
+          `Processing post-import actions for collection: ${collectionKey}`,
+          { prefix: "Import" }
         );
 
         // Iterate over each item in the collectionData.data
@@ -406,16 +409,18 @@ export class ImportController {
                 context
               );
             } catch (error) {
-              console.error(
-                `Failed to execute post-import actions for item in collection ${collectionKey}:`,
-                error
+              MessageFormatter.error(
+                `Failed to execute post-import actions for item in collection ${collectionKey}`,
+                error instanceof Error ? error : new Error(String(error)),
+                { prefix: "Import" }
               );
             }
           }
         }
       } else {
-        console.log(
-          `Skipping collection: ${collectionKey} because it's not valid for post-import actions`
+        MessageFormatter.info(
+          `Skipping collection: ${collectionKey} because it's not valid for post-import actions`,
+          { prefix: "Import" }
         );
       }
     }

package/src/migrations/relationships.ts

@@ -6,6 +6,7 @@ import type {
   RelationshipAttribute,
 } from "appwrite-utils";
 import { logger } from "../shared/logging.js";
+import { MessageFormatter } from "../shared/messageFormatter.js";
 
 /**
  * Finds collections that have defined relationship attributes.
@@ -44,24 +45,27 @@ export async function resolveAndUpdateRelationships(
 
   // Process each collection sequentially
   for (const collection of collections) {
-    console.log(
-      `Processing collection: ${collection.name} (${collection.$id})`
+    MessageFormatter.processing(
+      `Processing collection: ${collection.name} (${collection.$id})`,
+      { prefix: "Migration" }
     );
     const relAttributeMap = collectionsWithRelationships.get(
       collection.name
     ) as RelationshipAttribute[]; // Get the relationship attributes for the collections
 
     if (!relAttributeMap) {
-      console.log(
-        `No mapping found for collection: ${collection.name}, skipping...`
+      MessageFormatter.info(
+        `No mapping found for collection: ${collection.name}, skipping...`,
+        { prefix: "Migration" }
       );
       continue;
     }
 
     await processCollection(dbId, database, collection, relAttributeMap);
   }
-  console.log(
-    `Completed relationship resolution and update for database ID: ${dbId}`
+  MessageFormatter.success(
+    `Completed relationship resolution and update for database ID: ${dbId}`,
+    { prefix: "Migration" }
   );
 }
 
@@ -82,8 +86,9 @@ async function processCollection(
       ]);
 
     const documents = response.documents;
-    console.log(
-      `Fetched ${documents.length} documents from collection: ${collection.name}`
+    MessageFormatter.info(
+      `Fetched ${documents.length} documents from collection: ${collection.name}`,
+      { prefix: "Migration" }
     );
 
     if (documents.length > 0) {
@@ -119,7 +124,10 @@ async function findDocumentsByOriginalId(
     Query.equal("$id", relatedCollectionId),
   ]);
   if (collection.total === 0) {
-    console.log(`Collection ${relatedCollectionId} doesn't exist, skipping...`);
+    MessageFormatter.warning(
+      `Collection ${relatedCollectionId} doesn't exist, skipping...`,
+      { prefix: "Migration" }
+    );
     return undefined;
   }
   const targetAttr = collection.collections[0].attributes.find(
@@ -127,8 +135,9 @@ async function findDocumentsByOriginalId(
     (attr) => attr.key === targetKey
   ) as any;
   if (!targetAttr) {
-    console.log(
-      `Attribute ${targetKey} not found in collection ${relatedCollectionId}, skipping...`
+    MessageFormatter.warning(
+      `Attribute ${targetKey} not found in collection ${relatedCollectionId}, skipping...`,
+      { prefix: "Migration" }
     );
     return undefined;
   }
@@ -160,7 +169,7 @@ async function prepareDocumentUpdates(
   documents: Models.Document[],
   relationships: RelationshipAttribute[]
 ): Promise<{ collectionId: string; documentId: string; updatePayload: any }[]> {
-  console.log(`Preparing updates for collection: ${collectionName}`);
+  MessageFormatter.processing(`Preparing updates for collection: ${collectionName}`, { prefix: "Migration" });
   const updates: {
     collectionId: string;
     documentId: string;
@@ -173,7 +182,7 @@ async function prepareDocumentUpdates(
   const thisCollectionId = thisCollection?.$id;
 
   if (!thisCollectionId) {
-    console.log(`No collection found with name: ${collectionName}`);
+    MessageFormatter.warning(`No collection found with name: ${collectionName}`, { prefix: "Migration" });
     return [];
   }
 
@@ -183,7 +192,7 @@ async function prepareDocumentUpdates(
     for (const rel of relationships) {
       // Skip if not dealing with the parent side of a two-way relationship
       if (rel.twoWay && rel.side !== "parent") {
-        console.log("Skipping non-parent side of two-way relationship...");
+        MessageFormatter.info("Skipping non-parent side of two-way relationship...", { prefix: "Migration" });
         continue;
       }
 
@@ -192,7 +201,7 @@ async function prepareDocumentUpdates(
       const originalIdField = rel.importMapping?.originalIdField;
       const targetField = rel.importMapping?.targetField || originalIdField; // Use originalIdField if targetField is not specified
       if (!originalIdField) {
-        console.log("Missing originalIdField in importMapping, skipping...");
+        MessageFormatter.warning("Missing originalIdField in importMapping, skipping...", { prefix: "Migration" });
         continue;
       }
       const originalId = doc[originalIdField as keyof typeof doc];
@@ -207,8 +216,9 @@ async function prepareDocumentUpdates(
       ).collections[0];
 
       if (!relatedCollection) {
-        console.log(
-          `Related collection ${rel.relatedCollection} not found, skipping...`
+        MessageFormatter.warning(
+          `Related collection ${rel.relatedCollection} not found, skipping...`,
+          { prefix: "Migration" }
         );
         continue;
       }
@@ -240,7 +250,7 @@ async function prepareDocumentUpdates(
         updatePayload[relationshipKey] = isSingleReference
           ? newRefs[0] || existingRefIds[0]
           : allRefs;
-        console.log(`Updating ${relationshipKey} with ${allRefs.length} refs`);
+        MessageFormatter.info(`Updating ${relationshipKey} with ${allRefs.length} refs`, { prefix: "Migration" });
       }
     }
 

package/src/migrations/services/ImportOrchestrator.ts

@@ -28,6 +28,7 @@ import { MessageFormatter } from "../../shared/messageFormatter.js";
 import { ProgressManager } from "../../shared/progressManager.js";
 import { tryAwaitWithRetry } from "../../utils/index.js";
 import { updateOperation, findOrCreateOperation } from "../../shared/migrationHelpers.js";
+import { LegacyAdapter } from "../../adapters/LegacyAdapter.js";
 import { resolveAndUpdateRelationships } from "../relationships.js";
 
 // Enhanced rate limiting configuration - now managed by RateLimitManager
@@ -104,10 +105,6 @@ export class ImportOrchestrator {
     let processedDatabase: Models.Database | undefined;
 
     for (const db of databasesToProcess) {
-      if (!this.config.useMigrations && db.name.toLowerCase().trim().replace(" ", "") === "migrations") {
-        continue;
-      }
-
       MessageFormatter.banner(`Starting import data for database: ${db.name}`, "Database Import");
 
       if (!processedDatabase) {
@@ -206,17 +203,17 @@ export class ImportOrchestrator {
         this.config.collections[index] = collectionConfig;
 
         // Find or create an import operation for the collection
-        if (this.config.useMigrations) {
-          const collectionImportOperation = await findOrCreateOperation(
-            this.database,
-            collection.$id!,
-            "importData"
-          );
-          this.collectionImportOperations.set(
-            this.getCollectionKey(collection.name),
-            collectionImportOperation.$id
-          );
-        }
+        const adapter = new LegacyAdapter(this.database);
+        const collectionImportOperation = await findOrCreateOperation(
+          adapter,
+          dbId,
+          "importData",
+          collection.$id!
+        );
+        this.collectionImportOperations.set(
+          this.getCollectionKey(collection.name),
+          collectionImportOperation.$id
+        );
 
         // Initialize the collection in the import map
         this.importMap.set(this.getCollectionKey(collection.name), {
@@ -315,7 +312,7 @@ export class ImportOrchestrator {
     const rawData = this.loadDataFromFile(importDef);
     if (rawData.length === 0) return;
 
-    await this.updateOperationStatus(collection, "ready", rawData.length);
+    await this.updateOperationStatus(db, collection, "ready", rawData.length);
 
     const collectionData = this.importMap.get(this.getCollectionKey(collection.name));
     if (!collectionData) {
@@ -395,7 +392,7 @@ export class ImportOrchestrator {
     const rawData = this.loadDataFromFile(importDef);
     if (rawData.length === 0) return;
 
-    await this.updateOperationStatus(collection, "ready", rawData.length);
+    await this.updateOperationStatus(db, collection, "ready", rawData.length);
 
     const collectionData = this.importMap.get(this.getCollectionKey(collection.name));
     if (!collectionData) return;
@@ -504,8 +501,9 @@ export class ImportOrchestrator {
     logger.info(`Importing collection: ${collection.name} (${collectionData.data.length} items)`);
 
     const operationId = this.collectionImportOperations.get(this.getCollectionKey(collection.name));
-    if (operationId && this.config.useMigrations) {
-      await updateOperation(this.database, operationId, { status: "in_progress" }, this.config.useMigrations);
+    const adapter = new LegacyAdapter(this.database);
+    if (operationId) {
+      await updateOperation(adapter, db.$id, operationId, { status: "in_progress" });
     }
 
     // Create batches for processing
@@ -530,14 +528,14 @@ export class ImportOrchestrator {
       logger.info(`Batch ${i + 1} completed: ${successCount}/${batch.length} items imported`);
 
       // Update operation progress
-      if (operationId && this.config.useMigrations) {
-        await updateOperation(this.database, operationId, { progress: processedItems }, this.config.useMigrations);
+      if (operationId) {
+        await updateOperation(adapter, db.$id, operationId, { progress: processedItems });
       }
     }
 
     // Mark operation as completed
-    if (operationId && this.config.useMigrations) {
-      await updateOperation(this.database, operationId, { status: "completed" }, this.config.useMigrations);
+    if (operationId) {
+      await updateOperation(adapter, db.$id, operationId, { status: "completed" });
     }
 
     logger.info(`Completed importing collection: ${collection.name} (${processedItems} items)`);
@@ -636,13 +634,12 @@ export class ImportOrchestrator {
     }
   }
 
-  private async updateOperationStatus(collection: CollectionCreate, status: string, total?: number): Promise<void> {
-    if (!this.config.useMigrations) return;
-    
+  private async updateOperationStatus(db: ConfigDatabase, collection: CollectionCreate, status: string, total?: number): Promise<void> {
     const operationId = this.collectionImportOperations.get(this.getCollectionKey(collection.name));
     if (operationId) {
       const updateData = total ? { status, total } : { status };
-      await updateOperation(this.database, operationId, updateData, this.config.useMigrations);
+      const adapter = new LegacyAdapter(this.database);
+      await updateOperation(adapter, db.$id, operationId, updateData);
     }
   }