appwrite-utils-cli 1.5.2 → 1.6.0

package/src/storage/methods.ts

@@ -17,6 +17,9 @@ import { retryFailedPromises } from "../utils/retryFailedPromises.js";
 import { InputFile } from "node-appwrite/file";
 import { MessageFormatter, Messages } from "../shared/messageFormatter.js";
 import { ProgressManager } from "../shared/progressManager.js";
+import { recordBackup } from "../shared/backupTracking.js";
+import { AdapterFactory } from "../adapters/AdapterFactory.js";
+import { createBackupZip } from "./backupCompression.js";
 
 export const getStorage = (config: AppwriteConfig) => {
   const client = getClientFromConfig(config);
@@ -274,30 +277,70 @@ export const initOrGetDocumentStorage = async (
   }
 };
 
-export const initOrGetBackupStorage = async (
-  config: AppwriteConfig,
+/**
+ * Initializes or gets the centralized backup bucket
+ * All backups are stored in a single "appwrite-backups" bucket
+ */
+export const initBackupBucket = async (
   storage: Storage
-) => {
+): Promise<Models.Bucket | undefined> => {
+  const BACKUP_BUCKET_ID = "appwrite-backups";
+  const BACKUP_BUCKET_NAME = "Backups";
+
   try {
-    return await tryAwaitWithRetry(
-      async () => await storage.getBucket("backup")
-    );
-  } catch (e) {
-    return await initOrGetDocumentStorage(
-      storage,
-      config,
-      "backups",
-      "Database Backups"
-    );
+    // Try to get existing bucket
+    const bucket = await storage.getBucket(BACKUP_BUCKET_ID);
+    return bucket;
+  } catch (error) {
+    // Bucket doesn't exist, create it
+    try {
+      const bucket = await storage.createBucket(
+        BACKUP_BUCKET_ID,
+        BACKUP_BUCKET_NAME,
+        [
+          Permission.read(Role.any()),
+          Permission.create(Role.users()),
+          Permission.update(Role.users()),
+          Permission.delete(Role.users())
+        ],
+        false, // fileSecurity
+        true,  // enabled
+        undefined, // maximumFileSize
+        undefined, // allowedFileExtensions
+        Compression.Gzip, // compression
+        false,     // encryption
+        false      // antivirus
+      );
+
+      MessageFormatter.success(`Created backup bucket: ${BACKUP_BUCKET_ID}`);
+      return bucket;
+    } catch (createError) {
+      MessageFormatter.error("Failed to create backup bucket",
+        createError instanceof Error ? createError : new Error(String(createError))
+      );
+      return undefined;
+    }
   }
 };
 
+export interface DatabaseBackupResult {
+  backupFileId: string;
+  backupFileName: string;
+  backupSizeBytes: number;
+  databaseId: string;
+  databaseName: string;
+  collectionCount: number;
+  documentCount: number;
+  format: 'json' | 'zip';
+}
+
 export const backupDatabase = async (
   config: AppwriteConfig,
   database: Databases,
   databaseId: string,
-  storage: Storage
-): Promise<void> => {
+  storage: Storage,
+  format: 'json' | 'zip' = 'json'
+): Promise<DatabaseBackupResult> => {
   const startTime = Date.now();
   
   MessageFormatter.banner("Database Backup", `Backing up database: ${databaseId}`);
@@ -317,7 +360,7 @@ export const backupDatabase = async (
     total: 100,
     error: "",
     status: "in_progress",
-  }, undefined, config.useMigrations);
+  });
 
   let progress: ProgressManager | null = null;
   let totalDocuments = 0;
@@ -449,8 +492,7 @@ export const backupDatabase = async (
                   error: "",
                   status: "in_progress",
                 },
-                backupOperation.$id,
-                config.useMigrations
+                backupOperation.$id
               );
             }
 
@@ -484,21 +526,65 @@ export const backupDatabase = async (
     }
 
     MessageFormatter.step(3, 3, "Creating backup file");
-    
-    const bucket = await initOrGetDocumentStorage(storage, config, databaseId);
-    const backupData = JSON.stringify(data);
-    const backupSize = Buffer.byteLength(backupData, 'utf8');
-    const fileName = `${new Date().toISOString()}-${databaseId}.json`;
-    
-    const inputFile = InputFile.fromPlainText(backupData, fileName);
+
+    const bucket = await initBackupBucket(storage);
+    if (!bucket) {
+      throw new Error("Failed to initialize backup bucket");
+    }
+
+    let inputFile: any;
+    let fileName: string;
+    let backupSize: number;
+
+    if (format === 'zip') {
+      // Create compressed backup
+      const zipBuffer = await createBackupZip(data);
+      fileName = `${new Date().toISOString()}-${databaseId}.zip`;
+      backupSize = zipBuffer.length;
+      inputFile = InputFile.fromBuffer(new Uint8Array(zipBuffer), fileName);
+    } else {
+      // Use JSON format (existing logic)
+      const backupData = JSON.stringify(data, null, 2);
+      fileName = `${new Date().toISOString()}-${databaseId}.json`;
+      backupSize = Buffer.byteLength(backupData, 'utf8');
+      inputFile = InputFile.fromPlainText(backupData, fileName);
+    }
+
     const fileCreated = await storage.createFile(
-      bucket!.$id,
+      bucket.$id,
       ulid(),
       inputFile
     );
 
     progress?.stop();
 
