sumor 1.3.0 → 2.0.0

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

@@ -0,0 +1,121 @@
+import { describe, it, expect } from '@jest/globals'
+import prepareData from './index.js'
+
+describe('prepareData', () => {
+  it('应该转换类型并验证参数', () => {
+    const req = {
+      data: {
+        name: 'John',
+        age: '25'
+      },
+      namespace: namespace => {
+        if (namespace === 'SUMOR_API') {
+          return {
+            Error: class extends Error {
+              constructor(code, details) {
+                super(code)
+                this.details = details
+              }
+            }
+          }
+        }
+        if (namespace === 'API') {
+          return {
+            Error: class extends Error {
+              constructor(code, details) {
+                super(code)
+                this.details = details
+              }
+            }
+          }
+        }
+      }
+    }
+
+    const parameters = {
+      name: { type: 'string', required: true, length: 10 },
+      age: { type: 'number', required: true }
+    }
+
+    const result = prepareData(req, '/unit-test', parameters)
+
+    expect(result).toEqual({
+      name: 'John',
+      age: 25
+    })
+  })
+
+  it('应该抛出缺少必需参数的错误', () => {
+    const req = {
+      data: {},
+      namespace: namespace => {
+        if (namespace === 'SUMOR_API') {
+          return {
+            Error: class extends Error {
+              constructor(code, details) {
+                super(code)
+                this.details = details
+              }
+            }
+          }
+        }
+        if (namespace === 'API') {
+          return {
+            Error: class extends Error {
+              constructor(code, details) {
+                super(code)
+                this.details = details
+              }
+            }
+          }
+        }
+      }
+    }
+
+    const parameters = {
+      name: { type: 'string', required: true }
+    }
+
+    expect(() => prepareData(req, '/unit-test', parameters)).toThrowError(
+      'API_PARAMETERS_NOT_VALID'
+    )
+  })
+
+  it('应该抛出字符串超出长度限制的错误', () => {
+    const req = {
+      data: {
+        name: 'This is a very long name'
+      },
+      namespace: namespace => {
+        if (namespace === 'SUMOR_API') {
+          return {
+            Error: class extends Error {
+              constructor(code, details) {
+                super(code)
+                this.details = details
+              }
+            }
+          }
+        }
+        if (namespace === 'API') {
+          return {
+            Error: class extends Error {
+              constructor(code, details) {
+                super(code)
+                this.details = details
+              }
+            }
+          }
+        }
+      }
+    }
+
+    const parameters = {
+      name: { type: 'string', required: true, length: 10 }
+    }
+
+    expect(() => prepareData(req, '/unit-test', parameters)).toThrowError(
+      'API_PARAMETERS_NOT_VALID'
+    )
+  })
+})

package/modules/middlewares/apiMiddleware/prepareData/validate/checkLength.js

@@ -0,0 +1,26 @@
+export default (parameter, value) => {
+  if (parameter.length && value !== null) {
+    switch (parameter.type) {
+      case 'string':
+        if (value.length > parameter.length) {
+          return true
+        }
+        break
+      case 'number':
+        if (value.toString().length > parameter.length) {
+          return true
+        }
+        break
+      case 'array':
+      case 'file':
+        if (Array.isArray(value) && value.length > parameter.length) {
+          return true
+        }
+        break
+      default:
+        break
+    }
+  }
+
+  return false
+}

package/modules/middlewares/apiMiddleware/prepareData/validate/checkLength.test.js

