@sisin/egg-client 1.0.0

package/app/utils/jwt.js

@@ -0,0 +1,23 @@
+// JWT token 工具
+const jwt = require('jsonwebtoken');
+
+/**
+ * 生成签名
+ * @param {*} payload  token payload
+ * @param {String} SECRET 密钥
+ * @param {Object} options 其他选项，如 expiresIn: '1h'（1小时）、'30m'（30分钟）、'2d'（2天）
+ * @return {string} signed access token
+ */
+exports.createToken = (payload, SECRET, options = {}) => {
+  return jwt.sign(payload, SECRET, { ...options });
+};
+
+/**
+ * 验证是否与密钥匹配
+ * @param {*} token access token
+ * @param {String} SECRET 密钥
+ * @return {Object|null} { ...payload, exp } 解密后的payload 或 null
+ */
+exports.verifyToken = (token, SECRET) => {
+  return jwt.verify(token, SECRET);
+};

package/app/utils/logger.js

@@ -0,0 +1,209 @@
+const pino = require("pino");
+const path = require("path");
+const fs = require("fs");
+const { loggingConfig } = require("../../config/logging");
+
+// ── 日志级别权重 ─────────────────────────────────────
+const levelRank = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60,
+};
+
+// ── Time format: YYYY-MM-DD HH:mm:ss ────────────────
+function formatTime() {
+  const d = new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return (
+    `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ` +
+    `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`
+  );
+}
+
+// ── Date-rotating file writer ───────────────────────
+// Creates: {basePath}/YYYY-MM/DD.log
+// Content: YYYY-MM-DD HH:mm:ss: message
+class DateRotateWriter {
+  constructor(basePath) {
+    this.basePath = basePath;
+    this.currentDate = "";
+    this.stream = null;
+  }
+
+  _rotate() {
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    const yearMonth = `${now.getFullYear()}-${pad(now.getMonth() + 1)}`;
+    const day = pad(now.getDate());
+    const dateStr = `${yearMonth}-${day}`;
+
+    if (dateStr === this.currentDate) return;
+
+    if (this.stream) {
+      this.stream.destroy();
+      this.stream = null;
+    }
+
+    const dir = path.resolve(this.basePath, yearMonth);
+    fs.mkdirSync(dir, { recursive: true });
+    this.stream = fs.createWriteStream(path.join(dir, `${day}.log`), {
+      flags: "a",
+    });
+    this.stream.on("error", () => {
+      // silent — prevent crash on file write errors
+    });
+    this.currentDate = dateStr;
+  }
+
+  write(line) {
+    try {
+      this._rotate();
+      if (this.stream) {
+        this.stream.write(line + "\n");
+      }
+    } catch (_) {
+      // silent — don't crash the app over log write failures
+    }
+  }
+
+  close() {
+    if (this.stream) {
+      this.stream.end();
+      this.stream = null;
+    }
+  }
+}
+
+// ── Serialize extra data for plain-text file output ──
+function flatData(data) {
+  if (data === undefined || data === null) return "";
+  if (typeof data === "string") return ` ${data}`;
+  if (data instanceof Error) {
+    return ` ${data.message}${data.stack ? `\n${data.stack}` : ""}`;
+  }
+  return ` ${JSON.stringify(data)}`;
+}
+
+// ── Console-only logger factory ──────────────────────
+// 只在终端美化输出，不写入文件。用于初始化提示、状态消息等全局场景。
+function createConsoleLogger(config) {
+  const level = config.level || "info";
+  const p = pino({
+    level,
+    transport: {
+      target: "pino-pretty",
+      options: {
+        colorize: true,
+        translateTime: "yyyy-mm-dd HH:MM:ss",
+        ignore: "pid,hostname",
+      },
+    },
+  });
+
+  const logger = {};
+
+  const stdLevels = ["trace", "debug", "info", "warn", "error", "fatal"];
+  for (const lvl of stdLevels) {
+    logger[lvl] = (message, data) => {
+      if (data !== undefined && data !== null) {
+        p[lvl](data, message);
+      } else {
+        p[lvl](message);
+      }
+    };
+  }
+
+  // 终端专用美化方法（不落文件）
+  logger.success = (message) => p.info(`√ ${message}`);
+  logger.init = (message) => p.info(`◆ ${message}`);
+  logger.warning = logger.warn;
+
+  return logger;
+}
+
+// ── File-logger factory (with optional terminal) ────
+// 根据 config.terminal 决定是否同时在终端输出；根据 config.pretty 决定终端是否美化。
+// 日志文件始终通过 DateRotateWriter 写入（当 filePath 非空时），但受 config.level 过滤。
+function createLogger(config) {
+  const level = config.level || "info";
+  const minRank = levelRank[level] || levelRank.info;
+
+  // 终端输出 (pino + 可选 pino-pretty)，仅在 config.terminal 为 true 时创建
+  let p = null;
+  if (config.terminal) {
+    const pinoOpts = { level };
+    if (config.pretty) {
+      pinoOpts.transport = {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          translateTime: "yyyy-mm-dd HH:MM:ss",
+          ignore: "pid,hostname",
+        },
+      };
+    }
+    p = pino(pinoOpts);
+  }
+
+  // 文件写入器（始终创建，当 filePath 非空时）
+  const fw = config.filePath ? new DateRotateWriter(config.filePath) : null;
+
+  const logger = {};
+
+  const stdLevels = ["trace", "debug", "info", "warn", "error", "fatal"];
+  for (const lvl of stdLevels) {
+    logger[lvl] = (message, data) => {
+      // 终端输出：pino 内部自带 level 过滤
+      if (p) {
+        if (data !== undefined && data !== null) {
+          p[lvl](data, message);
+        } else {
+          p[lvl](message);
+        }
+      }
+      // 文件写入：手动检查 level 权重，低于配置级别的不落文件
+      if (fw && (levelRank[lvl] || 0) >= minRank) {
+        fw.write(`${formatTime()}: [${lvl.toUpperCase()}] ${message}${flatData(data)}`);
+      }
+    };
+  }
+
+  // success / init 按 info 级别处理，受 config.level 过滤
+  logger.success = (message) => {
+    if (p) p.info(`√ ${message}`);
+    if (fw && levelRank.info >= minRank) fw.write(`${formatTime()}: [SUCCESS] ${message}`);
+  };
+  logger.init = (message) => {
+    if (p) p.info(`◆ ${message}`);
+    if (fw && levelRank.info >= minRank) fw.write(`${formatTime()}: [INIT] ${message}`);
+  };
+  logger.warning = logger.warn;
+
+  return logger;
+}
+
+// ── Pre-configured loggers ───────────────────────────
+
+// consoleLogger：纯终端输出，不落文件。作为默认导出，供 index.js 初始化提示、全局状态消息等场景。
+const consoleLogger = createConsoleLogger(loggingConfig.console);
+
+// appLogger / requestLogger / prismaLogger：文件存储为主，终端输出由配置控制
+const appLogger = createLogger(loggingConfig.app);
+const requestLogger = createLogger(loggingConfig.request);
+const prismaLogger = createLogger({
+  level: loggingConfig.prisma.sqlLogLevel,
+  filePath: loggingConfig.prisma.filePath,
+  terminal: loggingConfig.prisma.sqlTerminal,
+  pretty: loggingConfig.prisma.sqlTerminal,
+});
+
+// 默认导出：纯终端美化输出，用于初始化等全局消息
+module.exports = consoleLogger;
+module.exports.createLogger = createLogger;
+module.exports.createConsoleLogger = createConsoleLogger;
+module.exports.requestLogger = requestLogger;
+module.exports.prismaLogger = prismaLogger;
+module.exports.appLogger = appLogger;

