whistle.mockbubu 2.0.0 → 2.1.1

package/lib/core/server-entry/capture-handler.js

@@ -0,0 +1,191 @@
+/**
+ * 文件名: capture-handler.js
+ * 功能: 源数据捕获逻辑
+ * 职责:
+ * - 捕获真实 API 响应数据
+ * - 处理响应体解压缩
+ * - 保存源数据到存储 (file.json)
+ * - 更新文件配置
+ * - 并发控制
+ */
+
+const {
+  setApiListUpdated,
+  handleBuffer2String,
+  withTryCatch,
+} = require('../../utils/utils')
+
+/**
+ * 捕获真实 API 响应数据
+ *
+ * @param {Object} params - 参数对象
+ * @param {Object} params.req - Whistle 请求对象
+ * @param {Object} params.res - Whistle 响应对象
+ * @param {Object} params.storageAdapter - 存储适配器
+ * @param {Object} params.groupManager - 组管理器
+ * @param {Object} params.memoryBuffer - 内存缓冲区
+ * @param {string} params.currentGroupId - 当前组ID
+ * @param {string} params.filename - 文件名
+ * @param {boolean} params.isFirstCapture - 是否首次捕获
+ * @param {boolean} params.mock - Mock 状态
+ * @param {Object} params.requestInfo - 请求信息 { method, rule, pattern, ruleValue, url }
+ * @param {Map} params.capturingFiles - 捕获中的文件 Map
+ * @param {Object} params.storage - Whistle storage 对象
+ */
+async function captureResponse(params) {
+  const {
+    req,
+    res,
+    storageAdapter,
+    groupManager,
+    memoryBuffer,
+    currentGroupId,
+    filename,
+    isFirstCapture,
+    mock,
+    requestInfo,
+    capturingFiles,
+    storage,
+  } = params
+
+  const { method, rule, pattern, ruleValue, url } = requestInfo
+  const captureKey = `${currentGroupId}/${filename}`
+
+  console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] 🚀 captureResponse 函数开始执行: ${filename}`)
+
+  // 设置捕获标志
+  let resolveCapture
+  const capturePromise = new Promise(resolve => { resolveCapture = resolve })
+  capturingFiles.set(captureKey, capturePromise)
+
+  console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] 🌐 准备调用 req.request(): ${filename}`)
+
+  // 发起真实请求
+  const client = req.request((svrRes) => {
+    console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] 🔵 req.request 回调已执行: ${filename}`)
+    const encoding = svrRes.headers['content-encoding']
+    let body
+
+    svrRes.on('data', (data) => {
+      console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] 📥 接收数据块: ${filename}, 大小: ${data?.length || 0}`)
+      body = body ? Buffer.concat([body, data]) : data
+    })
+
+    svrRes.on('end', withTryCatch(async () => {
+      try {
+        if (!body) {
+          console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] ⚠️  响应体为空，跳过捕获: ${filename}`)
+          return
+        }
+
+        console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] 📦 响应接收完成，开始解压: ${filename}`)
+        // 解压响应体
+        const content = await handleBuffer2String({ body, encoding })
+        console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] ✅ 解压完成，调用 req.getSession(): ${filename}`)
+
+        // 获取完整的请求响应数据 (用于构建源数据)
+        req.getSession(async (session) => {
+          console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] 🔍 getSession 回调已触发: ${filename}`)
+          console.log('[mockbubu DEBUG] session.req.body存在:', !!session?.req?.body)
+          console.log('[mockbubu DEBUG] session.req.body类型:', typeof session?.req?.body)
+          if (session?.req?.body) {
+            console.log('[mockbubu DEBUG] session.req.body前200字符:', String(session.req.body).substring(0, 200))
+          }
+          try {
+            // 如果设置了 enable://hide 会获取到空数据
+            if (!session) {
+              console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] ⚠️  session 为空（可能设置了 enable://hide）: ${filename}`)
+              return
+            }
+
+            console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] 💾 开始保存源数据: ${filename}`)
+            // 保存源数据和文件配置
+            await saveSourceData({
+              session,
+              content,
+              storageAdapter,
+              groupManager,
+              memoryBuffer,
+              currentGroupId,
+              filename,
+              isFirstCapture,
+              mock,
+              method,
+              rule,
+              pattern,
+              ruleValue,
+              url,
+              storage,
+            })
+
+            console.log(`[mockbubu] ✅ 捕获完成: ${filename}`)
+          } finally {
+            // 捕获完成，清除标志并通知等待的请求
+            resolveCapture()
+            capturingFiles.delete(captureKey)
+          }
+        })
+      } catch (err) {
+        console.error(`[mockbubu] ❌ 捕获过程出错: ${filename}`, err)
+        // 出错也要清除标志
+        resolveCapture()
+        capturingFiles.delete(captureKey)
+      }
+    }))
+
+    // 将响应透传给客户端
+    svrRes.pipe(res)
+  })
+
+  console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] ✅ req.request() 已调用，准备 pipe 数据: ${filename}`)
+
+  req.pipe(client)
+
+  console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] ✅ req.pipe(client) 已完成: ${filename}`)
+}
+
+/**
+ * 保存源数据到内存缓冲区
+ *
+ * 职责：
+ * - 不写入文件系统（文件仅在用户点击"保存"时创建）
+ * - 将完整会话数据添加到内存缓冲区（供前端轮询拉取）
+ * - 刷新页面后，memoryBuffer 自动清空，未保存的数据消失
+ *
+ * @param {Object} params - 参数对象
+ */
+async function saveSourceData(params) {
+  const {
+    session,
+    content,
+    memoryBuffer,
+    currentGroupId,
+    url,
+    method,
+    storage,
+  } = params
+
+  // 1. 构建完整会话数据
+  const sourceDataToSave = JSON.parse(JSON.stringify(session))
+  sourceDataToSave.res.body = content
+
+  // 2. 添加到内存缓冲区（供前端轮询拉取）
+  // MemoryBuffer 内部会检查暂存区是否已存在，已存在则跳过
+  memoryBuffer.add(currentGroupId, url, {
+    method,
+    status: session.res.statusCode,
+    session: sourceDataToSave,
+  })
+
+  // 3. ⚠️ 不要在捕获时创建文件配置
+  //    只有用户明确点击"保存"按钮后，才会创建 file.json + versions/
+  //    捕获的数据仅保存在 memoryBuffer 中，刷新后自动清空
+
+  // 4. 标记 API 列表已更新
+  await setApiListUpdated(storage, true)
+}
+
+module.exports = {
+  captureResponse,
+  saveSourceData,
+}

package/lib/core/server-entry/request-interceptor.js

@@ -0,0 +1,82 @@
+/**
+ * 文件名: request-interceptor.js
+ * 功能: 请求拦截判断逻辑
+ * 职责:
+ * - 判断请求是否需要拦截
+ * - 判断是否为 JSON 请求
+ * - 检查插件工作模式
+ * - 收集生效规则
+ */
+
+const {
+  getFilename,
+  getRule,
+  isJsonReq,
+} = require('../../utils/utils')
+const ruleCollector = require('../../config/rule-collector')
+const { PLUGIN_MODE, DEFAULT_PLUGIN_MODE } = require('../../config/const')
+
+/**
+ * 检查插件是否启用（兼容函数）
+ * @param {Object} storage - Whistle storage 对象
+ * @returns {boolean}
+ * @deprecated 使用 getPluginMode 替代
+ */
+function isPluginEnabled(storage) {
+  // 任何模式都算"启用"
+  return true
+}
+
+/**
+ * 判断是否应该拦截该请求
+ * @param {Object} req - Whistle 请求对象
+ * @param {Object} storage - Whistle storage 对象
+ * @param {string} cachedMode - 缓存的插件模式 ('capture' | 'mock-only')
+ * @returns {Object} { shouldIntercept, filename, rule, reason, mode }
+ */
+function shouldInterceptRequest(req, storage, cachedMode = DEFAULT_PLUGIN_MODE) {
+  const { originalReq, method } = req
+  const { headers, ruleValue, pattern } = originalReq
+
+  // 1. 使用缓存的插件工作模式（避免异步读取）
+  const mode = cachedMode
+
+  // 2. 提取文件名和规则
+  const filename = getFilename(originalReq)
+  const rule = getRule(originalReq)
+
+  // 收集生效的规则（用于 UI 帮助提示）
+  ruleCollector.addRule(rule)
+
+  // 3. 判断是否为 JSON 请求
+  if (!isJsonReq(headers)) {
+    return {
+      shouldIntercept: false,
+      reason: 'not-json',
+      message: '非 JSON 请求',
+      filename,
+      rule,
+      headers,
+      mode,
+    }
+  }
+
+  // 4. 应该拦截
+  return {
+    shouldIntercept: true,
+    filename,
+    rule,
+    method,
+    url: filename, // 使用处理后的 filename 作为 url,确保与 filename 一致
+    pattern,
+    ruleValue,
+    headers,
+    mode, // 携带当前模式，供后续流程使用
+  }
+}
+
+module.exports = {
+  isPluginEnabled,
+  shouldInterceptRequest,
+  PLUGIN_MODE, // 导出模式常量
+}

package/lib/core/server-entry/response-handler.js

@@ -0,0 +1,147 @@
+/**
+ * 文件名: response-handler.js
+ * 功能: Mock 响应返回逻辑
+ * 职责:
+ * - 返回 Mock 数据 (源数据或版本数据)
+ * - 处理版本切换
+ * - 处理响应头
+ */
+
+/**
+ * 返回 Mock 响应数据
+ * @param {Object} res - Whistle 响应对象
+ * @param {string} sourceData - 源数据 (file.json 的字符串内容)
+ * @param {Object} options - 配置选项
+ * @param {string} options.mockVersion - Mock 版本名称 (null 表示使用源数据)
+ * @param {Object} options.groupManager - 组管理器实例
+ * @param {string} options.currentGroupId - 当前组ID
+ * @param {string} options.filename - 文件名
+ */
+async function sendMockResponse(res, sourceData, options = {}) {
+  const { mockVersion, groupManager, currentGroupId, filename } = options
+
+  // 解析源数据 (storageAdapter.readFile 返回的是 session 对象的 JSON 字符串)
+  const session = JSON.parse(sourceData)
+  const sourceResponse = session?.res
+  const { statusCode, statusMessage, headers } = sourceResponse
+
+  // 设置响应头标记 (来自 Mock)
+  headers['from-mockbubu-source'] = 'true'
+  headers['x-mockbubu-mocked'] = 'true'
+  delete headers['content-encoding']
+  delete headers['content-length']
+
+  res.writeHead(statusCode, statusMessage, headers)
+
+  // 检查是否需要使用版本数据 (用户编辑的 Mock 数据)
+  if (mockVersion && groupManager && currentGroupId && filename) {
+    const versionData = await groupManager.getGroupVersionContent(currentGroupId, filename, mockVersion)
+    if (versionData) {
+      // 返回版本数据
+      res.end(JSON.stringify(versionData))
+      return
+    }
+    // 版本不存在时降级到源数据
+  }
+
+  // 返回源数据 (原始捕获的响应体)
+  res.end(sourceResponse.body)
+}
+
+/**
+ * 检查是否需要捕获源数据
+ * 如果文件已存在配置，则透传；如果是首次访问，则需要捕获
+ *
+ * @param {Object} params
+ * @param {Object} params.storageAdapter - 存储适配器
+ * @param {Object} params.groupManager - 组管理器
+ * @param {string} params.currentGroupId - 当前组ID
+ * @param {string} params.filename - 文件名
+ * @returns {Promise<{shouldCapture: boolean, isFirstCapture: boolean}>}
+ */
+async function checkShouldCapture(params) {
+  const { storageAdapter, groupManager, currentGroupId, filename } = params
+
+  // 检查源数据文件是否已存在
+  const configKey = groupManager.getGroupConfigKey(currentGroupId, filename)
+  const hasConfig = await storageAdapter.hasFileInIndex(configKey)
+
+  if (hasConfig) {
+    // 源数据已存在，不需要重复捕获
+    console.log(`[mockbubu] ⏭️  源数据已存在，跳过捕获并透传: ${filename}`)
+    return {
+      shouldCapture: false,
+      isFirstCapture: false,
+    }
+  } else {
+    // 源数据不存在 - 首次捕获
+    console.log(`[mockbubu] 🎣 首次捕获源数据: ${filename}`)
+    return {
+      shouldCapture: true,
+      isFirstCapture: true,
+    }
+  }
+}
+
+/**
+ * 处理并发捕获时的等待逻辑
+ * @param {Map} capturingFiles - 捕获中的文件 Map
+ * @param {string} captureKey - 捕获 key
+ * @param {Object} params - 参数对象
+ * @returns {Promise<Object>} { handled, response }
+ */
+async function handleConcurrentCapture(capturingFiles, captureKey, params) {
+  const {
+    res,
+    storageAdapter,
+    groupManager,
+    currentGroupId,
+    filename,
+    mockVersion,
+    filePath,
+  } = params
+
+  if (!capturingFiles.has(captureKey)) {
+    return { handled: false }
+  }
+
+  // 正在捕获源数据中，等待捕获完成
+  console.log(`[mockbubu] ⏳ 检测到并发请求，等待源数据捕获完成: ${filename}`)
+
+  try {
+    // 等待第一个请求捕获完成（最多等待10秒）
+    await Promise.race([
+      capturingFiles.get(captureKey),
+      new Promise((_resolve, reject) => setTimeout(() => reject(new Error('捕获超时')), 10000)),
+    ])
+
+    // 捕获完成，重新读取源数据
+    const freshSourceData = await storageAdapter.readFile(filePath)
+    if (freshSourceData) {
+      console.log(`[mockbubu] ✅ 等待成功，返回捕获的源数据: ${filename}`)
+
+      await sendMockResponse(res, freshSourceData, {
+        mockVersion,
+        groupManager,
+        currentGroupId,
+        filename,
+      })
+
+      return { handled: true, response: 'success' }
+    } else {
+      // 等待后仍无源数据，降级到透传
+      console.warn(`[mockbubu] ⚠️  等待后仍无源数据，降级透传: ${filename}`)
+      return { handled: true, response: 'passthrough' }
+    }
+  } catch (err) {
+    // 等待超时或失败，降级到透传
+    console.error(`[mockbubu] ❌ 等待捕获失败，降级透传: ${filename}`, err.message)
+    return { handled: true, response: 'passthrough' }
+  }
+}
+
+module.exports = {
+  sendMockResponse,
+  checkShouldCapture,
+  handleConcurrentCapture,
+}

package/lib/core/server-entry/server.js

@@ -0,0 +1,230 @@
+/**
+ * 文件名: server.js
+ * 功能: Whistle 插件主入口（请求拦截钩子）
+ * 职责:
+ * - 初始化存储和组管理器
+ * - 协调请求拦截、响应返回、数据捕获等模块
+ * - 处理请求生命周期
+ */
+
+const GroupManager = require('../../storage/group-manager')
+const StorageAdapter = require('../../storage/storage-adapter')
+const memoryBuffer = require('../memory-buffer/shared-instance')
+const {
+  shouldInterceptRequest,
+  PLUGIN_MODE,
+} = require('./request-interceptor')
+const {
+  sendMockResponse,
+  checkShouldCapture,
+  handleConcurrentCapture,
+} = require('./response-handler')
+const {
+  captureResponse,
+} = require('./capture-handler')
+const pluginModeManager = require('../plugin-mode-manager')
+
+module.exports = (server, options) => {
+  console.log('[mockbubu] 🚀 server.js 模块已加载!')
+  const { storage } = options
+
+  // 使用 StorageAdapter 包装 Whistle storage
+  const actualBaseDir = options.config.baseDir
+  const storageAdapter = new StorageAdapter({ baseDir: actualBaseDir })
+
+  // 初始化组管理器（使用适配器）
+  const groupManager = new GroupManager(storageAdapter)
+
+  // 并发捕获控制
+  // Key: `${groupId}/${filename}`, Value: Promise (捕获完成时 resolve)
+  const capturingFiles = new Map()
+
+  // 同步初始化：确保初始化完成后再处理请求
+  let isInitialized = false
+  storageAdapter.init().then(async () => {
+    console.log('[mockbubu] ✅ V3 Storage 初始化完成')
+    // 确保默认组存在
+    await groupManager.ensureDefaultGroup()
+    // 初始化模式管理器
+    await pluginModeManager.init(storage)
+    isInitialized = true
+  }).catch(err => {
+    console.error('[mockbubu] ❌ V3 Storage 初始化失败:', err)
+    isInitialized = true // 即使失败也标记为已初始化,避免阻塞
+  })
+
+  server.on('request', async (req, res) => {
+    // 等待初始化完成
+    // eslint-disable-next-line no-unmodified-loop-condition
+    while (!isInitialized) {
+      await new Promise(resolve => setTimeout(resolve, 100))
+    }
+
+    // 判断是否需要拦截该请求（使用模式管理器获取当前模式）
+    const interceptResult = shouldInterceptRequest(req, storage, pluginModeManager.getMode())
+
+    // 不需要拦截，直接透传
+    if (!interceptResult.shouldIntercept) {
+      if (interceptResult.reason === 'not-json') {
+        console.log(`[mockbubu] ⏭️  非 JSON 请求已跳过 | File: ${interceptResult.filename}`)
+        console.log(`[mockbubu] 📋 Headers: Accept=${interceptResult.headers.accept}, Sec-Fetch-Dest=${interceptResult.headers['sec-fetch-dest'] || interceptResult.headers['Sec-Fetch-Dest']}`)
+      }
+      return req.passThrough()
+    }
+
+    // 提取请求信息
+    const { filename, rule, method, url, pattern, ruleValue, mode } = interceptResult
+
+    try {
+      // 获取当前激活的组ID和文件配置
+      const currentGroupId = await groupManager.getCurrentGroupId()
+      const fileConfig = await groupManager.getGroupFileConfig(currentGroupId, filename)
+      const { mock, mockVersion } = fileConfig
+
+      // 从组目录读取源数据文件 (file.json)
+      const filePath = `${currentGroupId}/${filename}`
+      const sourceData = await storageAdapter.readFile(filePath)
+
+      // ⚠️ Mock-Only 模式特殊处理
+      if (mode === PLUGIN_MODE.MOCK_ONLY) {
+        // 如果没有开启 mock → 透传（不拦截，不捕获）
+        if (!mock) {
+          console.log(`[mockbubu] ⏭️  Mock-Only 模式: 文件未开启 Mock，透传 | URL: ${url}`)
+          return req.passThrough()
+        }
+
+        // 如果有 mock 但无数据 → 透传（不拦截，不捕获）
+        if (!sourceData) {
+          console.log(`[mockbubu] ⏭️  Mock-Only 模式: 文件无数据，透传 | URL: ${url}`)
+          return req.passThrough()
+        }
+
+        // 有 mock 且有数据 → 返回 mock（不捕获）
+        console.log(`[mockbubu] ✅ Mock-Only 模式: 返回 Mock 数据（不捕获） | URL: ${url}`)
+        return await sendMockResponse(res, sourceData, {
+          mockVersion,
+          groupManager,
+          currentGroupId,
+          filename,
+        })
+      }
+
+      // 以下是 Capture 模式的逻辑
+      console.log(`[mockbubu] 🎯 Capture 模式: JSON 请求,开始捕获 | URL: ${url}`)
+
+      // 场景 1: Mock 启用 + 有源数据 → 返回 Mock 数据
+      if (mock && sourceData) {
+        return await sendMockResponse(res, sourceData, {
+          mockVersion,
+          groupManager,
+          currentGroupId,
+          filename,
+        })
+      }
+
+      // 场景 2: Mock 启用 + 无源数据 → 容错恢复（自动捕获源数据）
+      // 可能原因：文件被删除、索引损坏、组导入不完整等
+      if (mock && !sourceData) {
+        const captureKey = `${currentGroupId}/${filename}`
+
+        // 检查文件是否已存在
+        const { shouldCapture, isFirstCapture } = await checkShouldCapture({
+          storageAdapter,
+          groupManager,
+          currentGroupId,
+          filename,
+        })
+
+        if (!shouldCapture) {
+          // 文件已存在，直接透传
+          return req.passThrough()
+        }
+
+        // 处理并发捕获
+        const concurrentResult = await handleConcurrentCapture(capturingFiles, captureKey, {
+          res,
+          storageAdapter,
+          groupManager,
+          currentGroupId,
+          filename,
+          mockVersion,
+          filePath,
+        })
+
+        if (concurrentResult.handled) {
+          if (concurrentResult.response === 'passthrough') {
+            return req.passThrough()
+          }
+          return // 已经返回响应
+        }
+
+        // 发起捕获
+        return await captureResponse({
+          req,
+          res,
+          storageAdapter,
+          groupManager,
+          memoryBuffer,
+          currentGroupId,
+          filename,
+          isFirstCapture,
+          mock: true, // mock 状态
+          requestInfo: { method, rule, pattern, ruleValue, url },
+          capturingFiles,
+          storage,
+        })
+      }
+
+      // 场景 3: Mock 未启用
+      if (!mock) {
+        // 3.1: 有源数据 → 直接透传
+        if (sourceData) {
+          return req.passThrough()
+        }
+
+        // 3.2: 无源数据 → 检查是否需要捕获
+        const captureKey = `${currentGroupId}/${filename}`
+
+        // 检查文件是否已存在
+        const { shouldCapture, isFirstCapture } = await checkShouldCapture({
+          storageAdapter,
+          groupManager,
+          currentGroupId,
+          filename,
+        })
+
+        if (!shouldCapture) {
+          // 文件已存在，直接透传
+          console.log(`[mockbubu] ⏭️  文件已存在（mock=false），跳过捕获并透传: ${filename}`)
+          return req.passThrough()
+        }
+
+        // 检查是否正在捕获中
+        if (capturingFiles.has(captureKey)) {
+          // mock=false 时，并发请求直接透传（不等待）
+          console.log(`[mockbubu] ⏳ 检测到并发请求（mock=false），直接透传: ${filename}`)
+          return req.passThrough()
+        }
+
+        // 发起捕获
+        return await captureResponse({
+          req,
+          res,
+          storageAdapter,
+          groupManager,
+          memoryBuffer,
+          currentGroupId,
+          filename,
+          isFirstCapture,
+          mock: false, // mock 状态
+          requestInfo: { method, rule, pattern, ruleValue, url },
+          capturingFiles,
+          storage,
+        })
+      }
+    } catch (error) {
+      console.error('[mockbubu] ❌ 请求处理失败:', error)
+      req.passThrough()
+    }
+  })
+}