whistle.mockbubu 1.0.0-dev.4 → 2.0.0-beta.0

package/lib/server.js

@@ -1,63 +1,180 @@
 const {
-  getProperty,
-  setProperty,
   getFilename,
   getRule,
   isJsonReq,
   setApiListUpdated,
-  getVersionContent,
   handleBuffer2String,
   withTryCatch,
 } = require('./utils')
-const qs = require('qs')
+const GroupManager = require('./group-manager')
+const StorageAdapter = require('./storage-adapter')
 
 module.exports = (server, { storage }) => {
-  server.on('request', (req, res) => {
+  console.log('[mockbubu] 🚀 server.js 模块已加载!')
+
+  // 使用 StorageAdapter 包装 Whistle storage
+  const actualBaseDir = storage.baseDir || storage._options?.baseDir
+  const storageAdapter = new StorageAdapter({ baseDir: actualBaseDir })
+
+  // 初始化组管理器（使用适配器）
+  const groupManager = new GroupManager(storageAdapter)
+
+  // ✅ 修复 Issue #3: 添加捕获中标志，防止并发重复捕获
+  // 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()
+    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 { originalReq, method } = req
     const { headers, ruleValue, url, pattern } = originalReq
     const filename = getFilename(originalReq)
     const rule = getRule(originalReq)
 
+    // 调试日志:记录所有请求
+    if (url.includes('trend_card')) {
+      console.log('[mockbubu] 🔍 [trend_card] 收到请求')
+      console.log(`[mockbubu] 🔍 [trend_card] URL: ${url}`)
+      console.log(`[mockbubu] 🔍 [trend_card] Accept: ${headers.accept}`)
+      console.log(`[mockbubu] 🔍 [trend_card] Sec-Fetch-Dest: ${headers['sec-fetch-dest'] || headers['Sec-Fetch-Dest']}`)
+      console.log('[mockbubu] 🔍 [trend_card] 完整 Headers:', JSON.stringify(headers, null, 2))
+      console.log(`[mockbubu] 🔍 [trend_card] isJsonReq 判断结果: ${isJsonReq(headers)}`)
+    }
+
     // 非json请求直接透传
-    if (!isJsonReq(headers)) return req.passThrough()
-
-    // 获取请求信息
-    let str = ''
-    req.on('data', (chunk) => {
-      str += chunk
-    })
-    req.on('end', () => {
-      setProperty(storage, filename, { payload: str })
-    })
-    setProperty(storage, filename, {
-      query: qs.parse(new URL(url).searchParams.toString()),
-    })
+    if (!isJsonReq(headers)) {
+      console.log(`[mockbubu] ⏭️  非 JSON 请求已跳过 | File: ${filename}`)
+      console.log(`[mockbubu] 📋 Headers: Accept=${headers.accept}, Sec-Fetch-Dest=${headers['sec-fetch-dest'] || headers['Sec-Fetch-Dest']}`)
+      return req.passThrough()
+    }
+
+    console.log(`[mockbubu] 🎯 JSON 请求,开始捕获 | URL: ${url}`)
+
+    // V3 架构：不再写入 query/payload 到 properties（无用数据）
 
     try {
-      const { mock, mockVersion } = getProperty(storage, filename) || {}
-      const sessionCache = storage.readFile(filename)
+      // 获取当前激活的组ID
+      const currentGroupId = await groupManager.getCurrentGroupId()
+      // 读取该组的配置
+      const groupConfig = await groupManager.getGroupFileConfig(currentGroupId, filename)
+      const { mock, mockVersion } = groupConfig
 
-      if (mock) {
-        if (sessionCache) {
-          const resCache = JSON.parse(sessionCache)?.res
-          const { statusCode, statusMessage, headers } = resCache
-
-          headers['from-res-cache'] = 'true'
-          delete headers['content-encoding']
-          delete headers['content-length']
-          res.writeHead(statusCode, statusMessage, headers)
-          if (mockVersion) {
-            const mockVersionContent = getVersionContent({ storage, filename, versionName: mockVersion })
+      // 从组目录读取缓存文件
+      const filePath = `${currentGroupId}/${filename}`
+      const sessionCache = await storageAdapter.readFile(filePath)
+
+      if (mock && sessionCache) {
+        // Mock: true 且有缓存，返回模拟数据
+        const resCache = JSON.parse(sessionCache)?.res
+        const { statusCode, statusMessage, headers } = resCache
+
+        headers['from-res-cache'] = 'true'
+        delete headers['content-encoding']
+        delete headers['content-length']
+        res.writeHead(statusCode, statusMessage, headers)
+
+        if (mockVersion) {
+          // 从当前组配置读取版本内容
+          const mockVersionContent = await groupManager.getGroupVersionContent(currentGroupId, filename, mockVersion)
+          if (mockVersionContent) {
             res.end(JSON.stringify(mockVersionContent))
           } else {
+            // 版本不存在时降级到原始数据
             res.end(resCache.body)
           }
+        } else {
+          res.end(resCache.body)
         }
-      } else {
-        // 已有缓存则直接透传
-        if (sessionCache) return req.passThrough()
+      } else if (mock && !sessionCache) {
+        // Mock: true 但无缓存，需要先捕获数据
+        const captureKey = `${currentGroupId}/${filename}`
 
-        // 命中插件规则，没有勾选mock的缓存最新的接口数据
+        // ✅ 修复：检查文件是否已存在，如果存在则直接透传，不重新捕获
+        // 设计原则：同一个URL只捕获一次，用户如需更新数据，应先删除旧文件
+        const configKey = groupManager.getGroupConfigKey(currentGroupId, filename)
+        const hasConfig = await storageAdapter.hasFileInIndex(configKey)
+
+        if (hasConfig) {
+          // 文件已存在，直接透传请求，不重新捕获
+          console.log(`[mockbubu] ⏭️  文件已存在，跳过捕获并透传: ${filename}`)
+          return req.passThrough()
+        } else {
+          // 文件不存在 - 首次捕获
+          console.log(`[mockbubu] 🎣 首次捕获: ${filename}`)
+        }
+
+        // ✅ 修复 Issue #3: 检查是否正在捕获中
+        if (capturingFiles.has(captureKey)) {
+          // 正在捕获中，等待捕获完成
+          console.log(`[mockbubu] ⏳ 检测到并发请求，等待捕获完成: ${filename}`)
+
+          try {
+            // 等待第一个请求捕获完成（最多等待10秒）
+            await Promise.race([
+              capturingFiles.get(captureKey),
+              new Promise((_resolve, reject) => setTimeout(() => reject(new Error('捕获超时')), 10000)),
+            ])
+
+            // 捕获完成，重新读取缓存
+            const freshCache = await storageAdapter.readFile(filePath)
+            if (freshCache) {
+              console.log(`[mockbubu] ✅ 等待成功，返回捕获的数据: ${filename}`)
+              const resCache = JSON.parse(freshCache)?.res
+              const { statusCode, statusMessage = '', headers } = resCache
+
+              headers['from-res-cache'] = 'true'
+              delete headers['content-encoding']
+              delete headers['content-length']
+              res.writeHead(statusCode, statusMessage, headers)
+
+              // 检查是否需要使用版本数据
+              if (mockVersion) {
+                const mockVersionContent = await groupManager.getGroupVersionContent(currentGroupId, filename, mockVersion)
+                if (mockVersionContent) {
+                  res.end(JSON.stringify(mockVersionContent))
+                } else {
+                  res.end(resCache.body)
+                }
+              } else {
+                res.end(resCache.body)
+              }
+              return
+            } else {
+              // 等待后仍无缓存，降级到透传
+              console.warn(`[mockbubu] ⚠️  等待后仍无缓存，降级透传: ${filename}`)
+              return req.passThrough()
+            }
+          } catch (err) {
+            // 等待超时或失败，降级到透传
+            console.error(`[mockbubu] ❌ 等待捕获失败，降级透传: ${filename}`, err.message)
+            return req.passThrough()
+          }
+        }
+
+        // ✅ 修复 Issue #3: 第一个请求，设置捕获标志
+        let resolveCapture
+        const capturePromise = new Promise(resolve => { resolveCapture = resolve })
+        capturingFiles.set(captureKey, capturePromise)
+
+        // 传递 hasConfig 标志到捕获逻辑中，避免重复检查
+        const isFirstCapture = !hasConfig
+
+        // 无缓存，捕获最新的接口数据
         const client = req.request((svrRes) => {
           const encoding = svrRes.headers['content-encoding']
           let body
@@ -66,34 +183,190 @@ module.exports = (server, { storage }) => {
             body = body ? Buffer.concat([body, data]) : data
           })
           svrRes.on('end', withTryCatch(async () => {
-            if (!body) return
-
-            const content = await handleBuffer2String({ body, encoding })
-            // 获取完整的抓包数据，要等待响应完成
-            req.getSession(async (session) => {
-              // 如果设置了 enable://hide 会获取到空数据
-              if (!session) {
-                return
-              }
-              setProperty(storage, filename, {
-                method,
-                rule,
-                status: session.res.statusCode,
-                pattern,
-                ruleValue: ruleValue || 'pathname',
-                url,
-                mock: false,
-                locked: false,
-                date: Date.now(),
-                mockTime: null,
+            try {
+              if (!body) return
+
+              const content = await handleBuffer2String({ body, encoding })
+              // 获取完整的抓包数据，要等待响应完成
+              req.getSession(async (session) => {
+                try {
+                  // 如果设置了 enable://hide 会获取到空数据
+                  if (!session) {
+                    return
+                  }
+
+                  // 完全隔离架构：将元数据和配置写入当前组
+                  // ✅ 修复 Issue #4: 使用外层已检查的 isFirstCapture，避免重复检查导致逻辑不一致
+
+                  if (isFirstCapture) {
+                    // 首次捕获：创建完整配置（保持当前 mock 状态）
+                    const configToSet = {
+                      method,
+                      rule,
+                      status: session.res.statusCode,
+                      pattern,
+                      ruleValue: ruleValue || 'pathname',
+                      url: filename, // ✅ 修复：使用 filename（不带查询参数），而不是完整的 url
+                      date: Date.now(),
+                      mock, // 使用当前的 mock 状态（true）
+                      locked: false,
+                      mockVersion: null,
+                      mockTime: null,
+                    }
+                    await groupManager.setGroupFileConfig(currentGroupId, filename, configToSet)
+                  } else {
+                    // 已存在配置，仅更新元数据（不覆盖 mock、locked 等用户配置）
+                    const existingGroupConfig = await groupManager.getGroupFileConfig(currentGroupId, filename)
+                    await groupManager.setGroupFileConfig(currentGroupId, filename, {
+                      ...existingGroupConfig,
+                      method,
+                      rule,
+                      status: session.res.statusCode,
+                      pattern,
+                      ruleValue: ruleValue || 'pathname',
+                      url: filename, // ✅ 修复：使用 filename（不带查询参数），而不是完整的 url
+                      date: Date.now(),
+                    })
+                  }
+
+                  // 将文件写入组目录
+                  const tempSession = JSON.parse(JSON.stringify(session))
+                  tempSession.res.body = content
+                  const groupFilePath = `${currentGroupId}/${filename}`
+                  await storageAdapter.writeFile(groupFilePath, JSON.stringify(tempSession))
+
+                  await setApiListUpdated(storage, true)
+
+                  console.log(`[mockbubu] ✅ 捕获完成: ${filename}`)
+                } finally {
+                  // ✅ 修复 Issue #3: 捕获完成，清除标志并通知等待的请求
+                  resolveCapture()
+                  capturingFiles.delete(captureKey)
+                }
               })
+            } catch (err) {
+              console.error(`[mockbubu] ❌ 捕获过程出错: ${filename}`, err)
+              // 出错也要清除标志
+              resolveCapture()
+              capturingFiles.delete(captureKey)
+            }
+          }))
+
+          // 将响应透传给客户端
+          svrRes.pipe(res)
+        })
+
+        req.pipe(client)
+      } else {
+        // mock: false，已有缓存则直接透传，无缓存则捕获
+        if (sessionCache) {
+          return req.passThrough()
+        }
+
+        // ✅ 修复 Issue #3: mock=false 时也要避免重复捕获
+        const captureKey = `${currentGroupId}/${filename}`
+
+        // ✅ 修复：检查文件是否已存在，如果存在则直接透传，不重新捕获
+        // 设计原则：同一个URL只捕获一次，用户如需更新数据，应先删除旧文件
+        const configKey = groupManager.getGroupConfigKey(currentGroupId, filename)
+        const hasConfig = await storageAdapter.hasFileInIndex(configKey)
+
+        if (hasConfig) {
+          // 文件已存在，直接透传请求，不重新捕获
+          console.log(`[mockbubu] ⏭️  文件已存在（mock=false），跳过捕获并透传: ${filename}`)
+          return req.passThrough()
+        } else {
+          // 文件不存在 - 首次捕获
+          console.log(`[mockbubu] 🎣 首次捕获（mock=false）: ${filename}`)
+        }
 
-              const tempSession = JSON.parse(JSON.stringify(session))
-              tempSession.res.body = content
-              storage.writeFile(filename, JSON.stringify(tempSession))
+        if (capturingFiles.has(captureKey)) {
+          // 正在捕获中，直接透传（mock=false 不需要等待）
+          console.log(`[mockbubu] ⏳ 检测到并发请求（mock=false），直接透传: ${filename}`)
+          return req.passThrough()
+        }
+
+        // ✅ 修复 Issue #3: 设置捕获标志
+        let resolveCapture
+        const capturePromise = new Promise(resolve => { resolveCapture = resolve })
+        capturingFiles.set(captureKey, capturePromise)
+
+        // 传递 hasConfig 标志到捕获逻辑中，避免重复检查
+        const isFirstCapture = !hasConfig
 
-              setApiListUpdated(storage, true)
-            })
+        // 无缓存，捕获最新的接口数据
+        const client = req.request((svrRes) => {
+          const encoding = svrRes.headers['content-encoding']
+          let body
+
+          svrRes.on('data', (data) => {
+            body = body ? Buffer.concat([body, data]) : data
+          })
+          svrRes.on('end', withTryCatch(async () => {
+            try {
+              if (!body) return
+
+              const content = await handleBuffer2String({ body, encoding })
+              // 获取完整的抓包数据，要等待响应完成
+              req.getSession(async (session) => {
+                try {
+                  // 如果设置了 enable://hide 会获取到空数据
+                  if (!session) {
+                    return
+                  }
+
+                  // 完全隔离架构：将元数据和配置写入当前组
+                  // ✅ 修复 Issue #4: 使用外层已检查的 isFirstCapture，避免重复检查导致逻辑不一致
+
+                  if (isFirstCapture) {
+                    // 首次捕获：创建完整配置
+                    await groupManager.setGroupFileConfig(currentGroupId, filename, {
+                      method,
+                      rule,
+                      status: session.res.statusCode,
+                      pattern,
+                      ruleValue: ruleValue || 'pathname',
+                      url: filename, // ✅ 修复：使用 filename（不带查询参数），而不是完整的 url
+                      date: Date.now(),
+                      mock: false,
+                      locked: false,
+                      mockVersion: null,
+                      mockTime: null,
+                    })
+                  } else {
+                    // 已存在配置，仅更新元数据（不覆盖 mock、locked 等用户配置）
+                    const existingGroupConfig = await groupManager.getGroupFileConfig(currentGroupId, filename)
+                    await groupManager.setGroupFileConfig(currentGroupId, filename, {
+                      ...existingGroupConfig,
+                      method,
+                      rule,
+                      status: session.res.statusCode,
+                      pattern,
+                      ruleValue: ruleValue || 'pathname',
+                      url: filename, // ✅ 修复：使用 filename（不带查询参数），而不是完整的 url
+                      date: Date.now(),
+                    })
+                  }
+
+                  // 将文件写入组目录
+                  const tempSession = JSON.parse(JSON.stringify(session))
+                  tempSession.res.body = content
+                  const groupFilePath = `${currentGroupId}/${filename}`
+                  await storageAdapter.writeFile(groupFilePath, JSON.stringify(tempSession))
+
+                  await setApiListUpdated(storage, true)
+                } finally {
+                  // ✅ 修复 Issue #3: 捕获完成，清除标志
+                  resolveCapture()
+                  capturingFiles.delete(captureKey)
+                }
+              })
+            } catch (err) {
+              console.error(`[mockbubu] ❌ 捕获过程出错: ${filename}`, err)
+              // 出错也要清除标志
+              resolveCapture()
+              capturingFiles.delete(captureKey)
+            }
           }))
 
           // 将响应透传给客户端