appwrite-utils-cli 0.9.77 → 0.9.79

package/src/interactiveCLI.ts

@@ -13,8 +13,10 @@ import {
 } from "node-appwrite";
 import { getClient } from "./utils/getClientFromConfig.js";
 import type { TransferOptions } from "./migrations/transfer.js";
-import type { AppwriteConfig, ConfigDatabases } from "appwrite-utils";
+import { parseAttribute, PermissionToAppwritePermission, type AppwriteConfig, type ConfigDatabases } from "appwrite-utils";
 import { ulid } from "ulidx";
+import chalk from "chalk";
+import { DateTime } from "luxon";
 
 enum CHOICES {
   CREATE_COLLECTION_CONFIG = "Create collection config file",
@@ -25,8 +27,10 @@ enum CHOICES {
   TRANSFER_DATA = "Transfer data",
   BACKUP_DATABASE = "Backup database",
   WIPE_DATABASE = "Wipe database",
+  WIPE_COLLECTIONS = "Wipe collections",
   GENERATE_SCHEMAS = "Generate schemas",
   IMPORT_DATA = "Import data",
+  RELOAD_CONFIG = "Reload configuration files",
   EXIT = "Exit",
 }
 
@@ -36,9 +40,9 @@ export class InteractiveCLI {
   constructor(private currentDir: string) {}
 
   async run(): Promise<void> {
-    console.log("Welcome to Appwrite Utils CLI Tool by Zach Handley");
+    console.log(chalk.green("Welcome to Appwrite Utils CLI Tool by Zach Handley"));
     console.log(
-      "For more information, visit https://github.com/zachhandley/AppwriteUtils"
+      chalk.blue("For more information, visit https://github.com/zachhandley/AppwriteUtils")
     );
 
     while (true) {
@@ -46,11 +50,13 @@ export class InteractiveCLI {
         {
           type: "list",
           name: "action",
-          message: "What would you like to do?",
+          message: chalk.yellow("What would you like to do?"),
           choices: Object.values(CHOICES),
         },
       ]);
 
+      await this.initControllerIfNeeded();
+
       switch (action) {
         case CHOICES.CREATE_COLLECTION_CONFIG:
           await this.createCollectionConfig();
@@ -81,6 +87,10 @@ export class InteractiveCLI {
           await this.initControllerIfNeeded();
           await this.wipeDatabase();
           break;
+        case CHOICES.WIPE_COLLECTIONS:
+          await this.initControllerIfNeeded();
+          await this.wipeCollections();
+          break;
         case CHOICES.GENERATE_SCHEMAS:
           await this.initControllerIfNeeded();
           await this.generateSchemas();
@@ -89,14 +99,18 @@ export class InteractiveCLI {
           await this.initControllerIfNeeded();
           await this.importData();
           break;
+        case CHOICES.RELOAD_CONFIG:
+          await this.initControllerIfNeeded();
+          await this.reloadConfig();
+          break;
         case CHOICES.EXIT:
-          console.log("Exiting...");
+          console.log(chalk.green("Goodbye!"));
           return;
       }
     }
   }
 
-  private async initControllerIfNeeded() {
+  private async initControllerIfNeeded(): Promise<void> {
     if (!this.controller) {
       this.controller = new UtilsController(this.currentDir);
       await this.controller.init();
@@ -108,13 +122,16 @@ export class InteractiveCLI {
     message: string,
     multiSelect = true
   ): Promise<Models.Database[]> {
-    const choices = databases.map((db) => ({ name: db.name, value: db }));
+    const choices = databases.map((db) => ({ name: db.name, value: db })).filter((db) => db.name.toLowerCase() !== "migrations");
+    const configDatabases = this.getLocalDatabases();
+    const allDatabases = Array.from(new Set([...databases, ...configDatabases]));
+
 
     const { selectedDatabases } = await inquirer.prompt([
       {
         type: multiSelect ? "checkbox" : "list",
         name: "selectedDatabases",
-        message,
+        message: chalk.blue(message),
         choices,
         loop: false,
         pageSize: 10,
@@ -134,7 +151,9 @@ export class InteractiveCLI {
       database.$id,
       databasesClient
     );
-    const choices = collections.map((collection) => ({
+    const configCollections = this.getLocalCollections();
+    const allCollections = Array.from(new Set([...collections, ...configCollections]));
+    const choices = allCollections.map((collection) => ({
       name: collection.name,
       value: collection,
     }));
@@ -143,7 +162,7 @@ export class InteractiveCLI {
       {
         type: multiSelect ? "checkbox" : "list",
         name: "selectedCollections",
-        message,
+        message: chalk.blue(message),
         choices,
         loop: false,
         pageSize: 10,
@@ -167,7 +186,7 @@ export class InteractiveCLI {
       {
         type: multiSelect ? "checkbox" : "list",
         name: "selectedBuckets",
-        message,
+        message: chalk.blue(message),
         choices,
         loop: false,
         pageSize: 10,
@@ -182,12 +201,12 @@ export class InteractiveCLI {
       {
         type: "input",
         name: "collectionName",
-        message: "Enter the name of the collection:",
+        message: chalk.blue("Enter the name of the collection:"),
         validate: (input) =>
           input.trim() !== "" || "Collection name cannot be empty.",
       },
     ]);
-    console.log(`Creating collection config file for '${collectionName}'...`);
+    console.log(chalk.green(`Creating collection config file for '${collectionName}'...`));
     createEmptyCollection(collectionName);
   }
 
@@ -211,7 +230,7 @@ export class InteractiveCLI {
           {
             type: "confirm",
             name: "wantCreateBucket",
-            message: `There are no buckets. Do you want to create a bucket for the database "${database.name}"?`,
+            message: chalk.blue(`There are no buckets. Do you want to create a bucket for the database "${database.name}"?`),
             default: true,
           },
         ]);
@@ -414,7 +433,20 @@ export class InteractiveCLI {
   }
 
   private async syncDb(): Promise<void> {
-    await this.controller!.syncDb();
+    console.log(chalk.yellow("Syncing database..."));
+    const databases = await this.selectDatabases(
+      await fetchAllDatabases(this.controller!.database!),
+      chalk.blue("Select databases to synchronize:"),
+      true,
+    );
+    const collections = await this.selectCollections(
+      databases[0],
+      this.controller!.database!,
+      chalk.blue("Select collections to synchronize:"),
+      true,
+    );
+    await this.controller!.syncDb(databases, collections);
+    console.log(chalk.green("Database sync completed."));
   }
 
   private async synchronizeConfigurations(): Promise<void> {
@@ -430,17 +462,18 @@ export class InteractiveCLI {
       "Select databases to synchronize:"
     );
 
-    console.log("Configuring storage buckets...");
+    console.log(chalk.yellow("Configuring storage buckets..."));
     const updatedConfig = await this.configureBuckets(
       this.controller!.config!,
       selectedDatabases
     );
 
-    console.log("Synchronizing configurations...");
+    console.log(chalk.yellow("Synchronizing configurations..."));
     await this.controller!.synchronizeConfigurations(
       selectedDatabases,
       updatedConfig
     );
+    console.log(chalk.green("Configuration synchronization completed."));
   }
 
   private async backupDatabase(): Promise<void> {
@@ -457,9 +490,10 @@ export class InteractiveCLI {
     );
 
     for (const db of selectedDatabases) {
-      console.log(`Backing up database: ${db.name}`);
+      console.log(chalk.yellow(`Backing up database: ${db.name}`));
       await this.controller!.backupDatabase(db);
     }
+    console.log(chalk.green("Database backup completed."));
   }
 
   private async wipeDatabase(): Promise<void> {
@@ -498,14 +532,15 @@ export class InteractiveCLI {
       {
         type: "confirm",
         name: "confirm",
-        message:
-          "Are you sure you want to wipe the selected items? This action cannot be undone.",
+        message: chalk.red(
+          "Are you sure you want to wipe the selected items? This action cannot be undone."
+        ),
         default: false,
       },
     ]);
 
     if (confirm) {
-      console.log("Wiping selected items...");
+      console.log(chalk.yellow("Wiping selected items..."));
       for (const db of selectedDatabases) {
         await this.controller!.wipeDatabase(db);
       }
@@ -515,39 +550,87 @@ export class InteractiveCLI {
       if (wipeUsers) {
         await this.controller!.wipeUsers();
       }
+      console.log(chalk.green("Wipe operation completed."));
     } else {
-      console.log("Wipe operation cancelled.");
+      console.log(chalk.blue("Wipe operation cancelled."));
     }
   }
 
-  private async generateSchemas(): Promise<void> {
-    console.log("Generating schemas...");
-    await this.controller!.generateSchemas();
-  }
-
-  private async importData(): Promise<void> {
+  private async wipeCollections(): Promise<void> {
     if (!this.controller!.database) {
       throw new Error(
         "Database is not initialized, is the config file correct & created?"
       );
     }
     const databases = await fetchAllDatabases(this.controller!.database);
-
     const selectedDatabases = await this.selectDatabases(
       databases,
-      "Select the database(s) to import data into:"
+      "Select the database(s) containing the collections to wipe:",
+      true
     );
 
-    let selectedCollections: Models.Collection[] = [];
-    for (const db of selectedDatabases) {
-      const dbCollections = await this.selectCollections(
-        db,
+    for (const database of selectedDatabases) {
+      const collections = await this.selectCollections(
+        database,
         this.controller!.database,
-        `Select collections to import data into for database ${db.name}:`,
+        `Select collections to wipe from ${database.name}:`,
         true
       );
-      selectedCollections = [...selectedCollections, ...dbCollections];
+
+      const { confirm } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: chalk.red(
+            `Are you sure you want to wipe the selected collections from ${database.name}? This action cannot be undone.`
+          ),
+          default: false,
+        },
+      ]);
+
+      if (confirm) {
+        console.log(chalk.yellow(`Wiping selected collections from ${database.name}...`));
+        for (const collection of collections) {
+          await this.controller!.wipeCollection(database, collection);
+          console.log(chalk.green(`Collection ${collection.name} wiped successfully.`));
+        }
+      } else {
+        console.log(chalk.blue(`Wipe operation cancelled for ${database.name}.`));
+      }
     }
+    console.log(chalk.green("Wipe collections operation completed."));
+  }
+
+  private async generateSchemas(): Promise<void> {
+    console.log(chalk.yellow("Generating schemas..."));
+    await this.controller!.generateSchemas();
+    console.log(chalk.green("Schema generation completed."));
+  }
+
+  private async importData(): Promise<void> {
+    console.log(chalk.yellow("Importing data..."));
+
+    const { doBackup } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "doBackup",
+        message: "Do you want to perform a backup before importing?",
+        default: true,
+      },
+    ]);
+
+    const databases = await this.selectDatabases(
+      await fetchAllDatabases(this.controller!.database!),
+      "Select databases to import data into:",
+      true
+    );
+
+    const collections = await this.selectCollections(
+      databases[0],
+      this.controller!.database!,
+      "Select collections to import data into (leave empty for all):",
+      true
+    );
 
     const { shouldWriteFile } = await inquirer.prompt([
       {
@@ -558,26 +641,20 @@ export class InteractiveCLI {
       },
     ]);
 
-    // const { checkDuplicates } = await inquirer.prompt([
-    //   {
-    //     type: "confirm",
-    //     name: "checkDuplicates",
-    //     message: "Do you want to check for duplicates during import?",
-    //     default: true,
-    //   },
-    // ]);
-
-    console.log("Importing data...");
-    await this.controller!.importData({
-      databases: selectedDatabases,
-      collections:
-        selectedCollections.length > 0
-          ? selectedCollections.map((c) => c.$id)
-          : undefined,
+    const options = {
+      databases,
+      collections: collections.map(c => c.name),
+      doBackup,
+      importData: true,
       shouldWriteFile,
-      checkDuplicates: false,
-      // checkDuplicates,
-    });
+    };
+
+    try {
+      await this.controller!.importData(options);
+      console.log(chalk.green("Data import completed successfully."));
+    } catch (error) {
+      console.error(chalk.red("Error importing data:"), error);
+    }
   }
 
   private async transferData(): Promise<void> {
@@ -647,14 +724,7 @@ export class InteractiveCLI {
       "Select the source database:",
       false
     );
-    console.log(fromDbs);
-    const fromDb = fromDbs as unknown as {
-      $id: string;
-      name: string;
-      $createdAt: string;
-      $updatedAt: string;
-      enabled: boolean;
-    };
+    const fromDb = fromDbs[0];
     if (!fromDb) {
       throw new Error("No source database selected");
     }
@@ -664,13 +734,7 @@ export class InteractiveCLI {
       "Select the target database:",
       false
     );
-    const targetDb = targetDbs as unknown as {
-      $id: string;
-      name: string;
-      $createdAt: string;
-      $updatedAt: string;
-      enabled: boolean;
-    };
+    const targetDb = targetDbs[0];
     if (!targetDb) {
       throw new Error("No target database selected");
     }
@@ -678,7 +742,7 @@ export class InteractiveCLI {
     const selectedCollections = await this.selectCollections(
       fromDb,
       sourceClient,
-      "Select collections to transfer):"
+      "Select collections to transfer:"
     );
 
     const { transferStorage } = await inquirer.prompt([
@@ -719,8 +783,8 @@ export class InteractiveCLI {
         "Select the target bucket:",
         false
       );
-      sourceBucket = sourceBucketPicked as unknown as Models.Bucket;
-      targetBucket = targetBucketPicked as unknown as Models.Bucket;
+      sourceBucket = sourceBucketPicked[0];
+      targetBucket = targetBucketPicked[0];
     }
 
     let transferOptions: TransferOptions = {
@@ -742,7 +806,47 @@ export class InteractiveCLI {
       };
     }
 
-    console.log("Transferring data...");
+    console.log(chalk.yellow("Transferring data..."));
     await this.controller!.transferData(transferOptions);
+    console.log(chalk.green("Data transfer completed."));
   }
-}
+
+
+  private getLocalCollections(): Models.Collection[] {
+    const configCollections = this.controller!.config!.collections || [];
+    // @ts-expect-error - appwrite invalid types
+    return configCollections.map(c => ({
+      $id: c.$id || ulid(),
+      $createdAt: DateTime.now().toISO(),
+      $updatedAt: DateTime.now().toISO(),
+      name: c.name,
+      enabled: c.enabled || true,
+      documentSecurity: c.documentSecurity || false,
+      attributes: c.attributes || [],
+      indexes: c.indexes || [],
+      $permissions: PermissionToAppwritePermission(c.$permissions) || [],
+      databaseId: c.databaseId!,
+    }));
+  }
+
+  private getLocalDatabases(): Models.Database[] {
+    const configDatabases = this.controller!.config!.databases || [];
+    return configDatabases.map(db => ({
+      $id: db.$id || ulid(),
+      $createdAt: DateTime.now().toISO(),
+      $updatedAt: DateTime.now().toISO(),
+      name: db.name,
+      enabled: true,
+    }));
+  }
+
+  private async reloadConfig(): Promise<void> {
+    console.log(chalk.yellow("Reloading configuration files..."));
+    try {
+      await this.controller!.reloadConfig();
+      console.log(chalk.green("Configuration files reloaded successfully."));
+    } catch (error) {
+      console.error(chalk.red("Error reloading configuration files:"), error);
+    }
+  }
+}

package/src/main.ts

@@ -7,6 +7,9 @@ import { UtilsController, type SetupOptions } from "./utilsController.js";
 import type { TransferOptions } from "./migrations/transfer.js";
 import { Databases, Storage, type Models } from "node-appwrite";
 import { getClient } from "./utils/getClientFromConfig.js";
+import { fetchAllDatabases } from "./migrations/databases.js";
+import { setupDirsFiles } from "./utils/setupFiles.js";
+import { fetchAllCollections } from "./collections/methods.js";
 
 interface CliOptions {
   it?: boolean;
@@ -14,6 +17,7 @@ interface CliOptions {
   collectionIds?: string;
   bucketIds?: string;
   wipe?: "all" | "docs" | "users";
+  wipeCollections?: boolean;
   generate?: boolean;
   import?: boolean;
   backup?: boolean;
@@ -62,6 +66,10 @@ const argv = yargs(hideBin(process.argv))
     description:
       "Wipe data (all: everything, docs: only documents, users: only user data)",
   })
+  .option("wipeCollections", {
+    type: "boolean",
+    description: "Wipe collections, uses collectionIds option to get the collections to wipe",
+  })
   .option("generate", {
     type: "boolean",
     description: "Generate TypeScript schemas from database schemas",
@@ -125,86 +133,88 @@ const argv = yargs(hideBin(process.argv))
     description: "Set the destination collection ID for transfer",
   })
   .option("fromBucketId", {
-    alias: ["fromBucket"],
     type: "string",
     description: "Set the source bucket ID for transfer",
   })
   .option("toBucketId", {
-    alias: ["toBucket"],
     type: "string",
     description: "Set the destination bucket ID for transfer",
   })
   .option("remoteEndpoint", {
     type: "string",
-    description: "Set the remote Appwrite endpoint for transfers",
+    description: "Set the remote Appwrite endpoint for transfer",
   })
   .option("remoteProjectId", {
     type: "string",
-    description: "Set the remote Appwrite project ID for transfers",
+    description: "Set the remote Appwrite project ID for transfer",
   })
   .option("remoteApiKey", {
     type: "string",
-    description: "Set the remote Appwrite API key for transfers",
+    description: "Set the remote Appwrite API key for transfer",
   })
   .option("setup", {
     type: "boolean",
-    description: "Setup the project with example data",
+    description: "Setup directories and files",
   })
-  .help()
-  .parse();
+  .parse() as ParsedArgv;
 
 async function main() {
-  const parsedArgv = (await argv) as ParsedArgv;
-  let controller: UtilsController | undefined;
+  const controller = new UtilsController(process.cwd());
 
-  if (parsedArgv.it) {
-    try {
-      controller = new UtilsController(process.cwd());
-      await controller.init();
-    } catch (error: any) {
-      // If it fails, that means there's no config, more than likely
-      console.log(
-        "No config found, you probably need to create the setup files"
-      );
-    }
+  if (argv.it) {
     const cli = new InteractiveCLI(process.cwd());
     await cli.run();
   } else {
-    if (!controller) {
-      controller = new UtilsController(process.cwd());
-      await controller.init();
+    await controller.init();
+
+    if (argv.setup) {
+      await setupDirsFiles(false, process.cwd());
+      return;
     }
-    // Handle non-interactive mode with the new options
+
+    const parsedArgv = argv;
+
     const options: SetupOptions = {
       databases: parsedArgv.dbIds
-        ? await controller.getDatabasesByIds(
-            parsedArgv.dbIds.replace(" ", "").split(",")
-          )
-        : undefined,
-      collections: parsedArgv.collectionIds
-        ? parsedArgv.collectionIds.replace(" ", "").split(",")
+        ? await controller.getDatabasesByIds(parsedArgv.dbIds.split(","))
         : undefined,
+      collections: parsedArgv.collectionIds?.split(","),
       doBackup: parsedArgv.backup,
       wipeDatabase: parsedArgv.wipe === "all" || parsedArgv.wipe === "docs",
       wipeDocumentStorage: parsedArgv.wipe === "all",
       wipeUsers: parsedArgv.wipe === "all" || parsedArgv.wipe === "users",
       generateSchemas: parsedArgv.generate,
       importData: parsedArgv.import,
-      checkDuplicates: false,
       shouldWriteFile: parsedArgv.writeData,
+      wipeCollections: parsedArgv.wipeCollections,
     };
 
-    if (parsedArgv.push) {
-      await controller.syncDb();
+    if (parsedArgv.push || parsedArgv.sync) {
+      const databases = options.databases || await fetchAllDatabases(controller.database!);
+      let collections: Models.Collection[] = [];
+      
+      if (options.collections) {
+        for (const db of databases) {
+          const dbCollections = await fetchAllCollections(db.$id, controller.database!);
+          collections = collections.concat(dbCollections.filter(c => options.collections!.includes(c.$id)));
+        }
+      }
+
+      if (parsedArgv.push) {
+        await controller.syncDb(databases, collections);
+      } else if (parsedArgv.sync) {
+        await controller.synchronizeConfigurations(databases);
+      }
     }
 
     if (
       options.wipeDatabase ||
       options.wipeDocumentStorage ||
-      options.wipeUsers
+      options.wipeUsers ||
+      options.wipeCollections
     ) {
-      if (options.wipeDatabase) {
-        for (const db of options.databases || []) {
+      if (options.wipeDatabase && options.databases) {
+        for (const db of options.databases) {
           await controller.wipeDatabase(db);
         }
       }
@@ -216,10 +226,19 @@ async function main() {
       if (options.wipeUsers) {
         await controller.wipeUsers();
       }
+      if (options.wipeCollections && options.databases) {
+        for (const db of options.databases) {
+          const dbCollections = await fetchAllCollections(db.$id, controller.database!);
+          const collectionsToWipe = dbCollections.filter(c => options.collections!.includes(c.$id));
+          for (const collection of collectionsToWipe) {
+            await controller.wipeCollection(db, collection);
+          }
+        }
+      }
     }
 
-    if (options.doBackup) {
-      for (const db of options.databases || []) {
+    if (options.doBackup && options.databases) {
+      for (const db of options.databases) {
         await controller.backupDatabase(db);
       }
     }
@@ -254,8 +273,8 @@ async function main() {
         );
         targetDatabases = new Databases(remoteClient);
         targetStorage = new Storage(remoteClient);
-        const remoteDbs = await targetDatabases.list();
-        toDb = remoteDbs.databases.find((db) => db.$id === parsedArgv.toDbId);
+        const remoteDbs = await fetchAllDatabases(targetDatabases);
+        toDb = remoteDbs.find((db) => db.$id === parsedArgv.toDbId);
       } else {
         toDb = (await controller.getDatabasesByIds([parsedArgv.toDbId!]))[0];
       }
@@ -293,14 +312,10 @@ async function main() {
 
       await controller.transferData(transferOptions);
     }
-
-    if (parsedArgv.sync) {
-      await controller.synchronizeConfigurations(options.databases);
-    }
   }
 }
 
 main().catch((error) => {
   console.error("An error occurred:", error);
   process.exit(1);
-});
+});