@@ -0,0 +1,52 @@
+import { describe, it, expect } from '@jest/globals'
+import checkLength from './checkLength.js'
+
+describe('数据长度检查', () => {
+  it('应该返回 true，当字符串长度超过限制', () => {
+    const parameter = { type: 'string', length: 5 }
+    const value = 'exceeds'
+    expect(checkLength(parameter, value)).toBe(true)
+  })
+
+  it('应该返回 false，当字符串长度在限制范围内', () => {
+    const parameter = { type: 'string', length: 10 }
+    const value = 'short'
+    expect(checkLength(parameter, value)).toBe(false)
+  })
+
+  it('应该返回 true，当数字长度超过限制', () => {
+    const parameter = { type: 'number', length: 3 }
+    const value = 12345
+    expect(checkLength(parameter, value)).toBe(true)
+  })
+
+  it('应该返回 false，当数字长度在限制范围内', () => {
+    const parameter = { type: 'number', length: 5 }
+    const value = 123
+    expect(checkLength(parameter, value)).toBe(false)
+  })
+
+  it('应该返回 true，当数组长度超过限制', () => {
+    const parameter = { type: 'array', length: 2 }
+    const value = [1, 2, 3]
+    expect(checkLength(parameter, value)).toBe(true)
+  })
+
+  it('应该返回 false，当数组长度在限制范围内', () => {
+    const parameter = { type: 'array', length: 5 }
+    const value = [1, 2, 3]
+    expect(checkLength(parameter, value)).toBe(false)
+  })
+
+  it('应该返回 false，当值为 null', () => {
+    const parameter = { type: 'string', length: 5 }
+    const value = null
+    expect(checkLength(parameter, value)).toBe(false)
+  })
+
+  it('应该返回 false，当类型不受支持', () => {
+    const parameter = { type: 'unsupported', length: 5 }
+    const value = 'test'
+    expect(checkLength(parameter, value)).toBe(false)
+  })
+})

package/modules/middlewares/apiMiddleware/prepareData/validate/index.js

@@ -0,0 +1,30 @@
+import checkLength from './checkLength.js'
+
+export default (Error, APIError, apiKey, parameter, value) => {
+  const errors = []
+
+  // 检查必填项
+  if (parameter.required) {
+    if (value === null || (parameter.type === 'string' && value === '')) {
+      errors.push(new Error('API_PARAMETER_REQUIRED'))
+    }
+  }
+
+  // 检查长度
+  if (checkLength(parameter, value)) {
+    errors.push(new Error('API_PARAMETER_TOO_LONG', { length: parameter.length }))
+  }
+
+  // 检查规则
+  for (const rule in parameter.rules) {
+    const ruleInfo = parameter.rules[rule]
+    if (ruleInfo.expression) {
+      const regexp = new RegExp(ruleInfo.expression)
+      if (!regexp.test(value)) {
+        errors.push(new APIError(`parameter.${parameter.key}.rules.${rule}@${apiKey}`))
+      }
+    }
+  }
+
+  return errors
+}

package/modules/middlewares/apiMiddleware/response/sendError.js

@@ -0,0 +1,57 @@
+import sendResponse from './sendResponse.js'
+
+export default (req, res, err) => {
+  const apiNamespace = req.namespace('SUMOR_API')
+
+  let error
+  if (err.json) {
+    error = err.json()
+  } else {
+    // 非可控错误
+    error = {
+      code: 'API_ERROR',
+      message: apiNamespace.i18n('API_ERROR_UNKNOWN_ERROR')
+    }
+    apiNamespace.logger.error('API_ERROR_UNKNOWN_MESSAGE', {
+      path: req.path
+    })
+    apiNamespace.logger.error(err)
+  }
+
+  let code
+  let svg
+  switch (error.code) {
+    case 'API_PARAMETERS_NOT_VALID':
+      code = 400
+      svg = 'undraw_complete-form'
+      break
+    case 'LOGIN_EXPIRED':
+      code = 401
+      svg = 'undraw_login'
+      break
+    case 'PERMISSION_DENIED':
+      code = 403
+      svg = 'undraw_access-denied'
+      break
+    default:
+      code = 500
+      svg = 'undraw_alert'
+      break
+  }
+
+  const data = {
+    svg,
+    status: code,
+    json: error,
+    html: {
+      title: error.message,
+      major: error.message,
+      minor: '',
+      showMore: true,
+      moreButton: apiNamespace.i18n('API_ERROR_SHOW_MORE'),
+      moreContent: JSON.stringify(error, null, 4)
+    }
+  }
+
+  sendResponse(req, res, data)
+}

package/modules/middlewares/apiMiddleware/response/sendError.test.js

