elysia-openapi-codegen 0.1.6 → 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,23 +51,33 @@ ${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;
@@ -80,45 +85,29 @@ function generateTypes(spec) {
       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 = toSafeIdentifier(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 pathParamsList = params.filter((p) => p.in === "path");
@@ -127,22 +116,35 @@ function generateHooks(spec) {
         for (const p of pathParamsList) {
           urlPath = urlPath.replace(`{${p.name}}`, `\${params.${p.name}}`);
         }
-        const qsLines = queryParamsList.map((p) => `      if (params?.${p.name} !== undefined) _qs.set('${p.name}', String(params.${p.name}));`).join(`
+        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}
+${qsLines("      ")}
       const _qstr = _qs.toString();
       const res = await fetch(\`\${baseUrl}${urlPath}\${_qstr ? '?' + _qstr : ''}\`);` : `      const res = await fetch(\`\${baseUrl}${urlPath}\`);`;
-        hooks.push(`
+        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 () => {
 ${fetchStatement}
-      if (!res.ok) throw new Error('API Error');
+      if (!res.ok) throw new Error(\`\${res.status}: \${await res.text()}\`);
       return res.json();
     },
     ...options,
@@ -159,32 +161,31 @@ ${fetchStatement}
         let mutationArg;
         if (hasBody && hasPathParams) {
           inputType = `${capitalize(opId)}Params & ${capitalize(opId)}Body`;
-          const pathParamNames = pathParamsList.map((p) => p.name).join(", ");
-          mutationArg = `{ ${pathParamNames}, ...body }`;
+          mutationArg = `{ ${pathParamsList.map((p) => p.name).join(", ")}, ...body }`;
         } else if (hasBody) {
           inputType = bodyType;
           mutationArg = "body";
         } else if (hasPathParams) {
           inputType = paramsType;
-          const pathParamNames = pathParamsList.map((p) => p.name).join(", ");
-          mutationArg = `{ ${pathParamNames} }`;
+          mutationArg = `{ ${pathParamsList.map((p) => p.name).join(", ")} }`;
         } else {
           inputType = "void";
           mutationArg = "";
         }
-        const fetchBodyLine = hasBody ? `
+        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),` : "";
-        hooks.push(`
+        g.hooks.push(`
 export const use${capitalize(opId)} = (
   options?: UseMutationOptions<${responseType}, Error, ${inputType}>
 ) => {
   return useMutation<${responseType}, Error, ${inputType}>({
     mutationFn: async (${mutationArg}) => {
       const res = await fetch(\`\${baseUrl}${urlPath}\`, {
-        method: '${method.toUpperCase()}',
-        headers: { 'Content-Type': 'application/json' },${fetchBodyLine}
+        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,
@@ -193,21 +194,11 @@ export const use${capitalize(opId)} = (
       }
     }
   }
-  return hooks.join(`
-`);
-}
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
+  return groups;
 }
-function toSafeIdentifier(id) {
-  return id.replace(/[^a-zA-Z0-9_-]/g, "").replace(/[-_]+(.?)/g, (_, c) => c ? c.toUpperCase() : "");
-}
-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)
@@ -250,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
 `);
 }
@@ -265,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.
 `);
@@ -275,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,6 +1,6 @@
 {
   "name": "elysia-openapi-codegen",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "author": "Khantamir mkhantamir77@gmail.com",
   "repository": {
     "type": "git",