whistle.mock-plugins 1.0.2 → 1.0.4

package/lib/dataManager.js

@@ -71,6 +71,12 @@ const dataManager = {
    */
   logRequest(logData) {
     try {
+      // 首先检查参数是否有效，避免不必要的文件操作
+      if (!logData || typeof logData !== 'object') {
+        this.log(`记录请求日志失败: 无效的日志数据`);
+        return false;
+      }
+      
       // 确保日志文件存在
       if (!fs.existsSync(this.logsFile)) {
         fs.writeJsonSync(this.logsFile, { logs: [] }, { spaces: 2 });

package/lib/ruleManager.js

@@ -105,8 +105,19 @@ const ruleManager = {
       return null;
     }
     
-    // 先尝试完全匹配
+    // 防止空路径
+    if (!requestPath) {
+      this.log(`[规则处理器] 错误: 请求路径为空`);
+      return null;
+    }
+    
+    // 先尝试完全匹配，效率更高
     let matchedInterface = interfaces.find(intf => {
+      // 检查接口对象是否有效
+      if (!intf || !intf.urlPattern) {
+        return false;
+      }
+      
       // 检查URL和方法是否匹配
       const urlMatches = intf.urlPattern === requestPath;
       
@@ -130,38 +141,59 @@ const ruleManager = {
     // 如果没有完全匹配，尝试正则表达式匹配
     this.log(`[规则处理器] 未找到完全匹配，尝试正则表达式匹配...`);
     
-    matchedInterface = interfaces.find(intf => {
-      try {
-        // 将通配符转换为正则表达式
-        const pattern = this.convertPatternToRegex(intf.urlPattern);
-        const regex = new RegExp(pattern);
-        
-        // 获取方法值，兼容不同的字段名
-        const methodField = intf.httpMethod || intf.method;
-        const methodValue = methodField && methodField.toUpperCase();
-        
-        // 只记录尝试匹配的模式，不记录详细过程
-        this.log(`[规则处理器] 尝试正则匹配，测试 ${interfaces.length} 个模式`);
-        
-        // 检查URL和方法是否匹配
-        const urlMatches = regex.test(requestPath);
-        const methodMatches = !methodValue || 
-                              methodValue === 'ALL' || 
-                              methodValue === 'ANY' || 
-                              methodValue === method;
-        
-        // 移除中间匹配过程的日志
-        return urlMatches && methodMatches;
-      } catch (err) {
-        this.log(`[规则处理器] 无效的URL模式: ${intf.urlPattern}, 错误: ${err.message}`);
-        return false;
-      }
-    });
+    // 使用正则表达式缓存优化性能
+    if (!this.regexCache) {
+      this.regexCache = new Map();
+    }
     
+    try {
+      matchedInterface = interfaces.find(intf => {
+        try {
+          // 验证接口对象
+          if (!intf || !intf.urlPattern) {
+            return false;
+          }
+          
+          // 从缓存获取或创建正则表达式
+          let regex;
+          if (this.regexCache.has(intf.urlPattern)) {
+            regex = this.regexCache.get(intf.urlPattern);
+          } else {
+            // 将通配符转换为正则表达式
+            const pattern = this.convertPatternToRegex(intf.urlPattern);
+            regex = new RegExp(pattern);
+            // 缓存正则表达式，避免重复创建
+            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;
+        } catch (err) {
+          // 记录特定接口的错误，但继续处理其他接口
+          this.log(`[规则处理器] 匹配接口 ${intf?.name || 'unknown'} 时出错: ${err.message}`);
+          return false;
+        }
+      });
+    } catch (err) {
+      // 记录整体匹配过程的错误
+      this.log(`[规则处理器] 正则匹配过程出错: ${err.message}`);
+      return null;
+    }
+
     if (matchedInterface) {
-      this.log(`[规则处理器] 找到模式匹配的接口: ${matchedInterface.name}`);
+      this.log(`[规则处理器] 找到正则匹配的接口: ${matchedInterface.name}`);
     } else {
-      this.log(`[规则处理器] 未找到任何匹配的接口`);
+      this.log(`[规则处理器] 未找到匹配的接口`);
     }
     
     return matchedInterface;

package/lib/rules-server.js

@@ -115,10 +115,25 @@ const loadInterfaces = () => {
 };
 
 // 匹配URL是否符合模式
-const isUrlMatch = (url, pattern) => {
+const isUrlMatch = (url, pattern, proxyType, fullUrl) => {
   if (!pattern) return false;
 
   try {
+    // 针对不同的代理类型采用不同的匹配策略
+    
+    // 对于url_redirect类型，需要完全匹配fullPath才命中
+    if (proxyType === 'url_redirect') {
+      // 精确匹配完整路径
+      return pattern === fullUrl;
+    }
+    
+    // 对于redirect类型，只要url以pattern开头即可命中（前缀匹配）
+    if (proxyType === 'redirect') {
+      return fullUrl.indexOf(pattern) === 0;
+    }
+    
+    // 以下是默认的匹配逻辑（用于response类型等）
+    
     // 精确匹配
     if (pattern === url) {
       return true;
@@ -148,6 +163,35 @@ const isUrlMatch = (url, pattern) => {
   return false;
 };
 
+// 验证目标URL是否有效
+const isValidTargetUrl = (url) => {
+  if (!url) return false;
+  
+  try {
+    // 检查是否是合法的URL格式
+    new URL(url);
+    return true;
+  } catch (e) {
+    log(`URL验证错误: ${e.message}`);
+    return false;
+  }
+};
+
+// 验证重定向规则的有效性
+const validateRedirectRule = (interface) => {
+  if (!interface) return false;
+  
+  const { proxyType, targetUrl } = interface;
+  
+  // 对于redirect和url_redirect类型，必须有有效的目标URL
+  if ((proxyType === 'redirect' || proxyType === 'url_redirect') && !isValidTargetUrl(targetUrl)) {
+    log(`接口 ${interface.id || interface.name || '未知'} 的目标URL无效: ${targetUrl}`);
+    return false;
+  }
+  
+  return true;
+};
+
 // Whistle 规则服务器实现
 module.exports = (server, options) => {
   server.on('request', (req, res) => {
@@ -220,21 +264,22 @@ module.exports = (server, options) => {
     const matchedInterface = enabledInterfaces.find(intf => {
       // 获取URL模式
       const pattern = intf.urlPattern || '';
+      const proxyType = intf.proxyType || 'response';
       
       if (!pattern) {
         log(`接口 ${intf.id || intf.name || '未知'} 缺少URL模式`);
         return false;
       }
       
-      // 检查URL模式匹配
-      const urlMatches = isUrlMatch(path, pattern);
+      // 检查URL模式匹配，根据proxyType选择适当的匹配策略
+      const urlMatches = isUrlMatch(path, pattern, proxyType, fullUrl);
       
       if (!urlMatches) {
         // 不记录每个失败的匹配，以减少日志量
         return false;
       }
       
-      log(`URL模式匹配成功: ${path} 匹配 ${pattern}`);
+      log(`URL模式匹配成功: ${fullUrl} 匹配 ${pattern} (${proxyType}模式)`);
       
       // 检查HTTP方法匹配
       const methodField = intf.httpMethod || intf.method || '';
@@ -254,9 +299,85 @@ module.exports = (server, options) => {
       return true;
     });
     
-    // 如果找到匹配的接口，返回对应的规则将请求转发到插件
+    // 如果找到匹配的接口，处理对应的规则
     if (matchedInterface) {
       log(`找到匹配接口 "${matchedInterface.name || matchedInterface.id || '未知'}" 用于 ${method} ${path}`);
+      
+      // 处理不同的代理类型
+      const proxyType = matchedInterface.proxyType || 'response';
+      
+      // 优先级判断：首先处理 response 类型
+      if (proxyType === 'response') {
+        // 返回指向插件服务的规则
+        log(`接口 "${matchedInterface.name}" 使用模拟响应模式`);
+        res.end(`${fullUrl} mock-plugins://`);
+        return;
+      }
+      
+      // 对于redirect和url_redirect类型，验证规则有效性
+      if ((proxyType === 'redirect' || proxyType === 'url_redirect') && !validateRedirectRule(matchedInterface)) {
+        log(`接口 "${matchedInterface.name}" 的重定向规则无效，跳过处理`);
+        res.end('');
+        return;
+      }
+      
+      // 处理 redirect 类型：将请求的 url 中的源 url 部分替换为目标 url
+      if (proxyType === 'redirect') {
+        const targetUrl = matchedInterface.targetUrl.trim();
+        const pattern = matchedInterface.urlPattern.trim();
+        log(`接口 "${matchedInterface.name}" 使用重定向模式，模式: ${pattern}, 目标URL: ${targetUrl}`);
+        
+        // 确保目标URL合法
+        if (!isValidTargetUrl(targetUrl)) {
+          log(`目标URL不合法: ${targetUrl}，跳过处理`);
+          res.end('');
+          return;
+        }
+        
+        // 执行重定向：将fullUrl中匹配的pattern替换为targetUrl
+        // 对于redirect类型，我们使用indexOf确认前缀匹配
+        if (fullUrl.indexOf(pattern) === 0) {
+          // 构建新的目标URL
+          const redirectUrl = fullUrl.replace(pattern, targetUrl);
+          
+          // 按照 whistle 规则格式返回重定向规则
+          res.end(`${fullUrl} ${redirectUrl}`);
+          log(`重定向规则: ${fullUrl} ${redirectUrl}`);
+          return;
+        } else {
+          log(`URL ${fullUrl} 不以 ${pattern} 开头，跳过处理`);
+          res.end('');
+          return;
+        }
+      }
+      
+      // 处理 url_redirect 类型：完全匹配 fullPath 并直接返回目标URL
+      if (proxyType === 'url_redirect') {
+        const targetUrl = matchedInterface.targetUrl.trim();
+        log(`接口 "${matchedInterface.name}" 使用URL重定向模式，目标URL: ${targetUrl}`);
+        
+        // 确保目标URL合法
+        if (!isValidTargetUrl(targetUrl)) {
+          log(`目标URL不合法: ${targetUrl}，跳过处理`);
+          res.end('');
+          return;
+        }
+        
+        // 对于url_redirect，我们需要完全匹配
+        if (fullUrl === matchedInterface.urlPattern) {
+          // 直接返回whistle规则
+          res.end(`${fullUrl} redirect://${targetUrl}`);
+          log(`URL重定向规则: ${fullUrl} redirect://${targetUrl}`);
+          return;
+        } else {
+          log(`URL ${fullUrl} 不完全匹配 ${matchedInterface.urlPattern}，跳过处理`);
+          res.end('');
+          return;
+        }
+      }
+      
+      // 默认情况下使用mock-plugins处理
+      log(`接口 "${matchedInterface.name}" 使用默认处理模式`);
       res.end(`${fullUrl} mock-plugins://`);
     } else {
       // 如果没有匹配的接口，返回空字符串，Whistle 会继续处理下一个规则

package/lib/server.js

@@ -43,6 +43,12 @@ const logMessage = (message) => {
 // 记录日志到 logs.json 文件
 const addToJsonLog = (logData) => {
   try {
+    // 验证参数有效性
+    if (!logData || typeof logData !== 'object') {
+      console.error('无效的日志数据');
+      return;
+    }
+    
     const logsFile = path.join(DATA_DIR, 'logs.json');
 
     // 确保日志文件存在
@@ -86,9 +92,9 @@ const addToJsonLog = (logData) => {
     // 添加新日志
     logsData.logs.unshift(newLog);
     
-    // 限制日志数量，最多保留10000条
-    if (logsData.logs.length > 10000) {
-      logsData.logs = logsData.logs.slice(0, 10000);
+    // 限制日志数量，最多保留5000条 (减少内存使用)
+    if (logsData.logs.length > 5000) {
+      logsData.logs = logsData.logs.slice(0, 5000);
     }
     
     fs.writeJsonSync(logsFile, logsData, { spaces: 2 });
@@ -643,6 +649,71 @@ const handleResponse = (interfaceItem, req, res) => {
         }
         break;
       
+      case 'redirect':
+        // 处理redirect - 完全重定向
+        const redirectUrl = interfaceItem.targetUrl || '';
+        logMessage(`重定向处理: ${req.url} -> ${redirectUrl}`);
+        // 这里不需要实际执行重定向，因为规则服务器已经返回了whistle规则
+        // 仅记录日志，并返回信息性消息
+        res.status(200).json({
+          code: 302,
+          message: '请求已被重定向到: ' + redirectUrl,
+          data: {
+            originalUrl: req.url,
+            targetUrl: redirectUrl,
+            mode: 'redirect'
+          }
+        });
+        
+        // 记录重定向日志
+        addToJsonLog({
+          eventType: 'redirect',
+          url: req.url,
+          method: req.method,
+          targetUrl: redirectUrl,
+          message: `请求被重定向: ${req.method} ${req.url} -> ${redirectUrl}`,
+          pattern: interfaceItem.urlPattern
+        });
+        break;
+        
+      case 'url_redirect':
+        // 处理url_redirect - URL重定向，保留查询参数
+        const baseUrl = interfaceItem.targetUrl || '';
+        // 提取原始URL的查询参数，实际重定向在规则服务器中处理
+        const reqUrl = req.url || '';
+        let finalRedirectUrl = baseUrl;
+        
+        if (req.url.includes('?')) {
+          const queryStr = req.url.split('?')[1];
+          finalRedirectUrl = baseUrl.includes('?') 
+            ? `${baseUrl}&${queryStr}` 
+            : `${baseUrl}?${queryStr}`;
+        }
+        
+        logMessage(`URL重定向处理: ${req.url} -> ${finalRedirectUrl}`);
+        
+        // 返回信息性消息
+        res.status(200).json({
+          code: 302,
+          message: '请求已被URL重定向到: ' + finalRedirectUrl,
+          data: {
+            originalUrl: req.url,
+            targetUrl: finalRedirectUrl,
+            mode: 'url_redirect'
+          }
+        });
+        
+        // 记录URL重定向日志
+        addToJsonLog({
+          eventType: 'url_redirect',
+          url: req.url,
+          method: req.method,
+          targetUrl: finalRedirectUrl,
+          message: `请求被URL重定向: ${req.method} ${req.url} -> ${finalRedirectUrl}`,
+          pattern: interfaceItem.urlPattern
+        });
+        break;
+      
     case 'url':
       // URL重定向 - 实际场景中这需要代理到目标URL
       logMessage(`URL重定向: ${req.url} -> ${interfaceItem.targetUrl}`);

package/package.json

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

package/rules.txt

@@ -3,7 +3,7 @@
 
 # ===== 基本规则配置 =====
 # 在 Whistle 的规则配置中，使用以下格式添加规则：
-* mock-plugins://
+* whistle.mock-plugins://
 
 # 该插件现在会自动匹配已配置的接口规则，对于没有在插件中配置的接口，不会进行拦截