whistle.mock-plugins 1.1.0 → 1.1.1-beta.2

package/lib/ruleManager.js

@@ -3,6 +3,113 @@ const path = require('path');
 const url = require('url');
 const Mock = require('mockjs');
 
+// 获取嵌套对象属性值的工具函数
+const getNestedValue = (obj, path) => {
+  return path.split('.').reduce((current, key) => {
+    return current && current[key] !== undefined ? current[key] : undefined;
+  }, obj);
+};
+
+// 参数匹配功能
+const isParamMatch = (req, paramMatchers, log) => {
+  if (!paramMatchers || !Array.isArray(paramMatchers) || paramMatchers.length === 0) {
+    return true; // 如果没有参数匹配规则，视为匹配成功
+  }
+
+  try {
+    // 合并所有可能的参数来源
+    let requestParams = {};
+    
+    // URL查询参数
+    if (req.query) {
+      requestParams = { ...requestParams, ...req.query };
+    }
+    
+    // POST请求体参数
+    if (req.body && typeof req.body === 'object') {
+      requestParams = { ...requestParams, ...req.body };
+    }
+    
+    // URL路径参数（如果有的话）
+    if (req.params) {
+      requestParams = { ...requestParams, ...req.params };
+    }
+
+    if (log) {
+      log(`参数匹配检查 - 请求参数: ${JSON.stringify(requestParams)}`);
+      log(`参数匹配检查 - 匹配规则: ${JSON.stringify(paramMatchers)}`);
+    }
+
+    // 检查每个匹配规则
+    for (const matcher of paramMatchers) {
+      const { paramPath, paramValue, matchType = 'exact' } = matcher;
+      
+      if (!paramPath) {
+        continue; // 跳过无效的匹配规则
+      }
+
+      // 获取实际参数值
+      const actualValue = getNestedValue(requestParams, paramPath);
+      
+      if (log) {
+        log(`参数匹配检查 - 路径: ${paramPath}, 期望值: ${paramValue}, 实际值: ${actualValue}, 匹配类型: ${matchType}`);
+      }
+
+      // 如果参数不存在，视为不匹配
+      if (actualValue === undefined || actualValue === null) {
+        if (log) {
+          log(`参数匹配失败 - 参数 ${paramPath} 不存在`);
+        }
+        return false;
+      }
+
+      // 根据匹配类型进行比较
+      let isMatch = false;
+      const actualStr = String(actualValue);
+      const expectedStr = String(paramValue);
+
+      switch (matchType) {
+        case 'exact':
+          isMatch = actualStr === expectedStr;
+          break;
+        case 'contains':
+          isMatch = actualStr.includes(expectedStr);
+          break;
+        case 'regex':
+          try {
+            const regex = new RegExp(expectedStr);
+            isMatch = regex.test(actualStr);
+          } catch (e) {
+            if (log) {
+              log(`参数匹配失败 - 正则表达式无效: ${expectedStr}`);
+            }
+            return false;
+          }
+          break;
+        default:
+          isMatch = actualStr === expectedStr;
+      }
+
+      if (!isMatch) {
+        if (log) {
+          log(`参数匹配失败 - ${paramPath}: ${actualStr} 不匹配 ${expectedStr} (${matchType})`);
+        }
+        return false;
+      }
+    }
+
+    if (log) {
+      log('参数匹配成功 - 所有规则都匹配');
+    }
+    return true;
+  } catch (error) {
+    if (log) {
+      log(`参数匹配检查出错: ${error.message}`);
+    }
+    return false;
+  }
+};
+
 /**
  * 规则管理模块，负责处理 Whistle 规则和代理请求
  */
