npm - @cnbcool/cnb-api-generate - Versions diffs - 2.4.7 → 2.5.0 - Mend

@cnbcool/cnb-api-generate 2.4.7 → 2.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/built/codegen/api/build-query-value-expression.js +62 -0
package/built/codegen/api/generate-api-function-ast-node.js +2 -2
package/built/codegen/api/generate-function-content-ast-node.js +16 -8
package/built/codegen/api/generate-function-params-ast-node.js +69 -12
package/built/utils/compute-param-aliases.js +55 -0
package/built/utils/flatten-tool-options.js +7 -2
package/built/utils/query-path-alias.js +38 -0
package/client/lib/format-params.ts +24 -2
package/package.json +1 -1

package/built/codegen/api/build-query-value-expression.js ADDED Viewed

@@ -0,0 +1,62 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildQueryValueExpression = buildQueryValueExpression;
+const ts = __importStar(require("typescript"));
+const query_path_alias_1 = require("../../utils/query-path-alias");
+/**
+ * 构造请求参数对象里 `params:` / `_originParams.query:` 字段的值表达式。
+ *
+ * 规则：
+ *  - path 与 query 没有同名冲突时：直接返回 `Identifier(queryVarName)`，
+ *    生成代码形如 `params: __query`；
+ *  - 存在同名冲突时（如 `/{repo}/-/knowledge/base/query/{query}` 同时带 `?query=xxx`）：
+ *    返回对象字面量 `{ ...__query, ["<原始 key>"]: q_<原始 key>, ... }`，
+ *    通过计算属性把别名 `q_xxx` 映射回 swagger 里的原始 key，
+ *    保证发给后端的 query string key 与 swagger 契约一致。
+ */
+function buildQueryValueExpression(queryVarName, pathParams, queryParams) {
+    const aliasMap = (0, query_path_alias_1.collectQueryPathAliasMap)(pathParams, queryParams);
+    if (aliasMap.size === 0) {
+        return ts.factory.createIdentifier(queryVarName);
+    }
+    const properties = [
+        ts.factory.createSpreadAssignment(ts.factory.createIdentifier(queryVarName)),
+    ];
+    aliasMap.forEach((aliasName, originalName) => {
+        properties.push(ts.factory.createPropertyAssignment(ts.factory.createComputedPropertyName(ts.factory.createStringLiteral(originalName)), ts.factory.createIdentifier(aliasName)));
+    });
+    return ts.factory.createObjectLiteralExpression(properties, false);
+}

package/built/codegen/api/generate-api-function-ast-node.js CHANGED Viewed

