sumor 1.3.0 → 2.0.0

package/modules/middlewares/tokenMiddleware/index.js

@@ -0,0 +1,32 @@
+import Token from './Token.js'
+import parseCookie from './parseCookie.js'
+
+export default app => {
+  if (app.namespace) {
+    app.use((req, res, next) => {
+      const authorization = req.headers.authorization
+      if (authorization) {
+        req.token = new Token(req)
+        if (authorization.startsWith('Bearer ')) {
+          req.token._id = authorization.substring(7)
+        }
+      } else {
+        req.token = new Token(req, id => {
+          let existingCookie = res.getHeader('Set-Cookie') || []
+          if (typeof existingCookie === 'string') {
+            existingCookie = [existingCookie]
+          }
+          const maxAge = 100 * 24 * 60 * 60
+          const newCookie = `t=${id}; Path=/; HttpOnly; Max-Age=${maxAge}`
+          existingCookie = existingCookie.filter(c => !c.startsWith('t='))
+          res.setHeader('Set-Cookie', [...existingCookie, newCookie])
+        })
+
+        const cookie = parseCookie(req.headers.cookie)
+        req.token._id = cookie.t || null
+      }
+
+      next()
+    })
+  }
+}

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

@@ -0,0 +1,115 @@
+import { describe, it, beforeAll, afterAll, expect } from '@jest/globals'
+import axios from 'axios'
+import express from 'express'
+import tokenMiddleware from './index.js'
+import i18nMiddleware from '../i18nMiddleware/index.js'
+import http from 'http'
+
+describe('Token Middleware 测试', () => {
+  let app
+  let server
+  let baseURL
+
+  beforeAll(async () => {
+    app = express()
+    await i18nMiddleware(app)
+    tokenMiddleware(app)
+
+    app.get('/test', (req, res) => {
+      res.json({ token: req.token.id })
+    })
+
+    app.get('/login', (req, res) => {
+      req.token.id = 'test-token'
+      res.json({ token: req.token.id })
+    })
+
+    server = http.createServer(app)
+    await new Promise(resolve => {
+      server.listen(() => {
+        const { port } = server.address()
+        baseURL = `http://localhost:${port}`
+        resolve()
+      })
+    })
+  })
+
+  afterAll(done => {
+    server.close(done)
+  })
+
+  it('应从 Authorization 头中提取 Bearer token', async () => {
+    const response = await axios.get(`${baseURL}/test`, {
+      headers: {
+        Authorization: 'Bearer test-token'
+      }
+    })
+
+    expect(response.data.token).toBe('test-token')
+  })
+
+  it('如存在 Authorization 头，但不以 Bearer 开头，则不读取token', async () => {
+    const response = await axios.get(`${baseURL}/test`, {
+      headers: {
+        Authorization: 'test-token'
+      }
+    })
+
+    expect(response.data.token).toBe('')
+  })
+
+  it('应从 Cookie 中提取 token', async () => {
+    const response = await axios.get(`${baseURL}/test`, {
+      headers: {
+        Cookie: 't=test-cookie-token'
+      }
+    })
+
+    expect(response.data.token).toBe('test-cookie-token')
+  })
+
+  it('应设置新的 token 到 Cookie 中', async () => {
+    const response = await axios.get(`${baseURL}/login`)
+
+    const setCookieHeader = response.headers['set-cookie']
+    expect(setCookieHeader).toBeDefined()
+    expect(setCookieHeader[0]).toMatch(/t=.+; Path=\/; HttpOnly; Max-Age=8640000/)
+  })
+})
+
+describe('Token Middleware 测试，无namespace中间件', () => {
+  let app
+  let server
+  let baseURL
+
+  beforeAll(async () => {
+    app = express()
+    tokenMiddleware(app)
+
+    app.get('/test', (req, res) => {
+      if (!req.token) {
+        res.send('NO_TOKEN')
+      } else {
+        res.send('HAS_TOKEN')
+      }
+    })
+
+    server = http.createServer(app)
+    await new Promise(resolve => {
+      server.listen(() => {
+        const { port } = server.address()
+        baseURL = `http://localhost:${port}`
+        resolve()
+      })
+    })
+  })
+
+  afterAll(done => {
+    server.close(done)
+  })
+
+  it('检测TOKEN，不应存在', async () => {
+    const response = await axios.get(`${baseURL}/test`)
+    expect(response.data).toBe('NO_TOKEN')
+  })
+})