@@ -60,7 +167,7 @@ const ruleManager = {
     const requestPath = parsedUrl.pathname;
     
     // 查找匹配的接口
-    const matchedInterface = this.findMatchingInterface(enabledInterfaces, requestPath, req.method);
+    const matchedInterface = this.findMatchingInterface(enabledInterfaces, requestPath, req.method, req);
     
     if (!matchedInterface) {
       this.log(`[规则处理器] 未找到匹配的接口，请求将透传: ${req.method} ${requestPath}`);
@@ -93,9 +200,10 @@ const ruleManager = {
    * @param {Array} interfaces 接口列表
    * @param {string} requestPath 请求路径
    * @param {string} method 请求方法
+   * @param {object} req 完整的请求对象，用于参数匹配
    * @returns {object|null} 匹配的接口对象，如果没有匹配则返回 null
    */
-  findMatchingInterface(interfaces, requestPath, method) {
+  findMatchingInterface(interfaces, requestPath, method, req) {
     // 简化日志，只记录正在进行匹配的操作
     this.log(`[规则处理器] 尝试匹配接口，路径: ${requestPath}, 方法: ${method}`);
     
@@ -111,17 +219,16 @@ const ruleManager = {
       return null;
     }
     
-    // 先尝试完全匹配，效率更高
-    let matchedInterface = interfaces.find(intf => {
-      // 检查接口对象是否有效
+    // 收集所有URL匹配的接口
+    const urlMatchedInterfaces = [];
+    
+    // 先收集所有URL匹配的接口（包括精确匹配和正则匹配）
+    for (const intf of interfaces) {
       if (!intf || !intf.urlPattern) {
-        return false;
+        continue;
       }
       
-      // 检查URL和方法是否匹配
-      const urlMatches = intf.urlPattern === requestPath;
-      
-      // 修复: 兼容不同的方法名称和值
+      // 检查HTTP方法是否匹配
       const methodField = intf.httpMethod || intf.method;
       const methodValue = methodField && methodField.toUpperCase();
       const methodMatches = !methodValue || 
@@ -129,32 +236,24 @@ const ruleManager = {
                             methodValue === 'ANY' || 
                             methodValue === method;
       
-      // 移除中间匹配过程的日志
-      return urlMatches && methodMatches;
-    });
-
-    if (matchedInterface) {
-      this.log(`[规则处理器] 找到完全匹配的接口: ${matchedInterface.name}`);
-      return matchedInterface;
-    }
-
-    // 如果没有完全匹配，尝试正则表达式匹配
-    this.log(`[规则处理器] 未找到完全匹配，尝试正则表达式匹配...`);
-    
-    // 使用正则表达式缓存优化性能
-    if (!this.regexCache) {
-      this.regexCache = new Map();
-    }
-    
-    try {
-      matchedInterface = interfaces.find(intf => {
+      if (!methodMatches) {
+        continue;
+      }
+      
+      // 检查URL是否匹配
+      let urlMatches = false;
+      
+      // 精确匹配
+      if (intf.urlPattern === requestPath) {
+        urlMatches = true;
+      } else {
+        // 正则表达式匹配
         try {
-          // 验证接口对象
-          if (!intf || !intf.urlPattern) {
-            return false;
+          // 从缓存获取或创建正则表达式
+          if (!this.regexCache) {
+            this.regexCache = new Map();
           }
           
-          // 从缓存获取或创建正则表达式
           let regex;
           if (this.regexCache.has(intf.urlPattern)) {
             regex = this.regexCache.get(intf.urlPattern);
@@ -166,37 +265,48 @@ const ruleManager = {
             this.regexCache.set(intf.urlPattern, regex);
           }
           
-          // 获取方法值，兼容不同的字段名
-          const methodField = intf.httpMethod || intf.method;
-          const methodValue = methodField && methodField.toUpperCase();
-          
-          // 检查URL和方法是否匹配
-          const urlMatches = regex.test(requestPath);
-          const methodMatches = !methodValue || 
-                                methodValue === 'ALL' || 
-                                methodValue === 'ANY' || 
-                                methodValue === method;
-          
-          return urlMatches && methodMatches;
+          urlMatches = regex.test(requestPath);
         } catch (err) {
-          // 记录特定接口的错误，但继续处理其他接口
-          this.log(`[规则处理器] 匹配接口 ${intf?.name || 'unknown'} 时出错: ${err.message}`);
-          return false;
+          this.log(`[规则处理器] 正则匹配接口 ${intf.name} 时出错: ${err.message}`);
+          continue;
         }
-      });
-    } catch (err) {
-      // 记录整体匹配过程的错误
-      this.log(`[规则处理器] 正则匹配过程出错: ${err.message}`);
-      return null;
+      }
+      
+      if (urlMatches) {
+        urlMatchedInterfaces.push(intf);
+      }
     }
-
-    if (matchedInterface) {
-      this.log(`[规则处理器] 找到正则匹配的接口: ${matchedInterface.name}`);
-    } else {
+    
+    this.log(`[规则处理器] 找到 ${urlMatchedInterfaces.length} 个URL匹配的接口`);
+    
+    if (urlMatchedInterfaces.length === 0) {
       this.log(`[规则处理器] 未找到匹配的接口`);
+      return null;
+    }
+    
+    // 在URL匹配的接口中，查找参数也匹配的接口
+    for (const intf of urlMatchedInterfaces) {
+      // 检查参数匹配
+      if (isParamMatch(req, intf.paramMatchers, this.log)) {
+        this.log(`[规则处理器] 找到完全匹配的接口: ${intf.name} (URL + 参数匹配)`);
+        return intf;
+      } else {
+        this.log(`[规则处理器] 接口 ${intf.name} URL匹配但参数不匹配，继续查找...`);
+      }
+    }
+    
+    // 如果没有参数匹配的接口，返回第一个没有参数匹配规则的接口
+    const fallbackInterface = urlMatchedInterfaces.find(intf => 
+      !intf.paramMatchers || !Array.isArray(intf.paramMatchers) || intf.paramMatchers.length === 0
+    );
+    
+    if (fallbackInterface) {
+      this.log(`[规则处理器] 使用回退接口: ${fallbackInterface.name} (无参数匹配规则)`);
+      return fallbackInterface;
     }
     
-    return matchedInterface;
+    this.log(`[规则处理器] 所有URL匹配的接口都有参数匹配规则且都不满足，未找到合适的接口`);
+    return null;
   },
 
   /**

package/lib/server.js

@@ -170,6 +170,99 @@ if (!fs.existsSync(INTERFACES_FILE)) {
 const RULE_VALUE_HEADER = 'x-whistle-rule-value';
 const MOCK_PREFIX = 'mock://';
 
+// 获取嵌套对象属性值的工具函数
+const getNestedValue = (obj, path) => {
+  return path.split('.').reduce((current, key) => {
+    return current && current[key] !== undefined ? current[key] : undefined;
+  }, obj);
+};
+
+// 参数匹配功能
+const isParamMatch = (req, paramMatchers) => {
+  if (!paramMatchers || !Array.isArray(paramMatchers) || paramMatchers.length === 0) {
+    return true; // 如果没有参数匹配规则，视为匹配成功
+  }
+
+  try {
+    // 合并所有可能的参数来源
+    let requestParams = {};
+    
+    // URL查询参数
+    if (req.query) {
+      requestParams = { ...requestParams, ...req.query };
+    }
+    
+    // POST请求体参数
+    if (req.body && typeof req.body === 'object') {
+      requestParams = { ...requestParams, ...req.body };
+    }
+    
+    // URL路径参数（如果有的话）
+    if (req.params) {
+      requestParams = { ...requestParams, ...req.params };
+    }
+
+    logMessage(`参数匹配检查 - 请求参数: ${JSON.stringify(requestParams)}`);
+    logMessage(`参数匹配检查 - 匹配规则: ${JSON.stringify(paramMatchers)}`);
+
+    // 检查每个匹配规则
+    for (const matcher of paramMatchers) {
+      const { paramPath, paramValue, matchType = 'exact' } = matcher;
+      
+      if (!paramPath) {
+        continue; // 跳过无效的匹配规则
+      }
+
+      // 获取实际参数值
+      const actualValue = getNestedValue(requestParams, paramPath);
+      
+      logMessage(`参数匹配检查 - 路径: ${paramPath}, 期望值: ${paramValue}, 实际值: ${actualValue}, 匹配类型: ${matchType}`);
+
+      // 如果参数不存在，视为不匹配
+      if (actualValue === undefined || actualValue === null) {
+        logMessage(`参数匹配失败 - 参数 ${paramPath} 不存在`);
+        return false;
+      }
+
+      // 根据匹配类型进行比较
+      let isMatch = false;
+      const actualStr = String(actualValue);
+      const expectedStr = String(paramValue);
+
+      switch (matchType) {
+        case 'exact':
+          isMatch = actualStr === expectedStr;
+          break;
+        case 'contains':
+          isMatch = actualStr.includes(expectedStr);
+          break;
+        case 'regex':
+          try {
+            const regex = new RegExp(expectedStr);
+            isMatch = regex.test(actualStr);
+          } catch (e) {
+            logMessage(`参数匹配失败 - 正则表达式无效: ${expectedStr}`);
+            return false;
+          }
+          break;
+        default:
+          isMatch = actualStr === expectedStr;
+      }
+
+      if (!isMatch) {
+        logMessage(`参数匹配失败 - ${paramPath}: ${actualStr} 不匹配 ${expectedStr} (${matchType})`);
+        return false;
+      }
+    }
+
+    logMessage('参数匹配成功 - 所有规则都匹配');
+    return true;
+  } catch (error) {
+    logMessage(`参数匹配检查出错: ${error.message}`);
+    return false;
+  }
+};
+
 // 创建 Express 应用
 const app = express();
 
@@ -577,6 +670,33 @@ const handleResponse = (interfaceItem, req, res) => {
   logMessage(`匹配到接口: ${interfaceItem.name}, ID: ${interfaceItem.id}`);
   logMessage(`URL匹配规则: ${interfaceItem.urlPattern}`);
   
+  // 检查参数匹配规则
+  if (!isParamMatch(req, interfaceItem.paramMatchers)) {
+    logMessage(`参数匹配失败，跳过接口: ${interfaceItem.name}`);
+    
+    // 记录参数匹配失败的日志
+    addToJsonLog({
+      eventType: 'param_mismatch',
+      url: req.url,
+      method: req.method,
+      message: `参数匹配失败: ${interfaceItem.name}`,
+      pattern: interfaceItem.urlPattern,
+      status: 'skipped',
+      paramMatchers: interfaceItem.paramMatchers || []
+    });
+    
+    // 返回404，表示没有匹配的接口
+    return res.status(404).json({
+      code: 404,
+      message: '参数匹配失败，未找到符合条件的接口',
+      data: {
+        interfaceName: interfaceItem.name,
+        urlPattern: interfaceItem.urlPattern,
+        paramMatchers: interfaceItem.paramMatchers || []
+      }
+    });
+  }
+  
   // 记录请求详情
   logMessage(`请求方法: ${req.method}`);
   logMessage(`原始URL: ${req.url}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whistle.mock-plugins",
-  "version": "1.1.0",
+  "version": "1.1.1-beta.2",
   "description": "Whistle 插件，用于快速创建 API 模拟数据",
   "main": "lib/index.js",
   "scripts": {

package/ui/src/pages/InterfaceManagement.js

@@ -166,7 +166,8 @@ const InterfaceManagement = () => {
       responses: defaultResponses,
       activeResponseId: defaultResponseId,
       httpMethod: 'ALL',
-      headerItems: [] // 初始化为空数组
+      headerItems: [], // 初始化为空数组
+      paramMatchers: [] // 初始化为空数组
     });
     
     setCurrentResponseId(defaultResponseId);
@@ -187,6 +188,16 @@ const InterfaceManagement = () => {
       }));
     }
 
+    // 处理参数匹配规则，转换为数组格式
+    let paramMatchersArray = [];
+    if (record.paramMatchers && Array.isArray(record.paramMatchers)) {
+      paramMatchersArray = record.paramMatchers.map(matcher => ({
+        paramPath: matcher.paramPath || '',
+        paramValue: matcher.paramValue || '',
+        matchType: matcher.matchType || 'exact'
+      }));
+    }
+
     // 处理多响应数据
     let initialResponses = [];
     let initialResponseId = null;
@@ -233,7 +244,8 @@ const InterfaceManagement = () => {
       activeResponseId: initialResponseId,
       httpMethod: record.httpMethod || 'ALL',
       targetUrl: record.targetUrl || '',
-      headerItems: headersArray // 使用数组存储表单项
+      headerItems: headersArray, // 使用数组存储表单项
+      paramMatchers: paramMatchersArray
     });
     setModalVisible(true);
   };
@@ -373,6 +385,22 @@ const InterfaceManagement = () => {
         }
       }
 
+      // 处理参数匹配规则，清理无效的规则
+      let paramMatchers = [];
+      if (values.proxyType === 'response' && values.paramMatchers && values.paramMatchers.length > 0) {
+        paramMatchers = values.paramMatchers
+          .filter(item => item && item.paramPath && item.paramPath.trim() && item.paramValue !== undefined)
+          .map(item => ({
+            paramPath: item.paramPath.trim(),
+            paramValue: item.paramValue,
+            matchType: item.matchType || 'exact'
+          }));
+      }
+
+      console.log('=== 参数匹配规则处理 ===');
+      console.log('原始参数匹配规则:', values.paramMatchers);
+      console.log('清理后的参数匹配规则:', paramMatchers);
+
       const interfaceData = {
         name: values.name,
         featureId: selectedFeatureId,
@@ -385,6 +413,7 @@ const InterfaceManagement = () => {
         responseContent: activeResponse ? activeResponse.content : '',
         targetUrl: (values.proxyType === 'redirect' || values.proxyType === 'url_redirect') ? values.targetUrl : '',
         customHeaders: (values.proxyType === 'redirect' || values.proxyType === 'url_redirect') ? customHeaders : {},
+        paramMatchers: paramMatchers, // 添加参数匹配规则
         httpStatus: parseInt(values.statusCode, 10), // 转换为数字
         contentType: values.contentType,
         responseDelay: 0,
@@ -584,6 +613,43 @@ const InterfaceManagement = () => {
         );
       }
     },
+    {
+      title: '参数匹配',
+      dataIndex: 'paramMatchers',
+      key: 'paramMatchers',
+      width: 100,
+      render: (_, record) => {
+        if (record.proxyType !== 'response') {
+          return '-';
+        }
+        
+        const matchers = record.paramMatchers || [];
+        const count = matchers.length;
+        
+        if (count === 0) {
+          return '-';
+        }
+        
+        return (
+          <Tooltip title={
+            <div>
+              {matchers.map((matcher, index) => (
+                <div key={index}>
+                  {matcher.paramPath}: {matcher.paramValue}
+                  <span style={{ color: '#52c41a', marginLeft: 4 }}>
+                    ({matcher.matchType === 'exact' ? '精确' : matcher.matchType === 'contains' ? '包含' : '正则'})
+                  </span>
+                </div>
+              ))}
+            </div>
+          }>
+            <span style={{ color: '#1890ff' }}>
+              {count}条规则
+            </span>
+          </Tooltip>
+        );
+      }
+    },
     {
       title: '请求方法',
       dataIndex: 'httpMethod',
@@ -711,7 +777,8 @@ const InterfaceManagement = () => {
               responses: [],
               httpMethod: 'ALL',
               targetUrl: '',
-              headerItems: []
+              headerItems: [],
+              paramMatchers: []
             }}
           >
             {/* 基础信息表单项保持原样 */}
@@ -900,6 +967,87 @@ const InterfaceManagement = () => {
                         </div>
                       </div>
 
+                      {/* 请求入参匹配设置 */}
+                      <Form.Item 
+                        label="请求入参匹配"
+                        tooltip="设置请求参数的匹配条件，只有当请求参数满足条件时才返回对应的响应。支持嵌套属性路径，如：a.b.c"
+                      >
+                        <Form.List name="paramMatchers">
+                          {(fields, { add, remove }) => (
+                            <>
+                              {fields.map(({ key, name, ...restField }) => (
+                                <div key={key} style={{ display: 'flex', gap: '8px', alignItems: 'center', marginBottom: '8px' }}>
+                                  <Form.Item
+                                    {...restField}
+                                    name={[name, 'paramPath']}
+                                    rules={[
+                                      { required: true, message: '请输入参数路径' },
+                                      {
+                                        pattern: /^[a-zA-Z_$][a-zA-Z0-9_$.]*$/,
+                                        message: '请输入有效的参数路径，如：userId 或 data.user.id'
+                                      }
+                                    ]}
+                                    style={{ flex: 1, margin: 0 }}
+                                  >
+                                    <Input placeholder="参数路径（如：userId 或 data.user.id）" />
+                                  </Form.Item>
+                                  <Form.Item
+                                    {...restField}
+                                    name={[name, 'paramValue']}
+                                    rules={[{ required: true, message: '请输入期望值' }]}
+                                    style={{ flex: 1, margin: 0 }}
+                                  >
+                                    <Input placeholder="期望值（如：123 或 admin）" />
+                                  </Form.Item>
+                                  <Form.Item
+                                    {...restField}
+                                    name={[name, 'matchType']}
+                                    style={{ width: 100, margin: 0 }}
+                                    initialValue="exact"
+                                  >
+                                    <Select placeholder="匹配类型">
+                                      <Option value="exact">精确匹配</Option>
+                                      <Option value="contains">包含</Option>
+                                      <Option value="regex">正则</Option>
+                                    </Select>
+                                  </Form.Item>
+                                  <Button 
+                                    type="text" 
+                                    danger 
+                                    icon={<DeleteOutlined />}
+                                    onClick={() => remove(name)}
+                                  />
+                                </div>
+                              ))}
+                              <Button
+                                type="dashed"
+                                onClick={() => add()}
+                                icon={<PlusOutlined />}
+                                style={{ width: '100%', marginTop: '8px' }}
+                              >
+                                添加参数匹配规则
+                              </Button>
+                              {fields.length > 0 && (
+                                <div style={{ 
+                                  fontSize: '12px', 
+                                  color: '#666', 
+                                  marginTop: '8px',
+                                  padding: '8px',
+                                  backgroundColor: '#f5f5f5',
+                                  borderRadius: '4px'
+                                }}>
+                                  <div><strong>说明：</strong></div>
+                                  <div>• <strong>精确匹配</strong>：参数值完全相等</div>
+                                  <div>• <strong>包含</strong>：参数值包含指定内容</div>
+                                  <div>• <strong>正则</strong>：参数值符合正则表达式</div>
+                                  <div>• <strong>嵌套路径</strong>：使用点号分隔，如 data.user.id</div>
+                                </div>
+                              )}
+                            </>
+                          )}
+                        </Form.List>
+                      </Form.Item>
+
                       {/* 隐藏的表单字段用于存储响应数据 */}
                       <Form.Item 
                         name="responses"