@@ -0,0 +1,251 @@
+import { afterAll, beforeAll, describe, expect, it } from '@jest/globals'
+import axios from 'axios'
+import express from 'express'
+import i18nMiddleware from '../../i18nMiddleware/index.js'
+import http from 'http'
+import fse from 'fs-extra'
+import sendError from './sendError.js'
+
+const tmpTroubleshooting = './tmp/testTroubleshooting'
+
+describe('Error Middleware', () => {
+  let app
+  let server
+  let baseURL
+
+  beforeAll(async () => {
+    app = express()
+    app.use(express.json())
+
+    process.env.LANGUAGE = 'en-US'
+    await i18nMiddleware(app)
+
+    app.get('/error', (req, res, next) => {
+      const error = new Error('Test Error')
+      error.code = 'TEST_ERROR'
+      throw error
+    })
+    app.get('/unknown_error', (req, res, next) => {
+      throw new Error('Unknown Error')
+    })
+
+    app.get('/json_error', (req, res, next) => {
+      const error = new Error('JSON Error')
+      error.code = 'JSON_ERROR'
+      error.json = () => {
+        return {
+          code: error.code,
+          message: error.message
+        }
+      }
+      throw error
+    })
+
+    app.get('/error_no_code', (req, res, next) => {
+      throw new Error('Unknown Error')
+    })
+
+    app.get('/no_error', (req, res, next) => {
+      res.status(200).send('No Error')
+    })
+
+    app.get('/no_login', (req, res, next) => {
+      sendError(req, res, {
+        json: () => {
+          return {
+            code: 'LOGIN_EXPIRED',
+            message: 'Login expired'
+          }
+        }
+      })
+    })
+
+    app.get('/no_permission', (req, res, next) => {
+      sendError(req, res, {
+        json: () => {
+          return {
+            code: 'PERMISSION_DENIED',
+            message: 'Permission denied'
+          }
+        }
+      })
+    })
+
+    app.use((err, req, res, next) => {
+      sendError(req, res, err)
+    })
+
+    app.get('*', (req, res, next) => {
+      res.status(404).send('Not Found')
+    })
+
+    await new Promise(resolve => {
+      server = http.createServer(app).listen(() => {
+        const { port } = server.address()
+        baseURL = `http://localhost:${port}`
+        resolve()
+      })
+    })
+  })
+
+  afterAll(done => {
+    server.close(done)
+  })
+
+  it('应该通过 HTML 返回错误信息', async () => {
+    let error
+    try {
+      await axios.get(`${baseURL}/error`, {
+        headers: {
+          Accept: 'text/html',
+          'Accept-Language': 'en-US'
+        }
+      })
+    } catch (e) {
+      error = e
+    }
+    expect(error).toBeDefined()
+    expect(error.response.status).toBe(500)
+    expect(error.response.data).toContain(`<title>Interface error`)
+    expect(error.response.data).toContain(`Show more technical details`)
+
+    // 保存 HTML 文件到临时目录
+    const tempDir = `${tmpTroubleshooting}/errorMiddleware.html`
+    await fse.ensureDir(tmpTroubleshooting)
+    await fse.writeFile(tempDir, error.response.data)
+  })
+
+  it('应该通过 JSON 返回错误信息', async () => {
+    let error
+    try {
+      await axios.get(`${baseURL}/error`, {
+        headers: { Accept: 'application/json' }
+      })
+    } catch (e) {
+      error = e
+    }
+    expect(error).toBeDefined()
+    expect(error.response.status).toBe(500)
+    expect(error.response.data.code).toEqual('API_ERROR')
+
+    // 保存 HTML 文件到临时目录
+    const tempDir = `${tmpTroubleshooting}/errorMiddleware.json`
+    await fse.ensureDir(tmpTroubleshooting)
+    await fse.writeJson(tempDir, error.response.data)
+  })
+
+  it('国际化支持', async () => {
+    let error
+    try {
+      await axios.get(`${baseURL}/error`, {
+        headers: {
+          Accept: 'text/html',
+          'Accept-Language': 'zh-CN'
+        }
+      })
+    } catch (e) {
+      error = e
+    }
+    expect(error).toBeDefined()
+    expect(error.response.status).toBe(500)
+    expect(error.response.data).toContain(`<title>接口异常`)
+    expect(error.response.data).toContain(`显示更多技术细节`)
+
+    // 保存 HTML 文件到临时目录
+    const tempDir = `${tmpTroubleshooting}/errorMiddleware_zh-CN.html`
+    await fse.ensureDir(tmpTroubleshooting)
+    await fse.writeFile(tempDir, error.response.data)
+  })
+
+  it('应该通过 JSON 返回自定义错误信息', async () => {
+    let error
+    try {
+      await axios.get(`${baseURL}/json_error`, {
+        headers: { Accept: 'application/json' }
+      })
+    } catch (e) {
+      error = e
+    }
+    expect(error).toBeDefined()
+    expect(error.response.status).toBe(500)
+    expect(error.response.data).toEqual({
+      code: 'JSON_ERROR',
+      message: 'JSON Error'
+    })
+
+    // 保存 JSON 文件到临时目录
+    const tempDir = `${tmpTroubleshooting}/errorMiddleware_json.json`
+    await fse.ensureDir(tmpTroubleshooting)
+    await fse.writeJson(tempDir, error.response.data)
+  })
+
+  it('应该返回 404 错误', async () => {
+    const response = await axios.get(`${baseURL}/not-found`, {
+      validateStatus: status => status === 404
+    })
+    expect(response.status).toBe(404)
+    expect(response.data).toBe('Not Found')
+  })
+
+  it('应该返回 200 状态码', async () => {
+    const response = await axios.get(`${baseURL}/no_error`)
+    expect(response.status).toBe(200)
+    expect(response.data).toBe('No Error')
+  })
+
+  it('未知错误', async () => {
+    let error
+    try {
+      await axios.get(`${baseURL}/error_no_code`, {
+        headers: {
+          Accept: 'application/json',
+          'Accept-Language': 'zh-CN'
+        }
+      })
+    } catch (e) {
+      error = e
+    }
+    expect(error).toBeDefined()
+    expect(error.response.status).toBe(500)
+    expect(error.response.data.message).toContain('接口异常')
+
+    // 保存 JSON 文件到临时目录
+    const tempDir = `${tmpTroubleshooting}/errorMiddleware_no_code.json`
+    await fse.ensureDir(tmpTroubleshooting)
+    await fse.writeJson(tempDir, error.response.data)
+  })
+
+  it('应该返回 401 状态码，当错误代码为 LOGIN_EXPIRED', async () => {
+    let error
+    try {
+      await axios.get(`${baseURL}/no_login`, {
+        headers: {
+          Accept: 'application/json',
+          'Accept-Language': 'en-US'
+        }
+      })
+    } catch (e) {
+      error = e
+    }
+    expect(error).toBeDefined()
+    expect(error.response.status).toBe(401)
+    expect(error.response.data.code).toEqual('LOGIN_EXPIRED')
+  })
+
+  it('应该返回 403 状态码，当错误代码为 PERMISSION_DENIED', async () => {
+    let error
+    try {
+      await axios.get(`${baseURL}/no_permission`, {
+        headers: {
+          Accept: 'application/json',
+          'Accept-Language': 'en-US'
+        }
+      })
+    } catch (e) {
+      error = e
+    }
+    expect(error).toBeDefined()
+    expect(error.response.status).toBe(403)
+    expect(error.response.data.code).toEqual('PERMISSION_DENIED')
+  })
+})

