@sisin/egg-client 1.0.0

package/app/extend/context.js

@@ -0,0 +1,57 @@
+// 统一返回格式 & 参数注入 & 数据库访问
+const { SUCCESS, SERVER_ERROR } = require('../constants/code');
+const BaseRepository = require('../core/repository/base-repository');
+const TransactionManager = require('../core/database/transaction-manager');
+const encrypt = require('../utils/encrypt');
+
+module.exports = {
+  /**
+   * 统一 API 响应
+   */
+  get api() {
+    const ctx = this;
+    return {
+      success(data = null, msg = '操作成功', code = SUCCESS) {
+        ctx.body = { code, success: true, msg, data };
+      },
+      fail(msg = '操作失败', code = SERVER_ERROR, data = null) {
+        ctx.body = { code, success: false, msg, data };
+      },
+      page(list = [], total = 0, msg = '查询成功', code = SUCCESS) {
+        ctx.body = { code, success: true, msg, data: { list, total } };
+      },
+    };
+  },
+
+  /**
+   * 统一参数注入（合并 body + query + params）
+   */
+  get payload() {
+    return { ...this.request.body, ...this.request.query, ...this.params };
+  },
+
+  /**
+   * 统一数据库访问
+   * 使用: ctx.repository.fx.Raw('user_info').findOne({ where: { id: 1 } })
+   * 事务: ctx.repository.fx.transaction(async (db) => { await db.Raw('user_info').create({...}) })
+   */
+  get repository() {
+    if (!this._repository) {
+      this._repository = {};
+      const Dbs = this.Dbs || {};
+      for (const key in Dbs) {
+        if (!Dbs[key]) continue;
+        this._repository[key] = {
+          Raw(modelName) { return new BaseRepository(Dbs[key][modelName]); },
+          transaction(callback) { return TransactionManager.execute(Dbs[key], async (tx) => {
+            const db = { Raw(modelName) { return new BaseRepository(tx[modelName]); } };
+            return await callback(db);
+          }); },
+        };
+      }
+    }
+    return this._repository;
+  },
+
+  get encrypt() { return encrypt; },
+};

package/app/extend/helper.js

@@ -0,0 +1,24 @@
+// 视图渲染、接口返回、业务常用格式化等函数
+const dayjs = require('dayjs');
+
+module.exports = {
+  formatTime(time = new Date()) {
+    return dayjs(time).format('YYYY-MM-DD HH:mm:ss');
+  },
+  formDateExp(start, end = new Date()) {
+    if (!start || !end) return false;
+    return dayjs(end).isAfter(dayjs(start));
+  },
+  timeUtil() {
+    return {
+      now: () => Date.now(),
+      addMs: (ms) => Date.now() + ms,
+      addSec: (s) => Date.now() + s * 1000,
+      addMin: (m) => Date.now() + m * 60 * 1000,
+      addHour: (h) => Date.now() + h * 3600 * 1000,
+      addDay: (d) => Date.now() + d * 86400 * 1000,
+    };
+  },
+  snakeToCamel(str) { return str.replace(/_(\w)/g, (_, letter) => letter.toUpperCase()); },
+  camelToSnake(str) { return str.replace(/[A-Z]/g, (match) => '_' + match.toLowerCase()); },
+};

package/app/middleware/auth.js

@@ -0,0 +1,16 @@
+// JWT 认证（旧版，兼容）
+module.exports = () => {
+  return async (ctx, next) => {
+    const { whitelists = [] } = ctx.app.config.auth;
+    if (whitelists.includes(ctx.request.path)) { return next(); }
+    const token = ctx.get('Authorization');
+    if (!token) { ctx.status = 401; return ctx.api.fail('未登录', 401, null); }
+    try {
+      ctx.user = ctx.app.jwt.verify(token.replace('Bearer ', ''));
+      await next();
+    } catch (e) {
+      ctx.status = 401;
+      return ctx.api.fail('用户未登录或登录已过期', 401, null);
+    }
+  };
+};

