sumor 1.3.0 → 2.0.0

package/modules/middlewares/bodyMiddleware/fileParser.js

@@ -0,0 +1,69 @@
+import multer from 'multer'
+import fse from 'fs-extra'
+import cleanupFiles from './cleanupFiles.js'
+
+const uploadPath = `${process.cwd()}/tmp/uploads`
+await fse.ensureDir(uploadPath)
+const upload = multer({ dest: 'tmp/uploads/' })
+
+export default api => {
+  // 初始化上传器
+  let uploader
+  const parameters = api.parameters || {}
+  const uploadParameters = []
+  for (const name in parameters) {
+    if (parameters[name].type === 'file') {
+      uploadParameters.push({ name })
+    }
+  }
+  if (uploadParameters.length > 0) {
+    uploader = upload.fields(uploadParameters)
+  }
+
+  const middlewares = []
+
+  middlewares.push((req, res, next) => {
+    if (uploader) {
+      uploader(req, res, err => {
+        if (err) {
+          throw err
+        } else {
+          const files = {}
+          req.files = req.files || {}
+          for (const name in req.files) {
+            files[name] = files[name] || []
+            for (const fileIndex in req.files[name]) {
+              files[name].push({
+                name: req.files[name][fileIndex].originalname,
+                size: req.files[name][fileIndex].size,
+                mime: req.files[name][fileIndex].mimetype,
+                encoding: req.files[name][fileIndex].encoding,
+                path: `${uploadPath}/${req.files[name][fileIndex].filename}`
+              })
+            }
+          }
+          req.files = files
+          next()
+        }
+      })
+    } else {
+      next()
+    }
+  })
+
+  middlewares.push((req, res, next) => {
+    if (uploader) {
+      res.on('finish', async () => {
+        await cleanupFiles(req.files)
+      })
+
+      res.on('close', async () => {
+        await cleanupFiles(req.files)
+      })
+    }
+
+    next()
+  })
+
+  return middlewares
+}

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

