sumor 1.3.0 → 2.0.0

package/modules/logger/index.js

@@ -0,0 +1,82 @@
+import stringifyCMD from './convert/stringifyCMD.js'
+import stringifyFile from './convert/stringifyFile.js'
+import { cacheWriteFile } from './logFileOperator.js'
+
+function getLogger({ namespace = 'default', transform = () => {}, id = '', path: logPath = '' }) {
+  // 确保命名空间是小写，避免大小写问题
+  namespace = namespace.toLowerCase()
+
+  const showInConsole = (level, message) => {
+    console.log(
+      stringifyCMD({
+        level,
+        namespace,
+        id
+      }),
+      message
+    )
+  }
+
+  const convertToFileString = (level, message, code, data) => {
+    let messageString = ''
+    if (message !== undefined && message !== null) {
+      switch (typeof message) {
+        case 'object':
+          try {
+            messageString = JSON.stringify(message)
+          } catch (e) {
+            messageString = '[object Object]'
+          }
+          break
+        case 'function':
+          messageString = '[Function: ' + (message.name || 'anonymous') + ']'
+          break
+        case 'symbol':
+          messageString = message.toString()
+          break
+        default:
+          messageString = String(message)
+      }
+    } else {
+      messageString = ''
+    }
+    return stringifyFile({
+      level,
+      message: messageString,
+      code,
+      data,
+      namespace,
+      id
+    })
+  }
+
+  function asyncLog(level, code, data) {
+    let message
+    if (typeof code === 'string') {
+      message = transform(namespace, code, data)
+    }
+    let actualCode, actualMessage
+    if (message) {
+      actualCode = code
+      actualMessage = message
+    } else {
+      actualCode = null
+      actualMessage = code
+    }
+    const fileString = convertToFileString(level, actualMessage, actualCode, data)
+    showInConsole(level, actualMessage)
+    if (logPath) {
+      cacheWriteFile(logPath, fileString)
+    }
+  }
+
+  return {
+    trace: asyncLog.bind(null, 'trace'),
+    debug: asyncLog.bind(null, 'debug'),
+    info: asyncLog.bind(null, 'info'),
+    warn: asyncLog.bind(null, 'warn'),
+    error: asyncLog.bind(null, 'error')
+  }
+}
+
+export default getLogger