@@ -55,7 +55,7 @@ function generateApiFunctionASTNode(methodData, definitions, defintionsMap) {
     let dependencies = new Set();
     // 根据parameters的类型，处理请求中不同的数据的处理方式
     const { pathParams, bodyParams, queryParams } = (0, filter_api_param_1.filterApiParam)(path, parameters);
-    const { requestParamsASTNodes: paramASTNodes, reduxActionMap, dependencies: paramsDependencies, requestInterfaceASTNodes: paramsInterfaceASTNodes, } = (0, generate_function_params_ast_node_1.generateFunctionParamsASTNode)(methodData, pathParams, queryParams, bodyParams, defintionsMap);
+    const { requestParamsASTNodes: paramASTNodes, reduxActionMap, dependencies: paramsDependencies, requestInterfaceASTNodes: paramsInterfaceASTNodes, paramAliases, } = (0, generate_function_params_ast_node_1.generateFunctionParamsASTNode)(methodData, pathParams, queryParams, bodyParams, defintionsMap);
     if (paramsDependencies && paramsDependencies.size > 0) {
         dependencies = new Set([...dependencies, ...paramsDependencies]);
     }
@@ -113,7 +113,7 @@ function generateApiFunctionASTNode(methodData, definitions, defintionsMap) {
         ? undefined
         : ts.factory.createIdentifier(methodData.exportName), undefined, paramASTNodes, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
         ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(constants_1.CNB_REQUEST_RESULT_INTERFACE), [successApiReturnType, errorApiReturnType]),
-    ]), (0, generate_function_content_ast_node_1.generateFunctionContentASTNode)(methodData, successApiReturnType, errorApiReturnType, pathParams, queryParams, bodyParams)));
+    ]), (0, generate_function_content_ast_node_1.generateFunctionContentASTNode)(methodData, successApiReturnType, errorApiReturnType, pathParams, queryParams, bodyParams, paramAliases)));
     for (const dependency of dependencies) {
         const defintion = defintionsMap[dependency];
         requestFileDependenciesASTNodes.push((0, generate_import_ast_node_1.generateImportAstNode)(defintion.exportName, defintion.filename, false, category, defintion.type));

package/built/codegen/api/generate-function-content-ast-node.js CHANGED Viewed

@@ -38,11 +38,17 @@ const ts = __importStar(require("typescript"));
 const constants_1 = require("../../constants");
 const generate_request_url_ast_node_1 = require("./generate-request-url-ast-node");
 const is_skills_1 = require("../../utils/is-skills");
-function generateFunctionContentASTNode(methodData, fetchSuccessResponse, fetchErrorResponse, pathParams, queryParams, bodyParams) {
+const build_query_value_expression_1 = require("./build-query-value-expression");
+function generateFunctionContentASTNode(methodData, fetchSuccessResponse, fetchErrorResponse, pathParams, queryParams, bodyParams, paramAliases) {
+    var _a, _b, _c, _d;
+    const queryVarName = (_a = paramAliases === null || paramAliases === void 0 ? void 0 : paramAliases.queryName) !== null && _a !== void 0 ? _a : constants_1.CNB_REQUEST_PARAM_QUERY_NAME;
+    const reqVarName = (_b = paramAliases === null || paramAliases === void 0 ? void 0 : paramAliases.reqName) !== null && _b !== void 0 ? _b : constants_1.CNB_REQUEST_PARAM_REQ_NAME;
+    const optionsVarName = (_c = paramAliases === null || paramAliases === void 0 ? void 0 : paramAliases.optionsName) !== null && _c !== void 0 ? _c : constants_1.CNB_REQUEST_PARAM_OPTIONS_NAME;
+    const axiosConfigVarName = (_d = paramAliases === null || paramAliases === void 0 ? void 0 : paramAliases.axiosConfigName) !== null && _d !== void 0 ? _d : constants_1.CNB_REQUEST_AXIOS_CONFIG_NAME;
     const requestParams = [
-        ts.factory.createSpreadAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_AXIOS_CONFIG_NAME)),
-        ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_CONFIG_NEXT_REQ), ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_REQ_NAME)),
-        ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_OPTIONS_NAME), ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_OPTIONS_NAME)),
+        ts.factory.createSpreadAssignment(ts.factory.createIdentifier(axiosConfigVarName)),
+        ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_CONFIG_NEXT_REQ), ts.factory.createIdentifier(reqVarName)),
+        ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_OPTIONS_NAME), ts.factory.createIdentifier(optionsVarName)),
     ];
     // 请求路径
     requestParams.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_CONFIG_URL), (0, generate_request_url_ast_node_1.generateRequestUrlASTNode)(methodData.path, pathParams)));