@@ -0,0 +1,163 @@
+import { describe, it, beforeEach, afterEach, expect } from '@jest/globals'
+import axios from 'axios'
+import express from 'express'
+import fileParser from './fileParser.js'
+import FormData from 'form-data'
+import http from 'http'
+import fse from 'fs-extra'
+
+const apis = [
+  {
+    route: '/upload',
+    parameters: {
+      file1: { type: 'file' },
+      file2: { type: 'file' }
+    }
+  },
+  {
+    route: '/test1',
+    parameters: {
+      name: { type: 'string' }
+    }
+  },
+  {
+    route: '/test2'
+  }
+]
+
+describe('fileParser 中间件', () => {
+  let app
+  let server
+  let baseURL
+
+  beforeEach(done => {
+    app = express()
+
+    app.post('/upload', fileParser(apis[0]), async (req, res) => {
+      if (req.files) {
+        for (const field in req.files) {
+          const files = req.files[field]
+          // load file
+          if (files[0].path) files[0].data = await fse.readFile(files[0].path, 'utf-8')
+        }
+        res.status(200).send(req.files)
+      } else {
+        res.status(400).send('No files uploaded')
+      }
+    })
+
+    app.post('/test1', fileParser(apis[1]), (req, res) => {
+      if (!req.files) {
+        res.status(400).send('No files uploaded')
+      } else {
+        res.status(200).send('Files uploaded')
+      }
+    })
+    app.post('/test2', fileParser(apis[2]), (req, res) => {
+      if (!req.files) {
+        res.status(400).send('No files uploaded')
+      } else {
+        res.status(200).send('Files uploaded')
+      }
+    })
+
+    server = http.createServer(app).listen(() => {
+      const { port } = server.address()
+      baseURL = `http://localhost:${port}`
+      done()
+    })
+  })
+
+  afterEach(() => {
+    server.close()
+  })
+
+  it('应该处理已定义路由的文件上传', async () => {
+    const formData = new FormData()
+    formData.append('file1', Buffer.from('test file 1'), 'file1.txt')
+    formData.append('file2', Buffer.from('test file 2'), 'file2.txt')
+
+    let response
+    try {
+      response = await axios.post(`${baseURL}/upload`, formData, {
+        headers: formData.getHeaders()
+      })
+    } catch (e) {
+      console.log(e.response.status)
+      console.log(e.response.statusMessage)
+      console.log(e.response.data)
+    }
+
+    expect(response.status).toBe(200)
+    expect(Object.keys(response.data)).toEqual(['file1', 'file2'])
+  })
+
+  it('应该返回400当没有文件上传到/test', async () => {
+    let response
+    try {
+      response = await axios.post(
+        `${baseURL}/test1`,
+        {},
+        {
+          headers: { 'Content-Type': 'application/json' }
+        }
+      )
+    } catch (e) {
+      response = e.response
+    }
+
+    expect(response.status).toBe(400)
+    expect(response.data).toBe('No files uploaded')
+  })
+
+  it('测试无parameters参数情况', async () => {
+    let response
+    try {
+      response = await axios.post(
+        `${baseURL}/test2`,
+        {},
+        {
+          headers: { 'Content-Type': 'application/json' }
+        }
+      )
+    } catch (e) {
+      response = e.response
+    }
+
+    expect(response.status).toBe(400)
+    expect(response.data).toBe('No files uploaded')
+  })
+
+  it('应该在请求结束后清理上传的文件', async () => {
+    const formData = new FormData()
+    formData.append('file1', Buffer.from('test file 1'), 'file1.txt')
+    formData.append('file2', Buffer.from('test file 2'), 'file2.txt')
+
+    let response
+    try {
+      response = await axios.post(`${baseURL}/upload`, formData, {
+        headers: formData.getHeaders()
+      })
+    } catch (e) {
+      console.log(e.response.status)
+      console.log(e.response.statusMessage)
+      console.log(e.response.data)
+    }
+
+    expect(response.status).toBe(200)
+    const files = response.data
+    expect(files.file1[0].data).toEqual('test file 1')
+
+    expect(Object.keys(files)).toEqual(['file1', 'file2'])
+
+    // Check if files are cleaned up
+    let existsFile = true
+    for (let retries = 0; retries < 5 && existsFile; retries++) {
+      existsFile = await fse.exists(files.file1[0].path)
+      if (existsFile) {
+        await new Promise(resolve => setTimeout(resolve, 100))
+      }
+    }
+    expect(existsFile).toBeFalsy()
+  })
+})

package/modules/middlewares/bodyMiddleware/index.js

@@ -0,0 +1,12 @@
+import bodyParser from 'body-parser'
+import fileParser from './fileParser.js'
+import mergeData from './mergeData.js'
+
+const basicParsers = [
+  bodyParser.urlencoded({ extended: false }),
+  bodyParser.json(),
+  bodyParser.text()
+]
+export default api => {
+  return [...basicParsers, ...fileParser(api), mergeData]
+}

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

@@ -0,0 +1,64 @@
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals'
+import bodyMiddleware from './index.js'
+import axios from 'axios'
+import express from 'express'
+import http from 'http'
+import FormData from 'form-data'
+
+const api = {
+  route: '/upload',
+  parameters: {
+    name: { type: 'string' },
+    file: { type: 'file' }
+  }
+}
+
+// 修改describe和it的描述为中文
+describe('bodyMiddleware', () => {
+  let app
+  let server
+  let baseURL
+
+  beforeEach(done => {
+    app = express()
+    app.use(express.json())
+    app.post(api.route, bodyMiddleware(api), (req, res) => {
+      res.status(200).send(req.data)
+    })
+
+    server = http.createServer(app).listen(() => {
+      const { port } = server.address()
+      baseURL = `http://localhost:${port}`
+      done()
+    })
+  })
+
+  afterEach(() => {
+    server.close()
+  })
+
+  it('应该正确加载所有中间件', () => {
+    const middlewares = bodyMiddleware(api)
+    expect(middlewares).toHaveLength(6)
+  })
+
+  it('应该正确处理文件上传', async () => {
+    const formData = new FormData()
+    formData.append('name', 'test')
+    formData.append('file', Buffer.from('test file'), 'file.txt')
+
+    let response
+    try {
+      response = await axios.post(`${baseURL}${api.route}`, formData, {
+        headers: formData.getHeaders()
+      })
+    } catch (e) {
+      response = e.response
+    }
+
+    expect(response.status).toBe(200)
+    expect(response.data.name).toBe('test')
+    expect(response.data.file).toBeDefined()
+    expect(response.data.file[0].name).toBe('file.txt')
+  })
+})

