appwrite-cli 13.0.0-rc.2 → 13.0.0-rc.3

package/scripts/generate-commands.ts

@@ -1,539 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import * as https from "https";
-
-interface SpecParameter {
-  name: string;
-  description: string;
-  required: boolean;
-  type: string;
-  in: string;
-  collectionFormat?: string;
-  items?: { type: string };
-  default?: any;
-  schema?: any;
-  "x-example"?: string;
-  "x-enum-name"?: string;
-  "x-enum-keys"?: string[];
-  format?: string;
-  enum?: string[];
-}
-
-interface SpecEndpoint {
-  summary: string;
-  operationId: string;
-  description: string;
-  deprecated: boolean;
-  parameters?: SpecParameter[];
-  "x-appwrite": {
-    method: string;
-    group: string;
-    methods?: Array<{
-      name: string;
-      parameters: string[];
-      required: string[];
-    }>;
-  };
-}
-
-interface SpecPaths {
-  [path: string]: {
-    [method: string]: SpecEndpoint;
-  };
-}
-
-interface OpenAPISpec {
-  paths: SpecPaths;
-}
-
-// Utility functions
-function capitalizeFirst(str: string): string {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-
-function camelToKebab(str: string): string {
-  return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
-}
-
-function getParamName(name: string): string {
-  return camelToKebab(name);
-}
-
-function getParamVarName(name: string): string {
-  // Convert kebab-case or snake_case to camelCase
-  let varName = name.replace(/[-_]([a-z])/g, (_, letter) =>
-    letter.toUpperCase(),
-  );
-
-  // Handle reserved keywords
-  const reservedKeywords = [
-    "default",
-    "const",
-    "let",
-    "var",
-    "function",
-    "class",
-    "interface",
-    "type",
-    "enum",
-    "export",
-    "import",
-    "return",
-    "if",
-    "else",
-    "for",
-    "while",
-    "do",
-    "switch",
-    "case",
-    "break",
-    "continue",
-    "throw",
-    "try",
-    "catch",
-    "finally",
-    "new",
-    "this",
-    "super",
-    "extends",
-    "implements",
-    "static",
-    "private",
-    "public",
-    "protected",
-    "readonly",
-    "async",
-    "await",
-  ];
-
-  if (reservedKeywords.includes(varName)) {
-    return `x${capitalizeFirst(varName)}`;
-  }
-
-  return varName;
-}
-
-// Unused but kept for future extension
-// function getTypeScriptType(param: SpecParameter): string {
-//   if (param.type === "array") {
-//     return "string[]";
-//   }
-//   if (param.type === "boolean") {
-//     return "boolean";
-//   }
-//   if (param.type === "integer" || param.type === "number") {
-//     return "number";
-//   }
-//   if (param.type === "object") {
-//     return "string"; // JSON string
-//   }
-//   return "string";
-// }
-
-function needsParser(param: SpecParameter): string | null {
-  if (param.type === "boolean") {
-    return "parseBool";
-  }
-  if (param.type === "integer" || param.type === "number") {
-    return "parseInteger";
-  }
-  if (param.type === "object") {
-    return "JSON.parse";
-  }
-  return null;
-}
-
-function getEnumTypesFromParams(params: SpecParameter[]): Set<string> {
-  const enumTypes = new Set<string>();
-
-  for (const param of params) {
-    // Use x-enum-name from the spec to determine enum type
-    if (param["x-enum-name"]) {
-      enumTypes.add(param["x-enum-name"]);
-    }
-  }
-
-  return enumTypes;
-}
-
-function generateCommand(
-  commandName: string,
-  endpoint: SpecEndpoint,
-  serviceName: string,
-  clientGetterName: string = `get${capitalizeFirst(serviceName)}Client`,
-): string {
-  const methodName = endpoint["x-appwrite"].method;
-  const deprecated = endpoint.deprecated;
-  const deprecationNote = deprecated
-    ? `[**DEPRECATED** - This command is deprecated. Please use '${serviceName} ${methodName}' instead] `
-    : "";
-
-  let code = `\n${serviceName}\n`;
-  code += `  .command(\`${commandName}\`)\n`;
-  code += `  .description(\n`;
-  code += `    \`${deprecationNote}${endpoint.description.replace(/`/g, "\\`")}\`,\n`;
-  code += `  )\n`;
-
-  // Get all parameters (both query and body)
-  const allParams: SpecParameter[] = [];
-
-  if (endpoint.parameters) {
-    for (const param of endpoint.parameters) {
-      if (param.in === "body" && param.schema?.properties) {
-        // Extract body parameters
-        const required = param.schema.required || [];
-        for (const [propName, propDef] of Object.entries<any>(
-          param.schema.properties,
-        )) {
-          allParams.push({
-            name: propName,
-            description: propDef.description || "",
-            required: required.includes(propName),
-            type: propDef.type || "string",
-            in: "body",
-            default: propDef.default,
-            "x-enum-name": propDef["x-enum-name"],
-            "x-enum-keys": propDef["x-enum-keys"],
-          });
-        }
-      } else {
-        // Query or path parameters
-        allParams.push(param);
-      }
-    }
-  }
-
-  // Filter parameters based on method definition if x-appwrite.methods exists
-  let filteredParams = allParams;
-  const xAppwriteMethods = endpoint["x-appwrite"].methods;
-  if (xAppwriteMethods && Array.isArray(xAppwriteMethods)) {
-    const methodDef = xAppwriteMethods.find((m) => m.name === methodName);
-    if (methodDef) {
-      const allowedParams = new Set(methodDef.parameters);
-      const requiredParams = new Set(methodDef.required || []);
-
-      filteredParams = allParams.filter((param) =>
-        allowedParams.has(param.name),
-      );
-
-      // Update required status based on method definition
-      filteredParams = filteredParams.map((param) => ({
-        ...param,
-        required: requiredParams.has(param.name),
-      }));
-    }
-  }
-
-  // Generate options
-  for (const param of filteredParams) {
-    const paramName = getParamName(param.name);
-    const isArray =
-      param.type === "array" || param.collectionFormat === "multi";
-    const isBool = param.type === "boolean";
-
-    let paramFlag: string;
-    if (isArray) {
-      paramFlag = `[${paramName}...]`;
-    } else if (isBool && !param.required) {
-      paramFlag = `[value]`;
-    } else {
-      paramFlag = `<${paramName}>`;
-    }
-
-    const optionMethod = param.required ? "requiredOption" : "option";
-
-    code += `  .${optionMethod}(\n`;
-    code += `    \`--${paramName} ${paramFlag}\`,\n`;
-    code += `    \`${param.description.replace(/`/g, "\\`")}\`,\n`;
-
-    // Add parser if needed
-    const parser = needsParser(param);
-    if (parser === "parseBool" && !param.required) {
-      // Special handling for optional boolean flags
-      code += `    (value: string | undefined) =>\n`;
-      code += `      value === undefined ? true : parseBool(value),\n`;
-    } else if (parser && parser !== "JSON.parse") {
-      code += `    ${parser},\n`;
-    }
-
-    code += `  )\n`;
-  }
-
-  // Generate action
-  const paramVars = filteredParams.map((p) => getParamVarName(p.name));
-  const paramVarsStr =
-    paramVars.length > 0 ? `{ ${paramVars.join(", ")} }` : "";
-
-  code += `  .action(\n`;
-  code += `    actionRunner(\n`;
-
-  if (paramVars.length === 0) {
-    code += `      async () => await (await ${clientGetterName}()).${methodName}(),\n`;
-  } else {
-    code += `      async (${paramVarsStr}) =>\n`;
-
-    // Build arguments list
-    const args: string[] = [];
-    for (const param of filteredParams) {
-      const varName = getParamVarName(param.name);
-      if (needsParser(param) === "JSON.parse") {
-        args.push(`JSON.parse(${varName})`);
-      } else if (param["x-enum-name"]) {
-        args.push(`${varName} as ${param["x-enum-name"]}`);
-      } else {
-        args.push(varName);
-      }
-    }
-
-    const argsStr = args.join(", ");
-
-    if (args.length <= 3) {
-      code += `        await (\n`;
-      code += `          await ${clientGetterName}()\n`;
-      code += `        ).${methodName}(${argsStr}),\n`;
-    } else {
-      code += `        await (\n`;
-      code += `          await ${clientGetterName}()\n`;
-      code += `        ).${methodName}(\n`;
-      for (let i = 0; i < args.length; i++) {
-        code += `          ${args[i]}${i < args.length - 1 ? "," : ""}\n`;
-      }
-      code += `        ),\n`;
-    }
-  }
-
-  code += `    ),\n`;
-  code += `  );\n`;
-
-  return code;
-}
-
-function generateCommandFile(
-  serviceName: string,
-  endpoints: { [key: string]: SpecEndpoint },
-  serviceClassName: string,
-  methodToServiceClassMap?: { [methodName: string]: string },
-): string {
-  // Map method names to their actual service class names
-  const actualServiceClassMap: { [methodName: string]: string } =
-    methodToServiceClassMap || {};
-
-  // Collect all enum types needed
-  const enumTypes = new Set<string>();
-  const serviceClassesNeeded = new Set<string>([serviceClassName]);
-
-  for (const endpoint of Object.values(endpoints)) {
-    const methodName = endpoint["x-appwrite"].method;
-    const actualServiceClass =
-      actualServiceClassMap[methodName] || serviceClassName;
-    serviceClassesNeeded.add(actualServiceClass);
-
-    const params: SpecParameter[] = [];
-
-    if (endpoint.parameters) {
-      for (const param of endpoint.parameters) {
-        if (param.in === "body" && param.schema?.properties) {
-          const required = param.schema.required || [];
-          for (const [propName, propDef] of Object.entries<any>(
-            param.schema.properties,
-          )) {
-            params.push({
-              name: propName,
-              description: propDef.description || "",
-              required: required.includes(propName),
-              type: propDef.type || "string",
-              in: "body",
-              "x-enum-name": propDef["x-enum-name"],
-              "x-enum-keys": propDef["x-enum-keys"],
-            });
-          }
-        } else {
-          params.push(param);
-        }
-      }
-    }
-
-    getEnumTypesFromParams(params).forEach((type) => enumTypes.add(type));
-  }
-
-  // Generate imports
-  let code = `import { Command } from "commander";\n`;
-  code += `import { sdkForProject } from "../../sdks.js";\n`;
-  code += `import { actionRunner, commandDescriptions, parseBool, parseInteger } from "../../parser.js";\n`;
-
-  const imports: string[] = [];
-  serviceClassesNeeded.forEach((className) => imports.push(className));
-  enumTypes.forEach((type) => imports.push(type));
-
-  code += `import {\n`;
-  for (const imp of imports) {
-    code += `  ${imp},\n`;
-  }
-  code += `} from "@appwrite.io/console";\n\n`;
-
-  // Generate client singletons for all needed service classes
-  const clientGetters: { [className: string]: string } = {};
-
-  for (const className of serviceClassesNeeded) {
-    const clientVarName =
-      className === serviceClassName
-        ? `${serviceName}Client`
-        : `${className.charAt(0).toLowerCase() + className.slice(1)}Client`;
-    const getterName = `get${className}Client`;
-    clientGetters[className] = getterName;
-
-    code += `let ${clientVarName}: ${className} | null = null;\n\n`;
-    code += `const ${getterName} = async (): Promise<${className}> => {\n`;
-    code += `  if (!${clientVarName}) {\n`;
-    code += `    const sdkClient = await sdkForProject();\n`;
-    code += `    ${clientVarName} = new ${className}(sdkClient);\n`;
-    code += `  }\n`;
-    code += `  return ${clientVarName};\n`;
-    code += `};\n\n`;
-  }
-
-  // Generate main command
-  code += `export const ${serviceName} = new Command("${serviceName}")\n`;
-  code += `  .description(commandDescriptions["${serviceName}"] ?? "")\n`;
-  code += `  .configureHelp({\n`;
-  code += `    helpWidth: process.stdout.columns || 80,\n`;
-  code += `  });\n`;
-
-  // Generate all commands
-  for (const [path, endpoint] of Object.entries(endpoints)) {
-    const commandName = camelToKebab(endpoint["x-appwrite"].method);
-    const methodName = endpoint["x-appwrite"].method;
-    const actualServiceClass =
-      actualServiceClassMap[methodName] || serviceClassName;
-    const clientGetterName = clientGetters[actualServiceClass];
-    code += generateCommand(
-      commandName,
-      endpoint,
-      serviceName,
-      clientGetterName,
-    );
-  }
-
-  return code;
-}
-
-async function downloadSpec(url: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    https
-      .get(url, (res) => {
-        let data = "";
-        res.on("data", (chunk) => {
-          data += chunk;
-        });
-        res.on("end", () => {
-          resolve(data);
-        });
-      })
-      .on("error", (err) => {
-        reject(err);
-      });
-  });
-}
-
-async function main() {
-  const branch = "1.8.x";
-  const version = "1.8.x";
-  const platform = "console";
-
-  const specUrl = `https://raw.githubusercontent.com/appwrite/appwrite/${branch}/app/config/specs/swagger2-${version}-${platform}.json`;
-
-  console.log("Downloading spec from:", specUrl);
-  const specContent = await downloadSpec(specUrl);
-  const spec: OpenAPISpec = JSON.parse(specContent);
-
-  console.log("Parsing spec...");
-
-  // Group endpoints by service based on path prefix
-  const services: { [key: string]: { [key: string]: SpecEndpoint } } = {};
-  const serviceClassNames: { [key: string]: string } = {
-    account: "Account",
-    users: "Users",
-    teams: "Teams",
-    databases: "Databases",
-    storage: "Storage",
-    functions: "Functions",
-    messaging: "Messaging",
-    locale: "Locale",
-    health: "Health",
-    projects: "Projects",
-    proxy: "Proxy",
-    vcs: "Vcs",
-    migrations: "Migrations",
-    console: "Console",
-    graphql: "Graphql",
-    organizations: "Organizations",
-    sites: "Sites",
-    tokens: "Tokens",
-    tablesdb: "TablesDB",
-    avatars: "Avatars",
-  };
-
-  for (const [pathStr, methods] of Object.entries(spec.paths)) {
-    // Determine service name from path prefix
-    const pathParts = pathStr.split("/").filter((p) => p);
-    const serviceName = pathParts[0];
-
-    for (const [method, endpoint] of Object.entries(methods)) {
-      if (endpoint && endpoint["x-appwrite"]) {
-        if (!services[serviceName]) {
-          services[serviceName] = {};
-        }
-
-        const key = `${method}:${pathStr}`;
-        services[serviceName][key] = endpoint as SpecEndpoint;
-      }
-    }
-  }
-
-  // Generate command files
-  const outputDir = path.join(process.cwd(), "lib", "commands", "services");
-
-  // Create services directory if it doesn't exist
-  if (!fs.existsSync(outputDir)) {
-    fs.mkdirSync(outputDir, { recursive: true });
-  }
-
-  console.log("Generating command files...");
-
-  // Map methods to their actual service classes (for methods that belong to different services)
-  const methodToServiceClassMaps: {
-    [serviceName: string]: { [methodName: string]: string };
-  } = {
-    console: {
-      chat: "Assistant",
-    },
-  };
-
-  for (const [serviceName, endpoints] of Object.entries(services)) {
-    const serviceClassName =
-      serviceClassNames[serviceName] || capitalizeFirst(serviceName);
-    const methodToServiceClassMap = methodToServiceClassMaps[serviceName];
-    const content = generateCommandFile(
-      serviceName,
-      endpoints,
-      serviceClassName,
-      methodToServiceClassMap,
-    );
-
-    const outputPath = path.join(outputDir, `${serviceName}.ts`);
-    fs.writeFileSync(outputPath, content);
-
-    console.log(`Generated: ${outputPath}`);
-  }
-
-  console.log(
-    "\nDone! Generated",
-    Object.keys(services).length,
-    "command files.",
-  );
-}
-
-main().catch((err) => {
-  console.error("Error:", err);
-  process.exit(1);
-});