elysia-openapi-codegen 0.1.4 → 0.1.6

package/README.md

@@ -318,26 +318,14 @@ your-project/
 ```bash
 # Install dependencies
 bun install
-```
-
-### Local Development
 
-```bash
-# Run directly with Bun during development
+# Run the generator locally
 bun index.ts -i ./example/openapi.json -o ./output
 ```
 
-### Building for Production
-
-```bash
-# Compile TypeScript to JavaScript
-npm run build
-
-# Test the compiled version
-node dist/index.js --help
-```
+### Building
 
-The build outputs JavaScript files to the `dist/` folder, which is what gets published to npm.
+This project uses Bun as the runtime. No build step is necessary for development.
 
 ## How It Works
 

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// src/index.ts
+// index.ts
 import fs from "fs";
 import path from "path";
 import https from "https";
@@ -11,7 +11,7 @@ async function fetchSpec(source) {
       const client = source.startsWith("https://") ? https : http;
       client.get(source, (res) => {
         let data = "";
-        res.on("data", (chunk) => data += chunk.toString());
+        res.on("data", (chunk) => data += chunk);
         res.on("end", () => {
           try {
             resolve(JSON.parse(data));
@@ -77,7 +77,7 @@ function generateTypes(spec) {
       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);
@@ -112,7 +112,7 @@ function generateHooks(spec) {
       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 hasResponse = !!op.responses?.["200"]?.content?.["application/json"]?.schema;
       const responseType = hasResponse ? `${capitalize(opId)}Response` : "any";
       const params = op.parameters || [];
@@ -121,8 +121,18 @@ function generateHooks(spec) {
       const hasBody = !!op.requestBody?.content?.["application/json"]?.schema;
       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("&")}` : "";
+        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 = queryParamsList.map((p) => `      if (params?.${p.name} !== undefined) _qs.set('${p.name}', String(params.${p.name}));`).join(`
+`);
+        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}\`);`;
         hooks.push(`
 export const use${capitalize(opId)} = (
   params${hasParams ? "" : "?"}: ${paramsType},
@@ -131,7 +141,7 @@ export const use${capitalize(opId)} = (
   return useQuery<${responseType}>({
     queryKey: ['${opId}', params],
     queryFn: async () => {
-      const res = await fetch(\`\${baseUrl}${pathUrl}${queryString}\`);
+${fetchStatement}
       if (!res.ok) throw new Error('API Error');
       return res.json();
     },
@@ -139,26 +149,40 @@ export const use${capitalize(opId)} = (
   });
 };`);
       } 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`;
+          const pathParamNames = pathParamsList.map((p) => p.name).join(", ");
+          mutationArg = `{ ${pathParamNames}, ...body }`;
+        } else if (hasBody) {
           inputType = bodyType;
-          inputArg = "body";
-        } else if (hasParams) {
+          mutationArg = "body";
+        } else if (hasPathParams) {
           inputType = paramsType;
-          inputArg = "params";
+          const pathParamNames = pathParamsList.map((p) => p.name).join(", ");
+          mutationArg = `{ ${pathParamNames} }`;
+        } else {
+          inputType = "void";
+          mutationArg = "";
         }
-        const hasInput = inputType !== "void";
+        const fetchBodyLine = hasBody ? `
+        body: JSON.stringify(body),` : "";
         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}\`, {
+    mutationFn: async (${mutationArg}) => {
+      const res = await fetch(\`\${baseUrl}${urlPath}\`, {
         method: '${method.toUpperCase()}',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(${hasInput ? inputArg : "{}"}),
+        headers: { 'Content-Type': 'application/json' },${fetchBodyLine}
       });
       if (!res.ok) throw new Error('API Error');
       return res.json();
@@ -175,6 +199,9 @@ export const use${capitalize(opId)} = (
 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() : "");
+}
 async function parseArgs() {
   const args = process.argv.slice(2);
   const config = {

package/package.json

@@ -1,27 +1,31 @@
 {
   "name": "elysia-openapi-codegen",
-  "module": "index.ts",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "type": "module",
-  "version": "0.1.4",
-  "description": "Generate React Query hooks and fully typed TypeScript interfaces from Elysia OpenAPI specs.",
-  "scripts": {
-    "build": "bun build --target=node ./src/index.ts --outfile=dist/index.js && bun run build:declaration",
-    "build:declaration": "tsc --emitDeclarationOnly --project tsconfig.types.json",
-    "postbuild": "rimraf tsconfig.types.tsbuildinfo"
+  "version": "0.1.6",
+  "author": "Khantamir mkhantamir77@gmail.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mkhantamir/elysia-openapi-codegen.git"
   },
+  "main": "dist/index.js",
+  "module": "index.ts",
   "devDependencies": {
-    "@types/bun": "latest",
-    "typescript": "^5"
+    "@types/bun": "latest"
   },
   "peerDependencies": {
-    "typescript": "^5"
+    "typescript": "^6.0.2"
   },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/mkhantamir/elysia-openapi-codegen.git"
+  "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",
     "openapi",
@@ -30,11 +34,9 @@
     "react-query",
     "tanstack-query"
   ],
-  "author": "Khantamir",
   "license": "MIT",
-  "files": [
-    "dist/*.js",
-    "dist/*.d.ts"
-  ],
-  "homepage": "https://github.com/mkhantamir/elysia-openapi-codegen#readme"
-}
+  "scripts": {
+    "build": "bun build index.ts --outfile dist/index.js --target node"
+  },
+  "type": "module"
+}

package/dist/index.d.ts

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-/**
- * Elysia OpenAPI Code Generator
- * Generates typed React Query hooks from OpenAPI specifications.
- */
-export {};

package/dist/types.d.ts

@@ -1,70 +0,0 @@
-export interface OpenAPISpec {
-    openapi: string;
-    info: {
-        title: string;
-        version: string;
-        [key: string]: unknown;
-    };
-    servers?: Array<{
-        url: string;
-        description?: string;
-    }>;
-    paths: Record<string, OpenAPIPathItem>;
-    components?: {
-        schemas?: Record<string, OpenAPISchema>;
-        [key: string]: unknown;
-    };
-    [key: string]: unknown;
-}
-export interface OpenAPIPathItem {
-    get?: OpenAPIOperation;
-    post?: OpenAPIOperation;
-    put?: OpenAPIOperation;
-    delete?: OpenAPIOperation;
-    patch?: OpenAPIOperation;
-    [key: string]: unknown;
-}
-export interface OpenAPIOperation {
-    operationId?: string;
-    summary?: string;
-    description?: string;
-    parameters?: OpenAPIParameter[];
-    responses?: Record<string, OpenAPIResponse>;
-    requestBody?: {
-        content: {
-            [contentType: string]: {
-                schema: OpenAPISchema;
-            };
-        };
-    };
-    [key: string]: unknown;
-}
-export interface OpenAPIParameter {
-    name: string;
-    in: 'query' | 'header' | 'path' | 'cookie';
-    description?: string;
-    required?: boolean;
-    schema?: OpenAPISchema;
-    [key: string]: unknown;
-}
-export interface OpenAPIResponse {
-    description: string;
-    content?: {
-        [contentType: string]: {
-            schema: OpenAPISchema;
-        };
-    };
-    [key: string]: unknown;
-}
-export interface OpenAPISchema {
-    type?: string;
-    items?: OpenAPISchema;
-    properties?: Record<string, OpenAPISchema>;
-    required?: string[];
-    $ref?: string;
-    nullable?: boolean;
-    anyOf?: OpenAPISchema[];
-    oneOf?: OpenAPISchema[];
-    allOf?: OpenAPISchema[];
-    [key: string]: unknown;
-}