package/modules/middlewares/bodyMiddleware/mergeData.js

@@ -0,0 +1,4 @@
+export default (req, res, next) => {
+  req.data = { ...req.params, ...req.query, ...req.body, ...req.files }
+  next()
+}

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

@@ -0,0 +1,38 @@
+import mergeData from './mergeData'
+import { describe, it, expect, beforeEach, jest } from '@jest/globals'
+
+describe('mergeData middleware', () => {
+  let req, res, next
+
+  beforeEach(() => {
+    req = {
+      params: { param1: 'value1' },
+      query: { query1: 'value2' },
+      body: { body1: 'value3' },
+      files: { file1: 'value4' }
+    }
+    res = {}
+    next = jest.fn()
+  })
+
+  it('应该将 params、query、body 和 files 合并到 req.data 中', () => {
+    mergeData(req, res, next)
+
+    expect(req.data).toEqual({
+      param1: 'value1',
+      query1: 'value2',
+      body1: 'value3',
+      file1: 'value4'
+    })
+    expect(next).toHaveBeenCalled()
+  })
+
+  it('应该处理空的 params、query、body 和 files', () => {
+    req = { params: {}, query: {}, body: {}, files: {} }
+
+    mergeData(req, res, next)
+
+    expect(req.data).toEqual({})
+    expect(next).toHaveBeenCalled()
+  })
+})

package/modules/middlewares/i18nMiddleware/index.js

@@ -0,0 +1,82 @@
+import getSystemLanguage from '../../system/getSystemLanguage.js'
+import { convert, registerAll } from '../../i18n/index.js'
+import getLogger from '../../logger/index.js'
+import getError from '../../utils/getError.js'
+import fse from 'fs-extra'
+
+let sequence = 0
+
+export default async (app, root) => {
+  root = root || process.cwd() + '/i18n'
+  const logPath = process.env.LOG_PATH || process.cwd() + '/tmp/logs/main.log'
+  const systemLanguage = await getSystemLanguage()
+  if (await fse.exists(root)) {
+    await registerAll(root)
+  }
+
+  app.namespace = namespace => {
+    const transform = (namespace, code, data) => {
+      return convert(namespace, systemLanguage, code, data)
+    }
+    const i18n = (code, data) => {
+      return transform(namespace, code, data)
+    }
+    const logger = getLogger({
+      transform,
+      namespace,
+      id: '',
+      path: logPath
+    })
+    const Error = getError({
+      namespace,
+      transform
+    })
+    return {
+      i18n,
+      logger,
+      Error
+    }
+  }
+
+  const appNamespace = app.namespace('app')
+  app.i18n = appNamespace.i18n
+  app.logger = appNamespace.logger
+  app.Error = appNamespace.Error
+
+  app.use((req, res, next) => {
+    req.sequence = sequence++
+    req.id = `ANONYMOUS-${req.sequence}`
+    const userLanguage = req.headers['accept-language'] || systemLanguage
+
+    req.namespace = namespace => {
+      const transform = (namespace, code, data) => {
+        return convert(namespace, userLanguage, code, data)
+      }
+      const i18n = (code, data) => {
+        return transform(namespace, code, data)
+      }
+      const logger = getLogger({
+        transform,
+        namespace,
+        id: req.id,
+        path: logPath
+      })
+      const Error = getError({
+        namespace,
+        transform
+      })
+      return {
+        i18n,
+        logger,
+        Error
+      }
+    }
+
+    const reqNamespace = req.namespace('req')
+    req.i18n = reqNamespace.i18n
+    req.logger = reqNamespace.logger
+    req.Error = reqNamespace.Error
+
+    next()
+  })
+}

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

