axigen 0.1.0

package/dist/index.mjs

@@ -0,0 +1,454 @@
+// src/generate.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/parser/openapi.ts
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+function parseOpenAPIFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`OpenAPI file not found: ${filePath}`);
+  }
+  const content = fs.readFileSync(filePath, "utf-8");
+  const ext = path.extname(filePath).toLowerCase();
+  let spec;
+  if (ext === ".json") {
+    spec = JSON.parse(content);
+  } else {
+    spec = yaml.load(content);
+  }
+  return validateSpec(spec, filePath);
+}
+function validateSpec(raw, filePath) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error(`Invalid OpenAPI file: ${filePath}`);
+  }
+  const s = raw;
+  const isOpenAPI3 = typeof s.openapi === "string" && s.openapi.startsWith("3.");
+  const isSwagger2 = typeof s.swagger === "string" && s.swagger.startsWith("2.");
+  if (!isOpenAPI3 && !isSwagger2) {
+    throw new Error(`Unsupported spec format in ${filePath}.
+Expected OpenAPI 3.x or Swagger 2.x`);
+  }
+  if (!s.paths || typeof s.paths !== "object") {
+    throw new Error(`OpenAPI spec has no "paths" defined: ${filePath}`);
+  }
+  return raw;
+}
+function extractEndpoints(spec, filterTags) {
+  const endpoints = [];
+  for (const [urlPath, pathItem] of Object.entries(spec.paths)) {
+    const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
+    for (const method of methods) {
+      const operation = pathItem[method];
+      if (!operation) continue;
+      const tags = operation.tags ?? [];
+      if (filterTags && filterTags.length > 0) {
+        if (!tags.some((t) => filterTags.includes(t))) continue;
+      }
+      const operationId = operation.operationId ?? buildOperationId(method, urlPath);
+      const allParams = [...pathItem.parameters ?? [], ...operation.parameters ?? []];
+      const pathParams = allParams.filter((p) => !("$ref" in p) && p.in === "path").map(normalizeParam);
+      const queryParams = allParams.filter((p) => !("$ref" in p) && p.in === "query").map(normalizeParam);
+      let bodySchema;
+      let bodyRequired = false;
+      if (operation.requestBody && !("$ref" in operation.requestBody)) {
+        bodyRequired = operation.requestBody.required ?? false;
+        const content = operation.requestBody.content;
+        const jsonContent = content?.["application/json"];
+        bodySchema = jsonContent?.schema;
+      }
+      let responseSchema;
+      for (const [status, response] of Object.entries(operation.responses)) {
+        if (status.startsWith("2") && !("$ref" in response)) {
+          const jsonContent = response.content?.["application/json"];
+          responseSchema = jsonContent?.schema;
+          break;
+        }
+      }
+      endpoints.push({
+        operationId,
+        method,
+        path: urlPath,
+        summary: operation.summary,
+        description: operation.description,
+        tags,
+        pathParams,
+        queryParams,
+        bodySchema,
+        bodyRequired,
+        responseSchema
+      });
+    }
+  }
+  return endpoints;
+}
+function normalizeParam(p) {
+  return {
+    name: p.name,
+    required: p.required ?? false,
+    schema: p.schema,
+    description: p.description
+  };
+}
+function buildOperationId(method, urlPath) {
+  const parts = urlPath.split("/").filter(Boolean).map((segment) => {
+    if (segment.startsWith("{") && segment.endsWith("}")) {
+      const name = segment.slice(1, -1);
+      return "By" + capitalize(name);
+    }
+    return capitalize(segment);
+  });
+  return method.toLowerCase() + parts.join("");
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+// src/generator/types.ts
+function schemaToTSType(schema, indent = 0) {
+  if (!schema) return "unknown";
+  if (schema.$ref) {
+    return refToTypeName(schema.$ref);
+  }
+  if (schema.allOf && schema.allOf.length > 0) {
+    return schema.allOf.map((s) => schemaToTSType(s, indent)).join(" & ");
+  }
+  if (schema.anyOf || schema.oneOf) {
+    const variants = schema.anyOf ?? schema.oneOf;
+    return variants.map((s) => schemaToTSType(s, indent)).join(" | ");
+  }
+  if (schema.enum) {
+    return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+  }
+  const nullable = schema.nullable ? " | null" : "";
+  switch (schema.type) {
+    case "string":
+      return `string${nullable}`;
+    case "number":
+    case "integer":
+      return `number${nullable}`;
+    case "boolean":
+      return `boolean${nullable}`;
+    case "null":
+      return "null";
+    case "array":
+      return `Array<${schemaToTSType(schema.items, indent)}>${nullable}`;
+    case "object":
+      return buildObjectType(schema, indent) + nullable;
+    default:
+      if (schema.properties) {
+        return buildObjectType(schema, indent) + nullable;
+      }
+      return `unknown${nullable}`;
+  }
+}
+function buildObjectType(schema, indent) {
+  if (!schema.properties || Object.keys(schema.properties).length === 0) {
+    return "Record<string, unknown>";
+  }
+  const required = new Set(schema.required ?? []);
+  const pad = "  ".repeat(indent + 1);
+  const closePad = "  ".repeat(indent);
+  const fields = Object.entries(schema.properties).map(([key, val]) => {
+    const optional = !required.has(key) ? "?" : "";
+    const comment = val.description ? `${pad}/** ${val.description} */
+` : "";
+    const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `'${key}'`;
+    return `${comment}${pad}${safeName}${optional}: ${schemaToTSType(val, indent + 1)}`;
+  }).join("\n");
+  return `{
+${fields}
+${closePad}}`;
+}
+function refToTypeName(ref) {
+  const parts = ref.split("/");
+  return parts[parts.length - 1] ?? "unknown";
+}
+function generateTypesFile(endpoints, schemas = {}) {
+  const lines = [];
+  lines.push(`// This file is auto-generated by axigen. DO NOT EDIT.`);
+  lines.push(`// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("");
+  if (Object.keys(schemas).length > 0) {
+    lines.push("// \u2500\u2500\u2500 Component Schemas \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    lines.push("");
+    for (const [name, schema] of Object.entries(schemas)) {
+      if (schema.description) {
+        lines.push(`/** ${schema.description} */`);
+      }
+      lines.push(`export type ${name} = ${schemaToTSType(schema)}`);
+      lines.push("");
+    }
+  }
+  lines.push("// \u2500\u2500\u2500 Endpoint Types \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  lines.push("");
+  for (const ep of endpoints) {
+    const baseName = operationToTypeName(ep.operationId);
+    if (ep.pathParams.length > 0) {
+      lines.push(`export interface ${baseName}PathParams {`);
+      for (const p of ep.pathParams) {
+        const type = schemaToTSType(p.schema);
+        const comment = p.description ? `  /** ${p.description} */
+` : "";
+        lines.push(`${comment}  ${p.name}: ${type}`);
+      }
+      lines.push(`}`);
+      lines.push("");
+    }
+    if (ep.queryParams.length > 0) {
+      lines.push(`export interface ${baseName}QueryParams {`);
+      for (const p of ep.queryParams) {
+        const optional = !p.required ? "?" : "";
+        const type = schemaToTSType(p.schema);
+        const comment = p.description ? `  /** ${p.description} */
+` : "";
+        lines.push(`${comment}  ${p.name}${optional}: ${type}`);
+      }
+      lines.push(`}`);
+      lines.push("");
+    }
+    if (ep.bodySchema) {
+      lines.push(`export type ${baseName}Body = ${schemaToTSType(ep.bodySchema)}`);
+      lines.push("");
+    }
+    if (ep.responseSchema) {
+      lines.push(`export type ${baseName}Response = ${schemaToTSType(ep.responseSchema)}`);
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function operationToTypeName(operationId) {
+  return operationId.charAt(0).toUpperCase() + operationId.slice(1);
+}
+
+// src/generator/axios.ts
+function generateClientFile(opts) {
+  const { endpoints, config, typesRelativePath } = opts;
+  const isTS = config.language !== "js";
+  const instanceExport = config.axiosInstanceExport ?? "axiosInstance";
+  const lines = [];
+  lines.push(`// This file is auto-generated by axigen. DO NOT EDIT.`);
+  lines.push(`// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("");
+  if (isTS) {
+    lines.push(`import type { AxiosResponse } from 'axios'`);
+  }
+  lines.push(`import { ${instanceExport} } from '${config.axiosInstancePath}'`);
+  if (isTS && typesRelativePath) {
+    const typeImports = collectTypeImports(endpoints);
+    if (typeImports.length > 0) {
+      lines.push(`import type { ${typeImports.join(", ")} } from '${typesRelativePath}'`);
+    }
+  }
+  lines.push("");
+  lines.push("");
+  for (const ep of endpoints) {
+    const fn = buildFunction(ep, isTS, instanceExport, config.jsdoc !== false);
+    lines.push(fn);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function buildFunction(ep, isTS, instanceExport, jsdoc) {
+  const typeName = operationToTypeName(ep.operationId);
+  const lines = [];
+  if (jsdoc) {
+    lines.push(`/**`);
+    if (ep.summary) lines.push(` * ${ep.summary}`);
+    if (ep.description && ep.description !== ep.summary) {
+      lines.push(` * ${ep.description}`);
+    }
+    lines.push(` * \`${ep.method.toUpperCase()} ${ep.path}\``);
+    if (ep.tags.length > 0) lines.push(` * @tags ${ep.tags.join(", ")}`);
+    lines.push(` */`);
+  }
+  const params = buildParams(ep, typeName, isTS);
+  const returnType = isTS ? buildReturnType(ep, typeName) : "";
+  const asyncKw = "async ";
+  lines.push(`export ${asyncKw}function ${ep.operationId}(${params})${returnType} {`);
+  const callLines = buildAxiosCall(ep, instanceExport, typeName, isTS);
+  for (const l of callLines) {
+    lines.push(`  ${l}`);
+  }
+  lines.push(`}`);
+  return lines.join("\n");
+}
+function buildParams(ep, typeName, isTS) {
+  const parts = [];
+  for (const p of ep.pathParams) {
+    const type = isTS ? `: ${typeName}PathParams['${p.name}']` : "";
+    parts.push(`${p.name}${type}`);
+  }
+  if (ep.bodySchema) {
+    const optional = !ep.bodyRequired ? "?" : "";
+    const type = isTS ? `: ${typeName}Body` : "";
+    parts.push(`data${optional}${type}`);
+  }
+  if (ep.queryParams.length > 0) {
+    const optional = ep.queryParams.every((p) => !p.required) ? "?" : "";
+    const type = isTS ? `: ${typeName}QueryParams` : "";
+    parts.push(`params${optional}${type}`);
+  }
+  return parts.join(", ");
+}
+function buildReturnType(ep, typeName) {
+  const responseType = ep.responseSchema ? `${typeName}Response` : "unknown";
+  return `: Promise<AxiosResponse<${responseType}>>`;
+}
+function buildAxiosCall(ep, instanceExport, _typeName, _isTS) {
+  const lines = [];
+  const interpolatedPath = ep.pathParams.length > 0 ? "`" + ep.path.replace(/\{(\w+)\}/g, "${$1}") + "`" : `'${ep.path}'`;
+  const hasBody = !!ep.bodySchema;
+  const hasQuery = ep.queryParams.length > 0;
+  const method = ep.method.toLowerCase();
+  if (method === "get" || method === "delete" || method === "head") {
+    if (hasQuery) {
+      lines.push(`return ${instanceExport}.${method}(${interpolatedPath}, { params })`);
+    } else {
+      lines.push(`return ${instanceExport}.${method}(${interpolatedPath})`);
+    }
+  } else {
+    const bodyArg = hasBody ? "data" : "undefined";
+    if (hasQuery) {
+      lines.push(`return ${instanceExport}.${method}(${interpolatedPath}, ${bodyArg}, { params })`);
+    } else {
+      lines.push(`return ${instanceExport}.${method}(${interpolatedPath}, ${bodyArg})`);
+    }
+  }
+  return lines;
+}
+function collectTypeImports(endpoints) {
+  const names = /* @__PURE__ */ new Set();
+  for (const ep of endpoints) {
+    const typeName = operationToTypeName(ep.operationId);
+    if (ep.pathParams.length > 0) names.add(`${typeName}PathParams`);
+    if (ep.queryParams.length > 0) names.add(`${typeName}QueryParams`);
+    if (ep.bodySchema) names.add(`${typeName}Body`);
+    if (ep.responseSchema) names.add(`${typeName}Response`);
+  }
+  return [...names].sort();
+}
+
+// src/generate.ts
+async function generate(config, cwd) {
+  const specPath = path2.resolve(cwd, config.input);
+  const spec = parseOpenAPIFile(specPath);
+  const endpoints = extractEndpoints(spec, config.tags);
+  if (endpoints.length === 0) {
+    throw new Error("No endpoints found in the OpenAPI spec. Check your input file or tags filter.");
+  }
+  const clientPath = path2.resolve(cwd, config.output.client);
+  const typesPath = config.output.types ? path2.resolve(cwd, config.output.types) : void 0;
+  let typesRelativePath;
+  if (typesPath) {
+    typesRelativePath = toRelativeImportPath(path2.dirname(clientPath), typesPath);
+  }
+  const schemas = spec.components?.schemas ?? {};
+  let typesContent;
+  if (config.language !== "js" && typesPath) {
+    typesContent = generateTypesFile(endpoints, schemas);
+  }
+  const clientContent = generateClientFile({
+    endpoints,
+    config,
+    typesRelativePath
+  });
+  ensureDir(path2.dirname(clientPath));
+  fs2.writeFileSync(clientPath, clientContent, "utf-8");
+  if (typesPath && typesContent) {
+    ensureDir(path2.dirname(typesPath));
+    fs2.writeFileSync(typesPath, typesContent, "utf-8");
+  }
+  return {
+    clientPath,
+    typesPath,
+    endpointCount: endpoints.length
+  };
+}
+function ensureDir(dir) {
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+}
+function toRelativeImportPath(fromDir, toFile) {
+  let rel = path2.relative(fromDir, toFile);
+  rel = rel.replace(/\.(ts|js|d\.ts)$/, "");
+  if (!rel.startsWith(".")) {
+    rel = "./" + rel;
+  }
+  return rel.replace(/\\/g, "/");
+}
+
+// src/config/loader.ts
+import path3 from "path";
+import fs3 from "fs";
+var CONFIG_FILES = ["axigen.config.js", "axigen.config.cjs", "axigen.config.mjs", "axigen.config.ts"];
+async function loadConfig(cwd, configPath) {
+  if (configPath) {
+    const abs = path3.resolve(cwd, configPath);
+    if (!fs3.existsSync(abs)) {
+      throw new Error(`Config file not found: ${abs}`);
+    }
+    return importConfig(abs);
+  }
+  for (const filename of CONFIG_FILES) {
+    const abs = path3.join(cwd, filename);
+    if (fs3.existsSync(abs)) {
+      return importConfig(abs);
+    }
+  }
+  throw new Error(`No config file found. Create one of: ${CONFIG_FILES.join(", ")}
+Or run: axigen init`);
+}
+async function importConfig(filePath) {
+  let raw;
+  try {
+    const mod = await import(filePath);
+    raw = mod.default ?? mod;
+  } catch {
+    throw new Error(`Failed to load config: ${filePath}`);
+  }
+  return validateConfig(raw, filePath);
+}
+function validateConfig(raw, filePath) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error(`Invalid config in ${filePath}: must export an object`);
+  }
+  const cfg = raw;
+  if (!cfg.input || typeof cfg.input !== "string") {
+    throw new Error(`Config error: "input" must be a string path to your OpenAPI file`);
+  }
+  if (!cfg.output || typeof cfg.output !== "object") {
+    throw new Error(`Config error: "output" must be an object with at least "client" path`);
+  }
+  const output = cfg.output;
+  if (!output.client || typeof output.client !== "string") {
+    throw new Error(`Config error: "output.client" is required`);
+  }
+  if (!cfg.axiosInstancePath || typeof cfg.axiosInstancePath !== "string") {
+    throw new Error(`Config error: "axiosInstancePath" is required (path to your axios instance)`);
+  }
+  return {
+    input: cfg.input,
+    output: {
+      client: output.client,
+      types: typeof output.types === "string" ? output.types : void 0
+    },
+    axiosInstancePath: cfg.axiosInstancePath,
+    axiosInstanceExport: typeof cfg.axiosInstanceExport === "string" ? cfg.axiosInstanceExport : "axiosInstance",
+    language: cfg.language === "js" ? "js" : "ts",
+    jsdoc: cfg.jsdoc !== false,
+    tags: Array.isArray(cfg.tags) ? cfg.tags : void 0
+  };
+}
+export {
+  extractEndpoints,
+  generate,
+  generateClientFile,
+  generateTypesFile,
+  loadConfig,
+  parseOpenAPIFile
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "axigen",
+  "version": "0.1.0",
+  "description": "Generate typed Axios client functions from OpenAPI / Swagger specs",
+  "keywords": [
+    "openapi",
+    "swagger",
+    "axios",
+    "axigen",
+    "typescript",
+    "cli"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/HamidrezaSafarpour/axigen.git"
+  },
+  "bin": {
+    "axigen": "./dist/cli/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "build:watch": "tsup --watch",
+    "dev": "tsx src/cli/index.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "prepublishOnly": "npm run build && npm run typecheck"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "js-yaml": "^4.1.0",
+    "ora": "^8.0.1"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.19.43",
+    "tsup": "^8.0.2",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}