package/modules/logger/index.test.js

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeAll, afterAll } from '@jest/globals'
+import getLogger from './index.js'
+import { setCacheInterval } from './logFileOperator.js'
+import fse from 'fs-extra'
+
+const logFolder = `${process.cwd()}/tmp/logger`
+
+describe('日志器', () => {
+  beforeAll(async () => {
+    setCacheInterval(50)
+    await fse.ensureDir(logFolder)
+  })
+  afterAll(async () => {
+    await fse.remove(logFolder)
+  })
+
+  it('记录日志消息到控制台和文件', async () => {
+    const logFile = `${logFolder}/default.log`
+    const logger = getLogger({
+      path: logFile
+    })
+
+    logger.info('测试消息')
+    await new Promise(resolve => setTimeout(resolve, 100))
+
+    const logContent = await fse.readFile(logFile, 'utf-8')
+    expect(logContent).toContain('default')
+    expect(logContent).toContain(encodeURIComponent('测试消息'))
+    expect(logContent).toContain('info')
+  })
+
+  it('消息不是字符串时，应该转换为字符串', async () => {
+    const logFile = `${logFolder}/nonStringMessage.log`
+    const logger = getLogger({
+      path: logFile
+    })
+
+    logger.info({ key: 'value' })
+    logger.info([1, 2, 3])
+    logger.info(() => 'function')
+    logger.info(Symbol('symbol'))
+    await new Promise(resolve => setTimeout(resolve, 100))
+
+    const logContent = await fse.readFile(logFile, 'utf-8')
+    expect(logContent).toContain('default')
+    expect(logContent).toContain(encodeURIComponent('"key":"value"'))
+    expect(logContent).toContain(encodeURIComponent('[1,2,3]'))
+    expect(logContent).toContain(encodeURIComponent('[Function: anonymous]'))
+    expect(logContent).toContain(encodeURIComponent('Symbol(symbol)'))
+  })
+
+  it('应该处理不同的日志级别', async () => {
+    const logFile = `${logFolder}/level.log`
+    const logger = getLogger({
+      namespace: 'test',
+      path: logFile
+    })
+    logger.error('错误信息')
+    logger.warn('警告信息')
+    logger.debug('调试信息')
+    await new Promise(resolve => setTimeout(resolve, 100))
+
+    const logContent = await fse.readFile(logFile, 'utf-8')
+    expect(logContent).toContain('test')
+    expect(logContent).toContain(encodeURIComponent('错误信息'))
+    expect(logContent).toContain('error')
+    expect(logContent).toContain(encodeURIComponent('警告信息'))
+    expect(logContent).toContain('warn')
+    expect(logContent).toContain(encodeURIComponent('调试信息'))
+    expect(logContent).toContain('debug')
+  })
+
+  it('测试消息转换', async () => {
+    const logFile = `${logFolder}/transform.log`
+    const logger = getLogger({
+      namespace: 'transform',
+      path: logFile,
+      transform: (namespace, code, data) =>
+        `转换后的消息: ${namespace} ${code} ${JSON.stringify(data)}`
+    })
+
+    logger.info('测试消息', { key: 'value' })
+    await new Promise(resolve => setTimeout(resolve, 100))
+    const logContent = await fse.readFile(logFile, 'utf-8')
+    expect(logContent).toContain('transform')
+    expect(logContent).toContain(
+      encodeURIComponent('转换后的消息: transform 测试消息 {"key":"value"}')
+    )
+    expect(logContent).toContain('info')
+  })
+
+  it('对象无法序列化时，应该记录为[object Object]', async () => {
+    const logFile = `${logFolder}/unserializableObject.log`
+    const logger = getLogger({
+      path: logFile
+    })
+
+    const circularObj = {}
+    circularObj.self = circularObj
+
+    logger.info(circularObj)
+    await new Promise(resolve => setTimeout(resolve, 100))
+
+    const logContent = await fse.readFile(logFile, 'utf-8')
+    expect(logContent).toContain('default')
+    expect(logContent).toContain(encodeURIComponent('[object Object]'))
+    expect(logContent).toContain('info')
+  })
+
+  it('消息为null时，应该记录为空字符串', async () => {
+    const logFile = `${logFolder}/nullMessage.log`
+    const logger = getLogger({
+      path: logFile
+    })
+
+    logger.info(null)
+    await new Promise(resolve => setTimeout(resolve, 100))
+
+    const logContent = await fse.readFile(logFile, 'utf-8')
+    expect(logContent).toContain('default')
+    expect(logContent).toContain(encodeURIComponent(''))
+    expect(logContent).toContain('info')
+  })
+})

package/modules/logger/logFileOperator.js

@@ -0,0 +1,50 @@
+import fse from 'fs-extra'
+import { setTimeout } from 'timers'
+
+const cache = {}
+let cacheInterval = 500
+
+const writeFile = async (fileName, logContent) => {
+  await fse.ensureFile(fileName)
+  await fse.appendFile(fileName, logContent + '\n')
+}
+
+const setTimer = fileName => {
+  return setTimeout(async () => {
+    const fileCache = cache[fileName]
+    if (fileCache) {
+      const logContent = fileCache.cache.join('\n')
+      fileCache.cache = []
+      fileCache.busy = true
+      await writeFile(fileName, logContent)
+      fileCache.busy = false
+
+      if (fileCache.cache.length === 0) {
+        cache[fileName] = {
+          timer: null,
+          busy: false,
+          cache: []
+        }
+      } else {
+        fileCache.timer = setTimer(fileName)
+      }
+    }
+  }, cacheInterval)
+}
+
+const cacheWriteFile = (fileName, logContent) => {
+  if (!cache[fileName] || !cache[fileName].timer) {
+    cache[fileName] = {
+      busy: false,
+      timer: setTimer(fileName),
+      cache: []
+    }
+  }
+  cache[fileName].cache.push(logContent)
+}
+
+const setCacheInterval = interval => {
+  cacheInterval = interval
+}
+
+export { writeFile, cacheWriteFile, setCacheInterval }