package/modules/middlewares/tokenMiddleware/parseCookie.js

@@ -0,0 +1,24 @@
+// 扩展 parseCookie 函数，增加详细的变量命名和中文备注
+export default function parseCookie(cookieString) {
+  // 如果 cookieString 是 null 或 undefined，则将其设置为空字符串
+  cookieString = cookieString || ''
+
+  // 将 cookieString 按照分号分割成数组
+  let cookieArray = cookieString.split(';')
+
+  // 如果分割后的数组第一个元素是空字符串，则将数组置为空数组
+  if (cookieArray[0] === '') {
+    cookieArray = []
+  }
+
+  // 使用 reduce 方法将 cookieArray 转换为键值对对象
+  return cookieArray.reduce((cookieObject, cookieItem) => {
+    // 将每个 cookie 项按照等号分割为键和值
+    const [key, value] = cookieItem.split('=')
+
+    // 去除键的多余空格，并将键值对存入结果对象
+    cookieObject[key.trim()] = value.trim() || null // 如果值不存在，则设置为 null
+
+    return cookieObject // 返回累积的结果对象
+  }, {}) // 初始值为一个空对象
+}

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

@@ -0,0 +1,49 @@
+import { describe, test, expect } from '@jest/globals'
+import parseCookie from './parseCookie'
+
+// 测试文件主要用于验证 parseCookie 函数的功能是否正确
+
+describe('parseCookie 函数测试', () => {
+  // 测试：正常解析 cookie 字符串
+  test('应该正确解析有效的 cookie 字符串', () => {
+    const cookieString = 'key1=value1; key2=value2'
+    const expectedOutput = {
+      key1: 'value1',
+      key2: 'value2'
+    }
+    expect(parseCookie(cookieString)).toEqual(expectedOutput)
+  })
+
+  // 测试：处理空字符串
+  test('应该返回空对象当输入为空字符串时', () => {
+    const cookieString = ''
+    const expectedOutput = {}
+    expect(parseCookie(cookieString)).toEqual(expectedOutput)
+  })
+
+  // 测试：处理 null 或 undefined
+  test('应该返回空对象当输入为 null 或 undefined 时', () => {
+    expect(parseCookie(null)).toEqual({})
+    expect(parseCookie(undefined)).toEqual({})
+  })
+
+  // 测试：处理没有值的键
+  test('应该将没有值的键的值设置为 null', () => {
+    const cookieString = 'key1=; key2=value2'
+    const expectedOutput = {
+      key1: null,
+      key2: 'value2'
+    }
+    expect(parseCookie(cookieString)).toEqual(expectedOutput)
+  })
+
+  // 测试：处理多余的空格
+  test('应该正确处理键和值周围的多余空格', () => {
+    const cookieString = ' key1 = value1 ; key2 = value2 '
+    const expectedOutput = {
+      key1: 'value1',
+      key2: 'value2'
+    }
+    expect(parseCookie(cookieString)).toEqual(expectedOutput)
+  })
+})

package/modules/serve/formatConfig.js

@@ -0,0 +1,7 @@
+export default config => {
+  config = config || {}
+  config.name = config.name || '轻呈云应用'
+  config.desc = config.desc || ''
+  config.port = config.port || 80
+  return config
+}

package/modules/serve/formatConfig.test.js

@@ -0,0 +1,28 @@
+import { describe, it, expect } from '@jest/globals'
+import format from './formatConfig.js'
+
+describe('format function', () => {
+  it('当未提供配置时应返回默认值', () => {
+    const result = format()
+    expect(result.port).toBe(80)
+    expect(result.name).toBe('轻呈云应用')
+    expect(result.desc).toBe('')
+  })
+
+  it('当提供带端口的配置时应覆盖端口', () => {
+    const result = format({ port: 3000 })
+    expect(result.port).toBe(3000)
+  })
+
+  it('应保留配置对象中的其他属性', () => {
+    const result = format({ port: 3000, host: 'localhost' })
+    expect(result.port).toBe(3000)
+    expect(result.host).toBe('localhost')
+  })
+
+  it('当提供name和desc时应覆盖默认值', () => {
+    const result = format({ name: '测试应用', desc: '这是一个测试应用' })
+    expect(result.name).toBe('测试应用')
+    expect(result.desc).toBe('这是一个测试应用')
+  })
+})

