elysia-openapi-codegen 0.1.8 → 0.1.9

package/README.md

@@ -11,6 +11,12 @@ Generate fully-typed React Query hooks and TypeScript interfaces from OpenAPI sp
 - **React Query Integration**: Generates `useQuery` and `useMutation` hooks ready to use
 - **Flexible Arguments**: Supports both flag-based and positional arguments
 
+### Using Bunx (Recommended)
+
+```bash
+bunx elysia-openapi-codegen -i https://api.example.com/openapi.json -o ./src/api
+```
+
 ## Installation
 
 ### Using Bun (Recommended)
@@ -50,6 +56,7 @@ elysia-codegen -i <source> -o <output>
 ```
 
 **Arguments:**
+
 - `-i, --input <source>` - OpenAPI spec source (URL or file path)
 - `-o, --output <output>` - Output directory for generated files
 - `-h, --help` - Show help message
@@ -98,13 +105,13 @@ The generator creates a single `generated.ts` file containing all types and hook
 All request/response types are automatically generated:
 
 ```typescript
-import type { User, CreateUserBody, GetUsersResponse } from './generated';
+import type { User, CreateUserBody, GetUsersResponse } from "./generated";
 
 // Use types in your components
 const user: User = {
   id: 1,
-  name: 'John Doe',
-  email: 'john@example.com'
+  name: "John Doe",
+  email: "john@example.com",
 };
 ```
 

package/dist/index.js

@@ -77,6 +77,8 @@ function generateGroups(spec) {
     }
   }
   for (const [pathUrl, pathItem] of Object.entries(spec.paths)) {
+    if (pathUrl.includes("*"))
+      continue;
     const g = getGroup(getPathGroup(pathUrl));
     for (const [method, operation] of Object.entries(pathItem)) {
       if (!["get", "post", "put", "patch", "delete"].includes(method))
@@ -100,6 +102,8 @@ ${paramProps.join(`
       }
       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;
+      const hasBinaryField = (s) => !!s && (s.format === "binary" || Object.values(s.properties ?? {}).some((p) => p.format === "binary"));
+      const useFormData = isMultipart || hasBinaryField(bodySchema);
       if (bodySchema) {
         g.types.push(`export type ${capitalize(opId)}Body = ${resolveType(bodySchema)};`);
       }
@@ -152,27 +156,40 @@ ${fetchStatement}
 };`);
       } else {
         const pathParamsList = params.filter((p) => p.in === "path");
+        const queryParamsList = params.filter((p) => p.in === "query");
         const hasPathParams = pathParamsList.length > 0;
+        const hasQueryParams = queryParamsList.length > 0;
+        const hasAnyParams = hasPathParams || hasQueryParams;
         let urlPath = pathUrl;
         for (const p of pathParamsList) {
           urlPath = urlPath.replace(`{${p.name}}`, `\${${p.name}}`);
         }
+        const mutQsCode = hasQueryParams ? `
+      const _qs = new URLSearchParams();
+${queryParamsList.map((p) => `      if (${p.name} !== undefined) _qs.set('${p.name}', String(${p.name}));`).join(`
+`)}
+      const _qstr = _qs.toString();` : "";
+        const fetchUrlExpr = hasQueryParams ? `\`\${baseUrl}${urlPath}\${_qstr ? '?' + _qstr : ''}\`` : `\`\${baseUrl}${urlPath}\``;
+        const allParamNames = [
+          ...pathParamsList.map((p) => p.name),
+          ...queryParamsList.map((p) => p.name)
+        ];
         let inputType;
         let mutationArg;
-        if (hasBody && hasPathParams) {
+        if (hasBody && hasAnyParams) {
           inputType = `${capitalize(opId)}Params & ${capitalize(opId)}Body`;
-          mutationArg = `{ ${pathParamsList.map((p) => p.name).join(", ")}, ...body }`;
+          mutationArg = `{ ${allParamNames.join(", ")}, ...body }`;
         } else if (hasBody) {
           inputType = bodyType;
           mutationArg = "body";
-        } else if (hasPathParams) {
+        } else if (hasAnyParams) {
           inputType = paramsType;
-          mutationArg = `{ ${pathParamsList.map((p) => p.name).join(", ")} }`;
+          mutationArg = `{ ${allParamNames.join(", ")} }`;
         } else {
           inputType = "void";
           mutationArg = "";
         }
-        const fetchBodyLines = hasBody ? isMultipart ? `
+        const fetchBodyLines = hasBody ? useFormData ? `
         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),` : "";
@@ -181,8 +198,8 @@ export const use${capitalize(opId)} = (
   options?: UseMutationOptions<${responseType}, Error, ${inputType}>
 ) => {
   return useMutation<${responseType}, Error, ${inputType}>({
-    mutationFn: async (${mutationArg}) => {
-      const res = await fetch(\`\${baseUrl}${urlPath}\`, {
+    mutationFn: async (${mutationArg}) => {${mutQsCode}
+      const res = await fetch(${fetchUrlExpr}, {
         method: '${method.toUpperCase()}',${fetchBodyLines}
       });
       if (!res.ok) throw new Error(\`\${res.status}: \${await res.text()}\`);
@@ -268,7 +285,8 @@ async function main() {
       fs.mkdirSync(output, { recursive: true });
     }
     fs.writeFileSync(path.join(output, "base.ts"), `/* eslint-disable */
-export const baseUrl = '${baseUrl}';
+/** Override this before making any API calls if your base URL changes at runtime */
+export let baseUrl = '${baseUrl}';
 `);
     const groupNames = [];
     for (const [groupName, { types, hooks }] of Object.entries(groups)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elysia-openapi-codegen",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "author": "Khantamir mkhantamir77@gmail.com",
   "repository": {
     "type": "git",