elysia-openapi-codegen 0.1.5 → 0.1.7

package/dist/index.js

@@ -3,31 +3,27 @@
 // index.ts
 import fs from "fs";
 import path from "path";
-import https from "https";
-import http from "http";
 async function fetchSpec(source) {
   if (source.startsWith("http://") || source.startsWith("https://")) {
-    return new Promise((resolve, reject) => {
-      const client = source.startsWith("https://") ? https : http;
-      client.get(source, (res) => {
-        let data = "";
-        res.on("data", (chunk) => data += chunk);
-        res.on("end", () => {
-          try {
-            resolve(JSON.parse(data));
-          } catch (e) {
-            reject(new Error(`Failed to parse OpenAPI spec: ${e.message}`));
-          }
-        });
-        res.on("error", reject);
-      });
-    });
+    const res = await fetch(source);
+    if (!res.ok)
+      throw new Error(`Failed to fetch spec: ${res.status} ${res.statusText}`);
+    return res.json();
   }
   return JSON.parse(fs.readFileSync(source, "utf8"));
 }
+var TYPE_MAP = {
+  string: "string",
+  number: "number",
+  integer: "number",
+  boolean: "boolean",
+  null: "null"
+};
 function resolveType(schema) {
   if (!schema)
     return "any";
+  if (schema.format === "binary")
+    return "File | Blob";
   if (schema.$ref) {
     return schema.$ref.split("/").pop() || "any";
   }
@@ -38,8 +34,7 @@ function resolveType(schema) {
     if (!schema.properties)
       return "Record<string, any>";
     const props = Object.entries(schema.properties).map(([key, prop]) => {
-      const isRequired = schema.required?.includes(key);
-      const optional = isRequired ? "" : "?";
+      const optional = schema.required?.includes(key) ? "" : "?";
       return `  ${key}${optional}: ${resolveType(prop)};`;
     });
     return `{
@@ -56,111 +51,141 @@ ${props.join(`
   if (schema.nullable) {
     return `${resolveType({ ...schema, nullable: false })} | null`;
   }
-  const typeMap = {
-    string: "string",
-    number: "number",
-    integer: "number",
-    boolean: "boolean",
-    null: "null"
-  };
-  return schema.type && typeMap[schema.type] || "any";
+  return schema.type && TYPE_MAP[schema.type] || "any";
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function toSafeIdentifier(id) {
+  return id.replace(/[^a-zA-Z0-9_-]/g, "").replace(/[-_]+(.?)/g, (_, c) => c ? c.toUpperCase() : "");
+}
+function getPathGroup(pathUrl) {
+  const segment = pathUrl.split("/").filter(Boolean)[0] || "root";
+  return toSafeIdentifier(segment);
 }
-function generateTypes(spec) {
-  const definitions = [];
+function generateGroups(spec) {
+  const groups = {};
+  const getGroup = (name) => {
+    if (!groups[name])
+      groups[name] = { types: [], hooks: [] };
+    return groups[name];
+  };
   if (spec.components?.schemas) {
+    const g = getGroup("schemas");
     for (const [name, schema] of Object.entries(spec.components.schemas)) {
-      definitions.push(`export type ${name} = ${resolveType(schema)};`);
+      g.types.push(`export type ${name} = ${resolveType(schema)};`);
     }
   }
   for (const [pathUrl, pathItem] of Object.entries(spec.paths)) {
+    const g = getGroup(getPathGroup(pathUrl));
     for (const [method, operation] of Object.entries(pathItem)) {
       if (!["get", "post", "put", "patch", "delete"].includes(method))
         continue;
       const op = operation;
-      const opId = op.operationId || `${method}${pathUrl.replace(/[^a-zA-Z0-9]/g, "")}`;
+      const opId = toSafeIdentifier(op.operationId || `${method}${pathUrl.replace(/[^a-zA-Z0-9]/g, "")}`);
       const response = op.responses?.["200"];
       if (response?.content?.["application/json"]?.schema) {
-        const responseType = resolveType(response.content["application/json"].schema);
-        definitions.push(`export type ${capitalize(opId)}Response = ${responseType};`);
+        g.types.push(`export type ${capitalize(opId)}Response = ${resolveType(response.content["application/json"].schema)};`);
       }
       const params = op.parameters || [];
       if (params.length > 0) {
         const paramProps = params.map((param) => {
-          const required = param.required ? "" : "?";
-          return `  ${param.name}${required}: ${resolveType(param.schema)};`;
+          const optional = param.in === "path" || param.required ? "" : "?";
+          return `  ${param.name}${optional}: ${resolveType(param.schema)};`;
         });
-        definitions.push(`export type ${capitalize(opId)}Params = {
+        g.types.push(`export type ${capitalize(opId)}Params = {
 ${paramProps.join(`
 `)}
 };`);
       }
-      if (op.requestBody?.content?.["application/json"]?.schema) {
-        const bodyType = resolveType(op.requestBody.content["application/json"].schema);
-        definitions.push(`export type ${capitalize(opId)}Body = ${bodyType};`);
+      const isMultipart = !op.requestBody?.content?.["application/json"] && !!op.requestBody?.content?.["multipart/form-data"];
+      const bodySchema = op.requestBody?.content?.["application/json"]?.schema ?? op.requestBody?.content?.["multipart/form-data"]?.schema;
+      if (bodySchema) {
+        g.types.push(`export type ${capitalize(opId)}Body = ${resolveType(bodySchema)};`);
       }
-    }
-  }
-  return definitions.join(`
-
-`);
-}
-function generateHooks(spec) {
-  const hooks = [];
-  const baseUrl = spec.servers?.[0]?.url || "";
-  for (const [pathUrl, pathItem] of Object.entries(spec.paths)) {
-    for (const [method, operation] of Object.entries(pathItem)) {
-      if (!["get", "post", "put", "patch", "delete"].includes(method))
-        continue;
-      const op = operation;
-      const opId = op.operationId || `${method}${pathUrl.replace(/[^a-zA-Z0-9]/g, "")}`;
-      const hasResponse = !!op.responses?.["200"]?.content?.["application/json"]?.schema;
+      const hasResponse = !!response?.content?.["application/json"]?.schema;
       const responseType = hasResponse ? `${capitalize(opId)}Response` : "any";
-      const params = op.parameters || [];
       const hasParams = params.length > 0;
       const paramsType = hasParams ? `${capitalize(opId)}Params` : "void";
-      const hasBody = !!op.requestBody?.content?.["application/json"]?.schema;
+      const hasBody = !!bodySchema;
       const bodyType = hasBody ? `${capitalize(opId)}Body` : "void";
       if (method === "get") {
-        const queryParams = params.map((p) => p.name);
-        const queryString = queryParams.length > 0 ? `?${queryParams.map((p) => `\${params?.${p} !== undefined ? '${p}=' + params.${p} : ''}`).join("&")}` : "";
-        hooks.push(`
+        const pathParamsList = params.filter((p) => p.in === "path");
+        const queryParamsList = params.filter((p) => p.in === "query");
+        let urlPath = pathUrl;
+        for (const p of pathParamsList) {
+          urlPath = urlPath.replace(`{${p.name}}`, `\${params.${p.name}}`);
+        }
+        const qsLines = (indent) => queryParamsList.map((p) => `${indent}if (params?.${p.name} !== undefined) _qs.set('${p.name}', String(params.${p.name}));`).join(`
+`);
+        if (!hasResponse) {
+          const body = queryParamsList.length > 0 ? `  const _qs = new URLSearchParams();
+${qsLines("  ")}
+  const _qstr = _qs.toString();
+  return \`\${baseUrl}${urlPath}\${_qstr ? '?' + _qstr : ''}\`;` : `  return \`\${baseUrl}${urlPath}\`;`;
+          g.hooks.push(`
+export const ${opId}Url = (params${hasParams ? "" : "?"}: ${paramsType}): string => {
+${body}
+};`);
+          continue;
+        }
+        const fetchStatement = queryParamsList.length > 0 ? `      const _qs = new URLSearchParams();
+${qsLines("      ")}
+      const _qstr = _qs.toString();
+      const res = await fetch(\`\${baseUrl}${urlPath}\${_qstr ? '?' + _qstr : ''}\`);` : `      const res = await fetch(\`\${baseUrl}${urlPath}\`);`;
+        const enabledGuard = pathParamsList.length > 0 ? `
+    enabled: ${pathParamsList.map((p) => `params.${p.name} != null`).join(" && ")},` : "";
+        g.hooks.push(`
 export const use${capitalize(opId)} = (
   params${hasParams ? "" : "?"}: ${paramsType},
   options?: Omit<UseQueryOptions<${responseType}>, 'queryKey' | 'queryFn'>
 ) => {
   return useQuery<${responseType}>({
-    queryKey: ['${opId}', params],
+    queryKey: ['${opId}', params],${enabledGuard}
     queryFn: async () => {
-      const res = await fetch(\`\${baseUrl}${pathUrl}${queryString}\`);
-      if (!res.ok) throw new Error('API Error');
+${fetchStatement}
+      if (!res.ok) throw new Error(\`\${res.status}: \${await res.text()}\`);
       return res.json();
     },
     ...options,
   });
 };`);
       } else {
-        let inputType = "void";
-        let inputArg = "";
-        if (hasBody) {
+        const pathParamsList = params.filter((p) => p.in === "path");
+        const hasPathParams = pathParamsList.length > 0;
+        let urlPath = pathUrl;
+        for (const p of pathParamsList) {
+          urlPath = urlPath.replace(`{${p.name}}`, `\${${p.name}}`);
+        }
+        let inputType;
+        let mutationArg;
+        if (hasBody && hasPathParams) {
+          inputType = `${capitalize(opId)}Params & ${capitalize(opId)}Body`;
+          mutationArg = `{ ${pathParamsList.map((p) => p.name).join(", ")}, ...body }`;
+        } else if (hasBody) {
           inputType = bodyType;
-          inputArg = "body";
-        } else if (hasParams) {
+          mutationArg = "body";
+        } else if (hasPathParams) {
           inputType = paramsType;
-          inputArg = "params";
+          mutationArg = `{ ${pathParamsList.map((p) => p.name).join(", ")} }`;
+        } else {
+          inputType = "void";
+          mutationArg = "";
         }
-        const hasInput = inputType !== "void";
-        hooks.push(`
+        const fetchBodyLines = hasBody ? isMultipart ? `
+        body: Object.entries(body as Record<string, unknown>).reduce((f, [k, v]) => { f.append(k, v as any); return f; }, new FormData()),` : `
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),` : "";
+        g.hooks.push(`
 export const use${capitalize(opId)} = (
   options?: UseMutationOptions<${responseType}, Error, ${inputType}>
 ) => {
   return useMutation<${responseType}, Error, ${inputType}>({
-    mutationFn: async (${hasInput ? inputArg : ""}) => {
-      const res = await fetch(\`\${baseUrl}${pathUrl}\`, {
-        method: '${method.toUpperCase()}',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(${hasInput ? inputArg : "{}"}),
+    mutationFn: async (${mutationArg}) => {
+      const res = await fetch(\`\${baseUrl}${urlPath}\`, {
+        method: '${method.toUpperCase()}',${fetchBodyLines}
       });
-      if (!res.ok) throw new Error('API Error');
+      if (!res.ok) throw new Error(\`\${res.status}: \${await res.text()}\`);
       return res.json();
     },
     ...options,
@@ -169,18 +194,11 @@ export const use${capitalize(opId)} = (
       }
     }
   }
-  return hooks.join(`
-`);
-}
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
+  return groups;
 }
-async function parseArgs() {
+function parseArgs() {
   const args = process.argv.slice(2);
-  const config = {
-    input: "",
-    output: ""
-  };
+  const config = { input: "", output: "" };
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (!arg)
@@ -223,12 +241,7 @@ Arguments:
   -o, --output <output>   Output directory for generated files
 
 Examples:
-  # Using flags
   elysia-codegen -i https://api.example.com/openapi.json -o ./src/api
-  elysia-codegen --input ./openapi.json --output ./generated
-
-  # Using positional arguments
-  elysia-codegen https://api.example.com/openapi.json ./src/api
   elysia-codegen ./openapi.json ./generated
 `);
 }
@@ -238,7 +251,7 @@ async function main() {
     showHelp();
     process.exit(0);
   }
-  const { input, output } = await parseArgs();
+  const { input, output } = parseArgs();
   if (!input || !output) {
     console.error(`Error: Both input source and output directory are required.
 `);
@@ -248,28 +261,45 @@ async function main() {
   console.log("Fetching OpenAPI spec...");
   try {
     const spec = await fetchSpec(input);
-    const types = generateTypes(spec);
-    const hooks = generateHooks(spec);
-    const baseUrl = spec.servers?.[0]?.url || "";
-    const fileContent = `/* eslint-disable */
-/**
- * Auto-generated by Elysia OpenAPI Codegen
- */
-
-import { useQuery, useMutation, UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
-
-const baseUrl = '${baseUrl}';
-
-${types}
-
-${hooks}
-`;
+    const groups = generateGroups(spec);
+    const serverPath = spec.servers?.[0]?.url || "";
+    const baseUrl = input.startsWith("http://") || input.startsWith("https://") ? new URL(input).origin + serverPath : serverPath;
     if (!fs.existsSync(output)) {
       fs.mkdirSync(output, { recursive: true });
     }
-    const outputPath = path.join(output, "generated.ts");
-    fs.writeFileSync(outputPath, fileContent);
-    console.log(`Successfully generated hooks at ${outputPath}`);
+    fs.writeFileSync(path.join(output, "base.ts"), `/* eslint-disable */
+export const baseUrl = '${baseUrl}';
+`);
+    const groupNames = [];
+    for (const [groupName, { types, hooks }] of Object.entries(groups)) {
+      if (types.length === 0 && hooks.length === 0)
+        continue;
+      const hasHooks = hooks.length > 0;
+      const sections = [`/* eslint-disable */`, `import { baseUrl } from './base';`];
+      if (hasHooks) {
+        sections.push(`import { useQuery, useMutation, UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';`);
+      }
+      if (types.length > 0)
+        sections.push(types.join(`
+
+`));
+      if (hooks.length > 0)
+        sections.push(hooks.join(`
+`));
+      fs.writeFileSync(path.join(output, `${groupName}.ts`), sections.join(`
+
+`) + `
+`);
+      groupNames.push(groupName);
+      console.log(`  ↳ ${groupName}.ts (${types.length} types, ${hooks.length} hooks)`);
+    }
+    const indexContent = ["base", ...groupNames].map((f) => `export * from './${f}';`).join(`
+`);
+    fs.writeFileSync(path.join(output, "index.ts"), `/* eslint-disable */
+${indexContent}
+`);
+    console.log(`
+Generated ${groupNames.length + 2} files at ${output}`);
   } catch (err) {
     console.error("Generation failed:", err instanceof Error ? err.message : String(err));
     process.exit(1);

package/package.json

@@ -1,25 +1,30 @@
 {
   "name": "elysia-openapi-codegen",
-  "version": "0.1.5",
-  "description": "Generate React Query hooks and fully typed TypeScript interfaces from Elysia OpenAPI specs.",
-  "module": "index.ts",
-  "type": "module",
-  "bin": {
-    "elysia-codegen": "./dist/index.js"
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
+  "version": "0.1.7",
   "author": "Khantamir mkhantamir77@gmail.com",
-  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/mkhantamir/elysia-openapi-codegen.git"
   },
+  "main": "dist/index.js",
+  "module": "index.ts",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^6.0.2"
+  },
+  "bin": {
+    "elysia-codegen": "./dist/index.js"
+  },
   "bugs": {
     "url": "https://github.com/mkhantamir/elysia-openapi-codegen/issues"
   },
+  "description": "Generate React Query hooks and fully typed TypeScript interfaces from Elysia OpenAPI specs.",
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "homepage": "https://github.com/mkhantamir/elysia-openapi-codegen#readme",
   "keywords": [
     "elysia",
@@ -29,14 +34,9 @@
     "react-query",
     "tanstack-query"
   ],
-  "devDependencies": {
-    "@types/bun": "latest"
-  },
-  "peerDependencies": {
-    "typescript": "^6.0.2"
-  },
+  "license": "MIT",
   "scripts": {
     "build": "bun build index.ts --outfile dist/index.js --target node"
   },
-  "main": "dist/index.js"
+  "type": "module"
 }