package/modules/logger/logFileOperator.test.js

@@ -0,0 +1,69 @@
+// logFileOperator.test.ts
+// 此文件用于测试 logFileOperator.ts 中的 writeFile 和 cacheWriteFile 方法
+import { describe, it, expect, beforeAll } from '@jest/globals'
+import { writeFile, cacheWriteFile, setCacheInterval } from './logFileOperator.js'
+import fse from 'fs-extra'
+import path from 'path'
+import tmp from '../../test-utils/tmp.js'
+
+describe('测试 logFileOperator', () => {
+  let tempFolder
+
+  beforeAll(async () => {
+    tempFolder = await tmp('logFileOperator')
+  })
+
+  it('测试 writeFile 方法', async () => {
+    setCacheInterval(50)
+    const tempFile = path.join(tempFolder, 'fileOperator1.log')
+    const log = '测试写入日志'
+    await writeFile(tempFile, log)
+    const content = await fse.readFile(tempFile, 'utf8')
+    // 检查日志内容是否正确写入
+    expect(content.trim()).toBe(log)
+  })
+
+  it('测试 cacheWriteFile 方法', async () => {
+    setCacheInterval(50)
+    const tempFile = path.join(tempFolder, 'fileOperator2.log')
+    const log1 = '缓存日志1'
+    const log2 = '缓存日志2'
+
+    await cacheWriteFile(tempFile, log1)
+    await cacheWriteFile(tempFile, log2)
+
+    // 延时等待写入完成
+    await new Promise(resolve => setTimeout(resolve, 100))
+
+    const content = await fse.readFile(tempFile, 'utf8')
+    // 检查文件中是否包含所有缓存日志
+    expect(content).toContain(log1)
+    expect(content).toContain(log2)
+  })
+
+  it('测试 setCacheInterval 功能', async () => {
+    const tempFile = path.join(tempFolder, 'fileOperator3.log')
+    // 设置新的缓存间隔
+    setCacheInterval(100)
+
+    const logA = '日志A'
+    const logB = '日志B'
+
+    await cacheWriteFile(tempFile, logA)
+    await cacheWriteFile(tempFile, logB)
+
+    await new Promise(resolve => setTimeout(resolve, 50))
+
+    const exists1 = await fse.exists(tempFile)
+    expect(exists1).toBe(false)
+
+    // 等待缓存间隔时间到达
+    await new Promise(resolve => setTimeout(resolve, 100))
+
+    const exists2 = await fse.exists(tempFile)
+    expect(exists2).toBe(true)
+    const content2 = await fse.readFile(tempFile, 'utf8')
+    expect(content2).toContain(logA)
+    expect(content2).toContain(logB)
+  })
+})

package/modules/middlewares/apiMiddleware/errorCatcher.js

@@ -0,0 +1,9 @@
+export default middleware => {
+  return async (req, res, next) => {
+    try {
+      await middleware(req, res, next)
+    } catch (e) {
+      next(e, req, res, next)
+    }
+  }
+}

package/modules/middlewares/apiMiddleware/exposeApis/index.js

