appwrite-utils-cli 0.10.86 → 1.0.1

package/dist/collections/methods.js

@@ -1,10 +1,12 @@
 import { Client, Databases, ID, Permission, Query, } from "node-appwrite";
-import { nameToIdMapping, processQueue } from "../migrations/queue.js";
+import { nameToIdMapping, processQueue } from "../shared/operationQueue.js";
 import { createUpdateCollectionAttributes } from "./attributes.js";
 import { createOrUpdateIndexes } from "./indexes.js";
-import { SchemaGenerator } from "../migrations/schemaStrings.js";
+import { SchemaGenerator } from "../shared/schemaGenerator.js";
 import { isNull, isUndefined, isNil, isPlainObject, isString, isJSONValue, chunk, } from "es-toolkit";
 import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { MessageFormatter } from "../shared/messageFormatter.js";
+import { ProgressManager } from "../shared/progressManager.js";
 export const documentExists = async (db, dbId, targetCollectionId, toCreateObject) => {
     const collection = await db.getCollection(dbId, targetCollectionId);
     const attributes = collection.attributes;
@@ -48,19 +50,19 @@ export const documentExists = async (db, dbId, targetCollectionId, toCreateObjec
 };
 export const checkForCollection = async (db, dbId, collection) => {
     try {
-        console.log(`Checking for collection with name: ${collection.name}`);
+        MessageFormatter.progress(`Checking for collection with name: ${collection.name}`, { prefix: "Collections" });
         const response = await tryAwaitWithRetry(async () => await db.listCollections(dbId, [Query.equal("name", collection.name)]));
         if (response.collections.length > 0) {
-            console.log(`Collection found: ${response.collections[0].$id}`);
+            MessageFormatter.info(`Collection found: ${response.collections[0].$id}`, { prefix: "Collections" });
             return { ...collection, ...response.collections[0] };
         }
         else {
-            console.log(`No collection found with name: ${collection.name}`);
+            MessageFormatter.info(`No collection found with name: ${collection.name}`, { prefix: "Collections" });
             return null;
         }
     }
     catch (error) {
-        console.error(`Error checking for collection: ${error}`);
+        MessageFormatter.error(`Error checking for collection: ${collection.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Collections" });
         return null;
     }
 };
@@ -68,20 +70,20 @@ export const checkForCollection = async (db, dbId, collection) => {
 export const fetchAndCacheCollectionByName = async (db, dbId, collectionName) => {
     if (nameToIdMapping.has(collectionName)) {
         const collectionId = nameToIdMapping.get(collectionName);
-        console.log(`\tCollection found in cache: ${collectionId}`);
+        MessageFormatter.debug(`Collection found in cache: ${collectionId}`, undefined, { prefix: "Collections" });
         return await tryAwaitWithRetry(async () => await db.getCollection(dbId, collectionId));
     }
     else {
-        console.log(`\tFetching collection by name: ${collectionName}`);
+        MessageFormatter.progress(`Fetching collection by name: ${collectionName}`, { prefix: "Collections" });
         const collectionsPulled = await tryAwaitWithRetry(async () => await db.listCollections(dbId, [Query.equal("name", collectionName)]));
         if (collectionsPulled.total > 0) {
             const collection = collectionsPulled.collections[0];
-            console.log(`\tCollection found: ${collection.$id}`);
+            MessageFormatter.info(`Collection found: ${collection.$id}`, { prefix: "Collections" });
             nameToIdMapping.set(collectionName, collection.$id);
             return collection;
         }
         else {
-            console.log(`\tCollection not found by name: ${collectionName}`);
+            MessageFormatter.warning(`Collection not found by name: ${collectionName}`, { prefix: "Collections" });
             return undefined;
         }
     }
@@ -103,55 +105,71 @@ async function wipeDocumentsFromCollection(database, databaseId, collectionId) {
                     ? docsResponse.documents[docsResponse.documents.length - 1].$id
                     : undefined;
             if (totalDocuments % 10000 === 0) {
-                console.log(`Found ${totalDocuments} documents...`);
+                MessageFormatter.progress(`Found ${totalDocuments} documents...`, { prefix: "Wipe" });
             }
         }
-        console.log(`Found ${totalDocuments} documents to delete`);
+        MessageFormatter.info(`Found ${totalDocuments} documents to delete`, { prefix: "Wipe" });
+        if (totalDocuments === 0) {
+            MessageFormatter.info("No documents to delete", { prefix: "Wipe" });
+            return;
+        }
+        // Create progress tracker for deletion
+        const progress = ProgressManager.create(`delete-${collectionId}`, totalDocuments, { title: "Deleting documents" });
         const maxStackSize = 50; // Reduced batch size
         const docBatches = chunk(documents, maxStackSize);
-        const quarterBatchSize = Math.ceil(docBatches.length / 4);
+        let documentsProcessed = 0;
         for (let i = 0; i < docBatches.length; i++) {
             const batch = docBatches[i];
             const deletePromises = batch.map(async (doc) => {
                 try {
                     await tryAwaitWithRetry(async () => database.deleteDocument(databaseId, collectionId, doc.$id));
+                    documentsProcessed++;
+                    progress.update(documentsProcessed);
                 }
                 catch (error) {
                     // Skip if document doesn't exist or other non-critical errors
                     if (!error.message?.includes("Document with the requested ID could not be found")) {
-                        console.error(`Failed to delete document ${doc.$id}:`, error.message);
+                        MessageFormatter.error(`Failed to delete document ${doc.$id}`, error.message, { prefix: "Wipe" });
                     }
+                    documentsProcessed++;
+                    progress.update(documentsProcessed);
                 }
             });
             await Promise.all(deletePromises);
             await delay(50); // Increased delay between batches
-            // Log at 25%, 50%, 75% and 100% completion
-            if ((i + 1) % quarterBatchSize === 0 || i === docBatches.length - 1) {
-                const percentComplete = Math.round(((i + 1) / docBatches.length) * 100);
-                const documentsProcessed = Math.min((i + 1) * maxStackSize, totalDocuments);
-                console.log(`Deleted ${documentsProcessed} documents (${percentComplete}% complete)`);
-            }
+            // Progress is now handled by ProgressManager automatically
         }
-        console.log(`Completed deletion of ${totalDocuments} documents from collection ${collectionId}`);
+        progress.stop();
+        MessageFormatter.success(`Completed deletion of ${totalDocuments} documents from collection ${collectionId}`, { prefix: "Wipe" });
     }
     catch (error) {
-        console.error(`Error wiping documents from collection ${collectionId}:`, error);
+        MessageFormatter.error(`Error wiping documents from collection ${collectionId}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Wipe" });
         throw error;
     }
 }
 export const wipeDatabase = async (database, databaseId) => {
-    console.log(`Wiping database: ${databaseId}`);
+    MessageFormatter.info(`Wiping database: ${databaseId}`, { prefix: "Wipe" });
     const existingCollections = await fetchAllCollections(databaseId, database);
     let collectionsDeleted = [];
+    if (existingCollections.length === 0) {
+        MessageFormatter.info("No collections to delete", { prefix: "Wipe" });
+        return collectionsDeleted;
+    }
+    const progress = ProgressManager.create(`wipe-db-${databaseId}`, existingCollections.length, { title: "Deleting collections" });
+    let processed = 0;
     for (const { $id: collectionId, name: name } of existingCollections) {
-        console.log(`Deleting collection: ${collectionId}`);
+        MessageFormatter.progress(`Deleting collection: ${collectionId}`, { prefix: "Wipe" });
         collectionsDeleted.push({
             collectionId: collectionId,
             collectionName: name,
         });
         tryAwaitWithRetry(async () => await database.deleteCollection(databaseId, collectionId)); // Try to delete the collection and ignore errors if it doesn't exist or if it's already being deleted
+        processed++;
+        progress.update(processed);
         await delay(100);
     }
+    progress.stop();
+    MessageFormatter.success(`Deleted ${collectionsDeleted.length} collections from database`, { prefix: "Wipe" });
     return collectionsDeleted;
 };
 export const wipeCollection = async (database, databaseId, collectionId) => {
@@ -159,7 +177,7 @@ export const wipeCollection = async (database, databaseId, collectionId) => {
         Query.equal("$id", collectionId),
     ]);
     if (collections.total === 0) {
-        console.log(`Collection ${collectionId} not found`);
+        MessageFormatter.warning(`Collection ${collectionId} not found`, { prefix: "Wipe" });
         return;
     }
     const collection = collections.collections[0];
@@ -202,7 +220,7 @@ export const createOrUpdateCollections = async (database, databaseId, config, de
                             permissions.push(Permission.write(permission.target));
                             break;
                         default:
-                            console.log(`Unknown permission: ${permission.permission}`);
+                            MessageFormatter.warning(`Unknown permission: ${permission.permission}`, { prefix: "Collections" });
                             break;
                     }
                 }
@@ -216,7 +234,7 @@ export const createOrUpdateCollections = async (database, databaseId, config, de
         // Determine the correct ID for the collection
         let collectionId;
         if (!collectionToUse) {
-            console.log(`Creating collection: ${collectionData.name}`);
+            MessageFormatter.info(`Creating collection: ${collectionData.name}`, { prefix: "Collections" });
             let foundColl = deletedCollections?.find((coll) => coll.collectionName.toLowerCase().trim().replace(" ", "") ===
                 collectionData.name.toLowerCase().trim().replace(" ", ""));
             if (collectionData.$id) {
@@ -236,18 +254,18 @@ export const createOrUpdateCollections = async (database, databaseId, config, de
                 nameToIdMapping.set(collectionData.name, collectionToUse.$id);
             }
             catch (error) {
-                console.error(`Failed to create collection ${collectionData.name} with ID ${collectionId}: ${error}`);
+                MessageFormatter.error(`Failed to create collection ${collectionData.name} with ID ${collectionId}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Collections" });
                 continue;
             }
         }
         else {
-            console.log(`Collection ${collectionData.name} exists, updating it`);
+            MessageFormatter.info(`Collection ${collectionData.name} exists, updating it`, { prefix: "Collections" });
             await tryAwaitWithRetry(async () => await database.updateCollection(databaseId, collectionToUse.$id, collectionData.name, permissions, collectionData.documentSecurity ?? false, collectionData.enabled ?? true));
         }
         // Add delay after creating/updating collection
         await delay(250);
         // Update attributes and indexes for the collection
-        console.log("Creating Attributes");
+        MessageFormatter.progress("Creating Attributes", { prefix: "Collections" });
         await createUpdateCollectionAttributes(database, databaseId, collectionToUse, 
         // @ts-expect-error
         attributes);
@@ -257,7 +275,7 @@ export const createOrUpdateCollections = async (database, databaseId, config, de
             ? indexes
             : config.collections?.find((c) => c.$id === collectionToUse.$id)
                 ?.indexes ?? [];
-        console.log("Creating Indexes");
+        MessageFormatter.progress("Creating Indexes", { prefix: "Collections" });
         await createOrUpdateIndexes(databaseId, database, collectionToUse.$id, indexesToUse);
         // Add delay after creating indexes
         await delay(250);
@@ -268,7 +286,7 @@ export const createOrUpdateCollections = async (database, databaseId, config, de
 export const generateMockData = async (database, databaseId, configCollections) => {
     for (const { collection, mockFunction } of configCollections) {
         if (mockFunction) {
-            console.log(`Generating mock data for collection: ${collection.name}`);
+            MessageFormatter.progress(`Generating mock data for collection: ${collection.name}`, { prefix: "Mock Data" });
             const mockData = mockFunction();
             for (const data of mockData) {
                 await database.createDocument(databaseId, collection.$id, ID.unique(), data);
@@ -277,7 +295,7 @@ export const generateMockData = async (database, databaseId, configCollections)
     }
 };
 export const fetchAllCollections = async (dbId, database) => {
-    console.log(`Fetching all collections for database ID: ${dbId}`);
+    MessageFormatter.progress(`Fetching all collections for database ID: ${dbId}`, { prefix: "Collections" });
     let collections = [];
     let moreCollections = true;
     let lastCollectionId;
@@ -294,7 +312,7 @@ export const fetchAllCollections = async (dbId, database) => {
                 response.collections[response.collections.length - 1].$id;
         }
     }
-    console.log(`Fetched a total of ${collections.length} collections.`);
+    MessageFormatter.success(`Fetched a total of ${collections.length} collections`, { prefix: "Collections" });
     return collections;
 };
 /**
@@ -305,7 +323,7 @@ export const transferDocumentsBetweenDbsLocalToLocal = async (db, fromDbId, toDb
     let fromCollDocs = await tryAwaitWithRetry(async () => db.listDocuments(fromDbId, fromCollId, [Query.limit(50)]));
     let totalDocumentsTransferred = 0;
     if (fromCollDocs.documents.length === 0) {
-        console.log(`No documents found in collection ${fromCollId}`);
+        MessageFormatter.info(`No documents found in collection ${fromCollId}`, { prefix: "Transfer" });
         return;
     }
     else if (fromCollDocs.documents.length < 50) {
@@ -360,7 +378,7 @@ export const transferDocumentsBetweenDbsLocalToLocal = async (db, fromDbId, toDb
             totalDocumentsTransferred += fromCollDocs.documents.length;
         }
     }
-    console.log(`Transferred ${totalDocumentsTransferred} documents from database ${fromDbId} to database ${toDbId} -- collection ${fromCollId} to collection ${toCollId}`);
+    MessageFormatter.success(`Transferred ${totalDocumentsTransferred} documents from database ${fromDbId} to database ${toDbId} -- collection ${fromCollId} to collection ${toCollId}`, { prefix: "Transfer" });
 };
 export const transferDocumentsBetweenDbsLocalToRemote = async (localDb, endpoint, projectId, apiKey, fromDbId, toDbId, fromCollId, toCollId) => {
     const client = new Client()
@@ -371,7 +389,7 @@ export const transferDocumentsBetweenDbsLocalToRemote = async (localDb, endpoint
     const remoteDb = new Databases(client);
     let fromCollDocs = await tryAwaitWithRetry(async () => localDb.listDocuments(fromDbId, fromCollId, [Query.limit(50)]));
     if (fromCollDocs.documents.length === 0) {
-        console.log(`No documents found in collection ${fromCollId}`);
+        MessageFormatter.info(`No documents found in collection ${fromCollId}`, { prefix: "Transfer" });
         return;
     }
     else if (fromCollDocs.documents.length < 50) {
@@ -426,5 +444,5 @@ export const transferDocumentsBetweenDbsLocalToRemote = async (localDb, endpoint
             totalDocumentsTransferred += fromCollDocs.documents.length;
         }
     }
-    console.log(`Total documents transferred from database ${fromDbId} to database ${toDbId} -- collection ${fromCollId} to collection ${toCollId}: ${totalDocumentsTransferred}`);
+    MessageFormatter.success(`Total documents transferred from database ${fromDbId} to database ${toDbId} -- collection ${fromCollId} to collection ${toCollId}: ${totalDocumentsTransferred}`, { prefix: "Transfer" });
 };