Improve gen interface

Author: owjs3901

examples/vite/openapi.json

@@ -53,6 +53,48 @@
         }
       }
     },
+    "/users/{user_id}/posts": {
+      "get": {
+        "summary": "Get user posts by ID",
+        "operationId": "getUserPostsById",
+        "parameters": [
+          {
+            "name": "user_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "default": 1
+            },
+            "description": "User ID"
+          },
+          {
+            "name": "post_id",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "integer"
+            },
+            "description": "Post ID"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "User details",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/Post"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "/users/{id}": {
       "get": {
         "summary": "Get user by ID",

examples/vite/src/App.tsx

@@ -14,8 +14,8 @@ function App() {
     })
 
     api
-      .get('getUserById', {
-        params: { id: 1 },
+      .get('/users/{userId}/posts', {
+        params: { userId: 1 },
       })
       .then((res) => {
         console.log(res)

packages/generator/src/create-url-map.ts

@@ -4,7 +4,6 @@ import { convertCase } from './convert-case'
 
 export function createUrlMap(
   schema: OpenAPIV3_1.Document,
-
   options?: DevupApiTypeGeneratorOptions,
 ) {
   const convertCaseType = options?.convertCase ?? 'camel'
@@ -14,6 +13,10 @@ export function createUrlMap(
     for (const method of ['get', 'post', 'put', 'delete', 'patch'] as const) {
       const operation = pathItem[method]
       if (!operation) continue
+      const normalizedPath = path.replace(/\{([^}]+)\}/g, (_, param) => {
+        // Convert param name based on case type
+        return `{${convertCase(param, convertCaseType)}}`
+      })
       if (operation.operationId) {
         urlMap[convertCase(operation.operationId, convertCaseType)] = {
           method: method.toUpperCase() as
@@ -22,17 +25,17 @@ export function createUrlMap(
             | 'PUT'
             | 'DELETE'
             | 'PATCH',
-          url: path,
+          url: normalizedPath,
         }
       }
-      urlMap[path] = {
+      urlMap[normalizedPath] = {
         method: method.toUpperCase() as
           | 'GET'
           | 'POST'
           | 'PUT'
           | 'DELETE'
           | 'PATCH',
-        url: path,
+        url: normalizedPath,
       }
     }
   }

packages/generator/src/generate-interface.ts

@@ -3,15 +3,25 @@ import { toPascal } from '@devup-api/utils'
 import type { OpenAPIV3_1 } from 'openapi-types'
 import { convertCase } from './convert-case'
 import {
+  areAllPropertiesOptional,
   extractParameters,
   extractRequestBody,
   formatTypeValue,
 } from './generate-schema'
+import { wrapInterfaceKeyGuard } from './wrap-interface-key-guard'
 
-interface EndpointDefinition {
-  params?: Record<string, unknown>
+export type ParameterDefinition = Omit<
+  OpenAPIV3_1.ParameterObject,
+  'schema'
+> & {
+  type: unknown
+  default?: unknown
+}
+
+export interface EndpointDefinition {
+  params?: Record<string, ParameterDefinition>
   body?: unknown
-  query?: Record<string, unknown>
+  query?: Record<string, ParameterDefinition>
 }
 
 export function generateInterface(
@@ -52,13 +62,13 @@ export function generateInterface(
         )
 
         // Apply case conversion to parameter names
-        const convertedPathParams: Record<string, unknown> = {}
+        const convertedPathParams: Record<string, ParameterDefinition> = {}
         for (const [key, value] of Object.entries(pathParams)) {
           const convertedKey = convertCase(key, convertCaseType)
           convertedPathParams[convertedKey] = value
         }
 
-        const convertedQueryParams: Record<string, unknown> = {}
+        const convertedQueryParams: Record<string, ParameterDefinition> = {}
         for (const [key, value] of Object.entries(queryParams)) {
           const convertedKey = convertCase(key, convertCaseType)
           convertedQueryParams[convertedKey] = value
@@ -78,32 +88,19 @@ export function generateInterface(
         }
 
         // Generate path key (normalize path by replacing {param} with converted param and removing slashes)
-        const normalizedPath = path
-          .replace(/\{([^}]+)\}/g, (_, param) => {
-            // Convert param name based on case type
-            return convertCase(param, convertCaseType)
-          })
-          .replace(/^\//, '')
-          .replace(/\//g, '')
-        const pathKey = convertCase(normalizedPath, convertCaseType)
+        const normalizedPath = path.replace(/\{([^}]+)\}/g, (_, param) => {
+          // Convert param name based on case type
+          return `{${convertCase(param, convertCaseType)}}`
+        })
 
+        endpoints[method][normalizedPath] = endpoint
         if (operation.operationId) {
           // If operationId exists, create both operationId and path keys
           const operationIdKey = convertCase(
             operation.operationId,
             convertCaseType,
           )
           endpoints[method][operationIdKey] = endpoint
-
-          // Add path key if different from operationId key
-          if (pathKey && pathKey !== operationIdKey) {
-            endpoints[method][pathKey] = endpoint
-          }
-        } else {
-          // If operationId doesn't exist, only use path key
-          if (pathKey) {
-            endpoints[method][pathKey] = endpoint
-          }
         }
       }
     }
@@ -114,16 +111,27 @@ export function generateInterface(
     .flatMap(([method, value]) => {
       const entries = Object.entries(value)
       if (entries.length > 0) {
+        const interfaceEntries = entries
+          .map(([key, endpointValue]) => {
+            const formattedValue = formatTypeValue(endpointValue, 2)
+            // Check if all properties in endpointValue are optional
+            const allOptional =
+              typeof endpointValue === 'object' &&
+              endpointValue !== null &&
+              !Array.isArray(endpointValue) &&
+              areAllPropertiesOptional(endpointValue as Record<string, unknown>)
+            const optionalMarker = allOptional ? '?' : ''
+            return `    ${wrapInterfaceKeyGuard(key)}${optionalMarker}: ${formattedValue}`
+          })
+          .join(';\n')
+
         return [
-          `interface Devup${toPascal(method)}ApiStruct{${entries
-            .map(([key, value]) => {
-              return `${key}:${formatTypeValue(value)}`
-            })
-            .join(';')}}`,
+          `  interface Devup${toPascal(method)}ApiStruct {\n${interfaceEntries};\n  }`,
         ]
       }
       return []
     })
-    .flat()
-  return `import "@devup-api/fetch";declare module "@devup-api/fetch"{${interfaceContent.join('')}}`
+    .join('\n')
+
+  return `import "@devup-api/fetch";\n\ndeclare module "@devup-api/fetch" {\n${interfaceContent}\n}`
 }