@@ -0,0 +1,82 @@
+import { register } from '../../../i18n/index.js'
+
+const hasFileParameter = parameters => {
+  let hasFile = false
+  for (const param in parameters) {
+    if (parameters[param].type === 'file') {
+      hasFile = true
+      break
+    }
+  }
+  return hasFile
+}
+
+export default async (apis, logger) => {
+  const exposeApis = {}
+  const i18n = {
+    origin: {}
+  }
+  for (const path in apis) {
+    const apiInfo = apis[path]
+
+    apiInfo.key = path
+    apiInfo.name = apiInfo.name || ''
+    apiInfo.desc = apiInfo.desc || ''
+    apiInfo.parameters = apiInfo.parameters || {}
+    const hasFile = hasFileParameter(apiInfo.parameters)
+    const defaultMethods = hasFile ? ['POST', 'PUT'] : ['GET', 'POST', 'PUT', 'DELETE']
+    if (apiInfo.methods) {
+      // 检查是否包含不合要求的方法，包含则抛出警告日志，并删除该方法
+      const invalidMethods = apiInfo.methods.filter(method => !defaultMethods.includes(method))
+      if (invalidMethods.length > 0) {
+        logger.warn('API_METHOD_NOT_ALLOWED', {
+          path,
+          methods: invalidMethods.join(',')
+        })
+        apiInfo.methods = apiInfo.methods.filter(method => defaultMethods.includes(method))
+      }
+    } else {
+      apiInfo.methods = defaultMethods
+    }
+    apiInfo.callback = apiInfo.callback || null
+
+    for (const parameter in apiInfo.parameters) {
+      const parameterInfo = apiInfo.parameters[parameter] || {}
+      parameterInfo.key = parameter
+      parameterInfo.type = parameterInfo.type || 'string'
+      parameterInfo.required = parameterInfo.required === true
+      parameterInfo.name = parameterInfo.name || ''
+      parameterInfo.desc = parameterInfo.desc || ''
+      parameterInfo.length = parameterInfo.length || null
+      i18n.origin[`parameter.${parameter}.name@${path}`] = parameterInfo.name
+      i18n.origin[`parameter.${parameter}.desc@${path}`] = parameterInfo.desc
+      parameterInfo.rules = parameterInfo.rules || {}
+
+      for (const rule in parameterInfo.rules) {
+        const ruleInfo = parameterInfo.rules[rule]
+        i18n.origin[`parameter.${parameter}.rules.${rule}@${path}`] = ruleInfo.message
+      }
+    }
+
+    const prefix = '/api'
+    const listenPaths = Array.isArray(apiInfo.path)
+      ? apiInfo.path
+      : [apiInfo.path || `${prefix}${path}`] // Renamed listenPath to path
+
+    for (const apiPath of listenPaths) {
+      // 处理国际化原始数据
+      i18n.origin[`name@${path}`] = apiInfo.name
+      exposeApis[apiPath] = {
+        key: apiInfo.key,
+        name: apiInfo.name,
+        desc: apiInfo.desc,
+        parameters: apiInfo.parameters,
+        methods: apiInfo.methods,
+        callback: apiInfo.callback
+      }
+    }
+  }
+
+  await register('API', i18n)
+  return exposeApis
+}

package/modules/middlewares/apiMiddleware/index.js