package/modules/serve/index.js

@@ -0,0 +1,30 @@
+import express from 'express'
+import listenApp from './listenApp.js'
+import format from './formatConfig.js'
+
+export default async function (config, callbacks) {
+  config = format(config)
+  const app = express()
+
+  // 添加交互参数
+  app.sumor = {
+    config
+  }
+  app.use((req, res, next) => {
+    req.sumor = {
+      config
+    }
+    next()
+  })
+
+  if (typeof callbacks === 'object') {
+    for (const callback of callbacks) {
+      await callback(app)
+    }
+  } else {
+    await callbacks(app)
+  }
+
+  const close = await listenApp(app, config.port)
+  return { app, config, close }
+}

package/modules/serve/index.test.js

@@ -0,0 +1,69 @@
+import { describe, it, expect, jest } from '@jest/globals'
+import serve from './index.js'
+
+describe('serve', () => {
+  it('应该执行单个回调函数', async () => {
+    const mockCallback = jest.fn()
+    const config = {
+      port: Math.floor(Math.random() * (65535 - 1024) + 1024)
+    }
+
+    const { app, close } = await serve(config, mockCallback)
+
+    expect(mockCallback).toHaveBeenCalledTimes(1)
+    expect(mockCallback).toHaveBeenCalledWith(app)
+
+    await close()
+  })
+
+  it('应该按顺序执行多个回调函数', async () => {
+    const mockCallback1 = jest.fn()
+    const mockCallback2 = jest.fn()
+    const config = {
+      port: Math.floor(Math.random() * (65535 - 1024) + 1024)
+    }
+
+    const { app, close } = await serve(config, [mockCallback1, mockCallback2])
+
+    expect(mockCallback1).toHaveBeenCalledTimes(1)
+    expect(mockCallback1).toHaveBeenCalledWith(app)
+    expect(mockCallback2).toHaveBeenCalledTimes(1)
+    expect(mockCallback2).toHaveBeenCalledWith(app)
+
+    await close()
+  })
+
+  it('应该启动并停止服务器', async () => {
+    const mockCallback = jest.fn()
+    const config = {
+      port: Math.floor(Math.random() * (65535 - 1024) + 1024)
+    }
+
+    const { close } = await serve(config, mockCallback)
+
+    expect(typeof close).toBe('function')
+
+    await close()
+  })
+
+  it('应该在请求中添加 sumor 对象', async () => {
+    const mockCallback = app => {
+      expect(app.sumor).toBeDefined()
+      app.get('/', (req, res) => {
+        if (req.sumor) {
+          res.send('OK')
+        } else {
+          res.send('FAIL')
+        }
+      })
+    }
+    const config = {
+      port: Math.floor(Math.random() * (65535 - 1024) + 1024)
+    }
+    const { close } = await serve(config, mockCallback)
+    const response = await fetch(`http://localhost:${config.port}/`)
+    const text = await response.text()
+    expect(text).toBe('OK')
+    await close()
+  })
+})

package/modules/serve/listenApp.js

@@ -0,0 +1,11 @@
+export default async (app, port) => {
+  return await new Promise(resolve => {
+    const server = app.listen(port, () => {
+      resolve(async () => {
+        await new Promise(resolve => {
+          server.close(resolve)
+        })
+      })
+    })
+  })
+}

package/modules/system/getSystemLanguage.js

@@ -0,0 +1,9 @@
+import { osLocale } from 'os-locale'
+
+export default async () => {
+  let language = process.env.LANGUAGE
+  if (!language) {
+    language = await osLocale()
+  }
+  return language
+}

package/modules/system/getSystemLanguage.test.js

