appwrite-utils-cli 1.5.1 → 1.6.0

package/dist/migrations/appwriteToX.js

@@ -7,6 +7,7 @@ import { CollectionSchema, attributeSchema, AppwriteConfigSchema, permissionsSch
 import { getDatabaseFromConfig } from "./afterImportActions.js";
 import { listBuckets } from "../storage/methods.js";
 import { listFunctions, listFunctionDeployments } from "../functions/methods.js";
+import { MessageFormatter } from "../shared/messageFormatter.js";
 export class AppwriteToX {
     config;
     storage;
@@ -62,16 +63,51 @@ export class AppwriteToX {
     async appwriteSync(config, databases) {
         const db = getDatabaseFromConfig(config);
         if (!databases) {
-            databases = await fetchAllDatabases(db);
+            try {
+                MessageFormatter.info("Fetching remote databases...", { prefix: "Migration" });
+                databases = await fetchAllDatabases(db);
+                MessageFormatter.info(`Found ${databases.length} remote databases`, { prefix: "Migration" });
+            }
+            catch (error) {
+                MessageFormatter.error("Failed to fetch remote databases", error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
+                throw new Error(`Database fetch failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
         }
         let updatedConfig = { ...config };
+        // Initialize databases array if it doesn't exist
+        if (!updatedConfig.databases) {
+            updatedConfig.databases = [];
+        }
+        // Sync remote databases to local config - add missing ones
+        MessageFormatter.info(`Syncing ${databases.length} remote databases with local config...`, { prefix: "Migration" });
+        let addedCount = 0;
+        let updatedCount = 0;
+        for (const remoteDb of databases) {
+            // Check if this database already exists in the config
+            const existingDbIndex = updatedConfig.databases.findIndex((localDb) => localDb.$id === remoteDb.$id);
+            if (existingDbIndex === -1) {
+                // Database doesn't exist locally, add it
+                MessageFormatter.success(`Adding new database to config: ${remoteDb.name} (${remoteDb.$id})`, { prefix: "Migration" });
+                updatedConfig.databases.push({
+                    $id: remoteDb.$id,
+                    name: remoteDb.name,
+                });
+                addedCount++;
+            }
+            else {
+                // Database exists, update name if different
+                if (updatedConfig.databases[existingDbIndex].name !== remoteDb.name) {
+                    MessageFormatter.info(`Updating database name: ${updatedConfig.databases[existingDbIndex].name} -> ${remoteDb.name}`, { prefix: "Migration" });
+                    updatedConfig.databases[existingDbIndex].name = remoteDb.name;
+                    updatedCount++;
+                }
+            }
+        }
+        MessageFormatter.success(`Database sync summary: ${addedCount} added, ${updatedCount} updated, ${updatedConfig.databases.length} total`, { prefix: "Migration" });
         // Fetch all buckets
         const allBuckets = await listBuckets(this.storage);
         // Loop through each database
         for (const database of databases) {
-            if (!this.config.useMigrations && database.name.toLowerCase() === "migrations") {
-                continue;
-            }
             // Match bucket to database
             const matchedBucket = allBuckets.buckets.find((bucket) => bucket.$id.toLowerCase().includes(database.$id.toLowerCase()));
             if (matchedBucket) {
@@ -95,7 +131,7 @@ export class AppwriteToX {
                 updatedConfig.collections = [];
             }
             for (const collection of collections) {
-                console.log(`Processing collection: ${collection.name}`);
+                MessageFormatter.processing(`Processing collection: ${collection.name}`, { prefix: "Migration" });
                 const existingCollectionIndex = updatedConfig.collections.findIndex((c) => c.name === collection.name);
                 // Parse the collection permissions and attributes
                 const collPermissions = this.parsePermissionsArray(collection.$permissions);
@@ -109,15 +145,15 @@ export class AppwriteToX {
                 for (const attribute of collAttributes) {
                     if (attribute.type === "relationship" &&
                         attribute.relatedCollection) {
-                        console.log(`Fetching related collection for ID: ${attribute.relatedCollection}`);
+                        MessageFormatter.info(`Fetching related collection for ID: ${attribute.relatedCollection}`, { prefix: "Migration" });
                         try {
                             const relatedCollectionPulled = await db.getCollection(database.$id, attribute.relatedCollection);
-                            console.log(`Fetched Collection Name: ${relatedCollectionPulled.name}`);
+                            MessageFormatter.info(`Fetched Collection Name: ${relatedCollectionPulled.name}`, { prefix: "Migration" });
                             attribute.relatedCollection = relatedCollectionPulled.name;
-                            console.log(`Updated attribute.relatedCollection to: ${attribute.relatedCollection}`);
+                            MessageFormatter.info(`Updated attribute.relatedCollection to: ${attribute.relatedCollection}`, { prefix: "Migration" });
                         }
                         catch (error) {
-                            console.log("Error fetching related collection:", error);
+                            MessageFormatter.error("Error fetching related collection", error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
                         }
                     }
                 }
@@ -152,7 +188,7 @@ export class AppwriteToX {
                     updatedConfig.collections.push(collToPush);
                 }
             }
-            console.log(`Processed ${collections.length} collections in ${database.name}`);
+            MessageFormatter.success(`Processed ${collections.length} collections in ${database.name}`, { prefix: "Migration" });
         }
         // Add unmatched buckets as global buckets
         const globalBuckets = allBuckets.buckets.filter((bucket) => !updatedConfig.databases.some((db) => db.bucket && db.bucket.$id === bucket.$id));
@@ -184,26 +220,36 @@ export class AppwriteToX {
             dirPath: `functions/${func.name}`,
             specification: func.specification,
         }));
-        // Make sure to update the config with all changes
+        // Make sure to update the config with all changes including databases
         updatedConfig.functions = this.updatedConfig.functions;
         this.updatedConfig = updatedConfig;
+        MessageFormatter.success(`Sync completed - ${updatedConfig.databases.length} databases, ${updatedConfig.collections?.length || 0} collections, ${updatedConfig.buckets?.length || 0} buckets, ${updatedConfig.functions?.length || 0} functions`, { prefix: "Migration" });
     }
     async toSchemas(databases) {
-        await this.appwriteSync(this.config, databases);
-        const generator = new SchemaGenerator(this.updatedConfig, this.appwriteFolderPath);
-        // Check if this is a YAML-based project
-        const yamlConfigPath = findYamlConfig(this.appwriteFolderPath);
-        const isYamlProject = !!yamlConfigPath;
-        if (isYamlProject) {
-            console.log("📄 Detected YAML configuration - generating YAML collection definitions");
-            generator.updateYamlCollections();
-            await generator.updateConfig(this.updatedConfig, true);
+        try {
+            MessageFormatter.info("Starting sync-from-Appwrite process...", { prefix: "Migration" });
+            await this.appwriteSync(this.config, databases);
+            const generator = new SchemaGenerator(this.updatedConfig, this.appwriteFolderPath);
+            // Check if this is a YAML-based project
+            const yamlConfigPath = findYamlConfig(this.appwriteFolderPath);
+            const isYamlProject = !!yamlConfigPath;
+            if (isYamlProject) {
+                MessageFormatter.info("Detected YAML configuration - generating YAML collection definitions", { prefix: "Migration" });
+                generator.updateYamlCollections();
+                await generator.updateConfig(this.updatedConfig, true);
+            }
+            else {
+                MessageFormatter.info("Generating TypeScript collection definitions", { prefix: "Migration" });
+                generator.updateTsSchemas();
+                await generator.updateConfig(this.updatedConfig, false);
+            }
+            MessageFormatter.info("Generating Zod schemas from synced collections...", { prefix: "Migration" });
+            generator.generateSchemas();
+            MessageFormatter.success("Sync-from-Appwrite process completed successfully", { prefix: "Migration" });
         }
-        else {
-            console.log("📝 Generating TypeScript collection definitions");
-            generator.updateTsSchemas();
-            await generator.updateConfig(this.updatedConfig, false);
+        catch (error) {
+            MessageFormatter.error("Error during sync-from-Appwrite process", error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
+            throw error;
         }
-        generator.generateSchemas();
     }
 }

package/dist/migrations/dataLoader.js

@@ -8,9 +8,11 @@ import { ID, Users } from "node-appwrite";
 import { logger } from "../shared/logging.js";
 import { findOrCreateOperation, updateOperation } from "../shared/migrationHelpers.js";
 import { AuthUserCreateSchema } from "../schemas/authUser.js";
+import { LegacyAdapter } from "../adapters/LegacyAdapter.js";
 import { UsersController } from "../users/methods.js";
 import { finalizeByAttributeMap } from "../utils/helperFunctions.js";
 import { isEmpty } from "es-toolkit/compat";
+import { MessageFormatter } from "../shared/messageFormatter.js";
 // Define a schema for the structure of collection import data using Zod for validation
 export const CollectionImportDataSchema = z.object({
     // Optional collection creation schema
@@ -149,9 +151,9 @@ export class DataLoader {
     loadData(importDef) {
         // Simply join appwriteFolderPath with the importDef.filePath
         const filePath = path.resolve(this.appwriteFolderPath, importDef.filePath);
-        console.log(`Loading data from: ${filePath}`); // Add logging
+        MessageFormatter.info(`Loading data from: ${filePath}`, { prefix: "Data" });
         if (!fs.existsSync(filePath)) {
-            console.error(`File not found: ${filePath}`);
+            MessageFormatter.error(`File not found: ${filePath}`, undefined, { prefix: "Data" });
             return [];
         }
         // Read the file and parse the JSON data
@@ -159,7 +161,7 @@ export class DataLoader {
         const parsedData = importDef.basePath
             ? JSON.parse(rawData)[importDef.basePath]
             : JSON.parse(rawData);
-        console.log(`Loaded ${parsedData?.length || 0} items from ${filePath}`);
+        MessageFormatter.success(`Loaded ${parsedData?.length || 0} items from ${filePath}`, { prefix: "Data" });
         return parsedData;
     }
     // Helper method to check if a new ID already exists in the old-to-new ID map
@@ -249,7 +251,8 @@ export class DataLoader {
                 collection.$id = collectionExists.$id;
                 this.config.collections[index] = collectionConfig;
                 // Find or create an import operation for the collection
-                const collectionImportOperation = await findOrCreateOperation(this.database, collection.$id, "importData");
+                const adapter = new LegacyAdapter(this.database);
+                const collectionImportOperation = await findOrCreateOperation(adapter, dbId, "importData", collection.$id);
                 // Store the operation ID in the map
                 this.collectionImportOperations.set(this.getCollectionKey(collection.name), collectionImportOperation.$id);
                 // Initialize the collection in the import map
@@ -300,12 +303,12 @@ export class DataLoader {
     }
     // Main method to start the data loading process for a given database ID
     async start(dbId) {
-        console.log("---------------------------------");
-        console.log(`Starting data setup for database: ${dbId}`);
-        console.log("---------------------------------");
+        MessageFormatter.divider();
+        MessageFormatter.info(`Starting data setup for database: ${dbId}`, { prefix: "Data" });
+        MessageFormatter.divider();
         await this.setupMaps(dbId);
         const allUsers = await this.getAllUsers();
-        console.log(`Fetched ${allUsers.length} users, waiting a few seconds to let the program catch up...`);
+        MessageFormatter.info(`Fetched ${allUsers.length} users, waiting a few seconds to let the program catch up...`, { prefix: "Data" });
         await new Promise((resolve) => setTimeout(resolve, 5000));
         // Iterate over the configured databases to find the matching one
         for (const db of this.config.databases) {
@@ -346,17 +349,17 @@ export class DataLoader {
                     this.prepareUpdateData(db, collection, updateDef);
                 }
             }
-            console.log("Running update references");
+            MessageFormatter.info("Running update references", { prefix: "Data" });
             // this.dealWithMergedUsers();
             this.updateOldReferencesForNew();
-            console.log("Done running update references");
+            MessageFormatter.success("Done running update references", { prefix: "Data" });
         }
         // for (const collection of this.config.collections) {
         //   this.resolveDataItemRelationships(collection);
         // }
-        console.log("---------------------------------");
-        console.log(`Data setup for database: ${dbId} completed`);
-        console.log("---------------------------------");
+        MessageFormatter.divider();
+        MessageFormatter.success(`Data setup for database: ${dbId} completed`, { prefix: "Data" });
+        MessageFormatter.divider();
         if (this.shouldWriteFile) {
             this.writeMapsToJsonFile();
         }
@@ -433,7 +436,7 @@ export class DataLoader {
             const collectionData = this.importMap.get(collectionKey);
             if (!collectionData || !collectionData.data)
                 continue;
-            console.log(`Updating references for collection: ${collectionConfig.name}`);
+            MessageFormatter.processing(`Updating references for collection: ${collectionConfig.name}`, { prefix: "Data" });
             let needsUpdate = false;
             // Iterate over each data item in the current collection
             for (let i = 0; i < collectionData.data.length; i++) {
@@ -567,10 +570,10 @@ export class DataLoader {
             const outputFile = path.join(outputDir, fileName);
             fs.writeFile(outputFile, JSON.stringify(data, null, 2), "utf8", (err) => {
                 if (err) {
-                    console.error(`Error writing data to ${fileName}:`, err);
+                    MessageFormatter.error(`Error writing data to ${fileName}`, err instanceof Error ? err : new Error(String(err)), { prefix: "Data" });
                     return;
                 }
-                console.log(`Data successfully written to ${fileName}`);
+                MessageFormatter.success(`Data successfully written to ${fileName}`, { prefix: "Data" });
             });
         };
         // Convert Maps to arrays of entries for serialization
@@ -751,16 +754,19 @@ export class DataLoader {
             this.oldIdToNewIdPerCollectionMap
                 .set(this.getCollectionKey(collection.name), oldIdToNewIdMap)
                 .get(this.getCollectionKey(collection.name));
+        const adapter = new LegacyAdapter(this.database);
         if (!operationId) {
-            const collectionImportOperation = await findOrCreateOperation(this.database, collection.$id, "importData");
+            const collectionImportOperation = await findOrCreateOperation(adapter, db.$id, "importData", collection.$id);
             // Store the operation ID in the map
             this.collectionImportOperations.set(this.getCollectionKey(collection.name), collectionImportOperation.$id);
             operationId = collectionImportOperation.$id;
         }
-        await updateOperation(this.database, operationId, {
-            status: "ready",
-            total: rawData.length,
-        });
+        if (operationId) {
+            await updateOperation(adapter, db.$id, operationId, {
+                status: "ready",
+                total: rawData.length,
+            });
+        }
         // Retrieve the current user data and the current collection data from the import map
         const currentUserData = this.importMap.get(this.getCollectionKey("users"));
         const currentData = this.importMap.get(this.getCollectionKey(collection.name));
@@ -901,16 +907,19 @@ export class DataLoader {
         // Load the raw data based on the import definition
         const rawData = this.loadData(importDef);
         let operationId = this.collectionImportOperations.get(this.getCollectionKey(collection.name));
+        const adapter = new LegacyAdapter(this.database);
         if (!operationId) {
-            const collectionImportOperation = await findOrCreateOperation(this.database, collection.$id, "importData");
+            const collectionImportOperation = await findOrCreateOperation(adapter, db.$id, "importData", collection.$id);
             // Store the operation ID in the map
             this.collectionImportOperations.set(this.getCollectionKey(collection.name), collectionImportOperation.$id);
             operationId = collectionImportOperation.$id;
         }
-        await updateOperation(this.database, operationId, {
-            status: "ready",
-            total: rawData.length,
-        });
+        if (operationId) {
+            await updateOperation(adapter, db.$id, operationId, {
+                status: "ready",
+                total: rawData.length,
+            });
+        }
         // Initialize a new map for old ID to new ID mappings
         const oldIdToNewIdMapNew = new Map();
         // Retrieve or initialize the collection-specific old ID to new ID map

package/dist/migrations/importController.js

@@ -4,6 +4,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, OperationSchema, } from "../storage/schemas.js";
 import { DataLoader } from "./dataLoader.js";
 import { transferDatabaseLocalToLocal, transferStorageLocalToLocal, } from "./transfer.js";
@@ -45,9 +46,6 @@ export class ImportController {
         let dataLoader;
         let databaseRan;
         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) {
                 databaseRan = db;
@@ -61,9 +59,9 @@ export class ImportController {
             else if (databaseRan.$id !== db.$id) {
                 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();
         }
     }
     async updateOthersToFinalData(updatedDb, targetDb) {
@@ -162,10 +160,10 @@ export class ImportController {
                                         item.context.docId, true);
                                 }
                             }
-                            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" });
                     }
                 }
                 if (!importOperationId) {
@@ -173,23 +171,22 @@ export class ImportController {
                     continue;
                 }
                 let importOperation = 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;
                 }
                 const dataSplit = createBatches(collectionData.data);
                 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 {
                             const id = item.finalData.docId ||
@@ -208,41 +205,43 @@ export class ImportController {
                             return tryAwaitWithRetry(async () => await this.database.createDocument(db.$id, collection.$id, id, item.finalData));
                         }
                         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);
+                    });
                 }
             }
         }
     }
     async executePostImportActions(dbId, dataLoader, specificCollections) {
-        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, collectionData,] of dataLoader.importMap.entries()) {
             const allCollectionKeys = collectionsToProcess.map((c) => 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
                 for (const item of collectionData.data) {
                     // Assuming each item has attributeMappings that contain actions to be executed
@@ -256,13 +255,13 @@ export class ImportController {
                             await this.importDataActions.executeAfterImportActions(item.finalData, item.importDef.attributeMappings, 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/dist/migrations/relationships.js

@@ -1,6 +1,7 @@
 import { Databases, Query } from "node-appwrite";
 import { fetchAllCollections } from "../collections/methods.js";
 import { logger } from "../shared/logging.js";
+import { MessageFormatter } from "../shared/messageFormatter.js";
 /**
  * Finds collections that have defined relationship attributes.
  */
@@ -30,15 +31,15 @@ export async function resolveAndUpdateRelationships(dbId, database, config) {
     const collectionsWithRelationships = findCollectionsWithRelationships(config);
     // 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); // 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" });
 }
 async function processCollection(dbId, database, collection, relAttributeMap) {
     let after; // For pagination
@@ -49,7 +50,7 @@ async function processCollection(dbId, database, collection, relAttributeMap) {
             ...(after ? [Query.cursorAfter(after)] : []),
         ]);
         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) {
             const updates = await prepareDocumentUpdates(database, dbId, collection.name, documents, relAttributeMap);
             // Execute updates for the current batch
@@ -69,14 +70,14 @@ async function findDocumentsByOriginalId(database, dbId, targetCollection, targe
         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(
     // @ts-ignore
     (attr) => attr.key === targetKey);
     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;
     }
     let queries = [];
@@ -102,12 +103,12 @@ async function findDocumentsByOriginalId(database, dbId, targetCollection, targe
     }
 }
 async function prepareDocumentUpdates(database, dbId, collectionName, documents, relationships) {
-    console.log(`Preparing updates for collection: ${collectionName}`);
+    MessageFormatter.processing(`Preparing updates for collection: ${collectionName}`, { prefix: "Migration" });
     const updates = [];
     const thisCollection = (await database.listCollections(dbId, [Query.equal("name", collectionName)])).collections[0];
     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 [];
     }
     for (const doc of documents) {
@@ -115,14 +116,14 @@ async function prepareDocumentUpdates(database, dbId, collectionName, documents,
         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;
             }
             const isSingleReference = rel.relationType === "oneToOne" || rel.relationType === "manyToOne";
             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];
@@ -133,7 +134,7 @@ async function prepareDocumentUpdates(database, dbId, collectionName, documents,
                 Query.equal("name", rel.relatedCollection),
             ])).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;
             }
             const foundDocuments = await findDocumentsByOriginalId(database, dbId, relatedCollection, targetField, String(originalId));
@@ -155,7 +156,7 @@ async function prepareDocumentUpdates(database, dbId, collectionName, documents,
                 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" });
             }
         }
         if (Object.keys(updatePayload).length > 0) {