package/modules/middlewares/apiMiddleware/response/sendNotFound.js

@@ -0,0 +1,26 @@
+import sendResponse from './sendResponse.js'
+export default (req, res) => {
+  const apiNamespace = req.namespace('SUMOR_API')
+
+  const name = apiNamespace.i18n('API_NOT_FOUND')
+  const detail = apiNamespace.i18n('API_NOT_FOUND_DETAIL')
+
+  const data = {
+    svg: 'undraw_alert',
+    status: 404,
+    json: {
+      code: 'API_NOT_FOUND',
+      message: detail
+    },
+    html: {
+      title: name,
+      major: name,
+      minor: detail,
+      showMore: true,
+      moreButton: '',
+      moreContent: ''
+    }
+  }
+
+  sendResponse(req, res, data)
+}

package/modules/middlewares/apiMiddleware/response/sendResponse.js

@@ -0,0 +1,25 @@
+import alertPage from '../../../alertPage/index.js'
+
+export default function sendResponse(req, res, data) {
+  const accept = req.headers.accept
+  const isJson = accept && accept.indexOf('application/json') !== -1
+
+  if (isJson) {
+    res.set('Content-Type', 'application/json;charset=utf-8')
+    res.status(data.status).json(data.json)
+  } else {
+    res.set('Content-Type', 'text/html;charset=utf-8')
+    res.status(data.status).send(
+      alertPage({
+        svg: data.svg,
+        status: data.status,
+        title: data.html.title,
+        major: data.html.major,
+        minor: data.html.minor,
+        showMore: data.html.showMore,
+        moreButton: data.html.moreButton,
+        moreContent: data.html.moreContent
+      })
+    )
+  }
+}