+    // Record backup metadata
+    try {
+      const { adapter } = await AdapterFactory.create({
+        appwriteEndpoint: config.appwriteEndpoint,
+        appwriteProject: config.appwriteProject,
+        appwriteKey: config.appwriteKey,
+        sessionCookie: config.sessionCookie
+      });
+
+      await recordBackup(adapter, databaseId, {
+        backupId: fileCreated.$id,
+        backupType: 'database',
+        databaseId: databaseId,
+        sizeBytes: backupSize,
+        collections: data.collections.length,
+        documents: processedDocuments,
+        format: format,
+        status: 'completed',
+        restorationStatus: 'not_restored'
+      });
+    } catch (metadataError) {
+      // Don't fail backup if metadata recording fails
+      MessageFormatter.warning(
+        `Failed to record backup metadata: ${metadataError instanceof Error ? metadataError.message : String(metadataError)}`
+      );
+    }
+
     if (backupOperation) {
       await logOperation(
         database,
@@ -512,13 +598,12 @@ export const backupDatabase = async (
           error: "",
           status: "completed",
         },
-        backupOperation.$id,
-        config.useMigrations
+        backupOperation.$id
       );
     }
 
     const duration = Date.now() - startTime;
-    
+
     MessageFormatter.operationSummary("Backup", {
       database: databaseId,
       collections: data.collections.length,
@@ -529,11 +614,24 @@ export const backupDatabase = async (
     }, duration);
 
     MessageFormatter.success(Messages.BACKUP_COMPLETED(databaseId, backupSize));
+
+    // Return backup result for tracking
+    const dbData = JSON.parse(data.database);
+    return {
+      backupFileId: fileCreated.$id,
+      backupFileName: fileName,
+      backupSizeBytes: backupSize,
+      databaseId: databaseId,
+      databaseName: dbData.name || databaseId,
+      collectionCount: data.collections.length,
+      documentCount: processedDocuments,
+      format: format
+    };
   } catch (error) {
     progress?.fail(error instanceof Error ? error.message : String(error));
-    
+
     MessageFormatter.error("Backup failed", error instanceof Error ? error : new Error(String(error)));
-    
+
     if (backupOperation) {
       await logOperation(
         database,
@@ -547,11 +645,10 @@ export const backupDatabase = async (
           error: String(error),
           status: "error",
         },
-        backupOperation.$id,
-        config.useMigrations
+        backupOperation.$id
       );
     }
-    
+
     throw error;
   }
 };

package/src/users/methods.ts

@@ -20,6 +20,7 @@ import {
 } from "../utils/helperFunctions.js";
 import { isUndefined } from "es-toolkit/compat";
 import { isEmpty } from "es-toolkit/compat";
+import { MessageFormatter } from "../shared/messageFormatter.js";
 
 export class UsersController {
   private config: AppwriteConfig;
@@ -43,7 +44,7 @@ export class UsersController {
 
   async wipeUsers() {
     const allUsers = await this.getAllUsers();
-    console.log("Deleting all users...");
+    MessageFormatter.progress("Deleting all users...", { prefix: "Users" });
 
     const createBatches = (finalData: any[], batchSize: number) => {
       const finalBatches: any[][] = [];
@@ -58,7 +59,7 @@ export class UsersController {
       const batchedUserPromises = createBatches(allUsers, 25); // Batch size of 25
 
       for (const batch of batchedUserPromises) {
-        console.log(`Deleting ${batch.length} users...`);
+        MessageFormatter.progress(`Deleting ${batch.length} users...`, { prefix: "Users" });
         await Promise.all(
           batch.map((user) =>
             tryAwaitWithRetry(async () => await this.users.delete(user.$id))
@@ -66,11 +67,11 @@ export class UsersController {
         );
         usersDeleted += batch.length;
         if (usersDeleted % 100 === 0) {
-          console.log(`Deleted ${usersDeleted} users...`);
+          MessageFormatter.progress(`Deleted ${usersDeleted} users...`, { prefix: "Users" });
         }
       }
     } else {
-      console.log("No users to delete");
+      MessageFormatter.info("No users to delete", { prefix: "Users" });
     }
   }
 
@@ -194,7 +195,7 @@ export class UsersController {
               item.email
             );
           } else {
-            console.log("Email update skipped: Email already exists.");
+            MessageFormatter.warning("Email update skipped: Email already exists.", { prefix: "Users" });
           }
         }
         if (item.password) {
@@ -228,8 +229,9 @@ export class UsersController {
         }
       }
       if (item.$createdAt && item.$updatedAt) {
-        console.log(
-          "$createdAt and $updatedAt are not yet supported, sorry about that!"
+        MessageFormatter.warning(
+          "$createdAt and $updatedAt are not yet supported, sorry about that!",
+          { prefix: "Users" }
         );
       }
       if (item.labels && item.labels.length) {
@@ -305,10 +307,10 @@ export class UsersController {
     let fromUsers = await localUsers.list([Query.limit(50)]);
 
     if (fromUsers.users.length === 0) {
-      console.log(`No users found`);
+      MessageFormatter.info("No users found", { prefix: "Users" });
       return;
     } else if (fromUsers.users.length < 50) {
-      console.log(`Transferring ${fromUsers.users.length} users to remote`);
+      MessageFormatter.progress(`Transferring ${fromUsers.users.length} users to remote`, { prefix: "Users" });
       const batchedPromises = fromUsers.users.map((user) => {
         return tryAwaitWithRetry(async () => {
           const toCreateObject: Partial<typeof user> = {