@@ -52,11 +58,12 @@ function generateFunctionContentASTNode(methodData, fetchSuccessResponse, fetchE
     requestParams.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_CONFIG_METHOD), ts.factory.createStringLiteral(methodData.method)));
     // 请求query
     if (queryParams && queryParams.length > 0) {
-        requestParams.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_QUERY_KEY_NAME), ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_QUERY_NAME)));
+        requestParams.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_QUERY_KEY_NAME), (0, build_query_value_expression_1.buildQueryValueExpression)(queryVarName, pathParams, queryParams)));
     }
     // 请求body
     if (bodyParams) {
-        requestParams.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_CONFIG_DATA), ts.factory.createIdentifier(bodyParams.name)));
+        const bodyVarName = (paramAliases === null || paramAliases === void 0 ? void 0 : paramAliases.bodyParamName) || bodyParams.name;
+        requestParams.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_CONFIG_DATA), ts.factory.createIdentifier(bodyVarName)));
     }
     // 生成skills时，请求参数需要包含_originalParams，用于后处理时使用
     if ((0, is_skills_1.isSkills)()) {
@@ -72,10 +79,11 @@ function generateFunctionContentASTNode(methodData, fetchSuccessResponse, fetchE
             objectLiteralExpression.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_PATH_PARAM_ORIGIN_NAME), ts.factory.createObjectLiteralExpression(pathParams.map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name), undefined)), false)));
         }
         if (queryParams.length > 0) {
-            objectLiteralExpression.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_QUERY_PARAM_ORIGIN_NAME), ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_QUERY_NAME)));
+            objectLiteralExpression.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_QUERY_PARAM_ORIGIN_NAME), (0, build_query_value_expression_1.buildQueryValueExpression)(queryVarName, pathParams, queryParams)));
         }
         if (bodyParams) {
-            objectLiteralExpression.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_BODY_PARAM_ORIGIN_NAME), ts.factory.createIdentifier(bodyParams.name)));
+            const bodyVarName = (paramAliases === null || paramAliases === void 0 ? void 0 : paramAliases.bodyParamName) || bodyParams.name;
+            objectLiteralExpression.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_BODY_PARAM_ORIGIN_NAME), ts.factory.createIdentifier(bodyVarName)));
         }
         requestParams.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_ORIGIN_PARAM_NAME), ts.factory.createObjectLiteralExpression(objectLiteralExpression, true)));
     }

package/built/codegen/api/generate-function-params-ast-node.js CHANGED Viewed

@@ -42,8 +42,13 @@ const get_keyword_type_node_1 = require("../../utils/get-keyword-type-node");
 const is_english_only_1 = require("../../utils/is-english-only");
 const constants_1 = require("../../constants");
 const md_array_type_content_ast_node_1 = require("../types/md-array-type-content-ast-node");