package/app/middleware/check_ready.js

@@ -0,0 +1,11 @@
+// 系统初始化是否完成
+module.exports = () => {
+  return async function checkReady(ctx, next) {
+    if (!ctx.app.initStatus.ready) {
+      ctx.status = 503;
+      ctx.api.fail('系统初始化中', 503, null);
+      return;
+    }
+    await next();
+  };
+};

package/app/middleware/error_handler.js

@@ -0,0 +1,28 @@
+// 全局错误处理中间件
+const errorCode = require('../constants/error');
+
+module.exports = () => {
+  return async function errorHandler(ctx, next) {
+    try {
+      await next();
+      if (ctx.status === 404 && !ctx.body) {
+        ctx.status = 404;
+        ctx.api.fail(errorCode[404].msg, 404, null);
+      }
+    } catch (err) {
+      ctx.status = err.status || 500;
+      ctx.logger.error(err);
+      if (err.code) {
+        if (err.code === 'invalid_param') {
+          ctx.status = 200;
+          const errors = err.errors[0];
+          ctx.api.fail(errors.field + ' ' + errors.message, 422, null);
+          return;
+        }
+        ctx.api.fail(err.msg || err.message, err.code, err.data || null);
+        return;
+      }
+      ctx.api.fail(err.message || errorCode[500].msg, 500, null);
+    }
+  };
+};

package/app/middleware/jwt_auth.js

@@ -0,0 +1,27 @@
+// JWT 认证中间件
+const errorCode = require('../constants/error');
+
+module.exports = () => {
+  return async (ctx, next) => {
+    const { allowDevice, whiteList } = ctx.app.config.auth;
+
+    // 白名单（前缀匹配）跳过 JWT 校验
+    if (whiteList.some((prefix) => ctx.request.path.startsWith(prefix))) {
+      await next();
+      return;
+    }
+
+    // 获取 accessToken
+    let token = ctx.get('Authorization');
+    if (!token) { ctx.api.fail(errorCode[401]?.msg, 401, null); return; }
+    token = token.replace('Bearer ', '');
+
+    // 调用 service 验证 accessToken
+    const result = await ctx.service.authSystem.auth.verifyAccessToken({ token });
+    if (!result.ok) { ctx.api.fail(errorCode[result.code]?.msg, result.code, null); return; }
+
+    // 挂载用户信息
+    ctx.user = { uid: result.payload.uid, sid: result.payload.sid, jti: result.payload.jti, type: result.payload.type };
+    await next();
+  };
+};

package/app/middleware/login_limit.js

@@ -0,0 +1,4 @@
+// 登录限制中间件（预留）
+module.exports = () => {
+  return async (ctx, next) => { await next(); };
+};

package/app/middleware/permission.js

@@ -0,0 +1,8 @@
+// 权限中间件（预留，由业务项目扩展）
+module.exports = (permissionCode) => {
+  return async (ctx, next) => {
+    const permissions = ctx.user.permissions || [];
+    if (!permissions.includes(permissionCode)) { return ctx.api.fail('No permission', 403, null); }
+    await next();
+  };
+};

package/app/middleware/request_log.js

@@ -0,0 +1,28 @@
+const { requestLogger } = require('../utils/logger');
+
+// 请求日志中间件
+module.exports = () => {
+  return async (ctx, next) => {
+    const start = Date.now();
+    const { method, url, ip } = ctx;
+
+    const matched = ctx.app.router.match(ctx.path, ctx.method);
+    if (!matched || !matched.route) {
+      ctx.status = 404;
+      ctx.api.fail('接口不存在', 404, null);
+      return;
+    }
+
+    try { await next(); } catch (err) {
+      const duration = Date.now() - start;
+      requestLogger.error(method + ' ' + url + ' ' + (ctx.status || 500) + ' ' + duration + 'ms', { type: 'error', method, url, ip, status: ctx.status || 500, duration, message: err.message, stack: err.stack, code: err.code || '' });
+      throw err;
+    }
+
+    const duration = Date.now() - start;
+    const status = ctx.status || 200;
+    if (status >= 500) requestLogger.error(method + ' ' + url + ' ' + status + ' ' + duration + 'ms', { type: 'response', method, url, ip, status, duration });
+    else if (status >= 400) requestLogger.warn(method + ' ' + url + ' ' + status + ' ' + duration + 'ms', { type: 'response', method, url, ip, status, duration });
+    else requestLogger.info(method + ' ' + url + ' ' + status + ' ' + duration + 'ms', { type: 'response', method, url, ip, status, duration });
+  };
+};

