befly 3.12.3 → 3.13.0

package/dist/checks/checkApi.js

@@ -5,70 +5,67 @@ export async function checkApi(apis) {
     for (const api of apis) {
         try {
             if (typeof api?.name !== "string" || api.name.trim() === "") {
-                Logger.warn(omit(api, ["handler"]), "接口的 name 属性必须是非空字符串");
+                Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 name 属性必须是非空字符串" }));
                 hasError = true;
                 continue;
             }
             if (typeof api?.handler !== "function") {
-                Logger.warn(omit(api, ["handler"]), "接口的 handler 属性必须是函数");
+                Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 handler 属性必须是函数" }));
                 hasError = true;
                 continue;
             }
             // routePath / routePrefix 由 scanFiles 系统生成：必须是严格的 pathname
             if (typeof api?.routePath !== "string" || api.routePath.trim() === "") {
-                Logger.warn(omit(api, ["handler"]), "接口的 routePath 属性必须是非空字符串（由系统生成）");
+                Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 routePath 属性必须是非空字符串（由系统生成）" }));
                 hasError = true;
             }
             else {
                 const routePath = api.routePath.trim();
                 // 不允许出现 "POST/api/..." 等 method 前缀
                 if (/^(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\b/i.test(routePath)) {
-                    Logger.warn(omit(api, ["handler"]), "接口的 routePath 不允许包含 method 前缀，应为 url.pathname（例如 /api/app/xxx）");
+                    Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 routePath 不允许包含 method 前缀，应为 url.pathname（例如 /api/app/xxx）" }));
                     hasError = true;
                 }
                 if (!routePath.startsWith("/api/")) {
-                    Logger.warn(omit(api, ["handler"]), "接口的 routePath 必须以 /api/ 开头");
+                    Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 routePath 必须以 /api/ 开头" }));
                     hasError = true;
                 }
                 if (routePath.includes(" ")) {
-                    Logger.warn(omit(api, ["handler"]), "接口的 routePath 不允许包含空格");
+                    Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 routePath 不允许包含空格" }));
                     hasError = true;
                 }
                 if (routePath.includes("/api//")) {
-                    Logger.warn(omit(api, ["handler"]), "接口的 routePath 不允许出现 /api//（重复斜杠）");
+                    Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 routePath 不允许出现 /api//（重复斜杠）" }));
                     hasError = true;
                 }
             }
             if (typeof api?.routePrefix !== "string" || api.routePrefix.trim() === "") {
-                Logger.warn(omit(api, ["handler"]), "接口的 routePrefix 属性必须是非空字符串（由系统生成）");
+                Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 routePrefix 属性必须是非空字符串（由系统生成）" }));
                 hasError = true;
             }
             if (api.method && !["GET", "POST", "GET,POST", "POST,GET"].includes(String(api.method).toUpperCase())) {
-                Logger.warn(omit(api, ["handler"]), "接口的 method 属性必须是有效的 HTTP 方法 (GET, POST, GET,POST, POST,GET)");
+                Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 method 属性必须是有效的 HTTP 方法 (GET, POST, GET,POST, POST,GET)" }));
                 hasError = true;
             }
             if (api.auth !== undefined && typeof api.auth !== "boolean") {
-                Logger.warn(omit(api, ["handler"]), "接口的 auth 属性必须是布尔值 (true=需登录, false=公开)");
+                Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 auth 属性必须是布尔值 (true=需登录, false=公开)" }));
                 hasError = true;
             }
             if (api.fields && !isPlainObject(api.fields)) {
-                Logger.warn(omit(api, ["handler"]), "接口的 fields 属性必须是对象");
+                Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 fields 属性必须是对象" }));
                 hasError = true;
             }
             if (api.required && !Array.isArray(api.required)) {
-                Logger.warn(omit(api, ["handler"]), "接口的 required 属性必须是数组");
+                Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 required 属性必须是数组" }));
                 hasError = true;
             }
             if (api.required && api.required.some((reqItem) => typeof reqItem !== "string")) {
-                Logger.warn(omit(api, ["handler"]), "接口的 required 属性必须是字符串数组");
+                Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 required 属性必须是字符串数组" }));
                 hasError = true;
             }
         }
         catch (error) {
-            Logger.error({
-                err: error,
-                item: api
-            }, "接口解析失败");
+            Logger.error({ err: error, item: api, msg: "接口解析失败" });
             hasError = true;
         }
     }

package/dist/checks/checkHook.js

@@ -1,82 +1,113 @@
 import { Logger } from "../lib/logger";
 import { isPlainObject, omit } from "../utils/util";
+const exportKeys = ["name", "enable", "deps", "handler"];
 export async function checkHook(hooks) {
     let hasError = false;
+    // 说明：hooks 实际是 scanFiles/scanSources 的结果对象（包含元信息字段）。
+    // 这里不再对白名单枚举 metaKeys（因为它们是系统生成的），只校验“用户 default export 导出的字段”。
     const coreBuiltinNameRegexp = /^[a-z]+(?:_[a-z]+)*$/;
     for (const hook of hooks) {
         try {
             if (!isPlainObject(hook)) {
-                Logger.warn(omit(hook, ["handler"]), "钩子导出必须是对象（export default { deps, handler }）");
+                Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "钩子导出必须是对象（export default { deps, handler }）" }));
                 hasError = true;
                 continue;
             }
             // moduleName 必须存在（用于依赖排序与运行时挂载）。
             if (typeof hook.moduleName !== "string" || hook.moduleName.trim() === "") {
-                Logger.warn(omit(hook, ["handler"]), "钩子的 moduleName 必须是非空字符串（由系统生成，用于 deps 与运行时挂载）");
+                Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "钩子的 moduleName 必须是非空字符串（由系统生成，用于 deps 与运行时挂载）" }));
                 hasError = true;
                 continue;
             }