@@ -0,0 +1,19 @@
+import { describe, it, expect } from '@jest/globals'
+import getSystemLanguage from './getSystemLanguage.js'
+import { osLocale } from 'os-locale'
+describe('i18n Middleware', () => {
+  it('加载系统语言', async () => {
+    delete process.env.LANGUAGE
+    const language = await getSystemLanguage()
+    const expectLanguage = await osLocale()
+    expect(language).toBe(expectLanguage)
+
+    process.env.LANGUAGE = 'zh-CN'
+    const language2 = await getSystemLanguage()
+    expect(language2).toBe('zh-CN')
+
+    process.env.LANGUAGE = 'en-US'
+    const language3 = await getSystemLanguage()
+    expect(language3).toBe('en-US')
+  })
+})

package/modules/utils/getError.js

@@ -0,0 +1,56 @@
+import type from './type.js'
+
+export default ({ namespace, transform = () => {} }) => {
+  const lowerCaseNamespace = namespace.toLowerCase()
+  const capitalizedNamespace =
+    lowerCaseNamespace.charAt(0).toUpperCase() + lowerCaseNamespace.slice(1)
+
+  return class SumorError extends Error {
+    constructor(code, data, errors) {
+      super()
+      this.name = `${capitalizedNamespace}Error`
+      this.namespace = lowerCaseNamespace
+      this.code = code
+
+      this.errors = []
+      if (errors) {
+        if (errors instanceof Error) {
+          this.errors = [errors]
+        } else if (Array.isArray(errors)) {
+          this.errors = errors.filter(error => error instanceof Error)
+        }
+      }
+
+      this.data = type(data) === 'object' ? data : {}
+    }
+
+    set message(_) {
+      throw new Error('message is readonly, please use code and data to set message.')
+    }
+
+    get message() {
+      return transform(namespace, this.code, this.data) || this.code
+    }
+
+    json() {
+      const errors = this.errors.map(error => {
+        if (error.json) {
+          return error.json()
+        } else {
+          return {
+            code: error.code || 'UNKNOWN_ERROR',
+            message: error.message,
+            data: error.data || {},
+            errors: []
+          }
+        }
+      })
+      return {
+        code: this.code,
+        message: this.message,
+        data: this.data,
+        errors
+      }
+    }
+  }
+}

package/modules/utils/getError.test.js

@@ -0,0 +1,97 @@
+import { describe, it, expect } from '@jest/globals'
+import getError from './getError'
+
+describe('getError 函数', () => {
+  const transform = (namespace, code, data) => `${code}: ${JSON.stringify(data)}`
+  const options = { namespace: 'Test', transform }
+  const SumorError = getError(options)
+
+  it('无transform函数时，message应该等于code', () => {
+    const NonTransformError = getError({ namespace: 'NonTransform' })
+    const error = new NonTransformError('ERROR_CODE')
+    expect(error.code).toBe('ERROR_CODE')
+    expect(error.message).toBe('ERROR_CODE')
+  })
+
+  it('应该创建一个具有正确名称和代码的错误对象', () => {
+    const error = new SumorError('ERROR_CODE', { key: 'value' })
+    expect(error.name).toBe('TestError')
+    expect(error.code).toBe('ERROR_CODE')
+    expect(error.data).toEqual({ key: 'value' })
+  })
+
+  it('应该正确处理 errors 数组', () => {
+    const innerError = new Error('Inner error')
+    const error = new SumorError('ERROR_CODE', {}, [innerError])
+    expect(error.errors).toHaveLength(1)
+    expect(error.errors[0].message).toBe('Inner error')
+  })
+
+  it('尝试直接设置 message 时应该抛出错误', () => {
+    const error = new SumorError('ERROR_CODE', {})
+    expect(() => {
+      error.message = 'New message'
+    }).toThrow('message is readonly, please use code and data to set message.')
+  })
+
+  it('应该将单个 Error 对象正确包装到 errors 数组中', () => {
+    const innerError = new Error('Inner error')
+    const error = new SumorError('ERROR_CODE', {}, innerError)
+    expect(error.errors).toHaveLength(1)
+    expect(error.errors[0]).toBe(innerError)
+  })
+
+  it('应该在 data 不是对象时将 data 设置为空对象', () => {
+    const error = new SumorError('ERROR_CODE', 'notAnObject')
+    expect(error.data).toEqual({})
+  })
+
+  it('应该生成正确的 JSON 表示', () => {
+    const error = new SumorError('ERROR_CODE', { key: 'value' })
+    const json = error.json()
+    expect(json).toEqual({
+      code: 'ERROR_CODE',
+      message: 'ERROR_CODE: {"key":"value"}',
+      data: { key: 'value' },
+      errors: []
+    })
+  })
+
+  it('应该在 JSON 表示中包含嵌套的错误', () => {
+    const error1 = new SumorError('ERROR_CODE', { key: 'value1' })
+    const error2 = new SumorError('ERROR_CODE', { key: 'value2' }, error1)
+    const json = error2.json()
+    expect(json).toEqual({
+      code: 'ERROR_CODE',
+      message: 'ERROR_CODE: {"key":"value2"}',
+      data: { key: 'value2' },
+      errors: [
+        {
+          code: 'ERROR_CODE',
+          message: 'ERROR_CODE: {"key":"value1"}',
+          data: { key: 'value1' },
+          errors: []
+        }
+      ]
+    })
+  })
+
+  it('应该在 JSON 表示中包含嵌套的其他错误', () => {
+    const error1 = new Error('Inner error 1')
+    const error2 = new SumorError('ERROR_CODE', { key: 'value2' }, error1)
+    const json = error2.json()
+    expect(json).toEqual({
+      code: 'ERROR_CODE',
+      message: 'ERROR_CODE: {"key":"value2"}',
+      data: { key: 'value2' },
+      errors: [
+        {
+          code: 'UNKNOWN_ERROR',
+          message: 'Inner error 1',
+          data: {},
+          errors: []
+        }
+      ]
+    })
+  })
+})

