czh-api 1.0.3 → 1.0.5

package/src/core/parser.ts

@@ -16,6 +16,11 @@ export interface Endpoint {
     hasData: boolean;
     contentType?: string;
     jsdocParams: Array<{ name: string; type?: string; description?: string; required?: boolean }>;
+    // Separate jsdoc params for params and data to avoid merging
+    paramsJsdocParams: Array<{ name: string; type?: string; description?: string; required?: boolean }>;
+    dataJsdocParams: Array<{ name: string; type?: string; description?: string; required?: boolean }>;
+    // Jsdoc params for response type
+    responseJsdocParams: Array<{ name: string; type?: string; description?: string; required?: boolean }>;
 }
 
 export interface Module {
@@ -106,7 +111,7 @@ function getModuleName(path: string, pathPrefixes: Array<{ path: string; package
     return parts[0] || 'default';
 }
 
-function convertOpenApiTypeToTypeScript(openApiType: string | undefined): string {
+function convertOpenApiTypeToTypeScript(openApiType: string | undefined): string {
     if (!openApiType) return 'any';
     
     switch (openApiType) {
@@ -120,12 +125,88 @@ function convertOpenApiTypeToTypeScript(openApiType: string | undefined): string
             return 'boolean';
         case 'string':
             return 'string';
-        case 'number':
-            return 'number';
-        default:
-            return 'any';
-    }
-}
+        case 'number':
+            return 'number';
+        default:
+            return openApiType;
+    }
+}
+
+function resolveSchemaToTypeScript(
+    schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject | undefined,
+    allSchemas: { [key: string]: any }
+): string {
+    if (!schema) return 'any';
+
+    if (isReferenceObject(schema)) {
+        return getSchemaName(schema.$ref) || 'any';
+    }
+
+    if (schema.anyOf && Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
+        const unionTypes = schema.anyOf
+            .map(item => resolveSchemaToTypeScript(item as OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject, allSchemas))
+            .filter(Boolean);
+        if (unionTypes.length > 0) {
+            return [...new Set(unionTypes)].join(' | ');
+        }
+    }
+
+    if (schema.oneOf && Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
+        const unionTypes = schema.oneOf
+            .map(item => resolveSchemaToTypeScript(item as OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject, allSchemas))
+            .filter(Boolean);
+        if (unionTypes.length > 0) {
+            return [...new Set(unionTypes)].join(' | ');
+        }
+    }
+
+    if (schema.allOf && Array.isArray(schema.allOf) && schema.allOf.length > 0) {
+        const intersectionTypes = schema.allOf
+            .map(item => resolveSchemaToTypeScript(item as OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject, allSchemas))
+            .filter(Boolean);
+        if (intersectionTypes.length > 0) {
+            return [...new Set(intersectionTypes)].join(' & ');
+        }
+    }
+
+    if (schema.type === 'array') {
+        const itemType = resolveSchemaToTypeScript(
+            schema.items as OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject | undefined,
+            allSchemas
+        );
+        return `${itemType || 'any'}[]`;
+    }
+
+    if (schema.type === 'object') {
+        if (schema.properties && Object.keys(schema.properties).length > 0) {
+            const requiredSet = new Set(schema.required || []);
+            const inlineFields = Object.entries(schema.properties).map(([key, value]) => {
+                const fieldType = resolveSchemaToTypeScript(
+                    value as OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject,
+                    allSchemas
+                );
+                const optional = requiredSet.has(key) ? '' : '?';
+                return `${key}${optional}: ${fieldType || 'any'}`;
+            });
+            return `{ ${inlineFields.join('; ')} }`;
+        }
+        if (schema.additionalProperties) {
+            if (schema.additionalProperties === true) {
+                return 'Record<string, any>';
+            }
+            const valueType = resolveSchemaToTypeScript(
+                schema.additionalProperties as OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject,
+                allSchemas
+            );
+            return `Record<string, ${valueType || 'any'}>`;
+        }
+        return 'any';
+    }
+
+    const baseType = convertOpenApiTypeToTypeScript(schema.type);
+    const nullable = schema.nullable ? ' | null' : '';
+    return `${baseType}${nullable}`;
+}
 
 function extractJsdocParamsFromSchema(schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject, allSchemas: { [key: string]: any }): Required<Endpoint>['jsdocParams'] {
     const params: Required<Endpoint>['jsdocParams'] = [];
@@ -141,13 +222,15 @@ function extractJsdocParamsFromSchema(schema: OpenAPIV3.SchemaObject | OpenAPIV3
 
     if (targetSchema?.properties) {
         for (const propName in targetSchema.properties) {
-            const prop = targetSchema.properties[propName] as OpenAPIV3.SchemaObject;
-            
-            let propType = 'any';
+            const prop = targetSchema.properties[propName] as OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
+            let propType = resolveSchemaToTypeScript(prop, allSchemas);
+            const propDescription = isReferenceObject(prop)
+                ? ((allSchemas[getSchemaName(prop.$ref)] as OpenAPIV3.SchemaObject | undefined)?.description || '')
+                : (prop?.description || '');
             
             // 处理 anyOf 数组 (FastAPI 常用的联合类型)
-            if (prop.anyOf && Array.isArray(prop.anyOf)) {
-                const types = prop.anyOf.map(item => {
+            if (false && (prop as OpenAPIV3.SchemaObject).anyOf && Array.isArray((prop as OpenAPIV3.SchemaObject).anyOf)) {
+                const types = (prop as OpenAPIV3.SchemaObject).anyOf!.map(item => {
                     if (isReferenceObject(item)) {
                         return getSchemaName(item.$ref);
                     } else {
@@ -168,8 +251,8 @@ function extractJsdocParamsFromSchema(schema: OpenAPIV3.SchemaObject | OpenAPIV3
                 }
             }
             // 处理 oneOf 数组
-            else if (prop.oneOf && Array.isArray(prop.oneOf)) {
-                const types = prop.oneOf.map(item => {
+            else if (false && (prop as OpenAPIV3.SchemaObject).oneOf && Array.isArray((prop as OpenAPIV3.SchemaObject).oneOf)) {
+                const types = (prop as OpenAPIV3.SchemaObject).oneOf!.map(item => {
                     if (isReferenceObject(item)) {
                         return getSchemaName(item.$ref);
                     } else {
@@ -190,16 +273,26 @@ function extractJsdocParamsFromSchema(schema: OpenAPIV3.SchemaObject | OpenAPIV3
                 }
             }
             // 处理普通类型
-            else if (prop.type) {
-                propType = convertOpenApiTypeToTypeScript(prop.type);
-            }
-
-            params.push({
-                name: propName,
-                type: propType,
-                description: prop?.description || '',
-                required: targetSchema.required?.includes(propName)
-            });
+            else if (false && (prop as OpenAPIV3.SchemaObject).type) {
+                const propSchema: any = prop as any;
+                if (propSchema.type === 'array' && propSchema.items) {
+                    if (isReferenceObject(propSchema.items)) {
+                        propType = `${getSchemaName(propSchema.items.$ref)}[]`;
+                    } else {
+                        const itemType = convertOpenApiTypeToTypeScript((propSchema.items as OpenAPIV3.SchemaObject).type);
+                        propType = `${itemType}[]`;
+                    }
+                } else {
+                    propType = convertOpenApiTypeToTypeScript(propSchema.type);
+                }
+            }
+
+            params.push({
+                name: propName,
+                type: propType || 'any',
+                description: propDescription,
+                required: targetSchema.required?.includes(propName)
+            });
         }
     }
     return params;
@@ -290,6 +383,9 @@ export const processApi = (api: OpenAPI.Document, excludePaths: string[] = [], i
             let requestBodyTypeName: string | undefined = undefined;
             let contentType: string | undefined = undefined;
             const jsdocParams: Required<Endpoint>['jsdocParams'] = [];
+            const paramsJsdocParams: Required<Endpoint>['paramsJsdocParams'] = [];
+            const dataJsdocParams: Required<Endpoint>['dataJsdocParams'] = [];
+            const responseJsdocParams: Required<Endpoint>['responseJsdocParams'] = [];
 
             // --- FormData Detection ---
             let isFormData = false;
@@ -378,14 +474,18 @@ export const processApi = (api: OpenAPI.Document, excludePaths: string[] = [], i
                     requestBodyTypeName = typeName;
                     modules[moduleName].schemas[typeName] = formDataSchema;
                     referencedTypes.push(typeName);
-                    jsdocParams.push(...extractJsdocParamsFromSchema(formDataSchema, allSchemas));
+                    const formDataJsdoc = extractJsdocParamsFromSchema(formDataSchema, allSchemas);
+                    jsdocParams.push(...formDataJsdoc);
+                    dataJsdocParams.push(...formDataJsdoc);
                 }
 
                 if (Object.keys(paramsSchema.properties || {}).length > 0) {
                     requestParamsTypeName = `${functionName.charAt(0).toUpperCase() + functionName.slice(1)}Params`;
                     modules[moduleName].schemas[requestParamsTypeName] = paramsSchema;
                     referencedTypes.push(requestParamsTypeName);
-                    jsdocParams.push(...extractJsdocParamsFromSchema(paramsSchema, allSchemas));
+                    const paramsJsdoc = extractJsdocParamsFromSchema(paramsSchema, allSchemas);
+                    jsdocParams.push(...paramsJsdoc);
+                    paramsJsdocParams.push(...paramsJsdoc);
                 }
             }
             
@@ -400,7 +500,9 @@ export const processApi = (api: OpenAPI.Document, excludePaths: string[] = [], i
                         requestBodyTypeName = name;
                         addSchemaWithDependencies(name, modules[moduleName], allSchemas);
                         referencedTypes.push(name);
-                        jsdocParams.push(...extractJsdocParamsFromSchema(jsonContent.schema, allSchemas));
+                        const bodyJsdoc = extractJsdocParamsFromSchema(jsonContent.schema, allSchemas);
+                        jsdocParams.push(...bodyJsdoc);
+                        dataJsdocParams.push(...bodyJsdoc);
                     } else {
                         // Handle inline schema (including arrays)
                         const schema = jsonContent.schema as OpenAPIV3.SchemaObject;
@@ -416,10 +518,14 @@ export const processApi = (api: OpenAPI.Document, excludePaths: string[] = [], i
                                     const itemSchemaName = getSchemaName(schema.items.$ref);
                                     addSchemaWithDependencies(itemSchemaName, modules[moduleName], allSchemas);
                                 } else {
-                                    jsdocParams.push(...extractJsdocParamsFromSchema(schema.items as OpenAPIV3.SchemaObject, allSchemas));
+                                    const arrayJsdoc = extractJsdocParamsFromSchema(schema.items as OpenAPIV3.SchemaObject, allSchemas);
+                                    jsdocParams.push(...arrayJsdoc);
+                                    dataJsdocParams.push(...arrayJsdoc);
                                 }
                             } else if (schema.type === 'object') {
-                                jsdocParams.push(...extractJsdocParamsFromSchema(schema, allSchemas));
+                                const objJsdoc = extractJsdocParamsFromSchema(schema, allSchemas);
+                                jsdocParams.push(...objJsdoc);
+                                dataJsdocParams.push(...objJsdoc);
                             }
                         }
                     }
@@ -431,8 +537,9 @@ export const processApi = (api: OpenAPI.Document, excludePaths: string[] = [], i
                     const typeName = `${functionName.charAt(0).toUpperCase() + functionName.slice(1)}Data`;
                     requestBodyTypeName = typeName;
                     modules[moduleName].schemas[typeName] = formDataContent.schema as OpenAPIV3.SchemaObject;
-                    referencedTypes.push(typeName);
-                    jsdocParams.push(...extractJsdocParamsFromSchema(formDataContent.schema, allSchemas));
+                     referencedTypes.push(typeName);
+                     const formJsdoc = extractJsdocParamsFromSchema(formDataContent.schema, allSchemas);
+                     dataJsdocParams.push(...formJsdoc);
                  }
             }
 
@@ -448,8 +555,34 @@ export const processApi = (api: OpenAPI.Document, excludePaths: string[] = [], i
                     responseTypeName = name;
                     addSchemaWithDependencies(name, modules[moduleName], allSchemas);
                     referencedTypes.push(name);
-                }
-            }
+                    responseJsdocParams.push(...extractJsdocParamsFromSchema(schema, allSchemas));
+                } else if (schema && !isReferenceObject(schema)) {
+                    const inlineSchema = schema as OpenAPIV3.SchemaObject;
+                    if (inlineSchema.type === 'object' || inlineSchema.properties) {
+                        // Generate a named type for inline response schema
+                        const typeName = `${functionName.charAt(0).toUpperCase() + functionName.slice(1)}Response`;
+                        responseTypeName = typeName;
+                        modules[moduleName].schemas[typeName] = inlineSchema;
+                        referencedTypes.push(typeName);
+                        responseJsdocParams.push(...extractJsdocParamsFromSchema(inlineSchema, allSchemas));
+                    } else if (inlineSchema.type === 'array' && inlineSchema.items) {
+                        if (isReferenceObject(inlineSchema.items)) {
+                            const itemSchemaName = getSchemaName(inlineSchema.items.$ref);
+                            // Prefer direct `ItemType[]` for array responses to avoid unnecessary alias schema compilation.
+                            responseTypeName = `${itemSchemaName}[]`;
+                            referencedTypes.push(itemSchemaName);
+                            addSchemaWithDependencies(itemSchemaName, modules[moduleName], allSchemas);
+                            responseJsdocParams.push(...extractJsdocParamsFromSchema(inlineSchema.items, allSchemas));
+                        } else {
+                            const typeName = `${functionName.charAt(0).toUpperCase() + functionName.slice(1)}Response`;
+                            responseTypeName = typeName;
+                            modules[moduleName].schemas[typeName] = inlineSchema;
+                            referencedTypes.push(typeName);
+                            responseJsdocParams.push(...extractJsdocParamsFromSchema(inlineSchema, allSchemas));
+                        }
+                    }
+                }
+            }
 
             // Convert path to template literal string for path parameters
             const urlTemplate = path.replace(/\{(\w+)\}/g, '${params.$1}');
@@ -467,6 +600,9 @@ export const processApi = (api: OpenAPI.Document, excludePaths: string[] = [], i
                 hasData: !!requestBodyTypeName,
                 contentType,
                 jsdocParams,
+                paramsJsdocParams,
+                dataJsdocParams,
+                responseJsdocParams,
             };
 
             modules[moduleName].endpoints.push(endpoint);
@@ -474,4 +610,4 @@ export const processApi = (api: OpenAPI.Document, excludePaths: string[] = [], i
     }
 
     return modules;
-}; 
+}; 

package/src/templates/api.hbs

@@ -10,12 +10,7 @@ export const {{functionName}} = ({{#if hasParams}}params: {{requestParamsTypeNam
   return http.request<{{responseTypeName}}>({
     url: `{{path}}`,
     method: '{{method}}',
-    {{#if hasParams}}
-    params,
-    {{/if}}
-    {{#if hasData}}
-    data,
-    {{/if}}
+    {{#if hasParams}}{{#unless (eq method 'put')}}{{#unless (eq method 'post')}}params,{{/unless}}{{/unless}}{{/if}}{{#if hasData}}data,{{/if}}
     {{#if contentType}}
     headers: { 'Content-Type': '{{contentType}}' },
     {{/if}}