-            // enable 必须显式声明且只能为 boolean（true/false），不允许 0/1 等其他类型。
-            if (!Object.prototype.hasOwnProperty.call(hook, "enable")) {
-                Logger.warn(omit(hook, ["handler"]), "钩子的 enable 属性是必填项，且必须显式声明为 true 或 false");
+            const customKeys = hook.customKeys;
+            if (!Array.isArray(customKeys)) {
+                Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "钩子扫描结果缺少 customKeys（无法判断用户导出的字段是否合法）" }));
                 hasError = true;
                 continue;
             }
-            if (typeof hook.enable !== "boolean") {
-                Logger.warn(omit(hook, ["handler"]), "钩子的 enable 属性必须是 boolean（true/false），不允许 0/1 等其他类型");
+            if (customKeys.some((k) => typeof k !== "string")) {
+                Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "钩子的 customKeys 必须是 string[]（由系统生成）" }));
                 hasError = true;
                 continue;
             }
+            // 严格字段校验：仅检查用户 default export 的字段集合，出现任何未支持字段都应视为错误。
+            const unknownCustomKeys = customKeys.filter((k) => !exportKeys.includes(k));
+            if (unknownCustomKeys.length > 0) {
+                Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: `钩子导出存在不支持的属性：${unknownCustomKeys.join(", ")}；仅允许：${exportKeys.join(", ")}；当前 customKeys：${customKeys.join(", ")}` }));
+                hasError = true;
+                continue;
+            }
+            const hasCustomEnable = customKeys.includes("enable");
+            const hasCustomDeps = customKeys.includes("deps");
+            // enable 必须显式声明且只能为 boolean（true/false），不允许 0/1 等其他类型。
+            // - 允许缺省：由系统在此处补全默认值 true
+            // - 若用户显式导出 enable：必须是 boolean
+            if (hasCustomEnable) {
+                if (typeof hook.enable !== "boolean") {
+                    Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "钩子的 enable 属性必须是 boolean（true/false），不允许 0/1 等其他类型" }));
+                    hasError = true;
+                    continue;
+                }
+            }
+            else {
+                hook.enable = true;
+            }
             // core 内置钩子：必须来自静态注册（filePath 以 core:hook: 开头），且 name 必须显式指定并与 moduleName 一致。
             if (hook.source === "core") {
                 const name = typeof hook.name === "string" ? hook.name : "";
                 if (name === "") {
-                    Logger.warn(omit(hook, ["handler"]), "core 内置钩子必须显式设置 name（string），用于确定钩子名称");
+                    Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "core 内置钩子必须显式设置 name（string），用于确定钩子名称" }));
                     hasError = true;
                     continue;
                 }
                 // name 必须满足：小写字母 + 下划线（不允许空格、驼峰、数字等）。
                 if (!coreBuiltinNameRegexp.test(name)) {
-                    Logger.warn(omit(hook, ["handler"]), "core 内置钩子的 name 必须满足小写字母+下划线格式（例如 auth / rate_limit），不允许空格、驼峰或其他字符");
+                    Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "core 内置钩子的 name 必须满足小写字母+下划线格式（例如 auth / rate_limit），不允许空格、驼峰或其他字符" }));
                     hasError = true;
                     continue;
                 }
                 if (!coreBuiltinNameRegexp.test(hook.moduleName)) {
-                    Logger.warn(omit(hook, ["handler"]), "core 内置钩子的 moduleName 必须满足小写字母+下划线格式（由系统生成，且必须与 name 一致）");
+                    Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "core 内置钩子的 moduleName 必须满足小写字母+下划线格式（由系统生成，且必须与 name 一致）" }));
                     hasError = true;
                     continue;
                 }
                 if (name !== hook.moduleName) {
-                    Logger.warn(omit(hook, ["handler"]), "core 内置钩子的 name 必须与 moduleName 完全一致");
+                    Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "core 内置钩子的 name 必须与 moduleName 完全一致" }));
                     hasError = true;
                     continue;
                 }
                 if (typeof hook.filePath !== "string" || !hook.filePath.startsWith(`core:hook:${name}`)) {
-                    Logger.warn(omit(hook, ["handler"]), "core 内置钩子必须来自静态注册（filePath 必须以 core:hook:<name> 开头），不允许通过扫描目录加载");
+                    Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "core 内置钩子必须来自静态注册（filePath 必须以 core:hook:<name> 开头），不允许通过扫描目录加载" }));
                     hasError = true;
                     continue;
                 }
             }