@@ -0,0 +1,111 @@
+import load from './load/index.js'
+import bodyMiddleware from '../bodyMiddleware/index.js'
+import sendSuccess from './response/sendSuccess.js'
+import sendNotFound from './response/sendNotFound.js'
+import sendError from './response/sendError.js'
+import errorCatcher from './errorCatcher.js'
+import prepareData from './prepareData/index.js'
+import getExposeApis from './exposeApis/index.js'
+import { data as i18nData } from '../../i18n/index.js'
+import metadataToSwagger from './metadataToSwagger.js'
+import swaggerUi from 'swagger-ui-express'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import express from 'express'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+export default apiRoot => {
+  return async app => {
+    const appNamespace = app.namespace('SUMOR_API')
+    const apis = await load(apiRoot)
+    const exposeApis = await getExposeApis(apis, appNamespace.logger)
+    const prefix = '/api'
+    for (const path in exposeApis) {
+      const apiInfo = exposeApis[path]
+
+      let middlewares = [...bodyMiddleware(apiInfo)]
+      const callback = apiInfo.callback
+
+      middlewares.push(async (req, res, next) => {
+        const reqNamespace = req.namespace('SUMOR_API')
+        if (callback) {
+          const dataString = JSON.stringify(req.data)
+          reqNamespace.logger.trace('API_CALLED', {
+            path: req.path,
+            data: dataString
+          })
+          req.data = prepareData(req, apiInfo.key, apiInfo.parameters)
+          const result = await callback(req, res)
+          sendSuccess(req, res, result)
+        } else {
+          // 接口程序加载失败，不可执行
+          throw new reqNamespace.Error('API_PROGRAM_WRONG')
+        }
+      })
+
+      // 捕捉中间件错误
+      middlewares = middlewares.map(errorCatcher)
+
+      middlewares.push((err, req, res, next) => {
+        sendError(req, res, err)
+      })
+
+      // 监听API请求
+      for (const method of apiInfo.methods) {
+        app[method.toLowerCase()](path, middlewares)
+      }
+
+      if (apiInfo.callback) {
+        appNamespace.logger.debug('API_REGISTERED', {
+          path,
+          name: apiInfo.name ? ' - ' + apiInfo.name : ''
+        })
+      } else {
+        appNamespace.logger.error('API_REGISTERED_FAILED', { path })
+      }
+    }
+
+    app.all(`/sumor/i18n`, (req, res) => {
+      sendSuccess(req, res, i18nData)
+    })
+
+    const metadata = {
+      name: '轻呈云应用',
+      desc: '',
+      apis: {}
+    }
+    if (app.sumor && app.sumor.config) {
+      metadata.name = app.sumor.config.name
+      metadata.desc = app.sumor.config.desc
+    }
+    for (const path in exposeApis) {
+      const result = Object.assign({}, exposeApis[path])
+      delete result.callback
+      metadata.apis[path] = result
+    }
+    app.all(`/sumor/metadata`, (req, res) => {
+      sendSuccess(req, res, metadata)
+    })
+
+    // 添加 Swagger UI
+    app.use('/api-docs', express.static(__dirname + '/public'))
+    app.use(
+      '/api-docs',
+      swaggerUi.serve,
+      swaggerUi.setup(metadataToSwagger(metadata), {
+        customCss: '.swagger-ui .topbar, .version-stamp { display: none !important }',
+        customSiteTitle: metadata.name,
+        customfavIcon: './favicon.ico'
+      })
+    )
+
+    app.get('/api', (req, res) => {
+      res.redirect('/api-docs')
+    })
+
+    // 监听prefix，让没匹配到的接口，返回报错页面
+    app.all(`${prefix}/*`, sendNotFound)
+  }
+}

package/modules/middlewares/apiMiddleware/index.test.js

