czh-api 1.0.2 → 1.0.3

package/src/core/parser.ts

@@ -42,26 +42,91 @@ function addSchemaWithDependencies(name: string, module: Module, allSchemas: { [
 
     const schema = allSchemas[name];
     if (!schema) {
+        console.warn(`警告: Schema "${name}" 未找到，跳过此引用`);
         return; // Schema not found
     }
 
     module.schemas[name] = schema as OpenAPIV3.SchemaObject;
 
-    // Recursively add dependencies
-    JSON.stringify(schema, (key, value) => {
-        if (key === '$ref' && typeof value === 'string') {
-            const depName = getSchemaName(value);
-            addSchemaWithDependencies(depName, module, allSchemas);
-        }
-        return value;
-    });
+    // Recursively add dependencies with error handling
+    try {
+        JSON.stringify(schema, (key, value) => {
+            if (key === '$ref' && typeof value === 'string') {
+                const depName = getSchemaName(value);
+                if (depName && allSchemas[depName]) {
+                    addSchemaWithDependencies(depName, module, allSchemas);
+                } else {
+                    console.warn(`警告: 依赖 Schema "${depName}" 未找到，跳过此引用`);
+                }
+            }
+            return value;
+        });
+    } catch (error) {
+        console.warn(`警告: 处理 Schema "${name}" 的依赖时出错:`, error);
+    }
 }
 
-function getModuleName(path: string): string {
+function toCamelCase(str: string): string {
+    return str
+        .split('/')
+        .filter(p => p)
+        .map((part, index) => {
+            const cleaned = part.replace(/[^a-zA-Z0-9]/g, '');
+            if (index === 0) {
+                return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
+            }
+            return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+        })
+        .join('');
+}
+
+function getModuleName(path: string, pathPrefixes: Array<{ path: string; packageName?: string }> = []): string {
+    // 尝试匹配配置的路径前缀
+    for (const prefix of pathPrefixes) {
+        if (path.startsWith(prefix.path)) {
+            // 获取前缀后的路径部分
+            const remainingPath = path.substring(prefix.path.length);
+            const parts = remainingPath.split('/').filter(p => p && !p.startsWith('{'));
+            
+            // 确定包名
+            const packageName = prefix.packageName || toCamelCase(prefix.path);
+            
+            // 如果有二级路径，使用二级路径作为子模块
+            if (parts.length > 0 && parts[0]) {
+                return `${packageName}/${parts[0]}`;
+            }
+            
+            // 如果没有二级路径，直接使用包名
+            return packageName;
+        }
+    }
+    
+    // 如果没有匹配到配置的前缀，使用默认逻辑
     const parts = path.split('/').filter(p => p && !p.startsWith('{'));
     return parts[0] || 'default';
 }
 
+function convertOpenApiTypeToTypeScript(openApiType: string | undefined): string {
+    if (!openApiType) return 'any';
+    
+    switch (openApiType) {
+        case 'integer':
+            return 'number';
+        case 'object':
+            return 'any';
+        case 'array':
+            return 'any[]';
+        case 'boolean':
+            return 'boolean';
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        default:
+            return 'any';
+    }
+}
+
 function extractJsdocParamsFromSchema(schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject, allSchemas: { [key: string]: any }): Required<Endpoint>['jsdocParams'] {
     const params: Required<Endpoint>['jsdocParams'] = [];
     if (!schema) return params;
@@ -78,12 +143,60 @@ function extractJsdocParamsFromSchema(schema: OpenAPIV3.SchemaObject | OpenAPIV3
         for (const propName in targetSchema.properties) {
             const prop = targetSchema.properties[propName] as OpenAPIV3.SchemaObject;
             
-            // 调试: 打印出当前处理的属性
-            // console.log(`正在处理属性: ${propName}`, '值为:', prop);
+            let propType = 'any';
+            
+            // 处理 anyOf 数组 (FastAPI 常用的联合类型)
+            if (prop.anyOf && Array.isArray(prop.anyOf)) {
+                const types = prop.anyOf.map(item => {
+                    if (isReferenceObject(item)) {
+                        return getSchemaName(item.$ref);
+                    } else {
+                        const itemSchema = item as OpenAPIV3.SchemaObject;
+                        // 处理 null 类型 (在 OpenAPI 中可能以不同方式表示)
+                        if ((itemSchema as any).type === 'null' || 
+                            itemSchema.type === undefined && (itemSchema as any).nullable === true ||
+                            JSON.stringify(itemSchema) === '{"type":"null"}' ||
+                            Object.keys(itemSchema).length === 0) {
+                            return 'null';
+                        }
+                        return convertOpenApiTypeToTypeScript(itemSchema.type);
+                    }
+                }).filter(type => type && type !== ''); // 只过滤掉空字符串，保留 any
+                
+                if (types.length > 0) {
+                    propType = types.join(' | ');
+                }
+            }
+            // 处理 oneOf 数组
+            else if (prop.oneOf && Array.isArray(prop.oneOf)) {
+                const types = prop.oneOf.map(item => {
+                    if (isReferenceObject(item)) {
+                        return getSchemaName(item.$ref);
+                    } else {
+                        const itemSchema = item as OpenAPIV3.SchemaObject;
+                        // 处理 null 类型 (在 OpenAPI 中可能以不同方式表示)
+                        if ((itemSchema as any).type === 'null' || 
+                            itemSchema.type === undefined && (itemSchema as any).nullable === true ||
+                            JSON.stringify(itemSchema) === '{"type":"null"}' ||
+                            Object.keys(itemSchema).length === 0) {
+                            return 'null';
+                        }
+                        return convertOpenApiTypeToTypeScript(itemSchema.type);
+                    }
+                }).filter(type => type && type !== ''); // 只过滤掉空字符串，保留 any
+                
+                if (types.length > 0) {
+                    propType = types.join(' | ');
+                }
+            }
+            // 处理普通类型
+            else if (prop.type) {
+                propType = convertOpenApiTypeToTypeScript(prop.type);
+            }
 
             params.push({
                 name: propName,
-                type: prop?.type || 'any',
+                type: propType,
                 description: prop?.description || '',
                 required: targetSchema.required?.includes(propName)
             });
@@ -111,9 +224,10 @@ function getModuleNameFromPackage(operation: OpenAPIV3.OperationObject): string
  * @param api The bundled OpenAPI document.
  * @param excludePaths Paths to exclude (by prefix).
  * @param includePaths Paths to include (by prefix). If provided, only these paths will be processed.
+ * @param pathPrefixes Path prefix configurations for custom module grouping.
  * @returns A structured representation of modules and their endpoints.
  */
-export const processApi = (api: OpenAPI.Document, excludePaths: string[] = [], includePaths: string[] = []): Modules => {
+export const processApi = (api: OpenAPI.Document, excludePaths: string[] = [], includePaths: string[] = [], pathPrefixes: Array<{ path: string; packageName?: string }> = []): Modules => {
     const modules: Modules = {};
     const allSchemas =  (api as OpenAPIV3.Document).components?.schemas || (api as any).definitions ||{};
 
@@ -141,7 +255,7 @@ export const processApi = (api: OpenAPI.Document, excludePaths: string[] = [], i
             if (!operation.tags) continue;
 
             const moduleNameFromPackage = getModuleNameFromPackage(operation);
-            const moduleName = moduleNameFromPackage || getModuleName(path);
+            const moduleName = moduleNameFromPackage || getModuleName(path, pathPrefixes);
 
             if (!modules[moduleName]) {
                 modules[moduleName] = {
@@ -227,13 +341,6 @@ export const processApi = (api: OpenAPI.Document, excludePaths: string[] = [], i
 
                 for (const param of operation.parameters) {
                     if (!isReferenceObject(param)) {
-                        const paramToAdd = {
-                            name: param.name,
-                            description: param.description || '',
-                            required: param.required,
-                            type: (param.schema as any)?.type || 'any'
-                        };
-
                         // If the parameter's schema is a reference, expand its properties
                         if (param.in === 'query' && param.schema && isReferenceObject(param.schema)) {
                             const schemaName = getSchemaName(param.schema.$ref);