appwrite-utils-cli 1.9.7 → 1.12.0

package/src/cli/commands/functionCommands.ts

@@ -1,418 +0,0 @@
-import inquirer from "inquirer";
-import { join } from "node:path";
-import fs from "node:fs";
-import os from "node:os";
-import { ulid } from "ulidx";
-import chalk from "chalk";
-import { Query } from "node-appwrite";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
-import {
-  createFunctionTemplate,
-  deleteFunction,
-  downloadLatestFunctionDeployment,
-  listFunctions,
-  listSpecifications,
-} from "../../functions/methods.js";
-import { deployLocalFunction } from "../../functions/deployments.js";
-import { discoverFnConfigs, mergeDiscoveredFunctions } from "../../functions/fnConfigDiscovery.js";
-import { addFunctionToYamlConfig, findYamlConfig } from "../../config/yamlConfig.js";
-import { RuntimeSchema, type AppwriteFunction, type Runtime, type Specification } from "appwrite-utils";
-import type { InteractiveCLI } from "../../interactiveCLI.js";
-
-export const functionCommands = {
-  async createFunction(cli: InteractiveCLI): Promise<void> {
-    const { name } = await inquirer.prompt([
-      {
-        type: "input",
-        name: "name",
-        message: "Function name:",
-        validate: (input) => input.length > 0,
-      },
-    ]);
-
-    const { template } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "template",
-        message: "Select a template:",
-        choices: [
-          { name: "TypeScript Node.js", value: "typescript-node" },
-          { name: "TypeScript with Hono Web Framework", value: "hono-typescript" },
-          { name: "Python with UV", value: "uv" },
-          { name: "Count Documents in Collection", value: "count-docs-in-collection" },
-          { name: "None (Empty Function)", value: "none" },
-        ],
-      },
-    ]);
-
-    // Get template defaults
-    const templateDefaults = (cli as any).getTemplateDefaults(template);
-
-    const { runtime } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "runtime",
-        message: "Select runtime:",
-        choices: Object.values(RuntimeSchema.Values),
-        default: templateDefaults.runtime,
-      },
-    ]);
-
-    const specifications = await listSpecifications(
-      (cli as any).controller!.appwriteServer!
-    );
-    const { specification } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "specification",
-        message: "Select specification:",
-        choices: [
-          { name: "None", value: undefined },
-          ...specifications.specifications.map((s: any) => ({
-            name: s.slug,
-            value: s.slug,
-          })),
-        ],
-        default: templateDefaults.specification,
-      },
-    ]);
-
-    const functionConfig: AppwriteFunction = {
-      $id: ulid(),
-      name,
-      runtime,
-      events: [],
-      execute: ["any"],
-      enabled: true,
-      logging: true,
-      entrypoint: templateDefaults.entrypoint,
-      commands: templateDefaults.commands,
-      specification: specification || templateDefaults.specification,
-      scopes: [],
-      timeout: 15,
-      schedule: "",
-      installationId: "",
-      providerRepositoryId: "",
-      providerBranch: "",
-      providerSilentMode: false,
-      providerRootDirectory: "",
-      templateRepository: "",
-      templateOwner: "",
-      templateRootDirectory: "",
-    };
-
-    if (template !== "none") {
-      await createFunctionTemplate(
-        template as "typescript-node" | "uv" | "count-docs-in-collection" | "hono-typescript",
-        name,
-        "./functions"
-      );
-    }
-
-    // Add to in-memory config
-    if (!(cli as any).controller!.config!.functions) {
-      (cli as any).controller!.config!.functions = [];
-    }
-    (cli as any).controller!.config!.functions.push(functionConfig);
-
-    // If using YAML config, also add to YAML file
-    const yamlConfigPath = findYamlConfig((cli as any).currentDir);
-    if (yamlConfigPath) {
-      try {
-        await addFunctionToYamlConfig(yamlConfigPath, functionConfig);
-      } catch (error) {
-        MessageFormatter.warning(
-          `Function created but failed to update YAML config: ${error instanceof Error ? error.message : error}`,
-          { prefix: "Functions" }
-        );
-      }
-    }
-
-    MessageFormatter.success("Function created successfully!", { prefix: "Functions" });
-  },
-
-  async deployFunction(cli: InteractiveCLI): Promise<void> {
-    await (cli as any).initControllerIfNeeded();
-    if (!(cli as any).controller?.config) {
-      MessageFormatter.error("Failed to initialize controller or load config", undefined, { prefix: "Functions" });
-      return;
-    }
-
-    // Discover per-function .fnconfig.yaml definitions and merge with central list for selection
-    // No global prompt; we'll handle conflicts per-function if both exist.
-    let discovered: any[] = [];
-    let central: any[] = (cli as any).controller!.config!.functions || [];
-    try {
-      discovered = discoverFnConfigs((cli as any).currentDir) as any[];
-      const merged = mergeDiscoveredFunctions(central as any, discovered as any);
-      (cli as any).controller!.config!.functions = merged as any;
-    } catch {}
-
-    const functions = await (cli as any).selectFunctions(
-      "Select function(s) to deploy:",
-      true,
-      true
-    );
-
-    if (!functions?.length) {
-      MessageFormatter.error("No function selected", undefined, { prefix: "Functions" });
-      return;
-    }
-
-    for (const functionConfig of functions) {
-      if (!functionConfig) {
-        MessageFormatter.error("Invalid function configuration", undefined, { prefix: "Functions" });
-        return;
-      }
-
-      // Resolve effective config for this function (prefer per-function choice if both sources exist)
-      const byIdOrName = (arr: any[]) => arr.find((f:any) => f?.$id === functionConfig.$id || f?.name === functionConfig.name);
-      const centralDef = byIdOrName(central as any[]);
-      const discoveredDef = byIdOrName(discovered as any[]);
-
-      let effectiveConfig = functionConfig;
-      if (centralDef && discoveredDef) {
-        try {
-          const answer = await inquirer.prompt([
-            {
-              type: 'list',
-              name: 'cfgChoice',
-              message: `Multiple configs found for '${functionConfig.name}'. Which to use?`,
-              choices: [
-                { name: 'config.yaml (central)', value: 'central' },
-                { name: '.fnconfig.yaml (local file)', value: 'fnconfig' },
-                { name: 'Merge (.fnconfig overrides central)', value: 'merge' },
-              ],
-              default: 'fnconfig'
-            }
-          ]);
-          if (answer.cfgChoice === 'central') effectiveConfig = centralDef;
-          else if (answer.cfgChoice === 'fnconfig') effectiveConfig = discoveredDef;
-          else effectiveConfig = { ...centralDef, ...discoveredDef };
-        } catch {}
-      }
-
-      // Ensure functions array exists
-      if (!(cli as any).controller.config.functions) {
-        (cli as any).controller.config.functions = [];
-      }
-
-      const functionNameLower = effectiveConfig.name
-        .toLowerCase()
-        .replace(/\s+/g, "-");
-
-      // Debug logging
-      MessageFormatter.info(`🔍 Function deployment debug:`, { prefix: "Functions" });
-      MessageFormatter.info(`  Function name: ${effectiveConfig.name}`, { prefix: "Functions" });
-      MessageFormatter.info(`  Function ID: ${effectiveConfig.$id}`, { prefix: "Functions" });
-      MessageFormatter.info(`  Config dirPath: ${effectiveConfig.dirPath || 'undefined'}`, { prefix: "Functions" });
-      if (effectiveConfig.dirPath) {
-        const expandedPath = effectiveConfig.dirPath.startsWith('~/')
-          ? effectiveConfig.dirPath.replace('~', os.homedir())
-          : effectiveConfig.dirPath;
-        MessageFormatter.info(`  Expanded dirPath: ${expandedPath}`, { prefix: "Functions" });
-      }
-      MessageFormatter.info(`  Appwrite folder: ${(cli as any).controller.getAppwriteFolderPath()}`, { prefix: "Functions" });
-      MessageFormatter.info(`  Current working dir: ${process.cwd()}`, { prefix: "Functions" });
-
-      // Resolve config dirPath relative to central YAML if it's relative
-      const yamlConfigPath = findYamlConfig((cli as any).currentDir);
-      const yamlBaseDir = yamlConfigPath ? require('node:path').dirname(yamlConfigPath) : process.cwd();
-      const expandTildePath = (p: string): string => (p?.startsWith('~/') ? p.replace('~', os.homedir()) : p);
-
-      // Check locations in priority order:
-      const priorityLocations = [
-        // 1. Config dirPath if specified (with tilde expansion)
-        effectiveConfig.dirPath
-          ? (require('node:path').isAbsolute(expandTildePath(effectiveConfig.dirPath))
-              ? expandTildePath(effectiveConfig.dirPath)
-              : require('node:path').resolve(yamlBaseDir, expandTildePath(effectiveConfig.dirPath)))
-          : undefined,
-        // 2. Appwrite config folder/functions/name
-        join(
-          (cli as any).controller.getAppwriteFolderPath()!,
-          "functions",
-          functionNameLower
-        ),
-        // 3. Current working directory/functions/name
-        join(process.cwd(), "functions", functionNameLower),
-        // 4. Current working directory/name
-        join(process.cwd(), functionNameLower),
-      ].filter((val): val is string => val !== undefined);
-
-      MessageFormatter.info(`🔍 Priority locations to check:`, { prefix: "Functions" });
-      priorityLocations.forEach((loc, i) => {
-        MessageFormatter.info(`  ${i + 1}. ${loc}`, { prefix: "Functions" });
-      });
-
-      let functionPath: string | null = null;
-
-      // Check each priority location
-      for (const location of priorityLocations) {
-        MessageFormatter.info(`  Checking: ${location} - ${fs.existsSync(location) ? 'EXISTS' : 'NOT FOUND'}`, { prefix: "Functions" });
-        if (fs.existsSync(location)) {
-          MessageFormatter.success(`✅ Found function at: ${location}`, { prefix: "Functions" });
-          functionPath = location;
-          break;
-        }
-      }
-
-      // If not found in priority locations, do a broader search
-      if (!functionPath) {
-        MessageFormatter.info(`Function not found in primary locations, searching subdirectories...`, { prefix: "Functions" });
-
-        // Search in both appwrite config directory and current working directory
-        functionPath = await (cli as any).findFunctionInSubdirectories(
-          [(cli as any).controller.getAppwriteFolderPath()!, process.cwd()],
-          functionNameLower
-        );
-      }
-
-      if (!functionPath) {
-        const { shouldDownload } = await inquirer.prompt([
-          {
-            type: "confirm",
-            name: "shouldDownload",
-            message:
-              "Function not found locally. Would you like to download the latest deployment?",
-            default: false,
-          },
-        ]);
-
-        if (shouldDownload) {
-          try {
-            MessageFormatter.progress("Downloading latest deployment...", { prefix: "Functions" });
-            const { path: downloadedPath, function: remoteFunction } =
-              await downloadLatestFunctionDeployment(
-                (cli as any).controller.appwriteServer!,
-                effectiveConfig.$id,
-                join((cli as any).controller.getAppwriteFolderPath()!, "functions")
-              );
-            MessageFormatter.success(`✨ Function downloaded to ${downloadedPath}`, { prefix: "Functions" });
-
-            functionPath = downloadedPath;
-            effectiveConfig.dirPath = downloadedPath;
-
-            const existingIndex = (cli as any).controller.config.functions.findIndex(
-              (f: any) => f?.$id === remoteFunction.$id
-            );
-
-            if (existingIndex >= 0) {
-              (cli as any).controller.config.functions[existingIndex].dirPath =
-                downloadedPath;
-            }
-
-            await (cli as any).reloadConfigWithSessionPreservation();
-          } catch (error) {
-            MessageFormatter.error("Failed to download function deployment", error instanceof Error ? error : new Error(String(error)), { prefix: "Functions" });
-            return;
-          }
-        } else {
-          MessageFormatter.error(`Function ${effectiveConfig.name} not found locally. Cannot deploy.`, undefined, { prefix: "Functions" });
-          return;
-        }
-      }
-
-      if (!(cli as any).controller.appwriteServer) {
-        MessageFormatter.error("Appwrite server not initialized", undefined, { prefix: "Functions" });
-        return;
-      }
-
-      try {
-        await deployLocalFunction(
-          (cli as any).controller.appwriteServer,
-          effectiveConfig.name,
-          {
-            ...effectiveConfig,
-            dirPath: functionPath,
-          },
-          functionPath
-        );
-        MessageFormatter.success("Function deployed successfully!", { prefix: "Functions" });
-      } catch (error) {
-        MessageFormatter.error("Failed to deploy function", error instanceof Error ? error : new Error(String(error)), { prefix: "Functions" });
-      }
-    }
-  },
-
-  async deleteFunction(cli: InteractiveCLI): Promise<void> {
-    const functions = await (cli as any).selectFunctions(
-      "Select functions to delete:",
-      true,
-      false
-    );
-
-    if (!functions.length) {
-      MessageFormatter.error("No functions selected", undefined, { prefix: "Functions" });
-      return;
-    }
-
-    for (const func of functions) {
-      try {
-        await deleteFunction((cli as any).controller!.appwriteServer!, func.$id);
-        MessageFormatter.success(`✨ Function ${func.name} deleted successfully!`, { prefix: "Functions" });
-      } catch (error) {
-        MessageFormatter.error(`Failed to delete function ${func.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Functions" });
-      }
-    }
-  },
-
-  async updateFunctionSpec(cli: InteractiveCLI): Promise<void> {
-    const remoteFunctions = await listFunctions(
-      (cli as any).controller!.appwriteServer!,
-      [Query.limit(1000)]
-    );
-    const localFunctions = (cli as any).getLocalFunctions();
-
-    const allFunctions = [
-      ...remoteFunctions.functions,
-      ...localFunctions.filter(
-        (f: any) => !remoteFunctions.functions.some((rf: any) => rf.name === f.name)
-      ),
-    ];
-
-    const functionsToUpdate = await inquirer.prompt([
-      {
-        type: "checkbox",
-        name: "functionId",
-        message: "Select functions to update:",
-        choices: allFunctions.map((f: any) => ({
-          name: `${f.name} (${f.$id})${
-            localFunctions.some((lf: any) => lf.name === f.name)
-              ? " (Local)"
-              : " (Remote)"
-          }`,
-          value: f.$id,
-        })),
-        loop: true,
-      },
-    ]);
-
-    const specifications = await listSpecifications(
-      (cli as any).controller!.appwriteServer!
-    );
-    const { specification } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "specification",
-        message: "Select new specification:",
-        choices: specifications.specifications.map((s: any) => ({
-          name: `${s.slug}`,
-          value: s.slug,
-        })),
-      },
-    ]);
-
-    try {
-      for (const functionId of functionsToUpdate.functionId) {
-        await (cli as any).controller!.updateFunctionSpecifications(
-          functionId,
-          specification
-        );
-        MessageFormatter.success(`Successfully updated function specification to ${specification}`, { prefix: "Functions" });
-      }
-    } catch (error) {
-      MessageFormatter.error("Error updating function specification", error instanceof Error ? error : new Error(String(error)), { prefix: "Functions" });
-    }
-  }
-};

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 "../../shared/messageFormatter.js";
-import { SchemaGenerator } from "../../shared/schemaGenerator.js";
-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("../../utils/constantsGenerator.js");
-      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);
-  }
-};