chanjs 2.7.4 → 2.7.6

package/core/Repository.js

@@ -0,0 +1,323 @@
+import { BaseComponent } from "./BaseComponent.js";
+import logger from "../utils/logger.js";
+import {
+  CODE_OK,
+  CODE_NOT_FOUND,
+  CODE_PARAM_INVALID,
+  CODE_PARAM_MISSING,
+} from "../response/code.js";
+
+const SORT_FIELD_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+const OPERATORS = { $like:'like', $gt:'>', $gte:'>=', $lt:'<', $lte:'<=', $ne:'<>' };
+
+/**
+ * 拼接查询条件，支持操作符/等值/数组in
+ * @param {import('knex').Knex.QueryBuilder} dbQuery
+ * @param {object} query
+ * @returns {import('knex').Knex.QueryBuilder}
+ */
+function applyQuery(dbQuery, query) {
+  for (const [field, val] of Object.entries(query)) {
+    if (!SORT_FIELD_REGEX.test(field)) {
+      logger.warn(`[Repository] 非法查询字段：${field}`);
+      continue;
+    }
+    if (val && typeof val === 'object' && !Array.isArray(val)) {
+      const ops = Object.keys(val);
+      if (ops.length && ops.every(k => k in OPERATORS || k === '$in' || k === '$null' || k === '$notNull')) {
+        for (const [op, operand] of Object.entries(val)) {
+          if (op === '$in') {
+            dbQuery = dbQuery.whereIn(field, Array.isArray(operand) ? operand : [operand]);
+          } else if (OPERATORS[op]) {
+            dbQuery = dbQuery.where(field, OPERATORS[op], operand);
+          } else if (op === '$null') {
+            operand ? dbQuery.whereNull(field) : dbQuery.whereNotNull(field);
+          } else if (op === '$notNull') {
+            dbQuery.whereNotNull(field);
+          }
+        }
+        continue;
+      }
+    }
+    Array.isArray(val) ? dbQuery.whereIn(field, val) : dbQuery.where(field, val);
+  }
+  return dbQuery;
+}
+
+/**
+ * 应用字段白名单 + 排序白名单到 query
+ * @param {import('knex').Knex.QueryBuilder} q
+ * @param {string[]} fields
+ * @param {object} sort
+ * @returns {import('knex').Knex.QueryBuilder}
+ */
+function applySelectAndSort(q, fields, sort) {
+  if (fields.length) {
+    const safeFields = fields.filter(f => SORT_FIELD_REGEX.test(f) || f === '*');
+    if (safeFields.length) q = q.select(safeFields);
+  }
+  if (sort && typeof sort === 'object') {
+    for (const [field, dir] of Object.entries(sort)) {
+      if (!SORT_FIELD_REGEX.test(field)) {
+        logger.warn(`[Repository] 非法排序字段：${field}`);
+        continue;
+      }
+      const d = ['asc','desc'].includes(String(dir).toLowerCase()) ? dir.toLowerCase() : 'asc';
+      q = q.orderBy(field, d);
+    }
+  }
+  return q;
+}
+
+/**
+ * 数据访问基类，封装通用CRUD操作
+ * 继承 BaseComponent 获得 app/config/db 快捷访问，不绑定组件加载职责
+ */
+class Repository extends BaseComponent {
+  constructor(table=null, dbName=null, opts={}) {
+    super();
+    this.tableName = table;
+    this._dbName = dbName;
+    this._customDb = null;
+    this._dateFields = Array.isArray(opts.dateFields) ? opts.dateFields : [];
+    typeof this.on === 'function' && this.on();
+  }
+
+  /** 动态获取数据库连接（支持多库：指定 dbName 时取对应连接，否则取默认） */
+  get db() {
+    if (this._dbName) {
+      this._customDb ??= this.app?.dbManager?.get(this._dbName);
+      return this._customDb;
+    }
+    return this.app?.db ?? null;
+  }
+
+  /** 分页配置快捷读取 */
+  get limit() { return this.config?.LIMIT_MAX || 300; }
+
+  /** 前置数据库校验 */
+  _checkDB() {
+    if (!this.db) throw new Error("Database connection not available");
+  }
+
+  /** 统一构建查询实例（子类可重写以扩展过滤逻辑） */
+  _buildBaseQuery({ query = {}, sort = {}, fields = [] } = {}) {
+    this._checkDB();
+    let q = this.db(this.tableName);
+    if (Object.keys(query).length) q = applyQuery(q, query);
+    return applySelectAndSort(q, fields, sort);
+  }
+
+  /** 工具：日期字段自动转Date */
+  #formatDate(data) {
+    if (!data || typeof data !== 'object' || !this._dateFields.length) return data;
+    const row = {...data};
+    for (const k of this._dateFields) {
+      if (typeof row[k] === 'string') {
+        const dt = new Date(row[k]);
+        !isNaN(dt.getTime()) && (row[k] = dt);
+      }
+    }
+    return row;
+  }
+
+  /** 查询全部，默认上限1000条 */
+  async all({ query={}, sort={}, fields=[], limit=1000 }={}) {
+    const list = await this._buildBaseQuery({query,sort,fields}).limit(limit);
+    return { success:true, code:CODE_OK, msg:"查询成功", data: list };
+  }
+
+  /** 分页偏移查询 */
+  async find({ query={}, sort={}, fields=[], limit, offset }={}) {
+    let q = this._buildBaseQuery({query,sort,fields});
+    typeof offset === 'number' && (q = q.offset(offset));
+    typeof limit === 'number' && (q = q.limit(limit));
+    return { success:true, code:CODE_OK, msg:"查询成功", data: await q };
+  }
+
+  /** 查询单条记录 */
+  async findOne({ query={}, fields=[] }={}) {
+    const row = await this._buildBaseQuery({query,fields}).first();
+    if (!row) return { success:false, code:CODE_NOT_FOUND, msg:"记录不存在", data:null };
+    return { success:true, code:CODE_OK, msg:"查询成功", data: row };
+  }
+
+  /** 根据ID查询单条 */
+  async findById(id, { fields=[] }={}) {
+    return this.findOne({ query:{id}, fields });
+  }
+
+  /** 单条插入 */
+  async insert(data={}) {
+    this._checkDB();
+    if (!Object.keys(data).length) return { success:false, code:CODE_PARAM_MISSING, msg:"参数缺失", data:{} };
+    const res = await this.db(this.tableName).insert(this.#formatDate(data));
+    return { success:true, code:CODE_OK, msg:"插入成功", data:{ insertId:res[0], affectedRows:res.length } };
+  }
+
+  /** 批量插入 */
+  async insertMany(records=[]) {
+    this._checkDB();
+    if (!records.length) return { success:false, code:CODE_PARAM_MISSING, msg:"参数缺失", data:{} };
+    const list = records.map(r => this.#formatDate(r));
+    const res = await this.db(this.tableName).insert(list);
+    return { success:true, code:CODE_OK, msg:"批量插入成功", data:{ insertId:res[0], affectedRows:res.length } };
+  }
+
+  /** 条件删除 */
+  async del(query={}) {
+    this._checkDB();
+    if (!Object.keys(query).length) return { success:false, code:CODE_PARAM_MISSING, msg:"参数缺失", data:{} };
+    const rows = await applyQuery(this.db(this.tableName), query).del();
+    return { success:true, code:CODE_OK, msg:"删除成功", data:{ affectedRows:rows } };
+  }
+
+  /** 根据ID删除单条 */
+  async delById(id) {
+    return this.del({ id });
+  }
+
+  /** ID数组批量删除 */
+  async delMany(ids=[]) {
+    this._checkDB();
+    if (!ids.length) return { success:false, code:CODE_PARAM_MISSING, msg:"参数缺失", data:{} };
+    const rows = await this.db(this.tableName).whereIn('id', ids).del();
+    return { success:true, code:CODE_OK, msg:"删除成功", data:{ affectedRows:rows } };
+  }
+
+  /** 按条件更新记录 */
+  async update({ query, data }={}) {
+    this._checkDB();
+    if (!query || !data || !Object.keys(query).length || !Object.keys(data).length) {
+      return { success:false, code:CODE_PARAM_INVALID, msg:"参数无效", data:{} };
+    }
+    const rows = await applyQuery(this.db(this.tableName), query).update(this.#formatDate(data));
+    return { success:true, code:CODE_OK, msg:"更新成功", data:{ affectedRows:rows } };
+  }
+
+  /** 根据ID更新，返回更新后完整数据 */
+  async updateById(id, data={}) {
+    this._checkDB();
+    if (!id || !Object.keys(data).length) return { success:false, code:CODE_PARAM_INVALID, msg:"参数无效", data:{} };
+    await this.db(this.tableName).where({id}).update(this.#formatDate(data));
+    return this.findById(id);
+  }
+
+  /** 事务批量更新，失败自动回滚 */
+  async updateMany(updates=[]) {
+    this._checkDB();
+    if (!Array.isArray(updates) || !updates.length) {
+      return { success:false, code:CODE_PARAM_MISSING, msg:"参数缺失", data:{} };
+    }
+    for (const item of updates) {
+      if (!item.query || !Object.keys(item.query).length) {
+        return { success:false, code:CODE_PARAM_INVALID, msg:"批量更新条件不能为空", data:{} };
+      }
+    }
+    const trx = await this.db.transaction();
+    let total = 0;
+    try {
+      for (const { query, data } of updates) {
+        const row = await trx(this.tableName).where(query).update(this.#formatDate(data));
+        row === 0 && logger.info("[Repository] updateMany无匹配行", query);
+        total += row;
+      }
+      await trx.commit();
+      return { success:true, code:CODE_OK, msg:"批量更新成功", data:{ affectedRows:total } };
+    } catch (err) {
+      await trx.rollback().catch(e => logger.error("[Repository] 事务回滚失败", e.message));
+      logger.error("[Repository] 批量更新异常", err.message);
+      throw err;
+    }
+  }
+
+  /**
+   * 分页查询核心实现
+   * 私有方法，避免 query/list 子类重写时发生互相递归
+   * @param {object} params 分页参数
+   * @returns {Promise<{success:boolean,code:number,msg:string,data:object}>}
+   */
+  async _doPaginate({ current=1, pageSize=10, query={}, sort={}, field=[] }={}) {
+    this._checkDB();
+    const size = Math.min(Math.max(pageSize, 1), this.limit);
+    const offset = (current - 1) * size;
+    const countQ = applyQuery(this.db(this.tableName), query);
+    const [totalRow, list] = await Promise.all([
+      countQ.count("* as total").first(),
+      this._buildBaseQuery({query,sort,fields:field}).offset(offset).limit(size)
+    ]);
+    const total = Number(totalRow?.total ?? 0);
+    return {
+      success:true,
+      code:CODE_OK,
+      msg:"查询成功",
+      data: {
+        list,
+        total,
+        current,
+        pageSize: size,
+        totalPages: Math.ceil(total / size)
+      }
+    };
+  }
+
+  /** 标准分页查询 */
+  async query(params={}) {
+    return this._doPaginate(params);
+  }
+
+  /** 统计符合条件记录行数 */
+  async count(query={}) {
+    this._checkDB();
+    const res = await applyQuery(this.db(this.tableName), query).count("* as total").first();
+    return { success:true, code:CODE_OK, msg:"统计成功", data:{ count: Number(res?.total ?? 0) } };
+  }
+
+  /** 判断查询条件下记录是否存在 */
+  async exists(query={}) {
+    this._checkDB();
+    const row = await applyQuery(this.db(this.tableName), query).first();
+    return { success:true, code:CODE_OK, msg:"检查成功", data:{ exists: !!row } };
+  }
+
+  /** 联表join查询 */
+  async join({ joinTable, localField, foreignField, fields=[], query={}, sort={} }) {
+    this._checkDB();
+    if (!SORT_FIELD_REGEX.test(joinTable) || !SORT_FIELD_REGEX.test(localField) || !SORT_FIELD_REGEX.test(foreignField)) {
+      logger.warn(`[Repository] 非法联表/字段：${joinTable}/${localField}/${foreignField}`);
+      return { success: false, code: CODE_PARAM_INVALID, msg: "非法联表或字段", data: null };
+    }
+    const select = fields.length
+      ? fields.filter(f => SORT_FIELD_REGEX.test(f) || f === '*')
+      : [`${this.tableName}.*`];
+    let q = this.db(this.tableName)
+      .join(joinTable, `${this.tableName}.${localField}`, '=', `${joinTable}.${foreignField}`)
+      .select(select);
+    q = applyQuery(q, query);
+    q = applySelectAndSort(q, [], sort);
+    return { success:true, code:CODE_OK, msg:"查询成功", data: await q };
+  }
+
+  /** 统计表总数量 + 今日新增数量 */
+  async stats() {
+    this._checkDB();
+    const createKey = this._dateFields.find(f => /created_at|createdAt/.test(f)) || "created_at";
+    const today = new Date();
+    today.setHours(0,0,0,0);
+    const [totalRes, todayRes] = await Promise.all([
+      this.db(this.tableName).count('* as count').first(),
+      this.db(this.tableName).where(createKey, '>=', today).count('* as count').first()
+    ]);
+    return {
+      success:true,
+      code:CODE_OK,
+      msg:"统计成功",
+      data: {
+        total: Number(totalRes?.count || 0),
+        today: Number(todayRes?.count || 0)
+      }
+    };
+  }
+}
+
+export default Repository;

package/core/Service.js

@@ -0,0 +1,11 @@
+/**
+ * Service 基类 - 纯业务逻辑层（无表绑定、无 CRUD 方法）
+ * 业务子类注入多个 Repository 做跨表事务编排
+ */
+import { Container } from "./Container.js";
+
+export class Service extends Container {
+  constructor() {
+    super('service');
+  }
+}

package/core/bootstrap/error-handler.js

@@ -0,0 +1,101 @@
+import { routeNotFound, serializeError, respondError } from "../../response/index.js";
+import { CODE_NOT_FOUND, CODE_CONFLICT, CODE_BUSINESS_FAIL } from "../../response/code.js";
+import {
+  AppError, isAppError, parseStack, describeError, wrapDbError,
+} from "../errors.js";
+import logger from "../../utils/logger.js";
+
+// 仅这些业务码明确经过了 DB 查询（如查无记录、唯一冲突、业务处理失败），
+// 才推断 DB 已恢复；鉴权(401/403)/参数(422)/限流(429) 等不查库的错误不触发 markUp
+const DB_RECOVERY_CODES = new Set([CODE_NOT_FOUND, CODE_CONFLICT, CODE_BUSINESS_FAIL]);
+
+// 安全开关：是否对外暴露 SQL / 堆栈等详情
+const EXPOSE_ERR_DETAIL = process.env.EXPOSE_ERR_DETAIL === "true";
+const IS_PROD = ["prd", "prod", "production"].includes(process.env.NODE_ENV || "dev");
+
+/**
+ * 注册全局异常兜底中间件（ChanJS底层框架）
+ * @description
+ * 唯一统一错误出口，职责收敛为：日志 / 环境鉴权 / HTTP状态 / 脱敏，全项目所有报错只打印一次。
+ * 1. 404 兜底：路由未匹配时返回标准 404 JSON（须在业务路由之后注册）
+ * 2. 全局异常捕获：DB/底层异常经 wrapDbError 归类为友好 AppError，
+ *    响应层 serializeError 零 DB 感知，换数据库不用改响应代码
+ * 3. 区分浏览器HTML / API JSON：HTML返回框架内置静态错误页，接口返回标准JSON
+ * 4. 双重安全校验：EXPOSE_ERR_DETAIL && (!生产环境 || 携带合法Debug令牌)，生产误开也不泄露堆栈/SQL
+ * @param {object} chan 框架核心实例 { app: Express }
+ */
+export function registerErrorHandler(chan) {
+  const { app, config } = chan;
+
+  // ============ 404 兜底（路由未匹配） ============
+  // 使用 respondError 做 HTML/JSON 分流：页面请求返回框架内置 HTML 错误页，
+  // 接口请求返回标准 JSON；避免浏览器直接访问不存在路径时看到一段 JSON 文本。
+  app.use((req, res) => {
+    const notFound = routeNotFound(req);
+    respondError(res, req, {
+      httpStatus: 404,
+      code: notFound.code,
+      msg: notFound.msg,
+      data: notFound.data,
+    });
+  });
+
+  // ============ 全局异常统一出口 ============
+  app.use((err, req, res, next) => {
+    // 响应头已发送，转交Express默认错误处理
+    if (res.headersSent) return next(err);
+
+    // DB / 底层异常下沉转换：非业务错误先归类为友好 AppError
+    if (!isAppError(err)) err = wrapDbError(err);
+
+    // 连接类故障实时标记：后续未登录请求可直接返回「数据库未连接」，
+    // 而非伪装成 token 缺失（详见 auth 中间件 isDown 短路）
+    const isDbConnection = isAppError(err) && (
+      err.code >= 6000 ||
+      /数据库连接|数据库访问被拒绝|ECONNREFUSED|ETIMEDOUT|连接中断/.test(err.message || "")
+    );
+    if (isDbConnection) {
+      chan.dbManager?.markDown?.();
+    } else if (isAppError(err) && DB_RECOVERY_CODES.has(err.code)) {
+      // 仅明确经过 DB 查询的业务错误（查无记录/唯一冲突/业务失败）才推断 DB 已恢复，
+      // 鉴权/参数/限流等不查库的错误不触发 markUp，避免误标
+      chan.dbManager?.markUp?.();
+    }
+
+    const httpStatus = isAppError(err) ? err.httpStatus : 500;
+    const stackInfo = parseStack(err.stack);
+    // 全链路追踪信息（requestId 需业务/框架注入 req.id 或 x-request-id 头）
+    const requestId = req.headers["x-request-id"] || req.id || "-";
+    const userId = req.user?.id ?? "-";
+
+    // 日志分级：业务错误 4xx → warn，系统错误 5xx → error（唯一打印点，杜绝重复刷屏）
+    const logFn = httpStatus < 500 ? logger.warn : logger.error;
+    logFn(JSON.stringify({
+      type: err.name || "UnknownError",
+      message: describeError(err), // 递归解析 cause 根因，支持 AggregateError
+      file: stackInfo.file,
+      line: stackInfo.line,
+      requestId,
+      method: req.method,
+      url: req.originalUrl,
+      userId,
+    }));
+
+    // 双重安全校验：生产环境即使环境变量开了，也必须携带合法 Debug Token 才暴露堆栈/SQL
+    const exposeDetail = EXPOSE_ERR_DETAIL && (!IS_PROD || req.headers["x-debug-token"] === process.env.DEBUG_TOKEN);
+
+    if (isAppError(err)) {
+      // 统一通过 respondError 做 HTML/JSON 分流（复用 response 层纯函数，消除重复逻辑）
+      const serialized = serializeError(err, exposeDetail);
+      return respondError(res, req, {
+        httpStatus,
+        code: serialized.code,
+        msg: serialized.msg,
+        data: serialized.data ?? null,
+      });
+    }
+
+    // 兆底分支（理论上 wrapDbError 已转 AppError，这里防万一）
+    respondError(res, req, { httpStatus: 500, code: 500, msg: "服务器内部错误" });
+  });
+}

package/core/bootstrap/hook-runner.js

@@ -0,0 +1,64 @@
+import logger from "../../utils/logger.js";
+import { describeError, errorExtraProps } from "../errors.js";
+import { HOOK_TIMEOUT as DEFAULT_HOOK_TIMEOUT } from "../../config/index.js";
+
+/**
+ * 带超时限制执行钩子，超时则 reject 跳过该钩子，不阻塞后续启动
+ * @param {Function} fn 钩子函数
+ * @param {number} timeout 超时毫秒
+ * @param {string} tag 钩子标识，用于日志
+ * @returns {Promise<void>}
+ */
+async function runHookWithTimeout(fn, timeout, tag) {
+  let timer;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`钩子 ${tag} 执行超时(${timeout}ms)，已跳过`)),
+      timeout
+    );
+  });
+  try {
+    await Promise.race([fn(), timeoutPromise]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * 串行执行启动钩子，单钩子超时/报错不阻塞整体启动
+ * 仅支持格式：{ name: string, fn: () => Promise<any> }
+ * @param {object} chan 框架实例
+ */
+export async function runHooks(chan) {
+  const { hooks = [], config = {} } = chan;
+  if (!hooks.length) return;
+
+  const hookTimeout = config.HOOK_TIMEOUT ?? DEFAULT_HOOK_TIMEOUT;
+
+  for (let i = 0; i < hooks.length; i++) {
+    const item = hooks[i];
+    const seq = i + 1;
+    // 支持两种格式：{ name, fn } 对象 或 纯函数（App.beforeStart 注册的是纯函数）
+    let name, fn;
+    if (typeof item === "function") {
+      fn = item;
+      name = null;
+    } else if (item && typeof item === "object") {
+      ({ name, fn } = item);
+    }
+    const hookTag = name || `hook#${seq}`;
+
+    // 非法钩子直接跳过
+    if (typeof fn !== "function") {
+      logger.warn(`[ChanHook][${hookTag}] 第${seq}项钩子fn非函数，跳过`);
+      continue;
+    }
+
+    try {
+      await runHookWithTimeout(fn, hookTimeout, hookTag);
+    } catch (err) {
+      const errLog = describeError(err) + errorExtraProps(err);
+      logger.error(`[ChanHook][${hookTag}] 第${seq}个钩子执行异常:\n${errLog}`, err);
+    }
+  }
+}

package/core/bootstrap/middleware.js

@@ -0,0 +1,35 @@
+import {
+  Cors, body, cookie, favicon, header,
+  staticMw, template, waf, wafBody, log,
+} from "../../middleware/index.js";
+import { BODY_LIMIT } from "../../config/index.js";
+
+/**
+ * 注册核心中间件（顺序固化：不可随意调整）
+ * WAF 前置 → Favicon → 静态 → Cookie → Body 解析 → WAF Body 检查 → CORS → 日志 → 模板 → 响应头
+ * @param {object} chan 框架实例
+ */
+export async function registerCoreMiddleware(chan) {
+  const { app, config: cfg } = chan;
+
+  // 1. WAF 前置（IP/封禁/限流/路径与 query 检查，不依赖请求体）
+  await waf(app, cfg.waf ?? { enabled: false });
+  // 2. Favicon
+  favicon(app);
+  // 3. 静态资源
+  staticMw(app, cfg.statics ?? []);
+  // 4. Cookie
+  cookie(app, cfg.cookieKey);
+  // 5. 请求体解析
+  body(app, cfg.BODY_LIMIT ?? BODY_LIMIT);
+  // 5.1 WAF Body 检查（须在 body 解析之后）
+  wafBody(app, cfg.waf ?? { enabled: false });
+  // 6. CORS
+  Cors(app, cfg.cors ?? {});
+  // 7. 请求日志
+  log(app, cfg.logger ?? {});
+  // 8. 模板渲染
+  template(app, { views: cfg.views ?? [], NODE_ENV: cfg.NODE_ENV ?? "dev" });
+  // 9. 响应头
+  header(app, { APP_NAME: cfg.APP_NAME ?? "ChanCMS", APP_VERSION: cfg.APP_VERSION ?? "1.0.0" });
+}

package/core/bootstrap/router-loader.js

@@ -0,0 +1,53 @@
+import fs from "fs";
+import path from "path";
+import { Router } from "express";
+import { loaderSort, importFile } from "../loader.js";
+import logger from "../../utils/logger.js";
+
+/**
+ * 加载路由公共逻辑：导入并执行路由注册函数
+ * @param {string} filePath 路由文件完整路径
+ * @param {object} app Express实例
+ * @param {object} router 顶层路由
+ * @param {object} config 全局配置
+ */
+async function registerRouterFile(filePath, app, router, config) {
+  if (!fs.existsSync(filePath)) return;
+  try {
+    const register = await importFile(filePath);
+    if (typeof register === "function") {
+      await register(app, router, config);
+    }
+  } catch (err) {
+    logger.error(`[RouterLoader] 路由文件加载失败: ${filePath}`, err);
+  }
+}
+
+/**
+ * 加载 modules 业务模块路由，按配置顺序挂载
+ * @param {object} chan 框架实例
+ */
+export async function loadModuleRouter(chan) {
+  const { paths, config, app, router } = chan;
+  const modulesDir = paths.modulesPath;
+  if (!fs.existsSync(modulesDir)) return;
+
+  const moduleNames = loaderSort(config.modules ?? []);
+  for (const name of moduleNames) {
+    const routeFile = path.join(modulesDir, name, "router.js");
+    // 每个模块使用独立的子 Router 实例，防止模块内 router.use(auth()) 等无路径前缀
+    // 的中间件污染全局，导致未匹配路径（如 404）被提前拦截成鉴权错误。
+    const subRouter = Router();
+    await registerRouterFile(routeFile, app, subRouter, config);
+  }
+}
+
+/**
+ * 加载项目根公共路由 router.js
+ * @param {object} chan 框架实例
+ */
+export async function loadCommonRouter(chan) {
+  const { paths, app, router, config } = chan;
+  const commonRouteFile = path.join(paths.appPath, "router.js");
+  await registerRouterFile(commonRouteFile, app, router, config);
+}