-            if (!Array.isArray(hook.deps)) {
-                Logger.warn(omit(hook, ["handler"]), "钩子的 deps 属性必须是字符串数组");
-                hasError = true;
-                continue;
+            // deps：允许缺省（补全为 []），但如果用户显式导出 deps，则必须是 string[]。
+            if (hasCustomDeps) {
+                if (!Array.isArray(hook.deps)) {
+                    Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "钩子的 deps 属性必须是字符串数组" }));
+                    hasError = true;
+                    continue;
+                }
+                if (hook.deps.some((depItem) => typeof depItem !== "string")) {
+                    Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "钩子的 deps 属性必须是字符串数组" }));
+                    hasError = true;
+                    continue;
+                }
             }
-            if (hook.deps.some((depItem) => typeof depItem !== "string")) {
-                Logger.warn(omit(hook, ["handler"]), "钩子的 deps 属性必须是字符串数组");
-                hasError = true;
+            else {
+                if (!Array.isArray(hook.deps)) {
+                    hook.deps = [];
+                }
             }
             if (typeof hook.handler !== "function") {
-                Logger.warn(omit(hook, ["handler"]), "钩子的 handler 属性必须是函数");
+                Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "钩子的 handler 属性必须是函数" }));
                 hasError = true;
                 continue;
             }
         }
         catch (error) {
-            Logger.error({
-                err: error,
-                item: hook
-            }, "钩子解析失败");
+            Logger.error({ err: error, item: hook, msg: "钩子解析失败" });
             hasError = true;
         }
     }

package/dist/checks/checkMenu.js

