rwz-dev-proxy 1.0.0

package/index.js

@@ -0,0 +1,625 @@
+var express = require('express')
+var path = require('path')
+var httpProxy = require('http-proxy')
+var Mock = require('mockjs')
+
+const { createProxyMiddleware, responseInterceptor, fixRequestBody } = require('http-proxy-middleware');
+var debug = require('debug')
+var proxyDebug = debug('rwz-dev-proxy:proxy')
+var app = express()
+var morgan = require('morgan');
+app.use(morgan('short', {
+  immediate: true
+}));
+app.use(function (req, res, next) {
+  const origin = req.headers && req.headers.origin
+  if (origin) {
+    res.setHeader('Access-Control-Allow-Origin', origin)
+    res.setHeader('Vary', 'Origin')
+    res.setHeader('Access-Control-Allow-Credentials', 'true')
+  } else {
+    res.setHeader('Access-Control-Allow-Origin', '*')
+  }
+
+  const requestHeaders = req.headers && req.headers['access-control-request-headers']
+  res.setHeader('Access-Control-Allow-Headers', requestHeaders || 'Content-Type, Authorization, X-Requested-With')
+  res.setHeader('Access-Control-Allow-Methods', 'GET,POST,PUT,PATCH,DELETE,OPTIONS')
+  res.setHeader('Access-Control-Expose-Headers', 'Content-Length, Content-Type')
+
+  if (req.method === 'OPTIONS') {
+    res.statusCode = 204
+    return res.end()
+  }
+  next()
+});
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+var db = require('./db')
+
+function isProxyDebugEnabled() {
+  return true
+  return process.env.RWZ_PROXY_DEBUG === '1' || process.env.PROXY_DEBUG === '1'
+}
+
+function logProxy() {
+  try {
+    proxyDebug.apply(null, arguments)
+  } catch (e) {}
+  if (!isProxyDebugEnabled()) return
+  try {
+    console.log.apply(console, ['[proxy]'].concat([].slice.call(arguments)))
+  } catch (e) {}
+}
+
+function safeJsonParse(str, fallbackValue) {
+  try {
+    return JSON.parse(str)
+  } catch (e) {
+    return fallbackValue
+  }
+}
+
+function normalizePrefix(prefix) {
+  if (!prefix) return ''
+  if (prefix[0] !== '/') return '/' + prefix
+  return prefix
+}
+
+function truncateString(str, maxLen) {
+  if (typeof str !== 'string') return ''
+  if (str.length <= maxLen) return str
+  return str.slice(0, maxLen)
+}
+
+function executeScript(scriptContent, context) {
+  if (!scriptContent || !scriptContent.trim()) return {};
+  const module = { exports: {} };
+  const { req, res, Mock } = context;
+  
+  try {
+      const fn = new Function('module', 'exports', 'require', 'Mock', 'req', 'res', scriptContent);
+      const result = fn(module, module.exports, require, Mock, req, res);
+      
+      // Compatibility: if script returns an object/function directly (legacy style), wrap it
+      if (result !== undefined && !module.exports.onRequest && !module.exports.onResponse) {
+           return { _legacy: result, ...module.exports };
+      }
+      return module.exports;
+  } catch (e) {
+      console.error('Script execution error:', e);
+      return {};
+  }
+}
+
+let routeCache = { expiresAt: 0, routes: [] }
+function invalidateRouteCache() {
+  routeCache.expiresAt = 0
+}
+
+async function ensureDefaultRoute() {
+  if (!db.proxyRoute) return
+  const count = await db.proxyRoute.count()
+  if (count > 0) return
+  await db.proxyRoute.create({
+    name: 'jeecg-boot',
+    enabled: true,
+    priority: 0,
+    routePrefix: '/jeecg-boot',
+    target: 'http://192.168.86.170:8001/mom',
+    changeOrigin: true,
+    pathRewrite: JSON.stringify({ '^/jeecg-boot': '' }),
+  })
+  invalidateRouteCache()
+}
+
+async function getEnabledRoutes() {
+  if (Date.now() < routeCache.expiresAt) return routeCache.routes
+  if (!db.proxyRoute) return []
+  const routes = await db.proxyRoute.findAll({
+    where: { enabled: true },
+    order: [['priority', 'DESC'], ['id', 'ASC']],
+  })
+  routeCache = { expiresAt: Date.now() + 1000, routes }
+  return routes
+}
+
+app.get('/api/health', function (req, res) {
+  res.json({ ok: true })
+})
+
+app.get('/api/routes', async function (req, res) {
+  const routes = await db.proxyRoute.findAll({ order: [['priority', 'DESC'], ['id', 'ASC']] })
+  res.json({ data: routes })
+})
+
+app.get('/api/routes/:id', async function (req, res) {
+  const id = Number(req.params.id)
+  const route = await db.proxyRoute.findByPk(id)
+  if (!route) return res.status(404).json({ message: '路由不存在' })
+  res.json({ data: route })
+})
+
+app.post('/api/routes', async function (req, res) {
+  const body = req.body || {}
+  const routePrefix = normalizePrefix(body.routePrefix || '')
+  const target = (body.target || '').trim()
+  if (!routePrefix || !target) {
+    return res.status(400).json({ message: 'routePrefix 和 target 不能为空' })
+  }
+  const created = await db.proxyRoute.create({
+    name: (body.name || routePrefix).trim(),
+    enabled: body.enabled !== false,
+    priority: Number.isFinite(Number(body.priority)) ? Number(body.priority) : 0,
+    routePrefix,
+    target,
+    changeOrigin: body.changeOrigin !== false,
+    pathRewrite: typeof body.pathRewrite === 'string' ? body.pathRewrite : JSON.stringify(body.pathRewrite || {}),
+  })
+  invalidateRouteCache()
+  res.json({ data: created })
+})
+
+app.put('/api/routes/:id', async function (req, res) {
+  const id = Number(req.params.id)
+  const body = req.body || {}
+  const route = await db.proxyRoute.findByPk(id)
+  if (!route) return res.status(404).json({ message: '路由不存在' })
+
+  const routePrefix = normalizePrefix(body.routePrefix ?? route.routePrefix)
+  const target = (body.target ?? route.target).trim()
+  if (!routePrefix || !target) {
+    return res.status(400).json({ message: 'routePrefix 和 target 不能为空' })
+  }
+
+  await route.update({
+    name: (body.name ?? route.name).trim(),
+    enabled: body.enabled ?? route.enabled,
+    priority: Number.isFinite(Number(body.priority)) ? Number(body.priority) : route.priority,
+    routePrefix,
+    target,
+    changeOrigin: body.changeOrigin ?? route.changeOrigin,
+    pathRewrite: typeof body.pathRewrite === 'string' ? body.pathRewrite : JSON.stringify(body.pathRewrite ?? safeJsonParse(route.pathRewrite, {})),
+  })
+  invalidateRouteCache()
+  res.json({ data: route })
+})
+
+app.delete('/api/routes/:id', async function (req, res) {
+  const id = Number(req.params.id)
+  const route = await db.proxyRoute.findByPk(id)
+  if (!route) return res.status(404).json({ message: '路由不存在' })
+  await route.destroy()
+  invalidateRouteCache()
+  res.json({ ok: true })
+})
+
+app.get('/api/logs', async function (req, res) {
+  const limit = Math.min(200, Math.max(1, Number(req.query.limit) || 50))
+  const logs = await db.proxyLog.findAll({ order: [['id', 'DESC']], limit })
+  res.json({ data: logs })
+})
+
+app.get('/api/routes/:id/interfaces', async function (req, res) {
+  const routeId = Number(req.params.id)
+  const interfaces = await db.proxyInterface.findAll({
+    where: { routeId },
+    order: [['pathname', 'ASC'], ['method', 'ASC']]
+  })
+  res.json({ data: interfaces })
+})
+
+app.put('/api/interfaces/:id', async function (req, res) {
+  const id = Number(req.params.id)
+  const body = req.body || {}
+  const iface = await db.proxyInterface.findByPk(id)
+  if (!iface) return res.status(404).json({ message: '接口不存在' })
+
+  const updateData = {
+    description: body.description,
+  }
+  if (body.reqHeaders !== undefined) updateData.reqHeaders = body.reqHeaders
+  if (body.reqQuery !== undefined) updateData.reqQuery = body.reqQuery
+  if (body.reqBody !== undefined) updateData.reqBody = body.reqBody
+  if (body.resBody !== undefined) updateData.resBody = body.resBody
+  if (body.mode !== undefined) updateData.mode = body.mode
+  if (body.staticData !== undefined) updateData.staticData = body.staticData
+  if (body.mockData !== undefined) updateData.mockData = body.mockData
+  if (body.mockResult !== undefined) updateData.mockResult = body.mockResult
+  if (body.mockScript !== undefined) updateData.mockScript = body.mockScript
+  
+  // Debug log
+  console.log('Updating interface:', id, 'staticData present:', body.staticData !== undefined, 'Length:', body.staticData ? body.staticData.length : 0)
+
+  await iface.update(updateData)
+  res.json({ data: iface })
+})
+
+app.delete('/api/interfaces/:id', async function (req, res) {
+  const id = Number(req.params.id)
+  const iface = await db.proxyInterface.findByPk(id)
+  if (!iface) return res.status(404).json({ message: '接口不存在' })
+  await iface.destroy()
+  res.json({ ok: true })
+})
+
+app.use(async function (req, res, next) {
+  try {
+    logProxy('incoming', {
+      method: req.method,
+      path: req.path,
+      url: req.url,
+      host: req.headers && req.headers.host,
+    })
+
+    if (req.path === '/api' || req.path.indexOf('/api/') === 0) {
+      logProxy('skip /api', { path: req.path })
+      return next()
+    }
+
+    let hookModule = {}
+    const routes = await getEnabledRoutes()
+    logProxy('routes loaded', { count: routes.length, prefixes: routes.map(r => r.routePrefix).slice(0, 20) })
+    const hit = routes.find(r => req.path === r.routePrefix || req.path.indexOf(r.routePrefix + '/') === 0)
+    if (!hit) {
+      logProxy('no route hit', { path: req.path })
+      return next()
+    }
+
+    if (db && db.proxyInterface) {
+      const pathname = req._parsedUrl && req._parsedUrl.pathname
+      console.log('DEBUG: Finding iface', hit.id, req.method, pathname);
+      if (pathname) {
+        const iface = await db.proxyInterface.findOne({
+          where: {
+            routeId: hit.id,
+            method: req.method,
+            pathname: pathname
+          }
+        })
+        if (iface) {
+          console.log('DEBUG: Found iface', iface.id, 'mockScript len:', iface.mockScript ? iface.mockScript.length : 0);
+          // Load hooks
+          if (iface.mockScript) {
+             hookModule = executeScript(iface.mockScript, { req, res, Mock });
+             console.log('DEBUG: Hook module keys', Object.keys(hookModule));
+             if (hookModule.onRequest) {
+              await hookModule.onRequest({ req, res, Mock });
+              if (res.headersSent) return;
+            }
+          }
+          if (iface.mode === 'static') {
+            logProxy('static hit', { pathname })
+            res.status(iface.statusCode || 200)
+            
+            let body
+            try {
+              // Prefer staticData, fallback to resBody ONLY if staticData is null (not set)
+              let content = iface.staticData
+              if (content === null || content === undefined) {
+                  content = iface.resBody || '{}'
+              }
+              body = JSON.parse(content)
+            } catch (e) {
+              // If JSON parse fails, use as raw string
+              let content = iface.staticData
+              if (content === null || content === undefined) {
+                  content = iface.resBody || ''
+              }
+              body = content
+            }
+
+            if (hookModule.onResponse) {
+                try {
+                   console.log('DEBUG: calling Static onResponse', body);
+                   const newBody = await hookModule.onResponse({ body, req, res, statusCode: iface.statusCode || 200, Mock });
+                   console.log('DEBUG: Static onResponse result', newBody);
+                   if (newBody !== undefined) body = newBody;
+                } catch(e) { console.error('Static onResponse error', e); }
+            }
+
+            if (typeof body === 'object') {
+                res.json(body)
+            } else {
+                res.send(body)
+            }
+            return
+          } else if (iface.mode === 'mock') {
+            logProxy('mock hit', { pathname })
+            try {
+              let mockTemplate = {}
+              
+              if (iface.mockScript && iface.mockScript.trim()) {
+                  // Use pre-loaded hookModule to avoid double execution
+                  if (hookModule._legacy) {
+                      mockTemplate = hookModule._legacy;
+                  } else {
+                       // If hookModule has other exports besides hooks, use them as template
+                       // Otherwise fallback to mockData
+                       const dataKeys = Object.keys(hookModule).filter(k => k !== 'onRequest' && k !== 'onResponse');
+                       if (dataKeys.length > 0) {
+                           mockTemplate = { ...hookModule };
+                           delete mockTemplate.onRequest;
+                           delete mockTemplate.onResponse;
+                       } else {
+                           mockTemplate = safeJsonParse(iface.mockData, {})
+                       }
+                  }
+                  
+                  // Support beforeMockData if present (legacy support?)
+                  // Since we are using module.exports style, beforeMockData should be an export if needed
+                  if (mockTemplate && typeof mockTemplate === 'object' && typeof mockTemplate.beforeMockData === 'function') {
+                      const contextReq = {
+                          query: req.query,
+                          body: req.body,
+                          headers: req.headers,
+                          params: req.params,
+                          path: req.path,
+                          url: req.url,
+                          method: req.method
+                      }
+                      mockTemplate = mockTemplate.beforeMockData({ req: contextReq, Mock })
+                  }
+              } else {
+                  mockTemplate = safeJsonParse(iface.mockData, {})
+              }
+              
+              const mockResult = Mock.mock(mockTemplate)
+              
+              let finalBody = mockResult
+              if (hookModule.onResponse) {
+                  try {
+                     console.log('DEBUG: calling Mock onResponse', finalBody);
+                     const newBody = await hookModule.onResponse({ body: finalBody, req, res, statusCode: 200, Mock });
+                     console.log('DEBUG: Mock onResponse result', newBody);
+                     if (newBody !== undefined) finalBody = newBody;
+                  } catch(e) { console.error('Mock onResponse error', e); }
+              }
+              
+              res.json(finalBody)
+            } catch (e) {
+              res.status(500).json({ message: 'Mock Error', error: e.message })
+            }
+            return
+          }
+        }
+      }
+    }
+
+    const pathRewriteObj = safeJsonParse(hit.pathRewrite, {})
+    const changeOrigin = hit.changeOrigin !== false
+
+    logProxy('route hit', {
+      routeId: hit.id,
+      routePrefix: hit.routePrefix,
+      target: hit.target,
+      changeOrigin,
+      pathRewrite: pathRewriteObj,
+    })
+
+    return createProxyMiddleware({
+      target: hit.target,
+      changeOrigin,
+      pathRewrite: pathRewriteObj,
+      timeout: 30000,
+      proxyTimeout: 30000,
+      selfHandleResponse: true,
+      on: {
+        error: function (err, req, res, target) {
+          logProxy('proxy error', {
+            message: err && err.message,
+            code: err && err.code,
+            target,
+            method: req && req.method,
+            url: req && req.url,
+          })
+          if (res && !res.headersSent) {
+            res.statusCode = 502
+            res.setHeader('content-type', 'application/json; charset=utf-8')
+          }
+          try {
+            if (res && !res.writableEnded) {
+              res.end(JSON.stringify({ message: '代理请求失败', error: (err && err.message) || 'unknown' }))
+            }
+          } catch (e) {}
+        },
+        proxyReq: function (proxyReq, req, res) {
+          // 禁用压缩，以便我们可以读取响应内容
+          try {
+             proxyReq.removeHeader('accept-encoding')
+             proxyReq.removeHeader('Accept-Encoding')
+          } catch(e) {}
+
+          try {
+            fixRequestBody(proxyReq, req, res)
+          } catch (e) {
+            logProxy('fixRequestBody error', { message: e && e.message })
+          }
+          try {
+            logProxy('proxy req', {
+              method: req.method,
+              url: req.url,
+              target: hit.target,
+              proxyPath: proxyReq && proxyReq.path,
+              proxyHost: proxyReq && proxyReq.getHeader && proxyReq.getHeader('host'),
+            })
+          } catch (e) {
+            console.log(e)
+          }
+        },
+        proxyRes: responseInterceptor(async (responseBuffer, proxyRes, req, res) => {
+          const contentType = (proxyRes.headers && (proxyRes.headers['content-type'] || proxyRes.headers['Content-Type'])) || ''
+          const contentEncoding = (proxyRes.headers && (proxyRes.headers['content-encoding'] || proxyRes.headers['Content-Encoding'])) || ''
+          const isText = String(contentType).indexOf('text/') === 0 || String(contentType).indexOf('application/json') >= 0 || String(contentType).indexOf('application/javascript') >= 0
+          const isCompressed = !!contentEncoding
+          
+          let responseText = ''
+          try {
+             if (isText && isCompressed) {
+                // 如果是压缩的响应，目前没有解压逻辑，这里直接转字符串可能乱码
+                // 暂时不处理压缩响应的文本读取，或者提示不支持
+             } else if (isText) {
+                responseText = responseBuffer.toString('utf8')
+                
+                // onResponse hook for Proxy
+                if (hookModule.onResponse) {
+                    try {
+                        let body = responseText;
+                        try { body = JSON.parse(responseText); } catch(e) {}
+                        
+                        const newBody = await hookModule.onResponse({ body, req, res, statusCode: proxyRes.statusCode, Mock });
+                        
+                        if (newBody !== undefined) {
+                            if (typeof newBody === 'object') {
+                                responseText = JSON.stringify(newBody);
+                            } else {
+                                responseText = String(newBody);
+                            }
+                            responseBuffer = Buffer.from(responseText);
+                        }
+                    } catch(e) { console.error('Proxy onResponse hook error', e) }
+                }
+             }
+          } catch(e) {}
+
+          const bodyText = req.body ? truncateString(JSON.stringify(req.body), 20000) : ''
+          logProxy('proxy res', {
+            routeId: hit.id,
+            statusCode: proxyRes.statusCode,
+            contentType,
+            contentEncoding,
+            isText,
+            bytes: responseBuffer && responseBuffer.length,
+          })
+          try {
+            (async () => {
+              try {
+                if (db && db.proxyLog) {
+                  await db.proxyLog.create({
+                    routeId: hit.id,
+                    method: req.method,
+                    pathname: req._parsedUrl && req._parsedUrl.pathname,
+                    query: req._parsedUrl && req._parsedUrl.query,
+                    url: req.url,
+                    body: bodyText,
+                    target: hit.target,
+                    statusCode: proxyRes.statusCode,
+                    response: truncateString(responseText, 20000),
+                  })
+                }
+                if (db && db.proxyInterface) {
+                  const pathname = req._parsedUrl && req._parsedUrl.pathname
+                  if (pathname) {
+                    const [iface, created] = await db.proxyInterface.findOrCreate({
+                      where: {
+                        routeId: hit.id,
+                        method: req.method,
+                        pathname: pathname
+                      },
+                      defaults: {
+                        reqQuery: req._parsedUrl.query,
+                        reqHeaders: JSON.stringify(req.headers),
+                        reqBody: bodyText,
+                        resBody: truncateString(responseText, 20000),
+                        statusCode: proxyRes.statusCode
+                      }
+                    })
+                    if (!created && iface.mode && iface.mode !== 'proxy') {
+                      // 非代理模式下不更新接口数据
+                    } else if (!created && proxyRes.statusCode >= 200 && proxyRes.statusCode < 300) {
+                      await iface.update({
+                        reqQuery: req._parsedUrl.query,
+                        reqHeaders: JSON.stringify(req.headers),
+                        reqBody: bodyText,
+                        resBody: truncateString(responseText, 20000),
+                        statusCode: proxyRes.statusCode
+                      })
+                    } else if (!created && (!iface.resBody || iface.statusCode >= 400)) {
+                       // 如果之前记录的是失败的，或者没有记录过返回结果，这次虽然不是200-299，但也更新一下，保留最后一次状态
+                       await iface.update({
+                        reqQuery: req._parsedUrl.query,
+                        reqHeaders: JSON.stringify(req.headers),
+                        reqBody: bodyText,
+                        resBody: truncateString(responseText, 20000),
+                        statusCode: proxyRes.statusCode
+                      })
+                    }
+                  }
+                }
+              } catch (e) {
+                logProxy('db record error', e && e.message)
+              }
+            })()
+          } catch (e) {}
+
+          // 强制返回 Buffer 以避免 responseInterceptor 内部错误
+          return responseBuffer
+        }),
+      }
+    }).call(this, req, res, next)
+  } catch (e) {
+    logProxy('middleware error', { message: e && e.message, stack: e && e.stack })
+    next(e)
+  }
+})
+
+app.use(express.static(path.join(__dirname, 'public')))
+
+app.get('*', function (req, res) {
+  res.sendFile(path.join(__dirname, 'public', 'index.html'))
+})
+
+const port = Number(process.env.PORT) || 8081
+const server = app.listen(port, function () {
+  console.log('listen port' + port, 'http://localhost:' + port)
+})
+
+server.on('upgrade', async function (req, socket, head) {
+  try {
+    const urlObj = new URL(req.url, 'http://localhost')
+    const pathname = urlObj.pathname
+
+    const routes = await getEnabledRoutes()
+    const hit = routes.find(r => pathname === r.routePrefix || pathname.indexOf(r.routePrefix + '/') === 0)
+
+    if (!hit) {
+      socket.destroy()
+      return
+    }
+
+    const pathRewriteObj = safeJsonParse(hit.pathRewrite, {})
+    const changeOrigin = hit.changeOrigin !== false
+
+    let targetPath = req.url
+    for (const key in pathRewriteObj) {
+      const regex = new RegExp(key)
+      if (regex.test(targetPath)) {
+        targetPath = targetPath.replace(regex, pathRewriteObj[key])
+        break
+      }
+    }
+    req.url = targetPath
+
+    const proxy = httpProxy.createProxyServer({
+      target: hit.target,
+      changeOrigin,
+      ws: true,
+      secure: false
+    })
+
+    proxy.on('error', function (err) {
+      console.error('ws proxy error', err)
+      socket.end()
+    })
+
+    proxy.ws(req, socket, head)
+  } catch (e) {
+    console.error(e)
+    socket.destroy()
+  }
+})
+
+if (db.ready && typeof db.ready.then === 'function') {
+  db.ready.then(ensureDefaultRoute).catch(function () {})
+} else {
+  ensureDefaultRoute()
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "rwz-dev-proxy",
+  "version": "1.0.0",
+  "description": "A development proxy server",
+  "bin": {
+    "rwz-dev-proxy": "./bin/rwz-dev-proxy.js"
+  },
+  "files": [
+    "bin",
+    "public",
+    "views",
+    "index.js",
+    "db.js"
+  ],
+  "scripts": {
+    "start": "node ./bin/rwz-dev-proxy.js",
+    "dev": "supervisor -i node_modules ./index.js",
+    "proxy": "node ./index.js"
+  },
+  "dependencies": {
+    "cookie-parser": "~1.4.4",
+    "debug": "~2.6.9",
+    "ejs": "~2.6.1",
+    "express": "~4.16.1",
+    "http-errors": "~1.6.3",
+    "http-proxy-middleware": "^3.0.5",
+    "mockjs": "^1.1.0",
+    "morgan": "~1.9.1",
+    "sequelize": "^6.16.0",
+    "sqlite3": "^5.0.2"
+  }
+}