@@ -0,0 +1,75 @@
+import { describe, it, beforeAll, afterAll, expect, beforeEach } from '@jest/globals'
+import axios from 'axios'
+import http from 'http'
+import express from 'express'
+import i18nMiddleware from './index.js'
+
+describe('i18nMiddleware', () => {
+  let app
+  let server
+  let baseURL
+
+  beforeAll(done => {
+    app = express()
+    server = http.createServer(app)
+    server.listen(() => {
+      const { port } = server.address()
+      baseURL = `http://localhost:${port}`
+      done()
+    })
+  })
+
+  afterAll(done => {
+    server.close(done)
+  })
+
+  beforeEach(async () => {
+    process.env.LANGUAGE = 'en-US'
+    await i18nMiddleware(app)
+  })
+
+  it('应该设置 app.i18n、app.logger 和 app.Error', () => {
+    expect(app.i18n).toBeDefined()
+    expect(app.logger).toBeDefined()
+    expect(app.Error).toBeDefined()
+    const { i18n, logger, Error } = app.namespace('sumor_internal')
+    expect(i18n).toBeDefined()
+    expect(logger).toBeDefined()
+    expect(Error).toBeDefined()
+    const message = i18n('TEST', { value: 'value' })
+    expect(message).toBeDefined() // 根据你的实现添加具体的期望
+    expect(message).toBe('Test value')
+  })
+
+  it('应该为每个请求设置 req.i18n、req.logger 和 req.Error', async () => {
+    app.use((req, res) => {
+      expect(req.i18n).toBeDefined()
+      expect(req.logger).toBeDefined()
+      expect(req.Error).toBeDefined()
+      const { i18n, logger, Error } = req.namespace('sumor_internal')
+      expect(i18n).toBeDefined()
+      expect(logger).toBeDefined()
+      expect(Error).toBeDefined()
+      const message = i18n('TEST', { value: 'value' })
+      expect(message).toBeDefined() // 根据你的实现添加具体的期望
+      expect(message).toBe('Test value')
+      res.status(200).send('OK')
+    })
+
+    const response = await axios.get(`${baseURL}/`)
+    expect(response.status).toBe(200)
+  })
+
+  it('应该从请求头中使用正确的用户语言', async () => {
+    app.use((req, res) => {
+      const i18nMessage = req.i18n('testNamespace', 'testCode', { key: 'value' })
+      expect(i18nMessage).toBeDefined() // 根据你的实现添加具体的期望
+      res.status(200).send('OK')
+    })
+
+    const response = await axios.get(`${baseURL}/`, {
+      headers: { 'Accept-Language': 'en-US' }
+    })
+    expect(response.status).toBe(200)
+  })
+})

package/modules/middlewares/tokenMiddleware/Token.js