@@ -59,24 +59,24 @@ export const checkMenu = async (addons, options = {}) => {
         const depth = typeof current?.depth === "number" ? current.depth : 0;
         if (menu === null || typeof menu !== "object") {
             hasError = true;
-            Logger.warn({ menu: menu }, "菜单节点必须是对象");
+            Logger.warn({ menu: menu, msg: "菜单节点必须是对象" });
             continue;
         }
         if (depth > 3) {
             hasError = true;
-            Logger.warn({ path: menu?.path, depth: depth }, "菜单层级超过 3 级（最多三级）");
+            Logger.warn({ path: menu?.path, depth: depth, msg: "菜单层级超过 3 级（最多三级）" });
             continue;
         }
         const children = menu.children;
         if (typeof children !== "undefined" && !Array.isArray(children)) {
             hasError = true;
-            Logger.warn({ path: menu?.path, childrenType: typeof children }, "菜单 children 必须是数组");
+            Logger.warn({ path: menu?.path, childrenType: typeof children, msg: "菜单 children 必须是数组" });
             continue;
         }
         if (Array.isArray(children) && children.length > 0) {
             if (depth >= 3) {
                 hasError = true;
-                Logger.warn({ path: menu?.path, depth: depth }, "菜单层级超过 3 级（最多三级）");
+                Logger.warn({ path: menu?.path, depth: depth, msg: "菜单层级超过 3 级（最多三级）" });
             }
             else {
                 for (const child of children) {
@@ -99,29 +99,29 @@ export const checkMenu = async (addons, options = {}) => {
         }
         if (!path) {
             hasError = true;
-            Logger.warn({ menu: menu }, "菜单缺少 path（必须是非空字符串）");
+            Logger.warn({ menu: menu, msg: "菜单缺少 path（必须是非空字符串）" });
             continue;
         }
         const pathCheck = isValidMenuPath(path);
         if (!pathCheck.ok) {
             hasError = true;
-            Logger.warn({ path: path, reason: pathCheck.reason }, "菜单 path 不合法");
+            Logger.warn({ path: path, reason: pathCheck.reason, msg: "菜单 path 不合法" });
         }
         if (!name) {
             hasError = true;
-            Logger.warn({ path: path, menu: menu }, "菜单缺少 name（必须是非空字符串）");
+            Logger.warn({ path: path, menu: menu, msg: "菜单缺少 name（必须是非空字符串）" });
         }
         if (typeof menu.sort !== "undefined" && typeof menu.sort !== "number") {
             hasError = true;
-            Logger.warn({ path: path, sort: menu.sort }, "菜单 sort 必须是 number");
+            Logger.warn({ path: path, sort: menu.sort, msg: "菜单 sort 必须是 number" });
         }
         if (typeof menu.sort === "number" && (!Number.isFinite(menu.sort) || menu.sort < 1)) {
             hasError = true;
-            Logger.warn({ path: path, sort: menu.sort }, "菜单 sort 最小值为 1");
+            Logger.warn({ path: path, sort: menu.sort, msg: "菜单 sort 最小值为 1" });
         }
         if (pathSet.has(path)) {
             hasError = true;
-            Logger.warn({ path: path }, "菜单 path 重复（严格模式禁止重复 path）");
+            Logger.warn({ path: path, msg: "菜单 path 重复（严格模式禁止重复 path）" });
             continue;
         }
         pathSet.add(path);

package/dist/checks/checkPlugin.js

@@ -1,82 +1,113 @@
 import { Logger } from "../lib/logger";
 import { isPlainObject, omit } from "../utils/util";
+const exportKeys = ["name", "enable", "deps", "handler"];
 export async function checkPlugin(plugins) {
     let hasError = false;
+    // 说明：plugins 实际是 scanFiles/scanSources 的结果对象（包含元信息字段）。
+    // 这里不再对白名单枚举 metaKeys（因为它们是系统生成的），只校验“用户 default export 导出的字段”。
     const coreBuiltinNameRegexp = /^[a-z]+(?:_[a-z]+)*$/;
     for (const plugin of plugins) {
         try {
             if (!isPlainObject(plugin)) {
-                Logger.warn(omit(plugin, ["handler"]), "插件导出必须是对象（export default { deps, handler }）");
+                Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "插件导出必须是对象（export default { deps, handler }）" }));
                 hasError = true;
                 continue;
             }
             // moduleName 必须存在（用于依赖排序与运行时挂载）。
             if (typeof plugin.moduleName !== "string" || plugin.moduleName.trim() === "") {
-                Logger.warn(omit(plugin, ["handler"]), "插件的 moduleName 必须是非空字符串（由系统生成，用于 deps 与运行时挂载）");
+                Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "插件的 moduleName 必须是非空字符串（由系统生成，用于 deps 与运行时挂载）" }));
                 hasError = true;
                 continue;
             }
-            // enable 必须显式声明且只能为 boolean（true/false），不允许 0/1 等其他类型。
-            if (!Object.prototype.hasOwnProperty.call(plugin, "enable")) {
-                Logger.warn(omit(plugin, ["handler"]), "插件的 enable 属性是必填项，且必须显式声明为 true 或 false");
+            const customKeys = plugin.customKeys;
+            if (!Array.isArray(customKeys)) {
+                Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "插件扫描结果缺少 customKeys（无法判断用户导出的字段是否合法）" }));
                 hasError = true;
                 continue;
             }