package/modules/utils/loadConfig.js

@@ -0,0 +1,73 @@
+import fs from 'fs'
+import yaml from 'yaml'
+import path from 'path'
+import { glob } from 'glob'
+
+export default async (condition, root) => {
+  const extensions = ['.yaml', '.json', '.yml']
+
+  if (root) {
+    // 多个配置查询，返回列表对象，key为相对路径，值为配置对象
+
+    // 如果condition不包括后缀，则添加后缀，限制其仅允许yaml和json
+    if (!condition.includes('yaml') && !condition.includes('json') && !condition.includes('yml')) {
+      condition = `${condition}.{yaml,json,yml}`
+    }
+
+    const files = await glob(condition, {
+      cwd: root
+    })
+
+    // 排序以确保后缀名优先级
+    files.sort((a, b) => {
+      const extA = path.extname(a)
+      const extB = path.extname(b)
+      return extensions.indexOf(extB) - extensions.indexOf(extA)
+    })
+
+    const result = {}
+    for (const file of files) {
+      const ext = path.extname(file)
+      const pathWithoutExt = file.replace(ext, '')
+      if (extensions.includes(ext)) {
+        const filePath = path.join(root, file)
+        const fileContent = fs.readFileSync(filePath, 'utf8')
+        if (ext === '.json') {
+          result[pathWithoutExt] = JSON.parse(fileContent)
+        } else {
+          result[pathWithoutExt] = yaml.parse(fileContent)
+        }
+      }
+    }
+    return result
+  } else {
+    // 单个配置查询，返回该配置对象
+    const filePath = condition
+    const ext = path.extname(filePath)
+
+    // 带后缀，则直接返回
+    if (extensions.includes(ext)) {
+      const fileContent = fs.readFileSync(filePath, 'utf8')
+      if (ext === '.json') {
+        return JSON.parse(fileContent)
+      } else {
+        return yaml.parse(fileContent)
+      }
+    }
+
+    // 不带后缀，尝试添加后缀
+    for (const ext of extensions) {
+      const fullPath = `${filePath}${ext}`
+      if (fs.existsSync(fullPath)) {
+        const fileContent = fs.readFileSync(fullPath, 'utf8')
+        if (ext === '.json') {
+          return JSON.parse(fileContent)
+        } else {
+          return yaml.parse(fileContent)
+        }
+      }
+    }
+
+    return {}
+  }
+}