appwrite-utils-cli 1.11.0 → 1.12.0

package/src/cli/commands/schemaCommands.ts

@@ -1,200 +0,0 @@
-import inquirer from "inquirer";
-import path from "path";
-import chalk from "chalk";
-import { MessageFormatter } from 'appwrite-utils-helpers';
-import { SchemaGenerator } from 'appwrite-utils-helpers';
-import { setupDirsFiles } from "../../utils/setupFiles.js";
-import { fetchAllDatabases } from "../../databases/methods.js";
-import type { InteractiveCLI } from "../../interactiveCLI.js";
-
-export const schemaCommands = {
-  async generateSchemas(cli: InteractiveCLI): Promise<void> {
-    MessageFormatter.progress("Generating schemas...", { prefix: "Schemas" });
-
-    // Prompt user for schema type preference
-    const { schemaType } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "schemaType",
-        message: "What type of schemas would you like to generate?",
-        choices: [
-          { name: "TypeScript (Zod) schemas", value: "zod" },
-          { name: "JSON schemas", value: "json" },
-          { name: "Python (Pydantic) models", value: "pydantic" },
-          { name: "TypeScript + JSON", value: "both" },
-          { name: "All (Zod, JSON, Pydantic)", value: "all" },
-        ],
-        default: "all",
-      },
-    ]);
-
-    // Get the config folder path (where the config file is located)
-    const configFolderPath = (cli as any).controller!.getAppwriteFolderPath();
-    if (!configFolderPath) {
-      MessageFormatter.error("Failed to get config folder path", undefined, { prefix: "Schemas" });
-      return;
-    }
-
-    // Prompt for schema output directory (optional override)
-    const defaultSchemaOut = path.join(configFolderPath, (cli as any).controller!.config?.schemaConfig?.outputDirectory || 'schemas');
-    const { schemaOutDir } = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'schemaOutDir',
-        message: 'Output directory for schemas:',
-        default: defaultSchemaOut,
-        validate: (input: string) => input && input.trim().length > 0 ? true : 'Please provide an output directory',
-      }
-    ]);
-
-    // Create SchemaGenerator with the correct base path and generate schemas
-    const schemaGenerator = new SchemaGenerator((cli as any).controller!.config!, configFolderPath);
-    const outDirRel = path.isAbsolute(schemaOutDir) ? schemaOutDir : path.relative(configFolderPath, schemaOutDir);
-    await schemaGenerator.generateSchemas({ format: schemaType as any, verbose: true, outputDir: outDirRel });
-
-    MessageFormatter.success("Schema generation completed", { prefix: "Schemas" });
-  },
-
-  async generateConstants(cli: InteractiveCLI): Promise<void> {
-    MessageFormatter.progress("Generating cross-language constants...", { prefix: "Constants" });
-
-    if (!(cli as any).controller?.config) {
-      MessageFormatter.error("No configuration found", undefined, { prefix: "Constants" });
-      return;
-    }
-
-    // Prompt for languages
-    const { languages } = await inquirer.prompt([
-      {
-        type: "checkbox",
-        name: "languages",
-        message: "Select languages for constants generation:",
-        choices: [
-          { name: "TypeScript", value: "typescript", checked: true },
-          { name: "JavaScript", value: "javascript" },
-          { name: "Python", value: "python" },
-          { name: "PHP", value: "php" },
-          { name: "Dart", value: "dart" },
-          { name: "JSON", value: "json" },
-          { name: "Environment Variables", value: "env" },
-        ],
-        validate: (input) => {
-          if (input.length === 0) {
-            return "Please select at least one language";
-          }
-          return true;
-        },
-      },
-    ]);
-
-    // Prompt for which constants to include
-    const { includeWhat } = await inquirer.prompt([
-      {
-        type: 'checkbox',
-        name: 'includeWhat',
-        message: 'Select which constants to generate:',
-        choices: [
-          { name: 'Databases', value: 'databases', checked: true },
-          { name: 'Collections/Tables', value: 'collections', checked: true },
-          { name: 'Buckets', value: 'buckets', checked: true },
-          { name: 'Functions', value: 'functions', checked: true },
-        ],
-        validate: (input) => input.length > 0 ? true : 'Select at least one category',
-      }
-    ]);
-
-    // Determine default output directory based on config location
-    const configPath = (cli as any).controller!.getAppwriteFolderPath();
-    const defaultOutputDir = configPath
-      ? path.join(configPath, "constants")
-      : path.join(process.cwd(), "constants");
-
-    // Prompt for output directory
-    const { outputDir } = await inquirer.prompt([
-      {
-        type: "input",
-        name: "outputDir",
-        message: "Output directory for constants files:",
-        default: defaultOutputDir,
-        validate: (input) => {
-          if (!input.trim()) {
-            return "Output directory cannot be empty";
-          }
-          return true;
-        },
-      },
-    ]);
-
-    try {
-      const { ConstantsGenerator } = await import("appwrite-utils-helpers");
-      const generator = new ConstantsGenerator((cli as any).controller.config);
-
-      const include = {
-        databases: includeWhat.includes('databases'),
-        collections: includeWhat.includes('collections'),
-        buckets: includeWhat.includes('buckets'),
-        functions: includeWhat.includes('functions'),
-      };
-      MessageFormatter.info(`Generating constants for: ${languages.join(", ")}`, { prefix: "Constants" });
-      await generator.generateFiles(languages, outputDir, include);
-
-      MessageFormatter.success(`Constants generated in ${outputDir}`, { prefix: "Constants" });
-    } catch (error) {
-      MessageFormatter.error("Failed to generate constants", error instanceof Error ? error : new Error(String(error)), { prefix: "Constants" });
-    }
-  },
-
-  async importData(cli: InteractiveCLI): Promise<void> {
-    MessageFormatter.progress("Importing data...", { prefix: "Import" });
-
-    const { doBackup } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "doBackup",
-        message: "Do you want to perform a backup before importing?",
-        default: true,
-      },
-    ]);
-
-    const databases = await (cli as any).selectDatabases(
-      await fetchAllDatabases((cli as any).controller!.database!),
-      "Select databases to import data into:",
-      true
-    );
-
-    const collections = await (cli as any).selectCollectionsAndTables(
-      databases[0],
-      (cli as any).controller!.database!,
-      "Select collections/tables to import data into (leave empty for all):",
-      true
-    );
-
-    const { shouldWriteFile } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "shouldWriteFile",
-        message: "Do you want to write the imported data to a file?",
-        default: false,
-      },
-    ]);
-
-    const options = {
-      databases,
-      collections: collections.map((c: any) => c.name),
-      doBackup,
-      importData: true,
-      shouldWriteFile,
-    };
-
-    try {
-      await (cli as any).controller!.importData(options);
-      MessageFormatter.success("Data import completed successfully", { prefix: "Import" });
-    } catch (error) {
-      MessageFormatter.error("Error importing data", error instanceof Error ? error : new Error(String(error)), { prefix: "Import" });
-    }
-  },
-
-  async setupDirsFiles(cli: InteractiveCLI, withExampleData: boolean = false): Promise<void> {
-    await setupDirsFiles(withExampleData, (cli as any).currentDir);
-  }
-};