-            if (typeof plugin.enable !== "boolean") {
-                Logger.warn(omit(plugin, ["handler"]), "插件的 enable 属性必须是 boolean（true/false），不允许 0/1 等其他类型");
+            if (customKeys.some((k) => typeof k !== "string")) {
+                Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "插件的 customKeys 必须是 string[]（由系统生成）" }));
                 hasError = true;
                 continue;
             }
+            // 严格字段校验：仅检查用户 default export 的字段集合，出现任何未支持字段都应视为错误。
+            const unknownCustomKeys = customKeys.filter((k) => !exportKeys.includes(k));
+            if (unknownCustomKeys.length > 0) {
+                Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: `插件导出存在不支持的属性：${unknownCustomKeys.join(", ")}；仅允许：${exportKeys.join(", ")}；当前 customKeys：${customKeys.join(", ")}` }));
+                hasError = true;
+                continue;
+            }
+            const hasCustomEnable = customKeys.includes("enable");
+            const hasCustomDeps = customKeys.includes("deps");
+            // enable 必须显式声明且只能为 boolean（true/false），不允许 0/1 等其他类型。
+            // - 允许缺省：由系统在此处补全默认值 true
+            // - 若用户显式导出 enable：必须是 boolean
+            if (hasCustomEnable) {
+                if (typeof plugin.enable !== "boolean") {
+                    Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "插件的 enable 属性必须是 boolean（true/false），不允许 0/1 等其他类型" }));
+                    hasError = true;
+                    continue;
+                }
+            }
+            else {
+                plugin.enable = true;
+            }
             // core 内置插件：必须来自静态注册（filePath 以 core:plugin: 开头），且 name 必须显式指定并与 moduleName 一致。
             if (plugin.source === "core") {
                 const name = typeof plugin.name === "string" ? plugin.name : "";
                 if (name === "") {
-                    Logger.warn(omit(plugin, ["handler"]), "core 内置插件必须显式设置 name（string），用于确定插件名称");
+                    Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "core 内置插件必须显式设置 name（string），用于确定插件名称" }));
                     hasError = true;
                     continue;
                 }
                 // name 必须满足：小写字母 + 下划线（不允许空格、驼峰、数字等）。
                 if (!coreBuiltinNameRegexp.test(name)) {
-                    Logger.warn(omit(plugin, ["handler"]), "core 内置插件的 name 必须满足小写字母+下划线格式（例如 logger / redis_cache），不允许空格、驼峰或其他字符");
+                    Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "core 内置插件的 name 必须满足小写字母+下划线格式（例如 logger / redis_cache），不允许空格、驼峰或其他字符" }));
                     hasError = true;
                     continue;
                 }
                 if (!coreBuiltinNameRegexp.test(plugin.moduleName)) {
-                    Logger.warn(omit(plugin, ["handler"]), "core 内置插件的 moduleName 必须满足小写字母+下划线格式（由系统生成，且必须与 name 一致）");
+                    Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "core 内置插件的 moduleName 必须满足小写字母+下划线格式（由系统生成，且必须与 name 一致）" }));
                     hasError = true;
                     continue;
                 }
                 if (name !== plugin.moduleName) {
-                    Logger.warn(omit(plugin, ["handler"]), "core 内置插件的 name 必须与 moduleName 完全一致");
+                    Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "core 内置插件的 name 必须与 moduleName 完全一致" }));
                     hasError = true;
                     continue;
                 }
                 if (typeof plugin.filePath !== "string" || !plugin.filePath.startsWith(`core:plugin:${name}`)) {
-                    Logger.warn(omit(plugin, ["handler"]), "core 内置插件必须来自静态注册（filePath 必须以 core:plugin:<name> 开头），不允许通过扫描目录加载");
+                    Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "core 内置插件必须来自静态注册（filePath 必须以 core:plugin:<name> 开头），不允许通过扫描目录加载" }));
                     hasError = true;
                     continue;
                 }
             }
