whistle.mockbubu 2.2.7 → 2.2.9-beta.1

package/lib/core/shared/initializers.js

@@ -0,0 +1,93 @@
+/**
+ * 文件名: initializers.js
+ * 功能: 钩子共享初始化器（共用模块）
+ * 职责:
+ * - 创建并缓存 StorageAdapter / GroupManager
+ * - 初始化 pluginModeManager 单例
+ * - 保证幂等：多个钩子（server / resWrite）调用只初始化一次
+ *
+ * 设计说明:
+ * - memoryBuffer 与 pluginModeManager 本身是单例，直接复用
+ * - storageAdapter / groupManager 按 storage 引用缓存，避免重复创建
+ */
+
+const GroupManager = require('../../storage/group-manager')
+const StorageAdapter = require('../../storage/storage-adapter')
+const memoryBuffer = require('../memory-buffer/shared-instance')
+const pluginModeManager = require('../plugin-mode-manager')
+
+// 按 storage 引用缓存初始化结果，保证幂等
+const cache = new WeakMap()
+
+/**
+ * 获取共享实例（未初始化时返回 undefined）
+ * @param {Object} options - Whistle 钩子 options
+ * @returns {Object} { storageAdapter, groupManager, memoryBuffer, pluginModeManager, storage }
+ */
+function getShared(options) {
+  const storage = options && options.storage
+  if (!storage) {
+    return { memoryBuffer, pluginModeManager }
+  }
+  const cached = cache.get(storage)
+  if (cached) return cached
+  // 未初始化时返回仅含 storage 的占位，调用方应 await initShared 后再取
+  return { storage, memoryBuffer, pluginModeManager }
+}
+
+/**
+ * 初始化共享存储/组管理器（幂等）
+ * @param {Object} options - Whistle 钩子 options
+ * @returns {Promise<Object>} { storageAdapter, groupManager, memoryBuffer, pluginModeManager, storage }
+ */
+async function initShared(options) {
+  const storage = options && options.storage
+  if (!storage) {
+    throw new Error('[mockbubu] initShared: options.storage 缺失')
+  }
+
+  const cached = cache.get(storage)
+  if (cached && cached._initialized) {
+    return cached
+  }
+
+  const storageAdapter = new StorageAdapter(options)
+  const groupManager = new GroupManager(storageAdapter)
+
+  const shared = {
+    storageAdapter,
+    groupManager,
+    memoryBuffer,
+    pluginModeManager,
+    storage,
+    _initialized: false,
+  }
+  cache.set(storage, shared)
+
+  await storageAdapter.init()
+  await groupManager.ensureDefaultGroup()
+  await pluginModeManager.init(storage)
+  shared._initialized = true
+
+  console.log('[mockbubu] ✅ 共享初始化完成（storageAdapter / groupManager / pluginModeManager）')
+  return shared
+}
+
+/**
+ * 同步等待初始化完成（供钩子 request 回调使用）
+ * @param {Object} options - Whistle 钩子 options
+ * @returns {Promise<Object>}
+ */
+async function awaitShared(options) {
+  const shared = await initShared(options)
+  while (!shared._initialized) {
+    await new Promise(resolve => setTimeout(resolve, 100))
+  }
+  return shared
+}
+
+module.exports = {
+  initShared,
+  getShared,
+  awaitShared,
+}

package/lib/core/shared/mock-response.js