+const compute_param_aliases_1 = require("../../utils/compute-param-aliases");
+const query_path_alias_1 = require("../../utils/query-path-alias");
 function generateFunctionParamsASTNode(methodData, pathParams, queryParams, bodyParams, defintionsMap) {
     var _a;
+    // 计算保留变量名（query/req/options/axiosConfig）的安全别名，
+    // 避免与 path/body 参数重名导致 "Argument name clash" 等语法错误。
+    const paramAliases = (0, compute_param_aliases_1.computeParamAliases)(pathParams, bodyParams);
     // request函数参数
     const requestParamsASTNodes = [];
     const requestInterfaceASTNodes = [];
@@ -60,8 +65,29 @@ function generateFunctionParamsASTNode(methodData, pathParams, queryParams, body
         const paramsInterfaceName = `${(0, format_interface_name_1.formatInterfaceName)(methodData.exportName)}Params`;
         const paramMap = {};
         const firstParams = [];
-        // 排重
-        [...pathParams, ...queryParams].map((item) => {
+        // path 参数与 query 参数同名时（如 /{repo}/-/knowledge/base/query/{query} 同时带 ?query=xxx）：
+        // 两者语义不同，需要同时在类型里表达：
+        //   - path 字段沿用 swagger 的原名（URL 模板里的字面占位，必须保持原名）；
+        //   - query 字段通过 `q_<name>` 别名字段在 interface 中暴露，
+        //     运行时再通过计算属性把别名映射回 swagger 的原始 key（见 generate-function-content-ast-node.ts）。
+        const pathParamNameSet = new Set(pathParams.map((p) => p.name));
+        [
+            ...pathParams,
+            ...queryParams.map((q) => {
+                if (!pathParamNameSet.has(q.name))
+                    return q;
+                // 同名冲突：拷贝 query 参数并改名为 `q_<name>`，以便在 interface 中作为独立字段出现
+                const aliasName = (0, query_path_alias_1.getQueryPathAliasName)(q.name);
+                const aliasDesc = q.description
+                    ? `${q.description}（query string 参数；该路由 path 也存在同名字段，为避免冲突此处使用别名 ${aliasName}）`
+                    : `query string 参数；该路由 path 也存在同名字段，为避免冲突此处使用别名 ${aliasName}`;
+                return {
+                    ...q,
+                    name: aliasName,
+                    description: aliasDesc,
+                };
+            }),
+        ].map((item) => {
             paramMap[item.name] = item;
         });
         Object.keys(paramMap).forEach((key) => {
@@ -146,10 +172,21 @@ function generateFunctionParamsASTNode(methodData, pathParams, queryParams, body
         const pathParamsBindingElements = pathParams.map((item) => {
             return ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(item.name), undefined);
         });
+        // 同名 path/query 别名字段（如 q_query），需要单独从对象中解构出来，
+        // 避免被 `...__query` 吞掉后再做重映射（保留了可读性，并与 generate-function-content-ast-node 联动）。
+        const aliasQueryBindingElements = (queryParams || [])
+            .filter((q) => pathParamNameSet.has(q.name))
+            .map((q) => {
+            const aliasName = (0, query_path_alias_1.getQueryPathAliasName)(q.name);
+            return ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(aliasName), undefined);
+        });
         // 创建解构参数
-        const deconstructionParams = [...pathParamsBindingElements];
+        const deconstructionParams = [
+            ...pathParamsBindingElements,
+            ...aliasQueryBindingElements,
+        ];
         if (queryParams && queryParams.length > 0) {
-            deconstructionParams.push(ts.factory.createBindingElement(ts.factory.createToken(ts.SyntaxKind.DotDotDotToken), undefined, ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_QUERY_NAME), undefined));
+            deconstructionParams.push(ts.factory.createBindingElement(ts.factory.createToken(ts.SyntaxKind.DotDotDotToken), undefined, ts.factory.createIdentifier(paramAliases.queryName), undefined));
         }
         requestParamsASTNodes.push(ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createObjectBindingPattern(deconstructionParams), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(paramsInterfaceName), undefined), undefined));
         // redux action参数定义
@@ -176,6 +213,11 @@ function generateFunctionParamsASTNode(methodData, pathParams, queryParams, body
     // eslint-disable-next-line @typescript-eslint/prefer-for-of
     for (let i = 0; i < allRequestParams.length; i++) {
         const param = allRequestParams[i];
+        // 仅 body 参数需要用别名替换标识符；单个 path 参数保留原名（必须等于 URL 占位符）
+        const isBodyParam = bodyParams !== null && param === bodyParams;
+        const effectiveParamName = isBodyParam && paramAliases.bodyParamName
+            ? paramAliases.bodyParamName
+            : param.name;
         if (param === null || param === void 0 ? void 0 : param.schema) {
             // 多维数组处理
             if (param.schema.type &&
@@ -192,13 +234,13 @@ function generateFunctionParamsASTNode(methodData, pathParams, queryParams, body
                 requestInterfaceASTNodes.push(ts.factory.createExpressionStatement(ts.factory.createStringLiteral(`<$${paramsBodyName}$>`)));
                 // 创建interface主体
                 requestInterfaceASTNodes.push(ts.factory.createTypeAliasDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(paramsBodyName), undefined, returnType));
-                requestParamsASTNodes.push(ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier(param.name), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(paramsBodyName), undefined), undefined));
+                requestParamsASTNodes.push(ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier(effectiveParamName), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(paramsBodyName), undefined), undefined));
                 if (typeDependencies && typeDependencies.size > 0) {
                     dependencies = new Set([...dependencies, ...typeDependencies]);
                 }
                 // redux action参数定义
                 reduxActionMap.paramsSequence.push({
-                    param: param.name,
+                    param: effectiveParamName,
                     typeLiteral: paramsBodyName,
                     typeLiteralLabel: constants_1.TypeLiteralLabel.Quoted,
                     required: param.required,
@@ -207,7 +249,14 @@ function generateFunctionParamsASTNode(methodData, pathParams, queryParams, body
             }
             else {
                 const [imports, astNode, paramsSequenceItem] = (0, generate_function_refs_type_params_ast_node_1.generateFunctionReferenceTypeDataParamsASTNode)(param, defintionsMap);
-                astNode && requestParamsASTNodes.push(astNode);
+                if (astNode && isBodyParam && effectiveParamName !== param.name) {
+                    // 替换 body 参数的标识符为别名
+                    requestParamsASTNodes.push(ts.factory.updateParameterDeclaration(astNode, astNode.modifiers, astNode.dotDotDotToken, ts.factory.createIdentifier(effectiveParamName), astNode.questionToken, astNode.type, astNode.initializer));
+                    paramsSequenceItem.param = effectiveParamName;
+                }
+                else {
+                    astNode && requestParamsASTNodes.push(astNode);
+                }
                 if (imports && imports.size > 0) {
                     dependencies = new Set([...dependencies, ...imports]);
                 }
@@ -216,11 +265,14 @@ function generateFunctionParamsASTNode(methodData, pathParams, queryParams, body
             }
         }
         else {
-            const normalParamsASTNode = (0, generate_function_normal_params_ast_node_1.generateFunctionNormalParamsASTNode)(param);
+            let normalParamsASTNode = (0, generate_function_normal_params_ast_node_1.generateFunctionNormalParamsASTNode)(param);
+            if (isBodyParam && effectiveParamName !== param.name) {
+                normalParamsASTNode = ts.factory.updateParameterDeclaration(normalParamsASTNode, normalParamsASTNode.modifiers, normalParamsASTNode.dotDotDotToken, ts.factory.createIdentifier(effectiveParamName), normalParamsASTNode.questionToken, normalParamsASTNode.type, normalParamsASTNode.initializer);
+            }
             requestParamsASTNodes.push(normalParamsASTNode);
             // redux action参数定义
             reduxActionMap.paramsSequence.push({
-                param: param.name,
+                param: effectiveParamName,
                 typeLiteral: param.type || null,
                 typeLiteralLabel: constants_1.TypeLiteralLabel.Native,
                 required: param.required,
@@ -229,9 +281,13 @@ function generateFunctionParamsASTNode(methodData, pathParams, queryParams, body
     }
     // 添加requestConfig
     requestParamsASTNodes.push(ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createObjectBindingPattern([
-        ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_REQ_NAME), undefined),
-        ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_OPTIONS_NAME), undefined),
-        ts.factory.createBindingElement(ts.factory.createToken(ts.SyntaxKind.DotDotDotToken), undefined, ts.factory.createIdentifier(constants_1.CNB_REQUEST_AXIOS_CONFIG_NAME), undefined),
+        ts.factory.createBindingElement(undefined, paramAliases.reqName === constants_1.CNB_REQUEST_PARAM_REQ_NAME
+            ? undefined
+            : ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_REQ_NAME), ts.factory.createIdentifier(paramAliases.reqName), undefined),
+        ts.factory.createBindingElement(undefined, paramAliases.optionsName === constants_1.CNB_REQUEST_PARAM_OPTIONS_NAME
+            ? undefined
+            : ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_OPTIONS_NAME), ts.factory.createIdentifier(paramAliases.optionsName), undefined),
+        ts.factory.createBindingElement(ts.factory.createToken(ts.SyntaxKind.DotDotDotToken), undefined, ts.factory.createIdentifier(paramAliases.axiosConfigName), undefined),
     ]), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_TYPE_NAME), undefined), ts.factory.createObjectLiteralExpression([], false)));
     // redux action参数定义
     reduxActionMap.paramsSequence.push({
@@ -245,5 +301,6 @@ function generateFunctionParamsASTNode(methodData, pathParams, queryParams, body
         reduxActionMap,
         dependencies,
         requestInterfaceASTNodes,
+        paramAliases,
     };
 }

package/built/utils/compute-param-aliases.js ADDED Viewed

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeParamAliases = computeParamAliases;
+const constants_1 = require("../constants");
+const RESERVED_DEFAULTS = {
+    queryName: constants_1.CNB_REQUEST_PARAM_QUERY_NAME,
+    reqName: constants_1.CNB_REQUEST_PARAM_REQ_NAME,
+    optionsName: constants_1.CNB_REQUEST_PARAM_OPTIONS_NAME,
+    axiosConfigName: constants_1.CNB_REQUEST_AXIOS_CONFIG_NAME,
+};
+/**
+ * 给定一个目标变量名 base 和已被占用的名字集合 used，
+ * 返回不与 used 冲突的安全名（依次尝试 _base、__base 等）。
+ */
+function pickUniqueName(base, used) {
+    if (!used.has(base))
+        return base;
+    let candidate = `_${base}`;
+    while (used.has(candidate)) {
+        candidate = `_${candidate}`;
+    }
+    return candidate;
+}
+/**
+ * 根据 path/body 参数名计算需要使用的保留变量名别名，避免命名冲突。
+ *
+ * 注意 path 参数名是"硬约束"（必须等于 URL 模板中的占位符名），
+ * 因此优先占用 path 参数名，再依次给 body / 保留变量分配安全名。
+ */
+function computeParamAliases(pathParams = [], bodyParams = null) {
+    var _a;
+    const used = new Set();
+    pathParams.forEach((p) => {
+        if (p === null || p === void 0 ? void 0 : p.name)
+            used.add(p.name);
+    });
+    // body 参数名：与 path 参数 / 保留名冲突时改名
+    const originalBodyName = (_a = bodyParams === null || bodyParams === void 0 ? void 0 : bodyParams.name) !== null && _a !== void 0 ? _a : '';
+    const bodyParamName = originalBodyName
+        ? pickUniqueName(originalBodyName, used)
+        : '';
+    if (bodyParamName)
+        used.add(bodyParamName);
+    const aliases = {
+        ...RESERVED_DEFAULTS,
+        bodyParamName,
+    };
+    // 保留变量按顺序分配，先分配出去的别名也要避免后续被占用
+    ['queryName', 'reqName', 'optionsName', 'axiosConfigName'].forEach((key) => {
+        const safe = pickUniqueName(RESERVED_DEFAULTS[key], used);
+        aliases[key] = safe;
+        used.add(safe);
+    });
+    return aliases;
+}

package/built/utils/flatten-tool-options.js CHANGED Viewed

@@ -36,20 +36,25 @@ function flattenToolOptions(toolInfo) {
             });
         }
     }