-            if (!Array.isArray(plugin.deps)) {
-                Logger.warn(omit(plugin, ["handler"]), "插件的 deps 属性必须是字符串数组");
-                hasError = true;
-                continue;
+            // deps：允许缺省（补全为 []），但如果用户显式导出 deps，则必须是 string[]。
+            if (hasCustomDeps) {
+                if (!Array.isArray(plugin.deps)) {
+                    Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "插件的 deps 属性必须是字符串数组" }));
+                    hasError = true;
+                    continue;
+                }
+                if (plugin.deps.some((depItem) => typeof depItem !== "string")) {
+                    Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "插件的 deps 属性必须是字符串数组" }));
+                    hasError = true;
+                    continue;
+                }
             }
-            if (plugin.deps.some((depItem) => typeof depItem !== "string")) {
-                Logger.warn(omit(plugin, ["handler"]), "插件的 deps 属性必须是字符串数组");
-                hasError = true;
+            else {
+                if (!Array.isArray(plugin.deps)) {
+                    plugin.deps = [];
+                }
             }
             if (typeof plugin.handler !== "function") {
-                Logger.warn(omit(plugin, ["handler"]), "插件的 handler 属性必须是函数");
+                Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "插件的 handler 属性必须是函数" }));
                 hasError = true;
                 continue;
             }
         }
         catch (error) {
-            Logger.error({
-                err: error,
-                item: plugin
-            }, "插件解析失败");
+            Logger.error({ err: error, item: plugin, msg: "插件解析失败" });
             hasError = true;
         }
     }

package/dist/checks/checkTable.js

@@ -40,25 +40,26 @@ export async function checkTable(tables) {
             continue;
         }
         const sourceName = typeof item.sourceName === "string" ? item.sourceName : "";