@@ -0,0 +1,115 @@
+import type from '../../utils/type.js'
+
+export default class Token {
+  constructor(req, onChange) {
+    this._id = null
+    this._user = null
+    this._data = null
+    this._permission = {}
+
+    this._onChange = function () {
+      if (this._user) {
+        req.id = `${this._user}-${req.sequence}`
+      } else {
+        req.id = `ANONYMOUS-${req.sequence}`
+      }
+      const reqNamespace = req.namespace('req')
+      req.i18n = reqNamespace.i18n
+      req.logger = reqNamespace.logger
+      req.Error = reqNamespace.Error
+      if (onChange) {
+        onChange(this.id)
+      }
+    }
+    this._Error = req.namespace('SUMOR_TOKEN').Error
+
+    this._onChange()
+  }
+
+  get id() {
+    return this._id || ''
+  }
+
+  set id(id) {
+    this._id = id
+    this._onChange()
+  }
+
+  get data() {
+    return this._data || {}
+  }
+
+  set data(val) {
+    this._data = Object.assign({}, val)
+    this._onChange()
+  }
+
+  get user() {
+    return this._user || ''
+  }
+
+  set user(user) {
+    this._user = user
+    this._onChange()
+  }
+
+  get permission() {
+    return this._permission
+  }
+
+  set permission(val) {
+    const result = {}
+    if (typeof val === 'string') {
+      result[val] = []
+    } else if (type(val) === 'array') {
+      for (const item of val) {
+        result[item] = []
+      }
+    } else if (type(val) === 'object') {
+      for (const key in val) {
+        if (type(val[key]) === 'array') {
+          result[key] = val[key]
+        } else if (type(val[key]) === 'string') {
+          result[key] = [val[key]]
+        } else {
+          result[key] = []
+        }
+      }
+    }
+    this._permission = result
+    this._onChange()
+  }
+
+  has(key, value) {
+    let matched = false
+    if (this._permission[key]) {
+      if (value) {
+        if (this._permission[key].indexOf(value) >= 0) {
+          matched = true
+        }
+      } else {
+        matched = true
+      }
+    }
+    return matched
+  }
+
+  check(key, value) {
+    if (!this.user) {
+      // Check if the user is logged in
+      throw new this._Error('LOGIN_EXPIRED')
+    } else if (key) {
+      // Check if the user has the required permission
+      const lacked = !this.has(key, value)
+      if (lacked) {
+        const permission = value ? `${key}=${value}` : key
+        throw new this._Error('PERMISSION_DENIED', { permission })
+      }
+    }
+  }
+
+  destroy() {
+    this._id = null
+    this._onChange()
+  }
+}

package/modules/middlewares/tokenMiddleware/Token.test.js

@@ -0,0 +1,67 @@
+import { describe, test, expect, beforeEach, jest } from '@jest/globals'
+import Token from './Token'
+
+describe('Token 类测试', () => {
+  let mockReq
+  let token
+
+  beforeEach(() => {
+    mockReq = {
+      id: '',
+      namespace: jest.fn().mockReturnValue({
+        i18n: {},
+        logger: {},
+        Error: class MockError extends Error {
+          constructor(code, details) {
+            super(code)
+            this.code = code
+            this.details = details
+          }
+        }
+      })
+    }
+    token = new Token(mockReq)
+  })
+
+  test('初始化 Token', () => {
+    expect(token.id).toBe('')
+    expect(token.user).toBe('')
+    expect(token.data).toEqual({})
+    expect(token.permission).toEqual({})
+  })
+
+  test('设置和获取 id', () => {
+    token.id = '123'
+    expect(token.id).toBe('123')
+  })
+
+  test('设置和获取 user', () => {
+    token.user = 'testUser'
+    expect(token.user).toBe('testUser')
+    expect(mockReq.id).toContain('testUser-')
+  })
+
+  test('设置和获取 data', () => {
+    token.data = { key: 'value' }
+    expect(token.data).toEqual({ key: 'value' })
+  })
+
+  test('设置和获取 permission', () => {
+    token.permission = { read: ['file1'], write: 'file2' }
+    expect(token.permission).toEqual({ read: ['file1'], write: ['file2'] })
+  })
+
+  test('检查权限', () => {
+    token.user = 'testUser'
+    token.permission = { read: ['file1'] }
+
+    expect(() => token.check('read', 'file1')).not.toThrow()
+    expect(() => token.check('write')).toThrowError('PERMISSION_DENIED')
+  })
+
+  test('销毁 Token', () => {
+    token.destroy()
+    expect(token.id).toBe('')
+    expect(mockReq.id).toContain('ANONYMOUS-')
+  })
+})