package/app/middleware/upload_limit.js

@@ -0,0 +1,17 @@
+"use strict";
+// 上传文件限制中间件（大小、类型）
+const path = require('path');
+const { BAD_REQUEST } = require('../constants/code');
+
+module.exports = () => {
+  return async function uploadLimit(ctx, next) {
+    const file = ctx.request.files?.[0];
+    if (!file) { ctx.api.fail('请上传文件', BAD_REQUEST, null); return; }
+    const { whiteList = [], size = 10 } = ctx.app.config.fileLimit;
+    const ext = path.extname(file.filename);
+    if (!whiteList.includes(ext)) { ctx.api.fail('文件格式错误', BAD_REQUEST, null); return; }
+    const maxSize = size * 1024 * 1024;
+    if (file.size > maxSize) { ctx.api.fail('文件大小超出限制', BAD_REQUEST, null); return; }
+    await next();
+  };
+};

package/app/model/redis/redis-auth.js

@@ -0,0 +1,42 @@
+// 用户 token 缓存 CRUD（Session 模式）
+const { AUTH_SESSION, AUTH_USER_SESSIONS, AUTH_REFRESH_LOCK } = require('../../constants/redis');
+
+class RedisAuth {
+  constructor(app, clientName = 'fx') {
+    this.app = app;
+    this.clientName = clientName;
+    this.redis = this.app.redis.getClient(this.clientName);
+  }
+
+  _client() { return this.app.redis.getClient(this.clientName); }
+
+  // ==================== Session ====================
+  async setAuthSession(sid, data, ttl) {
+    await this.redis.set('auth:session:' + sid, JSON.stringify(data), 'EX', ttl);
+  }
+  async getAuthSession(sid) {
+    const raw = await this.redis.get('auth:session:' + sid);
+    return raw ? JSON.parse(raw) : null;
+  }
+  async delAuthSession(sid) { await this.redis.del('auth:session:' + sid); }
+  async expireAuthSession(sid, ttl) { await this.redis.expire('auth:session:' + sid, ttl); }
+
+  // ==================== Session Index ====================
+  async addUserSession(uid, sid) { await this.redis.sadd('auth:user:' + uid + ':sessions', sid); }
+  async removeUserSession(uid, sid) { await this.redis.srem('auth:user:' + uid + ':sessions', sid); }
+  async getUserSessions(uid) { return await this.redis.smembers('auth:user:' + uid + ':sessions'); }
+  async clearUserSessions(uid) { await this.redis.del('auth:user:' + uid + ':sessions'); }
+
+  // ==================== User Cache ====================
+  async setUserCache(userId, userInfo, ttl) { await this.redis.set('user:login:' + userId, userInfo, 'EX', ttl * 60); }
+  async getUserCache(userId) { return await this.redis.get('user:login:' + userId); }
+
+  // ==================== Lock ====================
+  async acquireRefreshLock(sid, ttl = 5) {
+    const result = await this.redis.set('auth:refresh:lock:' + sid, '1', 'NX', 'EX', ttl);
+    return result === 'OK';
+  }
+  async releaseRefreshLock(sid) { await this.redis.del('auth:refresh:lock:' + sid); }
+}
+
+module.exports = RedisAuth;

package/app/redis/index.js