+        const tablePrefix = sourceName ? `${sourceName}表 ` : "表 ";
         try {
             const fileName = item.fileName;
             const table = item.content || {};
             // 1) 文件名小驼峰校验
             if (!LOWER_CAMEL_CASE_REGEX.test(fileName)) {
-                Logger.warn(`${sourceName}表 ${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
+                Logger.warn(`${tablePrefix}${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
                 hasError = true;
                 continue;
             }
             // 检查 table 中的每个验证规则
             for (const [colKey, fieldDef] of Object.entries(table)) {
                 if (typeof fieldDef !== "object" || fieldDef === null || Array.isArray(fieldDef)) {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 规则必须为对象`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 规则必须为对象`);
                     hasError = true;
                     continue;
                 }
                 // 检查是否使用了保留字段
                 if (RESERVED_FIELDS.includes(colKey)) {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件包含保留字段 ${colKey}，` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(", ")}`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件包含保留字段 ${colKey}，` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(", ")}`);
                     hasError = true;
                 }
                 // 直接使用字段对象
@@ -67,78 +68,78 @@ export async function checkTable(tables) {
                 const fieldKeys = Object.keys(field);
                 const illegalProps = fieldKeys.filter((key) => !ALLOWED_FIELD_PROPERTIES.includes(key));
                 if (illegalProps.length > 0) {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 包含非法属性: ${illegalProps.join(", ")}，` + `允许的属性为: ${ALLOWED_FIELD_PROPERTIES.join(", ")}`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 包含非法属性: ${illegalProps.join(", ")}，` + `允许的属性为: ${ALLOWED_FIELD_PROPERTIES.join(", ")}`);
                     hasError = true;
                 }
                 // 检查必填字段：name, type
                 if (!field.name || typeof field.name !== "string") {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 缺少必填字段 name 或类型错误`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 缺少必填字段 name 或类型错误`);
                     hasError = true;
                     continue;
                 }
                 if (!field.type || typeof field.type !== "string") {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 缺少必填字段 type 或类型错误`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 缺少必填字段 type 或类型错误`);
                     hasError = true;
                     continue;
                 }
                 // 检查可选字段的类型
                 if (field.min !== undefined && !(field.min === null || typeof field.min === "number")) {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 min 类型错误，必须为 null 或数字`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 min 类型错误，必须为 null 或数字`);
                     hasError = true;
                 }
                 if (field.max !== undefined && !(field.max === null || typeof field.max === "number")) {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 max 类型错误，必须为 null 或数字`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 max 类型错误，必须为 null 或数字`);
                     hasError = true;
                 }
                 if (field.detail !== undefined && typeof field.detail !== "string") {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 detail 类型错误，必须为字符串`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 detail 类型错误，必须为字符串`);
                     hasError = true;
                 }
                 if (field.index !== undefined && typeof field.index !== "boolean") {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 index 类型错误，必须为布尔值`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 index 类型错误，必须为布尔值`);
                     hasError = true;
                 }
                 if (field.unique !== undefined && typeof field.unique !== "boolean") {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 unique 类型错误，必须为布尔值`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 unique 类型错误，必须为布尔值`);
                     hasError = true;
                 }
                 if (field.nullable !== undefined && typeof field.nullable !== "boolean") {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 nullable 类型错误，必须为布尔值`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 nullable 类型错误，必须为布尔值`);
                     hasError = true;
                 }
                 if (field.unsigned !== undefined && typeof field.unsigned !== "boolean") {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 unsigned 类型错误，必须为布尔值`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 unsigned 类型错误，必须为布尔值`);
                     hasError = true;
                 }
                 if (field.regexp !== undefined && field.regexp !== null && typeof field.regexp !== "string") {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 regexp 类型错误，必须为 null 或字符串`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 regexp 类型错误，必须为 null 或字符串`);
                     hasError = true;
                 }
                 const { name: fieldName, type: fieldType, min: fieldMin, max: fieldMax, default: fieldDefault } = field;
                 // 字段名称必须为中文、数字、字母、下划线、短横线、空格
                 if (!FIELD_NAME_REGEX.test(fieldName)) {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，` + `必须为中文、数字、字母、下划线、短横线、空格`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，` + `必须为中文、数字、字母、下划线、短横线、空格`);
                     hasError = true;
                 }
                 // 字段类型必须为string,number,text,array_string,array_text之一
                 if (!FIELD_TYPES.includes(fieldType)) {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，` + `必须为${FIELD_TYPES.join("、")}之一`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，` + `必须为${FIELD_TYPES.join("、")}之一`);
                     hasError = true;
                 }
                 // unsigned 仅对 number 类型有效（且仅 MySQL 语义上生效）
                 if (fieldType !== "number" && field.unsigned !== undefined) {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段类型为 ${fieldType}，不允许设置 unsigned（仅 number 类型有效）`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段类型为 ${fieldType}，不允许设置 unsigned（仅 number 类型有效）`);
                     hasError = true;
                 }
                 // 约束：unique 与 index 不能同时为 true（否则会重复索引），必须阻断启动。
                 if (field.unique === true && field.index === true) {
-                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 同时设置了 unique=true 和 index=true，` + `unique 和 index 不能同时设置，请删除其一（否则会创建重复索引）`);
+                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 同时设置了 unique=true 和 index=true，` + `unique 和 index 不能同时设置，请删除其一（否则会创建重复索引）`);
                     hasError = true;
                 }
                 // 约束：当最小值与最大值均为数字时，要求最小值 <= 最大值
                 if (fieldMin !== undefined && fieldMax !== undefined && fieldMin !== null && fieldMax !== null) {
                     if (fieldMin > fieldMax) {
-                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 不能大于最大值 "${fieldMax}"`);
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 不能大于最大值 "${fieldMax}"`);
                         hasError = true;
                     }
                 }