@@ -0,0 +1,306 @@
+/**
+ * 文件名: mock-response.js
+ * 功能: Mock 响应构造与条件匹配（共用模块）
+ * 职责:
+ * - 返回 Mock 数据 (源数据或版本数据)
+ * - 条件匹配模式下匹配规则并返回对应数据
+ * - 处理版本切换
+ * - 处理响应头
+ *
+ * 从 lib/core/server-entry/response-handler.js 抽取，供 server / resWrite 钩子共用
+ */
+
+const { MATCH_MODE_VALUE } = require('../../config/const')
+
+/**
+ * 返回 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 - 文件名
+ * @param {Object} options.originalReq - Whistle 原始请求对象（用于条件匹配）
+ */
+async function sendMockResponse(res, sourceData, options = {}) {
+  const { mockVersion, groupManager, currentGroupId, filename, originalReq } = options
+
+  // 解析源数据 (storageAdapter.readFile 返回的是 session 对象的 JSON 字符串)
+  const session = JSON.parse(sourceData)
+  const sourceResponse = session?.res
+  const { statusCode, statusMessage } = sourceResponse
+
+  // 浅拷贝 headers，避免直接修改 session 对象（若未来引入缓存会产生副作用）
+  const headers = { ...sourceResponse.headers }
+  headers['from-mockbubu-source'] = 'true'
+  headers['x-mockbubu-mocked'] = 'true'
+  delete headers['content-encoding']
+  delete headers['content-length']
+
+  // 【条件匹配模式】
+  if (mockVersion === MATCH_MODE_VALUE) {
+    const matchResult = await matchByConditions({
+      groupManager,
+      currentGroupId,
+      filename,
+      originalReq,
+    })
+
+    headers['x-mockbubu-match-mode'] = 'match'
+
+    if (matchResult.matched) {
+      // header 值必须为 ASCII，对中文规则名做 encodeURIComponent 编码
+      headers['x-mockbubu-match-rule'] = encodeURIComponent(matchResult.ruleName || '')
+      headers['x-mockbubu-match-params'] = encodeURIComponent(matchResult.paramsSummary || '')
+      res.writeHead(statusCode, statusMessage, headers)
+      res.end(JSON.stringify(matchResult.content ?? {}))
+      return
+    }
+
+    // 全不命中 → 通知调用方透传请求，不返回 mock 数据
+    return { action: 'passthrough' }
+  }
+
+  // 【版本直选模式】先确认版本数据是否存在，再统一调用 writeHead
+  if (mockVersion && groupManager && currentGroupId && filename) {
+    const versionData = await groupManager.getGroupVersionContent(currentGroupId, filename, mockVersion)
+    if (versionData) {
+      res.writeHead(statusCode, statusMessage, headers)
+      res.end(JSON.stringify(versionData))
+      return
+    }
+    // 版本不存在时降级到源数据
+  }
+
+  res.writeHead(statusCode, statusMessage, headers)
+  res.end(sourceResponse.body)
+}
+
+/**
+ * 条件匹配核心逻辑
+ *
+ * 匹配规则：
+ * 1. 按条件数量降序（条件越多优先级越高）
+ * 2. 条件数量相同时按 priority 字段升序（数字越小越优先）
+ * 3. 空条件规则作为兜底，最后匹配
+ * 4. 全不命中时返回 matched: false，由调用方降级到 source
+ *
+ * @param {Object} params
+ * @param {Object} params.groupManager - 组管理器
+ * @param {string} params.currentGroupId - 当前组ID
+ * @param {string} params.filename - 文件名（URL）
+ * @param {Object} params.originalReq - Whistle 原始请求对象
+ * @returns {{ matched: boolean, content?, ruleName?, paramsSummary? }}
+ */
+async function matchByConditions(params) {
+  const { groupManager, currentGroupId, filename, originalReq } = params
+
+  // 获取所有匹配规则（storage 层已按 priority 排序）
+  const matchVersions = await groupManager.getMatchVersions(currentGroupId, filename)
+  if (!matchVersions || matchVersions.length === 0) {
+    return { matched: false }
+  }
+
+  // 提取当前请求参数
+  const queryParams = extractQueryParams(originalReq)
+  const payloadParams = extractPayloadParams(originalReq)
+
+  // 按条件数量降序 + priority 升序排序（条件越多越具体，优先匹配）
+  // storage 层已按 priority 排序，这里再按 conditions.length 降序叠加
+  const sorted = [...matchVersions].sort((a, b) => {
+    const condDiff = (b.conditions?.length || 0) - (a.conditions?.length || 0)
+    if (condDiff !== 0) return condDiff
+    return (a.priority || 0) - (b.priority || 0)
+  })
+
+  let fallbackRule = null
+
+  // 逐条匹配（AND 关系：所有条件必须同时满足）
+  for (const rule of sorted) {
+    if (!rule.conditions || rule.conditions.length === 0) {
+      // 空条件规则作为兜底，记录备用
+      if (!fallbackRule) fallbackRule = rule
+      continue
+    }
+
+    const allMatch = rule.conditions.every((cond) => {
+      const sourceParams = cond.source === 'query' ? queryParams : payloadParams
+      return matchCondition(sourceParams, cond)
+    })
+
+    if (allMatch) {
+      return {
+        matched: true,
+        content: rule.content ?? {},
+        ruleName: rule.name,
+        paramsSummary: rule.conditions
+          .map(c => `${c.source}.${c.key}[${c.operator || 'eq'}]${c.value ?? ''}`)
+          .join(', '),
+      }
+    }
+  }
+
+  // 尝试兜底规则（空条件规则）
+  if (fallbackRule) {
+    return {
+      matched: true,
+      content: fallbackRule.content ?? {},
+      ruleName: fallbackRule.name,
+      paramsSummary: '(default)',
+    }
+  }
+
+  return { matched: false }
+}
+
+/**
+ * 单条件匹配：根据 operator 执行对应的比较
+ * operator 缺省时向后兼容旧数据（等同 eq）
+ *
+ * @param {Object} sourceParams - 请求参数 key-value 对
+ * @param {{ key: string, operator?: string, value?: string }} cond
+ * @returns {boolean}
+ */
+function matchCondition(sourceParams, cond) {
+  const { key, value = '' } = cond
+  const operator = cond.operator || 'eq'
+
+  // 条件不完整时跳过（视为满足），避免空值产生意外的匹配行为
+  if (!key) return true
+  const VALUELESS_OPS = new Set(['exists', 'not_exists'])
+  if (!VALUELESS_OPS.has(operator) && !value) return true
+
+  const exists = Object.prototype.hasOwnProperty.call(sourceParams, key)
+  const actual = exists ? String(sourceParams[key]) : undefined
+  const expected = String(value)
+
+  switch (operator) {
+    case 'eq':
+      return actual === expected
+    case 'neq':
+      return actual !== expected
+    case 'contains':
+      return actual !== undefined && actual.includes(expected)
+    case 'regex': {
+      if (!actual) return false
+      try {
+        return new RegExp(expected).test(actual)
+      } catch {
+        return false
+      }
+    }
+    case 'exists':
+      return exists
+    case 'not_exists':
+      return !exists
+    default:
+      return actual === expected
+  }
+}
+
+/**
+ * 从原始请求中提取 query 参数
+ * 来源：req.originalReq.url，fallback 到 x-whistle-full-url header
+ *
+ * @param {Object} originalReq - Whistle 原始请求对象
+ * @returns {Object} query 参数 key-value 对
+ */
+function extractQueryParams(originalReq) {
+  if (!originalReq) return {}
+
+  try {
+    // 某些 Whistle 代理场景（tunnel/HTTP2）下 originalReq.url 可能不含 query，
+    // 完整 URL 会在 x-whistle-full-url header 里（URL 编码格式）
+    const fullUrlHeader = originalReq.headers?.['x-whistle-full-url']
+    const rawUrl = originalReq.url ||
+      (fullUrlHeader ? decodeURIComponent(fullUrlHeader) : '') ||
+      ''
+    const url = new URL(rawUrl)
+    const params = {}
+    url.searchParams.forEach((value, key) => {
+      params[key] = value
+    })
+    return params
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * 从原始请求中提取 payload 参数（支持 JSON 和 x-www-form-urlencoded，只提取第一层 key-value）
+ * 来源：req.originalReq.body
+ *
+ * @param {Object} originalReq - Whistle 原始请求对象
+ * @returns {Object} payload 参数 key-value 对（值统一转为字符串）
+ */
+function extractPayloadParams(originalReq) {
+  if (!originalReq) return {}
+
+  try {
+    // 优先使用 mock 路径预缓冲的请求体，fallback 到 Whistle 预解析的 body
+    let body = originalReq._reqBody || originalReq.body || ''
+
+    // Buffer 转字符串
+    if (Buffer.isBuffer(body)) {
+      body = body.toString('utf8')
+    }
+
+    // body 可能已被 Whistle 预解析为对象，直接提取
+    if (typeof body === 'object' && body !== null) {
+      return extractFlatParams(body)
+    }
+
+    if (typeof body !== 'string' || !body.trim()) {
+      return {}
+    }
+
+    // 尝试 JSON 格式
+    try {
+      const parsed = JSON.parse(body)
+      if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+        return extractFlatParams(parsed)
+      }
+    } catch {
+      // 不是 JSON，继续尝试
+    }
+
+    // 尝试 application/x-www-form-urlencoded 格式
+    if (body.includes('=')) {
+      const result = {}
+      new URLSearchParams(body).forEach((value, key) => {
+        result[key] = value
+      })
+      if (Object.keys(result).length > 0) return result
+    }
+
+    return {}
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * 从对象中提取第一层 string/number/boolean 类型的 key-value（统一转为字符串）
+ * @param {Object} obj
+ * @returns {Object}
+ */
+function extractFlatParams(obj) {
+  const params = {}
+  Object.keys(obj).forEach((key) => {
+    const val = obj[key]
+    if (typeof val === 'string' || typeof val === 'number' || typeof val === 'boolean') {
+      params[key] = String(val)
+    }
+  })
+  return params
+}
+
+module.exports = {
+  sendMockResponse,
+  matchByConditions,
+  matchCondition,
+  extractQueryParams,
+  extractPayloadParams,
+  extractFlatParams,
+}

package/lib/utils/utils.js

@@ -83,7 +83,7 @@ const getGroupFileList = async (storage, groupId) => {
     allFiles.forEach((item) => {
       try {
         // StorageAdapter 返回的文件名格式: groupId/filename
-        // 例如: default/https://m.shein.com/us/bff-api/...
+        // 例如: default/https://a.com/us/api/...
         // 不需要任何解码，直接使用
         const name = item.name
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whistle.mockbubu",
-  "version": "2.2.7",
+  "version": "2.2.9-beta.1",
   "description": "mock response data",
   "scripts": {
     "lint": "eslint . --ext .js",