whistle.mock-plugins 1.2.2-beta.2 → 1.2.2-beta.22

package/lib/models.js

@@ -22,6 +22,15 @@
  * @property {string} name - 响应名称
  * @property {string} description - 响应描述
  * @property {string} content - 响应内容，使用 Mock.js 语法
+ * @property {Array<ParamMatcher>} paramMatchers - 响应级入参匹配规则，运行时按顺序匹配，第一个满足所有规则的响应被返回；无规则的响应作为默认兜底
+ */
+
+/**
+ * 参数匹配规则数据模型
+ * @typedef {Object} ParamMatcher
+ * @property {string} paramPath - 参数路径，支持嵌套路径（如 data.user.id）
+ * @property {string} paramValue - 期望值
+ * @property {string} matchType - 匹配类型，可选值: 'exact'(精确匹配), 'contains'(包含), 'regex'(正则)
  */
 
 /**

package/lib/routes/interfaces.js

@@ -53,7 +53,8 @@ const processInterfaceData = (data) => {
         id: resp.id,
         name: resp.name,
         description: resp.description || '',
-        content: resp.content || '{}'
+        content: resp.content || '{}',
+        paramMatchers: Array.isArray(resp.paramMatchers) ? resp.paramMatchers : []
       };
       
       console.log(`处理后的响应 ${index}:`, processedResp);
@@ -86,7 +87,8 @@ const processInterfaceData = (data) => {
       id: Math.random().toString(36).substring(2, 15),
       name: '默认响应',
       description: '',
-      content: result.responseContent
+      content: result.responseContent,
+      paramMatchers: []
     }];
     result.activeResponseId = result.responses[0].id;
     console.log('创建的默认响应:', result.responses[0]);
@@ -98,7 +100,8 @@ const processInterfaceData = (data) => {
       id: Math.random().toString(36).substring(2, 15),
       name: '默认响应',
       description: '',
-      content: '{}'
+      content: '{}',
+      paramMatchers: []
     }];
     result.activeResponseId = result.responses[0].id;
     result.responseContent = '{}';

package/lib/routes/settings.js

@@ -0,0 +1,51 @@
+const express = require('express');
+const fs = require('fs-extra');
+const path = require('path');
+const storage = require('../storage');
+
+const DATA_DIR = storage.DATA_DIR;
+const SETTINGS_FILE = path.join(DATA_DIR, 'settings.json');
+
+fs.ensureDirSync(DATA_DIR);
+
+const DEFAULT_SETTINGS = {
+  interfaceParamMatcherEnabled: true,
+  responseParamMatcherEnabled: true,
+};
+
+const getSettings = () => {
+  try {
+    if (!fs.existsSync(SETTINGS_FILE)) return { ...DEFAULT_SETTINGS };
+    return { ...DEFAULT_SETTINGS, ...fs.readJsonSync(SETTINGS_FILE) };
+  } catch (err) {
+    return { ...DEFAULT_SETTINGS };
+  }
+};
+
+const saveSettings = (settings) => {
+  fs.writeJsonSync(SETTINGS_FILE, settings, { spaces: 2 });
+};
+
+const initRouter = () => {
+  const router = express.Router();
+  router.use(express.json());
+
+  router.get('/settings', (req, res) => {
+    res.json(getSettings());
+  });
+
+  router.put('/settings', (req, res) => {
+    try {
+      const current = getSettings();
+      const updated = { ...current, ...req.body };
+      saveSettings(updated);
+      res.json(updated);
+    } catch (err) {
+      res.status(500).json({ error: '保存设置失败' });
+    }
+  });
+
+  return router;
+};
+
+module.exports = { initRouter, getSettings };

package/lib/ruleManager.js

@@ -1,7 +1,24 @@
 const fs = require('fs');
+const fse = require('fs-extra');
 const path = require('path');
 const url = require('url');
 const Mock = require('mockjs');
+const storage = require('./storage');
+
+const SETTINGS_FILE = path.join(storage.DATA_DIR, 'settings.json');
+
+const getSettings = () => {
+  try {
+    if (!fse.existsSync(SETTINGS_FILE)) return { interfaceParamMatcherEnabled: true, responseParamMatcherEnabled: true };
+    const s = fse.readJsonSync(SETTINGS_FILE);
+    return {
+      interfaceParamMatcherEnabled: s.interfaceParamMatcherEnabled !== false,
+      responseParamMatcherEnabled: s.responseParamMatcherEnabled !== false,
+    };
+  } catch (e) {
+    return { interfaceParamMatcherEnabled: true, responseParamMatcherEnabled: true };
+  }
+};
 
 // 获取嵌套对象属性值的工具函数
 const getNestedValue = (obj, path) => {
@@ -268,29 +285,34 @@ const ruleManager = {
       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匹配但参数不匹配，继续查找...`);
+    // 在URL匹配的接口中，查找参数也匹配的接口（受接口入参匹配开关控制）
+    const settings = getSettings();
+    if (settings.interfaceParamMatcherEnabled) {
+      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;
+      }
+
+      this.log(`[规则处理器] 所有URL匹配的接口都有参数匹配规则且都不满足，未找到合适的接口`);
+      return null;
+    } else {
+      this.log('[规则处理器] 接口入参匹配已关闭，直接返回第一个URL匹配的接口');
+      return urlMatchedInterfaces[0];
     }
-    
-    // 如果没有参数匹配的接口，返回第一个没有参数匹配规则的接口
-    const fallbackInterface = urlMatchedInterfaces.find(intf => 
-      !intf.paramMatchers || !Array.isArray(intf.paramMatchers) || intf.paramMatchers.length === 0
-    );
-    
-    if (fallbackInterface) {
-      this.log(`[规则处理器] 使用回退接口: ${fallbackInterface.name} (无参数匹配规则)`);
-      return fallbackInterface;
-    }
-    
-    this.log(`[规则处理器] 所有URL匹配的接口都有参数匹配规则且都不满足，未找到合适的接口`);
-    return null;
   },
 
   /**
@@ -437,9 +459,9 @@ const ruleManager = {
         }
       }
       
-      // 对于有多个响应的接口，添加当前响应标识
-      if (config.responses && config.activeResponseId) {
-        const activeResponse = config.responses.find(r => r.id === config.activeResponseId);
+      // 对于有多个响应的接口，添加当前响应标识（优先展示实际命中的响应，在 handleDataTemplate 前此处只能用 activeResponseId 作为预估）
+      if (config.responses && config.responses.length > 0) {
+        const activeResponse = config.responses.find(r => r.id === config.activeResponseId) || config.responses[0];
         if (activeResponse && activeResponse.name) {
           res.setHeader('X-Whistle-Mock-Response', activeResponse.name);
         }
@@ -751,18 +773,63 @@ const ruleManager = {
     
     // 支持多响应系统
     let template = '';
+    let hitResponse = null;
     
     // 检查是否有多响应配置
     if (config.responses && Array.isArray(config.responses) && config.responses.length > 0) {
-      // 获取当前激活的响应
-      const activeResponseId = config.activeResponseId;
-      const activeResponse = activeResponseId 
-        ? config.responses.find(r => r.id === activeResponseId)
-        : config.responses[0];
-      
-      if (activeResponse) {
-        this.log(`[规则处理器] 使用响应: ${activeResponse.name || '未命名'}`);
-        template = activeResponse.content;
+      let selectedResponse = null;
+      const settings = getSettings();
+
+      // 1. 优先检查接口级 paramMatchers 中带 targetResponseId 的规则（受开关控制）
+      if (settings.interfaceParamMatcherEnabled) {
+        const interfaceMatchers = config.paramMatchers;
+        if (interfaceMatchers && Array.isArray(interfaceMatchers) && interfaceMatchers.length > 0) {
+          for (const matcher of interfaceMatchers) {
+            if (!matcher.targetResponseId) continue;
+            if (isParamMatch(req, [matcher], this.log)) {
+              const target = config.responses.find(r => r.id === matcher.targetResponseId);
+              if (target) {
+                selectedResponse = target;
+                this.log(`[规则处理器] 接口级规则指定响应匹配成功，使用响应: ${target.name || '未命名'}`);
+                break;
+              }
+            }
+          }
+        }
+      } else {
+        this.log('[规则处理器] 接口入参匹配已关闭，跳过接口级匹配');
+      }
+
+      // 2. 按顺序查找第一个响应级入参匹配的响应（受开关控制）
+      if (!selectedResponse) {
+        if (settings.responseParamMatcherEnabled) {
+          for (const resp of config.responses) {
+            if (resp.paramMatchers && Array.isArray(resp.paramMatchers) && resp.paramMatchers.length > 0) {
+              if (isParamMatch(req, resp.paramMatchers, this.log)) {
+                selectedResponse = resp;
+                this.log(`[规则处理器] 响应级入参匹配成功，使用响应: ${resp.name || '未命名'}`);
+                break;
+              } else {
+                this.log(`[规则处理器] 响应 "${resp.name || '未命名'}" 入参不匹配，继续检查下一个`);
+              }
+            }
+          }
+        } else {
+          this.log('[规则处理器] 响应入参匹配已关闭，跳过响应级匹配');
+        }
+      }
+
+      // 3. 无匹配则回退到 activeResponseId 指定的默认响应
+      if (!selectedResponse) {
+        const activeResponseId = config.activeResponseId;
+        selectedResponse = (activeResponseId && config.responses.find(r => r.id === activeResponseId))
+          || config.responses[0];
+        this.log(`[规则处理器] 无响应级匹配，使用默认响应: ${selectedResponse ? (selectedResponse.name || '未命名') : '无'}`);
+      }
+
+      if (selectedResponse) {
+        hitResponse = selectedResponse;
+        template = selectedResponse.content;
       }
     }
     
@@ -790,11 +857,10 @@ const ruleManager = {
       const enableMockHeaders = process.env.WHISTLE_MOCK_HEADERS !== 'false';
       if (enableMockHeaders) {
         res.setHeader('X-Whistle-Mock-Data-Type', 'template');
-        if (config.responses && config.activeResponseId) {
-          const activeResponse = config.responses.find(r => r.id === config.activeResponseId);
-          if (activeResponse) {
-            res.setHeader('X-Whistle-Mock-Template', activeResponse.name || 'unnamed');
-          }
+        if (hitResponse) {
+          res.setHeader('X-Whistle-Mock-Template', hitResponse.name || 'unnamed');
+          // 覆盖 processRequest 中预设的响应头，确保反映实际命中的响应
+          res.setHeader('X-Whistle-Mock-Response', hitResponse.name || 'unnamed');
         }
       }
       
@@ -807,9 +873,7 @@ const ruleManager = {
         mockInfo: {
           delay: parseInt(config.responseDelay || config.delay || 0, 10),
           timestamp: new Date().toISOString(),
-          responseName: config.responses && config.activeResponseId 
-            ? (config.responses.find(r => r.id === config.activeResponseId)?.name || '未命名')
-            : '默认响应'
+          responseName: hitResponse ? (hitResponse.name || '未命名') : '默认响应'
         }
       };
     } catch (err) {

package/lib/server.js

@@ -270,6 +270,10 @@ const app = express();
 app.use(express.json({limit: '100mb'}));
 app.use(express.urlencoded({ extended: true, limit: '100mb'}));
 
+// 注册设置路由
+const settingsRouter = require('./routes/settings');
+app.use('/api', settingsRouter.initRouter());
+
 // 加载功能和接口配置
 const loadConfigurations = () => {
   try {

package/package.json

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

package/ui/src/components/interface-management/DataManagementDrawer.js

@@ -0,0 +1,115 @@
+import React, { useEffect, useState } from 'react';
+import { Drawer, Form, Input, message, Button, Space } from 'antd';
+import axios from 'axios';
+import { ResponseContentEditor, PreviewModal, formatResponseContent, refreshCacheAfterUpdate } from '.';
+
+const DataManagementDrawer = ({ visible, onCancel, interfaceItem, onSaved }) => {
+  const [form] = Form.useForm();
+  const [previewVisible, setPreviewVisible] = useState(false);
+  const [previewContent, setPreviewContent] = useState(null);
+
+  useEffect(() => {
+    if (visible && interfaceItem) {
+      let responses = Array.isArray(interfaceItem.responses) ? interfaceItem.responses : [];
+      let activeResponseId = interfaceItem.activeResponseId || (responses[0] && responses[0].id) || '';
+      form.setFieldsValue({ responses, activeResponseId });
+    }
+  }, [visible, interfaceItem]);
+
+  const handlePreview = () => {
+    const values = form.getFieldsValue(true);
+    const responses = Array.isArray(values.responses) ? values.responses : [];
+    const activeResponse = responses.find(r => r.id === values.activeResponseId) || responses[0];
+    if (!activeResponse) {
+      message.error('未找到有效的响应内容');
+      return;
+    }
+    const contentType = 'application/json; charset=utf-8';
+    const formatted = formatResponseContent(activeResponse.content || '', contentType);
+    setPreviewContent({ title: `预览: ${activeResponse.name || '未命名响应'}`, content: formatted, contentType, description: '' });
+    setPreviewVisible(true);
+  };
+
+  const handleOk = async () => {
+    try {
+      await form.validateFields();
+      const values = form.getFieldsValue(true);
+      const payload = {
+        responses: Array.isArray(values.responses) ? values.responses : [],
+        activeResponseId: values.activeResponseId || (values.responses && values.responses[0] && values.responses[0].id) || ''
+      };
+      if (!interfaceItem || !interfaceItem.id) {
+        message.error('缺少接口ID，无法保存');
+        return;
+      }
+      const res = await axios.patch(`/cgi-bin/interfaces/${interfaceItem.id}`, payload);
+      if (res.data && res.data.code === 0) {
+        message.success('保存成功');
+        await refreshCacheAfterUpdate();
+        if (onSaved) onSaved();
+        if (onCancel) onCancel();
+      } else {
+        throw new Error(res.data?.message || '保存失败');
+      }
+    } catch (err) {
+      if (err && err.errorFields) return; // 表单校验错误
+      console.error('保存失败', err);
+      message.error(err.response?.data?.message || err.message || '保存失败');
+    }
+  };
+
+  return (
+    <>
+      <Drawer
+        title="数据管理"
+        placement="right"
+        width={1040}
+        open={visible}
+        onClose={onCancel}
+        destroyOnClose
+        bodyStyle={{ paddingBottom: 80 }}
+        footer={
+          <div style={{ textAlign: 'right' }}>
+            <Space>
+              <Button onClick={onCancel}>取消</Button>
+              <Button type="primary" onClick={handleOk}>保存</Button>
+            </Space>
+          </div>
+        }
+      >
+        <Form form={form} layout="vertical" initialValues={{ responses: [], activeResponseId: '' }}>
+          <Form.Item name="responses" hidden>
+            <Input />
+          </Form.Item>
+          <Form.Item name="activeResponseId" hidden>
+            <Input />
+          </Form.Item>
+          <Form.Item noStyle shouldUpdate>
+            {({ getFieldValue }) => {
+              const responses = getFieldValue('responses') || [];
+              const activeResponseId = getFieldValue('activeResponseId') || (responses[0] && responses[0].id) || '';
+              return (
+                <ResponseContentEditor
+                  form={form}
+                  responses={responses}
+                  activeResponseId={activeResponseId}
+                  onPreview={handlePreview}
+                  enableSorting={true}
+                />
+              );
+            }}
+          </Form.Item>
+        </Form>
+      </Drawer>
+
+      <PreviewModal
+        visible={previewVisible}
+        onCancel={() => setPreviewVisible(false)}
+        previewContent={previewContent}
+      />
+    </>
+  );
+};
+
+export default DataManagementDrawer;
+