@@ -146,47 +147,47 @@ export async function checkTable(tables) {
                 if (fieldType === "text" || fieldType === "array_text" || fieldType === "array_number_text") {
                     // text / array_text / array_number_text：min/max 必须为 null，默认值必须为 null，且不支持索引/唯一约束
                     if (fieldMin !== undefined && fieldMin !== null) {
-                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 的 ${fieldType} 类型最小值应为 null，当前为 "${fieldMin}"`);
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 的 ${fieldType} 类型最小值应为 null，当前为 "${fieldMin}"`);
                         hasError = true;
                     }
                     if (fieldMax !== undefined && fieldMax !== null) {
-                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 的 ${fieldType} 类型最大长度应为 null，当前为 "${fieldMax}"`);
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 的 ${fieldType} 类型最大长度应为 null，当前为 "${fieldMax}"`);
                         hasError = true;
                     }
                     if (fieldDefault !== undefined && fieldDefault !== null) {
-                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，默认值必须为 null，当前为 "${fieldDefault}"`);
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${fieldType} 类型，默认值必须为 null，当前为 "${fieldDefault}"`);
                         hasError = true;
                     }
                     if (field.index === true) {
-                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，不支持创建索引（index=true 无效）`);
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${fieldType} 类型，不支持创建索引（index=true 无效）`);
                         hasError = true;
                     }
                     if (field.unique === true) {
-                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，不支持唯一约束（unique=true 无效）`);
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${fieldType} 类型，不支持唯一约束（unique=true 无效）`);
                         hasError = true;
                     }
                 }
                 else if (fieldType === "string" || fieldType === "array_string" || fieldType === "array_number_string") {
                     if (fieldMax !== undefined && (fieldMax === null || typeof fieldMax !== "number")) {
-                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，` + `最大长度必须为数字，当前为 "${fieldMax}"`);
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${fieldType} 类型，` + `最大长度必须为数字，当前为 "${fieldMax}"`);
                         hasError = true;
                     }
                     else if (fieldMax !== undefined && fieldMax > MAX_VARCHAR_LENGTH) {
-                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，` + `${fieldType} 类型长度必须在 1..${MAX_VARCHAR_LENGTH} 范围内`);
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，` + `${fieldType} 类型长度必须在 1..${MAX_VARCHAR_LENGTH} 范围内`);
                         hasError = true;
                     }
                 }
                 else if (fieldType === "number") {
                     // number 类型：default 如果存在，必须为 null 或 number
                     if (fieldDefault !== undefined && fieldDefault !== null && typeof fieldDefault !== "number") {
-                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或 null，当前为 "${fieldDefault}"`);
+                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或 null，当前为 "${fieldDefault}"`);
                         hasError = true;
                     }
                 }
             }
         }
         catch (error) {
-            Logger.error(`${sourceName}表 ${item.fileName} 解析失败`, error);
+            Logger.error({ msg: `${tablePrefix}${item.fileName} 解析失败`, err: error });
             hasError = true;
         }
     }