czh-api 1.0.3 → 1.0.5

package/dist/core/parser.js

@@ -87,11 +87,68 @@ function convertOpenApiTypeToTypeScript(openApiType) {
         case 'number':
             return 'number';
         default:
-            return 'any';
+            return openApiType;
     }
 }
+function resolveSchemaToTypeScript(schema, allSchemas) {
+    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, 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, 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, allSchemas))
+            .filter(Boolean);
+        if (intersectionTypes.length > 0) {
+            return [...new Set(intersectionTypes)].join(' & ');
+        }
+    }
+    if (schema.type === 'array') {
+        const itemType = resolveSchemaToTypeScript(schema.items, 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, 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, allSchemas);
+            return `Record<string, ${valueType || 'any'}>`;
+        }
+        return 'any';
+    }
+    const baseType = convertOpenApiTypeToTypeScript(schema.type);
+    const nullable = schema.nullable ? ' | null' : '';
+    return `${baseType}${nullable}`;
+}
 function extractJsdocParamsFromSchema(schema, allSchemas) {
-    var _a;
+    var _a, _b;
     const params = [];
     if (!schema)
         return params;
@@ -106,9 +163,12 @@ function extractJsdocParamsFromSchema(schema, allSchemas) {
     if (targetSchema === null || targetSchema === void 0 ? void 0 : targetSchema.properties) {
         for (const propName in targetSchema.properties) {
             const prop = targetSchema.properties[propName];
-            let propType = 'any';
+            let propType = resolveSchemaToTypeScript(prop, allSchemas);
+            const propDescription = isReferenceObject(prop)
+                ? (((_a = allSchemas[getSchemaName(prop.$ref)]) === null || _a === void 0 ? void 0 : _a.description) || '')
+                : ((prop === null || prop === void 0 ? void 0 : prop.description) || '');
             // 处理 anyOf 数组 (FastAPI 常用的联合类型)
-            if (prop.anyOf && Array.isArray(prop.anyOf)) {
+            if (false && prop.anyOf && Array.isArray(prop.anyOf)) {
                 const types = prop.anyOf.map(item => {
                     if (isReferenceObject(item)) {
                         return getSchemaName(item.$ref);
@@ -130,7 +190,7 @@ function extractJsdocParamsFromSchema(schema, allSchemas) {
                 }
             }
             // 处理 oneOf 数组
-            else if (prop.oneOf && Array.isArray(prop.oneOf)) {
+            else if (false && prop.oneOf && Array.isArray(prop.oneOf)) {
                 const types = prop.oneOf.map(item => {
                     if (isReferenceObject(item)) {
                         return getSchemaName(item.$ref);
@@ -152,14 +212,26 @@ function extractJsdocParamsFromSchema(schema, allSchemas) {
                 }
             }
             // 处理普通类型
-            else if (prop.type) {
-                propType = convertOpenApiTypeToTypeScript(prop.type);
+            else if (false && prop.type) {
+                const propSchema = prop;
+                if (propSchema.type === 'array' && propSchema.items) {
+                    if (isReferenceObject(propSchema.items)) {
+                        propType = `${getSchemaName(propSchema.items.$ref)}[]`;
+                    }
+                    else {
+                        const itemType = convertOpenApiTypeToTypeScript(propSchema.items.type);
+                        propType = `${itemType}[]`;
+                    }
+                }
+                else {
+                    propType = convertOpenApiTypeToTypeScript(propSchema.type);
+                }
             }
             params.push({
                 name: propName,
-                type: propType,
-                description: (prop === null || prop === void 0 ? void 0 : prop.description) || '',
-                required: (_a = targetSchema.required) === null || _a === void 0 ? void 0 : _a.includes(propName)
+                type: propType || 'any',
+                description: propDescription,
+                required: (_b = targetSchema.required) === null || _b === void 0 ? void 0 : _b.includes(propName)
             });
         }
     }
@@ -238,6 +310,9 @@ const processApi = (api, excludePaths = [], includePaths = [], pathPrefixes = []
             let requestBodyTypeName = undefined;
             let contentType = undefined;
             const jsdocParams = [];
+            const paramsJsdocParams = [];
+            const dataJsdocParams = [];
+            const responseJsdocParams = [];
             // --- FormData Detection ---
             let isFormData = false;
             // Method 1: Check requestBody
@@ -331,13 +406,17 @@ const processApi = (api, excludePaths = [], includePaths = [], pathPrefixes = []
                     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);
                 }
             }
             // Handle standard Request Body
@@ -350,7 +429,9 @@ const processApi = (api, excludePaths = [], includePaths = [], pathPrefixes = []
                         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)
@@ -367,11 +448,15 @@ const processApi = (api, excludePaths = [], includePaths = [], pathPrefixes = []
                                     addSchemaWithDependencies(itemSchemaName, modules[moduleName], allSchemas);
                                 }
                                 else {
-                                    jsdocParams.push(...extractJsdocParamsFromSchema(schema.items, allSchemas));
+                                    const arrayJsdoc = extractJsdocParamsFromSchema(schema.items, 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);
                             }
                         }
                     }
@@ -385,7 +470,8 @@ const processApi = (api, excludePaths = [], includePaths = [], pathPrefixes = []
                     requestBodyTypeName = typeName;
                     modules[moduleName].schemas[typeName] = formDataContent.schema;
                     referencedTypes.push(typeName);
-                    jsdocParams.push(...extractJsdocParamsFromSchema(formDataContent.schema, allSchemas));
+                    const formJsdoc = extractJsdocParamsFromSchema(formDataContent.schema, allSchemas);
+                    dataJsdocParams.push(...formJsdoc);
                 }
             }
             // Handle Response Body
@@ -399,6 +485,35 @@ const processApi = (api, excludePaths = [], includePaths = [], pathPrefixes = []
                     responseTypeName = name;
                     addSchemaWithDependencies(name, modules[moduleName], allSchemas);
                     referencedTypes.push(name);
+                    responseJsdocParams.push(...extractJsdocParamsFromSchema(schema, allSchemas));
+                }
+                else if (schema && !isReferenceObject(schema)) {
+                    const inlineSchema = schema;
+                    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
@@ -416,6 +531,9 @@ const processApi = (api, excludePaths = [], includePaths = [], pathPrefixes = []
                 hasData: !!requestBodyTypeName,
                 contentType,
                 jsdocParams,
+                paramsJsdocParams,
+                dataJsdocParams,
+                responseJsdocParams,
             };
             modules[moduleName].endpoints.push(endpoint);
         }

package/dist/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}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "czh-api",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "A CLI tool to generate TypeScript API clients from Swagger/OpenAPI documents.",
   "main": "dist/index.js",
   "bin": {