@@ -0,0 +1,25 @@
+// Redis 客户端创建
+const Redis = require('ioredis');
+const logger = require('../utils/logger');
+
+module.exports = (app) => {
+  const clients = {};
+  const configs = app.config.redis;
+  for (const name in configs) {
+    const config = configs[name];
+    const redis = new Redis({
+      host: config.host, port: config.port, password: config.password, db: config.db,
+      lazyConnect: true,
+      maxRetriesPerRequest: config?.maxRetriesPerRequest || 3,
+      enableOfflineQueue: false,
+      connectTimeout: config?.connectTimeout || 10000,
+      retryStrategy(times) { const delay = Math.min(times * 100, 3000); logger.warning('[Redis:' + name + '] reconnecting ' + times); return delay; },
+      reconnectOnError(err) { if (err.message.includes('READONLY')) return true; return false; },
+    });
+    redis.on('ready', () => logger.success('[Redis:' + name + '] 已就绪'));
+    redis.on('error', (err) => logger.error('[Redis:' + name + '] 错误', err));
+    redis.on('close', () => logger.warning('[Redis:' + name + '] 连接关闭'));
+    clients[name] = redis;
+  }
+  return clients;
+};

package/app/redis/redis-manager.js

@@ -0,0 +1,46 @@
+class RedisManager {
+  constructor(clients) { this.clients = clients; }
+
+  getClient(name = 'fx') {
+    const client = this.clients[name];
+    if (!client) throw new Error('Redis client "' + name + '" not found');
+    return client;
+  }
+
+  async set(clientName, key, value, expire = null) {
+    const client = this.getClient(clientName);
+    const data = typeof value === 'string' ? value : JSON.stringify(value);
+    return expire ? await client.set(key, data, 'EX', expire) : await client.set(key, data);
+  }
+
+  async hset(clientName, key, field, value) {
+    const client = this.getClient(clientName);
+    const data = typeof value === 'string' ? value : JSON.stringify(value);
+    return await client.hset(key, field, data);
+  }
+
+  async get(clientName, key) {
+    const client = this.getClient(clientName);
+    const data = await client.get(key);
+    try { return JSON.parse(data); } catch { return data; }
+  }
+
+  async hget(clientName, key, field) {
+    const client = this.getClient(clientName);
+    const data = await client.hget(key, field);
+    try { return JSON.parse(data); } catch { return data; }
+  }
+
+  async hgetall(clientName, key, parse = false) {
+    const client = this.getClient(clientName);
+    const data = await client.hgetall(key);
+    if (!parse) return data;
+    const result = {};
+    for (const field in data) { try { result[field] = JSON.parse(data[field]); } catch { result[field] = data[field]; } }
+    return result;
+  }
+
+  async del(clientName, key) { return await this.getClient(clientName).del(key); }
+}
+
+module.exports = RedisManager;

package/app/router/auth.js

@@ -0,0 +1,17 @@
+/**
+ * 认证路由
+ *
+ * POST /api/public/auth/login        - 用户登录
+ * POST /api/public/auth/refresh      - 刷新 accessToken
+ * POST /api/auth/logout              - 登出（需鉴权）
+ * POST /api/auth/changePassword      - 修改密码（需鉴权）
+ * GET  /api/auth/getUserInfo         - 获取用户信息
+ */
+module.exports = (app) => {
+  const { router, controller } = app;
+  router.post("/public/auth/login", controller.authSystem.auth.login);
+  router.post("/public/auth/refresh", controller.authSystem.auth.refresh);
+  router.post("/auth/logout", controller.authSystem.auth.logout);
+  router.post("/auth/changePassword", controller.authSystem.auth.changePassword);
+  router.get("/auth/getUserInfo", controller.authSystem.auth.getUserInfo);
+};

package/app/router/common.js

@@ -0,0 +1,11 @@
+/**
+ * 通用路由
+ *
+ * GET /              - 首页
+ * GET /health        - 健康检查
+ */
+module.exports = app => {
+  const { router, controller } = app;
+  router.get("/", controller.home.index);
+  router.get("/health", controller.common.health.index);
+};