package/app/utils/permission.js

@@ -0,0 +1,2 @@
+// 权限工具（预留）
+module.exports = {};

package/app/utils/prisma-manager.js

@@ -0,0 +1,127 @@
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
+const { buildDataBaseUrl } = require('./prisma');
+const logger = require('./logger');
+
+/**
+ * Prisma 生命周期管理器
+ * 自动构建每个数据库的 config、schema 和 generated client
+ *
+ * 对于 Dbs 中的每个 key，生成:
+ *   - prisma.{key}.config.ts      — Prisma 7 配置 (schema 路径 + 连接 URL)
+ *   - prisma/{key}/schema.prisma  — 从数据库 pull 的 schema
+ *   - prisma/generated/{key}/     — 生成的 PrismaClient 实例
+ */
+const CONFIG_TPL = (key, url) => `import { defineConfig } from "prisma/config";
+
+export default defineConfig({
+  schema: "prisma/${key}/schema.prisma",
+  datasource: { url: "${url}" },
+});
+`;
+
+const INITIAL_SCHEMA = (key, type = 'mysql') => `generator client {
+  provider = "prisma-client-js"
+  output   = "../generated/${key}"
+}
+
+datasource db {
+  provider = "${type}"
+}
+`;
+
+class PrismaManager {
+  constructor(app) {
+    this.app = app;
+    this.baseDir = app.baseDir;
+    this.dbConfig = app.config.Dbs || {};
+  }
+
+  /** 所有数据库是否就绪（generated client 存在） */
+  isReady() {
+    for (const key in this.dbConfig) {
+      if (!this.dbConfig[key]) continue;
+      try {
+        const mod = require(path.join(this.baseDir, 'prisma', 'generated', key));
+        if (!mod.PrismaClient) return false;
+      } catch (_) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /** 为每个数据库生成 prisma.{key}.config.ts */
+  generateConfigs() {
+    for (const key in this.dbConfig) {
+      if (!this.dbConfig[key]) continue;
+      const url = buildDataBaseUrl(this.dbConfig[key]);
+      const configPath = path.join(this.baseDir, 'prisma.' + key + '.config.ts');
+      logger.info('[PrismaManager] 生成配置 ' + configPath);
+      fs.writeFileSync(configPath, CONFIG_TPL(key, url), 'utf-8');
+    }
+  }
+
+  /** 确保 prisma/{key}/ 目录和初始 schema 存在（generator 块，prisma pull 不会覆盖它） */
+  ensureInitialSchemas() {
+    for (const key in this.dbConfig) {
+      if (!this.dbConfig[key]) continue;
+      const schemaDir = path.join(this.baseDir, 'prisma', key);
+      fs.mkdirSync(schemaDir, { recursive: true });
+      const schemaPath = path.join(schemaDir, 'schema.prisma');
+      if (!fs.existsSync(schemaPath)) {
+        logger.info('[PrismaManager] 创建初始 schema ' + schemaPath);
+        fs.writeFileSync(schemaPath, INITIAL_SCHEMA(key,this.dbConfig[key]?.type || 'mysql'), 'utf-8');
+      }
+    }
+  }
+
+  /** 执行 npx prisma db pull --config prisma.{key}.config.ts */
+  pullSchemas() {
+    for (const key in this.dbConfig) {
+      if (!this.dbConfig[key]) continue;
+      const cfg = path.join(this.baseDir, 'prisma.' + key + '.config.ts');
+      if (!fs.existsSync(cfg)) {
+        logger.warn('[PrismaManager] 配置 ' + key + ' 不存在，跳过 pull');
+        continue;
+      }
+      logger.info('[PrismaManager] prisma db pull - ' + key);
+      execSync('npx prisma db pull --config "' + cfg + '"', {
+        cwd: this.baseDir,
+        stdio: 'inherit',
+        env: { ...process.env },
+      });
+    }
+  }
+
+  /** 执行 npx prisma generate --config prisma.{key}.config.ts */
+  generateClients() {
+    for (const key in this.dbConfig) {
+      if (!this.dbConfig[key]) continue;
+      const cfg = path.join(this.baseDir, 'prisma.' + key + '.config.ts');
+      if (!fs.existsSync(cfg)) {
+        logger.warn('[PrismaManager] 配置 ' + key + ' 不存在，跳过 generate');
+        continue;
+      }
+      logger.info('[PrismaManager] prisma generate - ' + key);
+      execSync('npx prisma generate --config "' + cfg + '"', {
+        cwd: this.baseDir,
+        stdio: 'inherit',
+        env: { ...process.env },
+      });
+    }
+  }
+
+  /** 完整同步：生成配置 → 初始 schema → db pull → generate */
+  sync() {
+    logger.info('[PrismaManager] ====== 开始 Prisma 同步 ======');
+    this.generateConfigs();
+    this.ensureInitialSchemas();
+    this.pullSchemas();
+    this.generateClients();
+    logger.info('[PrismaManager] ====== Prisma 同步完成 ======');
+  }
+}
+
+module.exports = PrismaManager;

package/app/utils/prisma.js

@@ -0,0 +1,21 @@
+/**
+ * 构建 Prisma 数据库连接 URL
+ *
+ * @param {Object} options
+ * @param {string} options.type - 数据库类型，如 "mysql"
+ * @param {number} [options.connectLimit=5] - 连接数限制
+ * @param {number} [options.socketTimeout=30000] - Socket 超时时间 (ms)
+ * @param {number} [options.poolTimeout=30000] - 连接池超时 (ms)
+ * @param {number} [options.connectTimeout=30000] - 连接超时 (ms)
+ * @param {Object} [options.rest] - 额外配置
+ * @returns {string} 数据库连接 URL
+*/
+function buildDataBaseUrl({ type, user, password, host, port, database, pool = {}, ...config }) {
+  const { connectLimit = 5, socketTimeout = 30000, poolTimeout = 30000, connectTimeout = 30000, } = pool
+  if (type === "mysql") {
+    return `${type}://${user}:${password}@${host}:${port}/${database}?connect_limit=${connectLimit}&socket_timeout=${socketTimeout}&pool_timeout=${poolTimeout}&connect_timeout=${connectTimeout}`;
+  }
+  throw new Error(`暂不支持当前数据库类型：${type}`);
+}
+
+module.exports = { buildDataBaseUrl };

package/app/validate/user.js

@@ -0,0 +1,6 @@
+module.exports = {
+  login: {
+    username: { type: 'string', required: true, min: 3, max: 20 },
+    password: { type: 'string', required: true, min: 6, max: 20 },
+  },
+};

package/app.js

@@ -0,0 +1,21 @@
+// @niceguy/egg-client - Framework lifecycle entry
+'use strict';
+
+const init = require('./init');
+
+module.exports = (app) => {
+  app.initStatus = { ready: false, tasks: {}, startTime: Date.now() };
+
+  // 提供 initFramework 方法，可以从外部调用
+  app.initFramework = async () => {
+    if (app._frameworkInitDone) return;
+    app._frameworkInitDone = true;
+    await init(app);
+    app.initStatus.ready = true;
+  };
+
+  // 如果 app.js 被 Egg.js 加载，通过 beforeStart 触发初始化
+  app.beforeStart(async () => {
+    await app.initFramework();
+  });
+};

package/config/config.default.js

@@ -0,0 +1,137 @@
+/**
+ * @niceguy/egg-client - Framework-level default configuration
+ * 框架提供的默认配置，业务项目可通过 config.default.js 覆盖
+ */
+'use strict';
+
+const path = require('path');
+
+module.exports = (appInfo) => {
+  const config = {
+    // 集群监听
+    cluster: {
+      listen: {
+        path: '',
+        port: 7001,
+      },
+    },
+
+    // Cookie 签名密钥
+    keys: appInfo.name + '_niceguy_egg_client_key',
+
+    // 密码是否加密
+    isPwdEncrypt: true,
+
+    // JWT 配置
+    jwt: {
+      accessToken: 60 * 60 * 1000,        // 有效期 1 小时
+      refreshToken: 60 * 60 * 24 * 7 * 1000, // 有效期 7 天
+      secret: 'niceguy-core',
+    },
+
+    // WebSocket 配置
+    websocket: {
+      enable: false,
+    },
+
+    // 数据库连接配置（业务项目覆盖具体连接信息）
+    Dbs: {
+      fx: { // 登录库
+        type: 'mysql',// 数据库类型
+        host: '127.0.0.1',
+        port: 3306,
+        user: 'root',
+        password: '123456',
+        database: 'db_base',
+        pool: {
+          connectLimit: 5,// 连接池大小 - 按worker
+          poolTimeout: 30000,// 连接池超时时间 ms
+          socketTimeout: 30000,// SQL执行超时时间
+          connectTimeout: 30000,// 建立连接超时
+        }
+      },
+      business: { // 业务库
+        type: 'mysql',// 数据库类型
+        host: '127.0.0.1',
+        port: 3306,
+        user: 'root',
+        password: '123456',
+        database: 'db_business',
+        pool: {
+          connectLimit: 5,// 连接池大小 - 按worker
+          poolTimeout: 30000,// 连接池超时时间 ms
+          socketTimeout: 30000,// SQL执行超时时间
+          connectTimeout: 30000,// 建立连接超时
+        }
+      }
+    },
+
+    // Redis 连接配置（业务项目覆盖具体连接信息）
+    redis: {
+      fx: {
+        // 登录库
+        host: "127.0.0.1",
+        port: 6379,
+        password: "123456",
+        db: 0,
+      },
+      bussiness: {
+        host: "127.0.0.1",
+        port: 6379,
+        password: "123456",
+        db: 1,
+      },
+    },
+
+    // 日志配置（框架内置，亦可被项目覆盖）
+    logging: {
+      console: {
+        level: 'info',
+        pretty: true,
+      },
+      request: {
+        level: 'warn',
+        terminal: false,
+        filePath: path.join(appInfo.baseDir, 'logs', 'request'),
+      },
+      app: {
+        level: 'warn',
+        pretty: true,
+        terminal: false,
+        filePath: path.join(appInfo.baseDir, 'logs', 'app'),
+      },
+      prisma: {
+        level: 'warn',
+        sqlTerminal: true,
+        sqlLogLevel: 'debug',
+        slowQueryMs: 20000,
+        filePath: path.join(appInfo.baseDir, 'logs', 'prisma'),
+      },
+    },
+
+    // CSRF 安全配置（API 使用 JWT Header 鉴权，不依赖 Cookie）
+    security: {
+      csrf: {
+        enable: false,
+        ignore: (ctx) => ctx.path.startsWith('/api'),
+      },
+    },
+
+    // 全局中间件
+    middleware: ['checkReady', 'errorHandler', 'requestLog', 'jwtAuth'],
+
+    // 文件上传限制
+    fileLimit: {
+      whiteList: ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.xlsx', '.xls', '.doc', '.docx'],
+      size: 10, // MB
+    },
+
+    // 认证配置
+    auth: {
+      whiteList: ['/api/public'],           // API 白名单（前缀匹配，跳过 jwt 校验）
+      allowDevice: ['pc', 'h5', 'app', 'miniapp'],
+    },
+  };
+
+  return config;
+};

package/config/logging.js

@@ -0,0 +1,26 @@
+const loggingConfig = {
+  console: {
+    level: process.env.CONSOLE_LOG_LEVEL || "info", // 控制台日志级别
+    pretty: true, // 始终美化终端输出
+  },
+  request: {
+    level: process.env.REQUEST_LOG_LEVEL || "warn", // 日志级别 (info, warn, error)
+    terminal: process.env.REQUEST_LOG_TERMINAL === "true", // 是否终端输出
+    filePath: process.env.REQUEST_LOG_FILE_PATH || "./logs/request", // 日志文件路径
+  },
+  app: {
+    level: process.env.APP_LOG_LEVEL || "warn", // 日志级别 (info, warn, error)
+    pretty: true,//process.env.APP_LOG_PRETTY !== "false", // 是否美化输出
+    terminal: process.env.APP_LOG_TERMINAL === "true", // 是否终端输出
+    filePath: process.env.APP_LOG_FILE_PATH || "./logs/app", // 日志文件路径
+  },
+  prisma: {
+    level: process.env.PRISMA_LOG_LEVEL || "warn", // 日志级别 (info, warn, error)
+    sqlTerminal: true, // process.env.PRISMA_SQL_TERMINAL !== "false", // 是否终端输出日志
+    sqlLogLevel: process.env.PRISMA_SQL_LOG_LEVEL || "debug", // 日志级别 (info, warn, error)
+    slowQueryMs: Number(process.env.PRISMA_SLOW_QUERY_MS || 20000), // 慢查询阈值
+    filePath: process.env.PRISMA_LOG_FILE_PATH || "./logs/prisma", // 日志文件路径
+  },
+};
+
+module.exports = { loggingConfig };

package/config/plugin.default.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = {};

package/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+// 1) 重新导出 egg 框架，使 egg-bin 能找到 startCluster / Application / Controller 等
+const egg = require('egg');
+Object.assign(exports, egg);
+
+// 2) 框架自定义导出（lazy getter，使用时才加载）
+const customExports = {
+  prisma:       () => require('./app/utils/prisma'),
+  PrismaManager:() => require('./app/utils/prisma-manager'),
+  BaseRepository:   () => require('./app/core/repository/base-repository'),
+  TransactionManager:() => require('./app/core/database/transaction-manager'),
+  encrypt:      () => require('./app/utils/encrypt'),
+  jwt:          () => require('./app/utils/jwt'),
+  common:       () => require('./app/utils/common'),
+  logger:       () => require('./app/utils/logger'),
+  permission:   () => require('./app/utils/permission'),
+};
+
+for (const [name, loader] of Object.entries(customExports)) {
+  Object.defineProperty(exports, name, { enumerable: true, get: loader });
+}

package/init/index.js

@@ -0,0 +1,39 @@
+// 框架初始化入口 — 挂载日志 → 初始化数据库 → 初始化 Redis → 初始化认证
+const logger = require('../app/utils/logger');
+const initDatabase = require('./init-database');
+const initRedis = require('./init-redis');
+const initLogger = require('./init-logger');
+const initAuth = require('./init-auth');
+
+module.exports = async (app) => {
+  app.logger.info('[INIT] Framework init start');
+  try {
+    // 并发执行：日志、数据库、Redis
+    await Promise.all([initLogger(app), initDatabase(app), initRedis(app)]);
+    // 依赖上述资源的后续初始化
+    await Promise.all([initAuth(app)]);
+
+    // 注册框架路由（此时 controller / service / middleware 均已加载完毕）
+    app.logger.info('[INIT] Registering framework routes...');
+
+    app.router.prefix('/api');
+    app.logger.info('[INIT] Prefix set, loading router files...');
+
+    // 直接注册一条测试路由（不依赖 controller/router 文件）
+    app.router.get('/api/test', (ctx) => { ctx.body = { test: 'ok' }; });
+
+    // 载入框架的 app/router.js（注册 controller 路由）
+    try {
+      require('../app/router')(app);
+      app.logger.info('[INIT] Router files loaded successfully');
+    } catch (subErr) {
+      app.logger.error('[INIT] Router file load FAILED: ' + subErr.message);
+    }
+
+    app.logger.info('[INIT] Routes registration complete');
+  } catch (err) {
+    app.logger.error('[INIT] Framework init FAILED: ' + err.message);
+    logger.error('系统初始化任务执行失败', err);
+    return;
+  }
+};

package/init/init-auth.js

@@ -0,0 +1,37 @@
+// 用户初始化（密码加密检查、挂载 RedisAuth 模型）
+const { isEncrypted, encryptPassword } = require('../app/utils/encrypt');
+const logger = require('../app/utils/logger');
+const RedisAuth = require('../app/model/redis/redis-auth');
+
+module.exports = async (app) => {
+  try {
+    const ctx = app.createAnonymousContext();
+
+    // 挂载 modle 命名空间
+    app.modle = { redis: {}, prisma: {} };
+    app.modle.redis.redisAuth = new RedisAuth(app);
+
+    // 检查并加密现有用户密码
+    if (!ctx.service || !ctx.service.authSystem || !ctx.service.authSystem.auth) {
+      logger.warn('警告：authSystem.auth service 未找到，跳过用户初始化');
+      return;
+    }
+
+    const userList = await ctx.service.authSystem.auth.findMany();
+    const user = userList.find((item) => item.en_name === 'admin');
+    if (!user) return;
+
+    if (!isEncrypted(user.pwd)) {
+      const updateUser = [];
+      for (const o of userList) {
+        const pwd = await encryptPassword(o.pwd);
+        updateUser.push({ id: o.id, pwd });
+      }
+      await ctx.service.authSystem.auth.updateUserMany(updateUser);
+      logger.success('用户密码强加密');
+    }
+  } catch (err) {
+    logger.error('用户初始化失败', err);
+    throw err;
+  }
+};