@@ -0,0 +1,145 @@
+import { afterAll, beforeAll, describe, expect, it } from '@jest/globals'
+import axios from 'axios'
+import express from 'express'
+import http from 'http'
+import fse from 'fs-extra'
+import tmp from '../../../test-utils/tmp.js'
+import apiMiddleware from './index.js'
+import i18nMiddleware from '../i18nMiddleware/index.js'
+
+const tmpFolder = await tmp('apiMiddleware')
+
+describe('API Middleware', () => {
+  let app
+  let server
+  let baseURL
+
+  beforeAll(async () => {
+    app = express()
+    app.use(express.json())
+
+    const apiPath = `${tmpFolder}/api`
+    await fse.ensureDir(apiPath)
+    const files = {
+      'hello.js':
+        'export default (req, res) => { const name = req.data.name || "World"; return `Hello, ${name}!`; }', // eslint-disable-line
+      'hello.json': JSON.stringify({
+        name: 'Hello API',
+        path: ['/api/hello', '/api/hello/:name'],
+        parameters: {
+          name: {
+            type: 'string',
+            required: true,
+            description: 'Name of the person to greet'
+          }
+        }
+      }),
+      'syntaxError.js': 'syntax error`' // eslint-disable-line
+    }
+    for (const [fileName, content] of Object.entries(files)) {
+      await fse.writeFile(`${apiPath}/${fileName}`, content)
+    }
+
+    await i18nMiddleware(app, tmpFolder + '/i18n')
+    await apiMiddleware(apiPath)(app)
+
+    await new Promise(resolve => {
+      server = http.createServer(app).listen(() => {
+        const { port } = server.address()
+        baseURL = `http://localhost:${port}`
+        resolve()
+      })
+    })
+  })
+
+  afterAll(done => {
+    server.close(done)
+  })
+
+  it('验证参数传递正常', async () => {
+    // 测试缺少必填参数
+    let error
+    try {
+      await axios.get(`${baseURL}/api/hello`)
+    } catch (e) {
+      error = e
+    }
+    expect(error).toBeDefined()
+    expect(error.response.status).toBe(400)
+    expect(error.response.data.code).toBe('API_PARAMETERS_NOT_VALID')
+    expect(error.response.data.errors[0].code).toBe('API_PARAMETER_NOT_VALID')
+    expect(error.response.data.errors[0].errors[0].code).toBe('API_PARAMETER_REQUIRED')
+
+    // 测试params
+    const response1 = await axios.get(`${baseURL}/api/hello/Alice`)
+    expect(response1.status).toBe(200)
+    expect(response1.data.data).toBe('Hello, Alice!')
+
+    // 测试query
+    const response2 = await axios.get(`${baseURL}/api/hello?name=Bob`)
+    expect(response2.status).toBe(200)
+    expect(response2.data.data).toBe('Hello, Bob!')
+
+    // 测试body
+    const response3 = await axios.post(`${baseURL}/api/hello`, { name: 'Charlie' })
+    expect(response3.status).toBe(200)
+    expect(response3.data.data).toBe('Hello, Charlie!')
+
+    // 测试HTML响应
+    const response4 = await axios.get(`${baseURL}/api/hello`, {
+      params: { name: 'John' },
+      headers: {
+        Accept: 'text/html'
+      }
+    })
+    expect(response4.status).toBe(200)
+    expect(response4.data).toContain('Hello, John!</pre>')
+  })
+
+  it('验证错误处理', async () => {
+    let error
+    try {
+      await axios.get(`${baseURL}/api/syntaxError`)
+    } catch (e) {
+      error = e
+    }
+
+    expect(error).toBeDefined()
+    expect(error.response.status).toBe(500)
+    expect(error.response.data.code).toBe('API_PROGRAM_WRONG')
+  })
+
+  it('获取API元数据', async () => {
+    const response = await axios.get(`${baseURL}/sumor/metadata`)
+    expect(response.status).toBe(200)
+    expect(response.data.code).toBe('OK')
+    expect(response.data.data.apis['/api/hello']).toBeDefined()
+  })
+
+  it('未找到接口', async () => {
+    let error
+    try {
+      await axios.get(`${baseURL}/api/nonexistent`)
+    } catch (e) {
+      error = e
+    }
+    expect(error).toBeDefined()
+    expect(error.response.status).toBe(404)
+    expect(error.response.data.code).toBe('API_NOT_FOUND')
+  })
+
+  it('长文本处理', async () => {
+    const longText = 'a'.repeat(10000) + 'DEMO'
+    const response = await axios.post(
+      `${baseURL}/api/hello`,
+      { name: longText },
+      {
+        headers: {
+          Accept: 'text/html'
+        }
+      }
+    )
+    expect(response.status).toBe(200)
+    expect(response.data).toContain('DEMO')
+  })
+})