package/app/router/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+/**
+ * 框架内置路由：认证、健康检查
+ */
+module.exports = app => {
+  for (const routeFile of ["./auth", "./common"]) {
+    const register = require(routeFile);
+    if (typeof register === "function") {
+      register(app);
+    }
+  }
+};

package/app/router.js

@@ -0,0 +1,11 @@
+"use strict";
+
+/**
+ * @niceguy/egg-client - 框架内置路由
+ * 设置 /api 前缀，加载认证、健康检查等内置路由
+ * 业务项目可在自己的 app/router.js 中添加额外路由
+ */
+module.exports = app => {
+  app.router.prefix("/api");
+  require("./router/index")(app);
+};

package/app/service/authSystem/auth.js

@@ -0,0 +1,144 @@
+const Service = require('egg').Service;
+const { comparePassword, encryptPassword } = require('../../utils/encrypt');
+const { createToken, verifyToken } = require('../../utils/jwt');
+const { TOKEN_EXPIRES_IN, REFRESH_TOKEN_EXPIRES_IN, ACCESS_SECRET, REFRESH_SECRET, SESSION_EXPIRES_IN } = require('../../constants/crypt');
+const { randomUUID } = require('crypto');
+
+class AuthService extends Service {
+
+  async login({ username, password }) {
+    const { ctx, app } = this;
+    const user = await this.findByUser({ username });
+    if (!user) return { ok: false, code: 40105 };
+    if (user.status !== 1) return { ok: false, code: 40301 };
+
+    const valid = await comparePassword(password, user.pwd);
+    if (!valid) return { ok: false, code: 40106 };
+
+    const sid = randomUUID();
+    const accessJti = randomUUID();
+    const refreshJti = randomUUID();
+    const now = Math.floor(Date.now() / 1000);
+
+    const accessToken = createToken({ uid: user.id, sid, jti: accessJti, type: 'access', iat: now }, ACCESS_SECRET, { expiresIn: TOKEN_EXPIRES_IN + 'm' });
+    const refreshToken = createToken({ uid: user.id, sid, jti: refreshJti, type: 'refresh', iat: now }, REFRESH_SECRET, { expiresIn: REFRESH_TOKEN_EXPIRES_IN + 'm' });
+
+    const sessionTtl = SESSION_EXPIRES_IN * 60;
+    const redis = app.modle.redis.redisAuth;
+    await redis.setAuthSession(sid, { uid: user.id, refreshJti, platform: 'unknown', iat: now, lastRefreshTime: now }, sessionTtl);
+    await redis.addUserSession(user.id, sid);
+    await redis.setUserCache(user.id, JSON.stringify({ userId: user.id, enName: user.en_name, roles: [], status: user.status }), REFRESH_TOKEN_EXPIRES_IN);
+
+    return { ok: true, data: { accessToken, refreshToken, sid } };
+  }
+
+  async verifyAccessToken({ token }) {
+    const { app } = this;
+    let payload;
+    try { payload = verifyToken(token, ACCESS_SECRET); }
+    catch (err) { return { ok: false, code: err.name === 'TokenExpiredError' ? 40101 : 40103 }; }
+    if (!payload || payload.type !== 'access') return { ok: false, code: 40103 };
+    const session = await app.modle.redis.redisAuth.getAuthSession(payload.sid);
+    if (!session) return { ok: false, code: 40104 };
+    return { ok: true, payload };
+  }
+
+  async refreshToken({ token }) {
+    const { ctx, app } = this;
+    let payload;
+    try { payload = verifyToken(token, REFRESH_SECRET); }
+    catch (err) { return { ok: false, code: err.name === 'TokenExpiredError' ? 40102 : 40103 }; }
+    if (payload.type !== 'refresh') return { ok: false, code: 40103 };
+    const { uid, sid, jti } = payload;
+    const redis = app.modle.redis.redisAuth;
+    const session = await redis.getAuthSession(sid);
+    if (!session) return { ok: false, code: 40104 };
+    if (session.refreshJti !== jti) return { ok: false, code: 401 };
+
+    const locked = await redis.acquireRefreshLock(sid);
+    if (!locked) return { ok: false, code: 401 };
+    try {
+      const sessionAfterLock = await redis.getAuthSession(sid);
+      if (!sessionAfterLock || sessionAfterLock.refreshJti !== jti) return { ok: false, code: 401 };
+      const now = Math.floor(Date.now() / 1000);
+      const newRefreshJti = randomUUID();
+      const newAccessJti = randomUUID();
+      const newAccessToken = createToken({ uid, sid, jti: newAccessJti, type: 'access', iat: now }, ACCESS_SECRET, { expiresIn: TOKEN_EXPIRES_IN + 'm' });
+      const newRefreshToken = createToken({ uid, sid, jti: newRefreshJti, type: 'refresh', iat: now }, REFRESH_SECRET, { expiresIn: REFRESH_TOKEN_EXPIRES_IN + 'm' });
+      sessionAfterLock.refreshJti = newRefreshJti;
+      sessionAfterLock.lastRefreshTime = now;
+      await redis.setAuthSession(sid, sessionAfterLock, SESSION_EXPIRES_IN * 60);
+      return { ok: true, data: { accessToken: newAccessToken, refreshToken: newRefreshToken } };
+    } finally { await redis.releaseRefreshLock(sid); }
+  }
+
+  async logout({ uid, sid }) {
+    const { app } = this;
+    const redis = app.modle.redis.redisAuth;
+    await redis.delAuthSession(sid);
+    await redis.removeUserSession(uid, sid);
+  }
+
+  async kickout({ uid }) {
+    const { app } = this;
+    const redis = app.modle.redis.redisAuth;
+    const { AUTH_SESSION, AUTH_USER_SESSIONS } = require('../../constants/redis');
+    const sids = await redis.getUserSessions(uid);
+    const pipeline = redis._client().pipeline();
+    for (const sid of sids) pipeline.del(AUTH_SESSION + ':' + sid);
+    pipeline.del(AUTH_USER_SESSIONS + ':' + uid);
+    await pipeline.exec();
+  }
+
+  async changePassword({ uid, oldPassword, newPassword }) {
+    const { ctx, app } = this;
+    const { Raw } = ctx.repository.fx;
+    const user = await Raw('user_info').findOne({ where: { id: uid } });
+    if (!user) return { ok: false, code: 40105 };
+    const valid = await comparePassword(oldPassword, user.pwd);
+    if (!valid) return { ok: false, code: 40106 };
+    const newHash = encryptPassword(newPassword);
+    await Raw('user_info').updateByFilter({ where: { id: uid }, data: { pwd: newHash, update_time: new Date() } });
+    await this.kickout({ uid });
+    return { ok: true };
+  }
+
+  async refreshUserCache({ id }) {
+    if (!id) return null;
+    const { ctx, app } = this;
+    const { Raw } = ctx.repository.fx;
+    const user = await Raw('user_info').findOne({ where: { id } });
+    if (!user) return null;
+    const payload = { userId: id, enName: user.en_name, roles: [], status: user.status };
+    await app.modle.redis.redisAuth.setUserCache(id, JSON.stringify(payload), TOKEN_EXPIRES_IN);
+    return user;
+  }
+
+  async findByUser({ username }) {
+    const { ctx } = this;
+    const { Raw } = ctx.repository.fx;
+    return await Raw('user_info').findOne({ where: { en_name: username } });
+  }
+
+  async findMany(query = {}) {
+    const { ctx } = this;
+    const { Raw } = ctx.repository.fx;
+    return await Raw('user_info').findMany(query);
+  }
+
+  async updateUserMany(user) {
+    const { ctx } = this;
+    if (!Array.isArray(user)) user = [user];
+    const { transaction } = ctx.repository.fx;
+    const dateTime = new Date();
+    await transaction(async (db) => {
+      for (const o of user) {
+        const { id, ...data } = o;
+        if (!id) continue;
+        await db.Raw('user_info').updateByFilter({ where: { id }, data: { ...data, update_time: dateTime } });
+      }
+    });
+  }
+}
+
+module.exports = AuthService;