-    // query 参数
+    // query 参数：与 path 同名时，optKey 前缀 q- 以避免 Commander 选项名冲突
     if (queryDef) {
+        const pathKeys = new Set(pathDef ? Object.keys(pathDef) : []);
         for (const [key, param] of Object.entries(queryDef)) {
             const valuePlaceholder = (0, option_value_flag_1.optionValueFlag)(param.type);
             const rawDesc = (0, trim_summary_1.trimSummary)(param.description || '');
             const desc = param.required ? `[必填] ${rawDesc}` : rawDesc;
+            const conflict = pathKeys.has(key);
+            const optKey = conflict ? `q-${key}` : key;
             const opt = {
-                optKey: key,
+                optKey,
                 valuePlaceholder,
                 description: desc,
                 required: !!param.required,
                 isArray: false,
                 source: 'query',
             };
+            if (conflict)
+                opt.originalName = key;
             if (param.enum)
                 opt.choices = param.enum;
             if (param.default !== undefined)

package/built/utils/query-path-alias.js ADDED Viewed

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUERY_PATH_ALIAS_PREFIX = void 0;
+exports.getQueryPathAliasName = getQueryPathAliasName;
+exports.collectQueryPathAliasMap = collectQueryPathAliasMap;
+/**
+ * path 参数与 query 参数同名时，query 字段在生成的 interface / 函数解构里
+ * 统一使用的别名前缀。
+ *
+ * 例如 swagger 中 `/{repo}/-/knowledge/base/query/{query}` 同时存在
+ *   { name: 'query', in: 'path' }
+ *   { name: 'query', in: 'query' }
+ * 两个语义不同的参数。我们保留 path 字段的原名（URL 占位），
+ * 而 query 字段改名为 `q_query`，运行时再用计算属性映射回原始 key。
+ */
+exports.QUERY_PATH_ALIAS_PREFIX = 'q_';
+/**
+ * 给定 swagger 原始 query 参数名，返回它在生成代码里的别名。
+ */
+function getQueryPathAliasName(originalName) {
+    return `${exports.QUERY_PATH_ALIAS_PREFIX}${originalName}`;
+}
+/**
+ * 收集 query 参数中名字与 path 参数同名的项，返回 `原始名 -> 别名` 的映射。
+ * 没有冲突时返回空 Map。
+ */
+function collectQueryPathAliasMap(pathParams = [], queryParams = []) {
+    const map = new Map();
+    if (!pathParams.length || !queryParams.length)
+        return map;
+    const pathNameSet = new Set(pathParams.map((p) => p.name));
+    for (const q of queryParams) {
+        if (pathNameSet.has(q.name)) {
+            map.set(q.name, getQueryPathAliasName(q.name));
+        }
+    }
+    return map;
+}

package/client/lib/format-params.ts CHANGED Viewed

@@ -48,8 +48,7 @@ export function formatParams(
     const bodyProps = paramDefs.body?.schema?.properties || {};
     const reservedKeys = new Set([
-      'module', 'tool', 'help', 'short', 'verbose',
-      'path', 'query', 'data', 'h', 'v',
+      'module', 'tool', 'help', 'short', 'verbose', 'h', 'v',
     ]);
     // 收集 array<object> 展开字段的临时存储：{ arrayName: { propName: string[] } }
@@ -97,6 +96,18 @@ export function formatParams(
         // 归入 path
         if (!formatted.path) formatted.path = {};
         formatted.path[key] = value;
+        // path 与 query 同名时，query 参数通过 q- 前缀传入（见下方 q- 分支）；
+        // 但若调用方直接用 --<name> 传了值（旧习惯/兼容），且 queryDef 里也有同名项，
+        // 则同时回填到 query，保证 URL 查询参数也被带上。
+        if (queryDef[key]) {
+          if (!formatted.query) formatted.query = {};
+          const paramType = queryDef[key].type;
+          if (paramType === 'number' && typeof value === 'string' && !isNaN(Number(value))) {
+            formatted.query[key] = Number(value);
+          } else {
+            formatted.query[key] = value;
+          }
+        }
       } else if (queryDef[key]) {
         // 归入 query
         if (!formatted.query) formatted.query = {};
@@ -106,6 +117,17 @@ export function formatParams(
         } else {
           formatted.query[key] = value;
         }
+      } else if ((key.startsWith('q-') || key.startsWith('q_'))
+        && queryDef[key.replace(/^q[-_]/, '')]) {
+        // query 参数与 path 同名时，CLI 层以 q- 前缀区分，这里还原为真实 query key
+        const originalKey = key.replace(/^q[-_]/, '');
+        if (!formatted.query) formatted.query = {};
+        const paramType = queryDef[originalKey].type;
+        if (paramType === 'number' && typeof value === 'string' && !isNaN(Number(value))) {
+          formatted.query[originalKey] = Number(value);
+        } else {
+          formatted.query[originalKey] = value;
+        }
       } else if (bodyProps[key]) {
         // body 字段（无冲突，直接用原 key）
         if (!formatted.data) formatted.data = {};

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@cnbcool/cnb-api-generate",
-  "version": "2.4.7",
+  "version": "2.5.0",
   "main": "./built/index.js",
   "module": "./src/index.ts",
   "types": "./src/index.ts",