package/src/cli/commands/storageCommands.ts

@@ -1,151 +0,0 @@
-import inquirer from "inquirer";
-import chalk from "chalk";
-import { Storage, Permission, Role, Compression, type Models } from "node-appwrite";
-import type { InteractiveCLI } from "../../interactiveCLI.js";
-import { MessageFormatter } from 'appwrite-utils-helpers';
-import { listBuckets, createBucket as createBucketApi, deleteBucket as deleteBucketApi } from "../../storage/methods.js";
-import { writeYamlConfig, ConfigManager } from "appwrite-utils-helpers";
-
-export const storageCommands = {
-  async createBucket(cli: InteractiveCLI): Promise<void> {
-    const storage: Storage = (cli as any).controller!.storage!;
-    if (!storage) {
-      MessageFormatter.error("Storage client not initialized", undefined, { prefix: "Buckets" });
-      return;
-    }
-
-    const answers = await inquirer.prompt([
-      { type: 'input', name: 'name', message: 'Bucket name:', validate: (v:string)=> v?.trim()?.length>0 || 'Required' },
-      { type: 'input', name: 'id', message: 'Bucket ID (optional):' },
-      { type: 'confirm', name: 'publicRead', message: 'Public read access?', default: false },
-      { type: 'confirm', name: 'fileSecurity', message: 'Enable file-level security?', default: false },
-      { type: 'confirm', name: 'enabled', message: 'Enable bucket?', default: true },
-      { type: 'number', name: 'maximumFileSize', message: 'Max file size (bytes, optional):', default: undefined },
-      { type: 'input', name: 'allowedFileExtensions', message: 'Allowed extensions (comma separated, optional):', default: '' },
-      { type: 'list', name: 'compression', message: 'Compression:', choices: ['none','gzip','zstd'], default: 'none' },
-      { type: 'confirm', name: 'encryption', message: 'Enable encryption?', default: false },
-      { type: 'confirm', name: 'antivirus', message: 'Enable antivirus?', default: false },
-    ]);
-
-    const permissions: string[] = [];
-    if (answers.publicRead) permissions.push(Permission.read(Role.any()));
-
-    const bucketInput: Omit<Models.Bucket, "$id" | "$createdAt" | "$updatedAt"> = {
-      name: answers.name,
-      $permissions: permissions,
-      fileSecurity: !!answers.fileSecurity,
-      enabled: !!answers.enabled,
-      maximumFileSize: answers.maximumFileSize || undefined,
-      allowedFileExtensions: String(answers.allowedFileExtensions || '')
-        .split(',')
-        .map((s) => s.trim())
-        .filter(Boolean),
-      compression: answers.compression as Compression,
-      encryption: !!answers.encryption,
-      antivirus: !!answers.antivirus,
-    } as any;
-
-    try {
-      const created = await createBucketApi(storage, bucketInput, answers.id || undefined);
-      MessageFormatter.success(`Bucket '${answers.name}' created`, { prefix: 'Buckets' });
-
-      // Update in-memory config and persist to YAML as a global bucket entry
-      const controller = (cli as any).controller!;
-      controller.config.buckets = controller.config.buckets || [];
-      controller.config.buckets.push({
-        $id: (created as any).$id || answers.id || bucketInput.name,
-        name: bucketInput.name,
-        permissions: [],
-        fileSecurity: bucketInput.fileSecurity,
-        enabled: bucketInput.enabled,
-        maximumFileSize: bucketInput.maximumFileSize,
-        allowedFileExtensions: bucketInput.allowedFileExtensions,
-        compression: bucketInput.compression,
-        encryption: bucketInput.encryption,
-        antivirus: bucketInput.antivirus,
-      });
-
-      const cfgMgr = ConfigManager.getInstance();
-      const cfgPath = cfgMgr.getConfigPath();
-      if (cfgPath && /\.ya?ml$/i.test(cfgPath)) {
-        await writeYamlConfig(cfgPath, controller.config);
-        MessageFormatter.info(`Added bucket to config.yaml`, { prefix: 'Buckets' });
-      } else {
-        MessageFormatter.warning(`Config is not YAML; updated in-memory only. Please update your TypeScript config manually.`, { prefix: 'Buckets' });
-      }
-    } catch (e) {
-      MessageFormatter.error('Failed to create bucket', e instanceof Error ? e : new Error(String(e)), { prefix: 'Buckets' });
-    }
-  },
-
-  async deleteBuckets(cli: InteractiveCLI): Promise<void> {
-    const storage: Storage = (cli as any).controller!.storage!;
-    if (!storage) {
-      MessageFormatter.error("Storage client not initialized", undefined, { prefix: "Buckets" });
-      return;
-    }
-
-    try {
-      const res = await listBuckets(storage);
-      const buckets: Models.Bucket[] = res.buckets || [];
-      if (buckets.length === 0) {
-        MessageFormatter.info('No buckets found', { prefix: 'Buckets' });
-        return;
-      }
-
-      const { toDelete } = await inquirer.prompt([
-        {
-          type: 'checkbox',
-          name: 'toDelete',
-          message: chalk.red('Select buckets to delete:'),
-          choices: buckets.map((b) => ({ name: `${b.name} (${b.$id})`, value: b.$id })),
-          pageSize: 10,
-        }
-      ]);
-
-      if (!toDelete || toDelete.length === 0) {
-        MessageFormatter.info('No buckets selected', { prefix: 'Buckets' });
-        return;
-      }
-
-      const { confirm } = await inquirer.prompt([
-        { type: 'confirm', name: 'confirm', message: `Delete ${toDelete.length} bucket(s)?`, default: false }
-      ]);
-      if (!confirm) return;
-
-      const controller = (cli as any).controller!;
-      for (const id of toDelete) {
-        try {
-          await deleteBucketApi(storage, id);
-          MessageFormatter.success(`Deleted bucket ${id}`, { prefix: 'Buckets' });
-
-          // Remove from in-memory config (global buckets)
-          if (Array.isArray(controller.config.buckets)) {
-            controller.config.buckets = controller.config.buckets.filter((b: any) => b.$id !== id);
-          }
-          // Clear database-linked bucket references if matching
-          if (Array.isArray(controller.config.databases)) {
-            controller.config.databases = controller.config.databases.map((db: any) => ({
-              ...db,
-              bucket: db.bucket && db.bucket.$id === id ? undefined : db.bucket,
-            }));
-          }
-        } catch (e) {
-          MessageFormatter.error(`Failed to delete bucket ${id}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Buckets' });
-        }
-      }
-
-      // Persist YAML changes
-      const cfgMgr = ConfigManager.getInstance();
-      const cfgPath = cfgMgr.getConfigPath();
-      if (cfgPath && /\.ya?ml$/i.test(cfgPath)) {
-        await writeYamlConfig(cfgPath, controller.config);
-        MessageFormatter.info(`Updated config.yaml after deletion`, { prefix: 'Buckets' });
-      } else {
-        MessageFormatter.warning(`Config is not YAML; updated in-memory only. Please update your TypeScript config manually.`, { prefix: 'Buckets' });
-      }
-    } catch (e) {
-      MessageFormatter.error('Failed to list buckets', e instanceof Error ? e : new Error(String(e)), { prefix: 'Buckets' });
-    }
-  }
-};