package/modules/middlewares/apiMiddleware/response/sendSuccess.js

@@ -0,0 +1,30 @@
+import sendResponse from './sendResponse.js'
+export default (req, res, result) => {
+  const apiNamespace = req.namespace('SUMOR_API')
+
+  const name = apiNamespace.i18n('API_CALL_DEFAULT_TITLE')
+
+  let moreContent = result
+  if (typeof result !== 'string') {
+    moreContent = JSON.stringify(result, null, 4)
+  }
+
+  const data = {
+    svg: 'undraw_celebration', // 'undraw_data-processing',
+    status: 200,
+    json: {
+      code: 'OK',
+      data: result
+    },
+    html: {
+      title: name,
+      major: name,
+      minor: '',
+      showMore: false,
+      moreButton: apiNamespace.i18n('API_CALL_SHOW_MORE'),
+      moreContent
+    }
+  }
+
+  sendResponse(req, res, data)
+}

package/modules/middlewares/bodyMiddleware/cleanupFiles.js

@@ -0,0 +1,14 @@
+import fse from 'fs-extra'
+
+const cleanupFiles = async files => {
+  if (!files) return
+
+  for (const fileField in files) {
+    const fileArray = files[fileField]
+    for (const file of fileArray) {
+      await fse.remove(file.path)
+    }
+  }
+}
+
+export default cleanupFiles

package/modules/middlewares/bodyMiddleware/cleanupFiles.test.js

@@ -0,0 +1,54 @@
+import { describe, it, expect, beforeAll, afterEach, afterAll } from '@jest/globals'
+import cleanupFiles from './cleanupFiles.js'
+import fse from 'fs-extra'
+import path from 'path'
+import tmp from '../../../test-utils/tmp.js'
+
+const tempDir = await tmp('bodyMiddlewareCleanupFiles')
+describe('cleanupFiles', () => {
+  beforeAll(async () => {
+    await fse.ensureDir(tempDir)
+  })
+
+  afterEach(async () => {
+    // Ensure temp directory is clean after each test
+    const files = await fse.readdir(tempDir)
+    await Promise.all(files.map(file => fse.remove(path.join(tempDir, file))))
+  })
+
+  afterAll(async () => {
+    // Remove temp directory after all tests
+    await fse.remove(tempDir)
+  })
+
+  it('should do nothing if files is undefined', async () => {
+    await cleanupFiles(undefined)
+    const files = await fse.readdir(tempDir)
+    expect(files.length).toBe(0)
+  })
+
+  it('should remove all files in the files object', async () => {
+    const filePaths = [
+      path.join(tempDir, 'file1.txt'),
+      path.join(tempDir, 'file2.txt'),
+      path.join(tempDir, 'file3.txt')
+    ]
+
+    // Create temporary files
+    await Promise.all(filePaths.map(filePath => fse.writeFile(filePath, 'test content')))
+
+    const files = {
+      field1: [{ path: filePaths[0] }, { path: filePaths[1] }],
+      field2: [{ path: filePaths[2] }]
+    }
+
+    await cleanupFiles(files)
+
+    // Assert files are removed
+    await Promise.all(
+      filePaths.map(async filePath => {
+        expect(await fse.exists(filePath)).toBe(false)
+      })
+    )
+  })
+})