package/app/service/authSystem/permission.js

@@ -0,0 +1,4 @@
+// 权限服务（预留）
+const Service = require('egg').Service;
+class PermissionService extends Service {}
+module.exports = PermissionService;

package/app/service/authSystem/token.js

@@ -0,0 +1,4 @@
+// token 服务（预留）
+const Service = require('egg').Service;
+class TokenService extends Service {}
+module.exports = TokenService;

package/app/service/redis/auth.js

@@ -0,0 +1,4 @@
+// Redis 缓存服务（预留）
+const Service = require('egg').Service;
+class RedisService extends Service {}
+module.exports = RedisService;

package/app/utils/common.js

@@ -0,0 +1,58 @@
+const dayjs = require("dayjs");
+
+module.exports = {
+  /**
+   * 格式化时间为 YYYY-MM-DD HH:mm:ss
+   * @param {Date|string|number} [time=new Date()]
+   * @returns {string}
+   */
+  formatTime(time = new Date()) {
+    return dayjs(time).format("YYYY-MM-DD HH:mm:ss");
+  },
+
+  /**
+   * 判断结束时间是否大于开始时间（true=未过期）
+   * @param {Date|string} start
+   * @param {Date|string} [end=new Date()]
+   * @returns {boolean}
+   */
+  formDateExp(start, end = new Date()) {
+    if (!start || !end) return false;
+    return dayjs(end).isAfter(dayjs(start));
+  },
+
+  /**
+   * 时间工具函数
+   * @returns {{ now: function, addMs: function, addSec: function, addMin: function, addHour: function, addDay: function }}
+   */
+  timeUtil() {
+    return {
+      now: () => Date.now(),
+      addMs: (ms) => Date.now() + ms,
+      addSec: (s) => Date.now() + s * 1000,
+      addMin: (m) => Date.now() + m * 60 * 1000,
+      addHour: (h) => Date.now() + h * 3600 * 1000,
+      addDay: (d) => Date.now() + d * 86400 * 1000,
+    };
+  },
+
+  /**
+   * 下划线命名转驼峰命名
+   * @param {string} str
+   * @returns {string}
+   * @example snakeToCamel("user_name") => "userName"
+   */
+  snakeToCamel(str) {
+    return str.replace(/_(\w)/g, (_, letter) => letter.toUpperCase());
+  },
+
+  /**
+   * 驼峰命名转下划线命名
+   * @param {string} str
+   * @returns {string}
+   * @example camelToSnake("userName") => "user_name"
+   */
+  camelToSnake(str) {
+    return str.replace(/[A-Z]/g, (match) => "_" + match.toLowerCase());
+  },
+};

package/app/utils/encrypt.js

@@ -0,0 +1,33 @@
+// 加密 用户密码加密-不可逆哈希
+const bcrypt = require('bcryptjs');
+const SALT_ROUNDS = 10;
+
+/**
+ * 密码加密
+ * @param {string} password 明文密码
+ * @return {string} 密文
+ */
+function encryptPassword(password) {
+  if (isEncrypted(password)) return password;
+  return bcrypt.hashSync(password, SALT_ROUNDS);
+}
+
+/**
+ * 校验密码
+ * @param {string} password 明文
+ * @param {string} hash 密文
+ * @return {boolean} 是否匹配
+ */
+function comparePassword(password, hash) {
+  return bcrypt.compare(password, hash);
+}
+
+/**
+ * 判断是否已加密
+ * @param {string} password 密码
+ */
+function isEncrypted(password) {
+  return /^\[aby]\$\d{2}\$/.test(password);
+}
+
+module.exports = { encryptPassword, comparePassword, isEncrypted };