befly 3.10.18 → 3.11.1

package/dist/checks/checkApi.d.ts

@@ -0,0 +1 @@
+export declare function checkApi(apis: any[]): Promise<void>;

package/{checks/checkApi.ts → dist/checks/checkApi.js}

@@ -1,11 +1,7 @@
-import { isPlainObject } from "es-toolkit/compat";
-import { omit } from "es-toolkit/object";
-
-import { Logger } from "../lib/logger.ts";
-
-export async function checkApi(apis: any[]): Promise<void> {
+import { Logger } from "../lib/logger";
+import { isPlainObject, omit } from "../utils/util";
+export async function checkApi(apis) {
     let hasError = false;
-
     for (const api of apis) {
         try {
             if (typeof api?.name !== "string" || api.name.trim() === "") {
@@ -13,83 +9,69 @@ export async function checkApi(apis: any[]): Promise<void> {
                 hasError = true;
                 continue;
             }
-
             if (typeof api?.handler !== "function") {
                 Logger.warn(omit(api, ["handler"]), "接口的 handler 属性必须是函数");
                 hasError = true;
                 continue;
             }
-
             // routePath / routePrefix 由 scanFiles 系统生成：必须是严格的 pathname
             if (typeof api?.routePath !== "string" || api.routePath.trim() === "") {
                 Logger.warn(omit(api, ["handler"]), "接口的 routePath 属性必须是非空字符串（由系统生成）");
                 hasError = true;
-            } else {
+            }
+            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）");
                     hasError = true;
                 }
-
                 if (!routePath.startsWith("/api/")) {
                     Logger.warn(omit(api, ["handler"]), "接口的 routePath 必须以 /api/ 开头");
                     hasError = true;
                 }
-
                 if (routePath.includes(" ")) {
                     Logger.warn(omit(api, ["handler"]), "接口的 routePath 不允许包含空格");
                     hasError = true;
                 }
-
                 if (routePath.includes("/api//")) {
                     Logger.warn(omit(api, ["handler"]), "接口的 routePath 不允许出现 /api//（重复斜杠）");
                     hasError = true;
                 }
             }
-
             if (typeof api?.routePrefix !== "string" || api.routePrefix.trim() === "") {
                 Logger.warn(omit(api, ["handler"]), "接口的 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)");
                 hasError = true;
             }
-
             if (api.auth !== undefined && typeof api.auth !== "boolean") {
                 Logger.warn(omit(api, ["handler"]), "接口的 auth 属性必须是布尔值 (true=需登录, false=公开)");
                 hasError = true;
             }
-
             if (api.fields && !isPlainObject(api.fields)) {
                 Logger.warn(omit(api, ["handler"]), "接口的 fields 属性必须是对象");
                 hasError = true;
             }
-
             if (api.required && !Array.isArray(api.required)) {
                 Logger.warn(omit(api, ["handler"]), "接口的 required 属性必须是数组");
                 hasError = true;
             }
-
-            if (api.required && api.required.some((reqItem: any) => typeof reqItem !== "string")) {
+            if (api.required && api.required.some((reqItem) => typeof reqItem !== "string")) {
                 Logger.warn(omit(api, ["handler"]), "接口的 required 属性必须是字符串数组");
                 hasError = true;
             }
-        } catch (error: any) {
-            Logger.error(
-                {
-                    err: error,
-                    item: api
-                },
-                "接口解析失败"
-            );
+        }
+        catch (error) {
+            Logger.error({
+                err: error,
+                item: api
+            }, "接口解析失败");
             hasError = true;
         }
     }
-
     if (hasError) {
         throw new Error("接口结构检查失败");
     }

package/dist/checks/checkHook.d.ts

@@ -0,0 +1 @@
+export declare function checkHook(hooks: any[]): Promise<void>;

package/dist/checks/checkHook.js

@@ -0,0 +1,86 @@
+import { Logger } from "../lib/logger";
+import { isPlainObject, omit } from "../utils/util";
+export async function checkHook(hooks) {
+    let hasError = false;
+    const coreBuiltinNameRegexp = /^[a-z]+(?:_[a-z]+)*$/;
+    for (const hook of hooks) {
+        try {
+            if (!isPlainObject(hook)) {
+                Logger.warn(omit(hook, ["handler"]), "钩子导出必须是对象（export default { deps, handler }）");
+                hasError = true;
+                continue;
+            }
+            // moduleName 必须存在（用于依赖排序与运行时挂载）。
+            if (typeof hook.moduleName !== "string" || hook.moduleName.trim() === "") {
+                Logger.warn(omit(hook, ["handler"]), "钩子的 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");
+                hasError = true;
+                continue;
+            }
+            if (typeof hook.enable !== "boolean") {
+                Logger.warn(omit(hook, ["handler"]), "钩子的 enable 属性必须是 boolean（true/false），不允许 0/1 等其他类型");
+                hasError = true;
+                continue;
+            }
+            // 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），用于确定钩子名称");
+                    hasError = true;
+                    continue;
+                }
+                // name 必须满足：小写字母 + 下划线（不允许空格、驼峰、数字等）。
+                if (!coreBuiltinNameRegexp.test(name)) {
+                    Logger.warn(omit(hook, ["handler"]), "core 内置钩子的 name 必须满足小写字母+下划线格式（例如 auth / rate_limit），不允许空格、驼峰或其他字符");
+                    hasError = true;
+                    continue;
+                }
+                if (!coreBuiltinNameRegexp.test(hook.moduleName)) {
+                    Logger.warn(omit(hook, ["handler"]), "core 内置钩子的 moduleName 必须满足小写字母+下划线格式（由系统生成，且必须与 name 一致）");
+                    hasError = true;
+                    continue;
+                }
+                if (name !== hook.moduleName) {
+                    Logger.warn(omit(hook, ["handler"]), "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> 开头），不允许通过扫描目录加载");
+                    hasError = true;
+                    continue;
+                }
+            }
+            if (!Array.isArray(hook.deps)) {
+                Logger.warn(omit(hook, ["handler"]), "钩子的 deps 属性必须是字符串数组");
+                hasError = true;
+                continue;
+            }
+            if (hook.deps.some((depItem) => typeof depItem !== "string")) {
+                Logger.warn(omit(hook, ["handler"]), "钩子的 deps 属性必须是字符串数组");
+                hasError = true;
+            }
+            if (typeof hook.handler !== "function") {
+                Logger.warn(omit(hook, ["handler"]), "钩子的 handler 属性必须是函数");
+                hasError = true;
+                continue;
+            }
+        }
+        catch (error) {
+            Logger.error({
+                err: error,
+                item: hook
+            }, "钩子解析失败");
+            hasError = true;
+        }
+    }
+    if (hasError) {
+        throw new Error("钩子结构检查失败");
+    }
+}

package/dist/checks/checkMenu.d.ts

@@ -0,0 +1,7 @@
+import type { MenuConfig } from "../types/sync";
+import type { AddonInfo } from "../utils/scanAddons";
+type CheckMenuOptions = {
+    disableMenus?: string[];
+};
+export declare const checkMenu: (addons: AddonInfo[], options?: CheckMenuOptions) => Promise<MenuConfig[]>;
+export {};

package/{checks/checkMenu.ts → dist/checks/checkMenu.js}

@@ -1,11 +1,7 @@
-import type { MenuConfig } from "../types/sync.ts";
-import type { AddonInfo } from "../utils/scanAddons.ts";
-
-import { Logger } from "../lib/logger.ts";
-import { compileDisableMenuGlobRules, isMenuPathDisabledByGlobRules } from "../utils/disableMenusGlob.ts";
-import { loadMenuConfigs } from "../utils/loadMenuConfigs.ts";
-
-function isValidMenuPath(path: string): { ok: boolean; reason: string } {
+import { Logger } from "../lib/logger";
+import { compileDisableMenuGlobRules, isMenuPathDisabledByGlobRules } from "../utils/disableMenusGlob";
+import { loadMenuConfigs } from "../utils/loadMenuConfigs";
+function isValidMenuPath(path) {
     if (!path) {
         return { ok: false, reason: "path 不能为空" };
     }
@@ -23,96 +19,74 @@ function isValidMenuPath(path: string): { ok: boolean; reason: string } {
     }
     return { ok: true, reason: "" };
 }
-
-type CheckMenuOptions = {
-    disableMenus?: string[];
-};
-
-type DisableMenuRule = ReturnType<typeof compileDisableMenuGlobRules>[number];
-
-function filterMenusByDisableRules(mergedMenus: MenuConfig[], rules: DisableMenuRule[]): MenuConfig[] {
+function filterMenusByDisableRules(mergedMenus, rules) {
     if (rules.length === 0) {
         return mergedMenus;
     }
-
-    const filtered: MenuConfig[] = [];
-
+    const filtered = [];
     for (const menu of mergedMenus) {
-        const menuPath = typeof (menu as any)?.path === "string" ? String((menu as any).path).trim() : "";
+        const menuPath = typeof menu?.path === "string" ? String(menu.path).trim() : "";
         if (menuPath && isMenuPathDisabledByGlobRules(menuPath, rules)) {
             continue;
         }
-
-        const children = Array.isArray((menu as any)?.children) ? ((menu as any).children as MenuConfig[]) : null;
+        const children = Array.isArray(menu?.children) ? menu.children : null;
         if (children && children.length > 0) {
             const nextChildren = filterMenusByDisableRules(children, rules);
             if (nextChildren.length > 0) {
-                (menu as any).children = nextChildren;
-            } else {
-                delete (menu as any).children;
+                menu.children = nextChildren;
+            }
+            else {
+                delete menu.children;
             }
         }
-
         filtered.push(menu);
     }
-
     return filtered;
 }
-
-export const checkMenu = async (addons: AddonInfo[], options: CheckMenuOptions = {}): Promise<MenuConfig[]> => {
+export const checkMenu = async (addons, options = {}) => {
     let hasError = false;
-
     const mergedMenus = await loadMenuConfigs(addons);
-
     const disableRules = compileDisableMenuGlobRules(options.disableMenus);
     const filteredMenus = filterMenusByDisableRules(mergedMenus, disableRules);
-
-    const stack: Array<{ menu: any; depth: number }> = [];
+    const stack = [];
     for (const m of filteredMenus) {
         stack.push({ menu: m, depth: 1 });
     }
-
-    const pathSet = new Set<string>();
-
+    const pathSet = new Set();
     while (stack.length > 0) {
-        const current = stack.pop() as { menu: any; depth: number };
+        const current = stack.pop();
         const menu = current?.menu;
         const depth = typeof current?.depth === "number" ? current.depth : 0;
-
         if (menu === null || typeof menu !== "object") {
             hasError = true;
             Logger.warn({ menu: menu }, "菜单节点必须是对象");
             continue;
         }
-
         if (depth > 3) {
             hasError = true;
             Logger.warn({ path: menu?.path, depth: depth }, "菜单层级超过 3 级（最多三级）");
             continue;
         }
-
         const children = menu.children;
         if (typeof children !== "undefined" && !Array.isArray(children)) {
             hasError = true;
             Logger.warn({ path: menu?.path, childrenType: typeof children }, "菜单 children 必须是数组");
             continue;
         }
-
         if (Array.isArray(children) && children.length > 0) {
             if (depth >= 3) {
                 hasError = true;
                 Logger.warn({ path: menu?.path, depth: depth }, "菜单层级超过 3 级（最多三级）");
-            } else {
+            }
+            else {
                 for (const child of children) {
                     stack.push({ menu: child, depth: depth + 1 });
                 }
             }
         }
-
         const path = typeof menu.path === "string" ? menu.path.trim() : "";
         const name = typeof menu.name === "string" ? menu.name.trim() : "";
         const sort = typeof menu.sort === "number" ? menu.sort : 999999;
-
         // 标准化输出（用于后续 syncMenu 直接使用）
         if (typeof menu.path === "string") {
             menu.path = path;
@@ -123,46 +97,37 @@ export const checkMenu = async (addons: AddonInfo[], options: CheckMenuOptions =
         if (typeof menu.sort === "undefined") {
             menu.sort = sort;
         }
-
         if (!path) {
             hasError = true;
             Logger.warn({ menu: menu }, "菜单缺少 path（必须是非空字符串）");
             continue;
         }
-
         const pathCheck = isValidMenuPath(path);
         if (!pathCheck.ok) {
             hasError = true;
             Logger.warn({ path: path, reason: pathCheck.reason }, "菜单 path 不合法");
         }
-
         if (!name) {
             hasError = true;
             Logger.warn({ path: path, menu: menu }, "菜单缺少 name（必须是非空字符串）");
         }
-
         if (typeof menu.sort !== "undefined" && typeof menu.sort !== "number") {
             hasError = true;
             Logger.warn({ path: path, sort: menu.sort }, "菜单 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");
         }
-
         if (pathSet.has(path)) {
             hasError = true;
             Logger.warn({ path: path }, "菜单 path 重复（严格模式禁止重复 path）");
             continue;
         }
-
         pathSet.add(path);
     }
-
     if (hasError) {
         throw new Error("菜单结构检查失败");
     }
-
     return filteredMenus;
 };

package/dist/checks/checkPlugin.d.ts

@@ -0,0 +1 @@
+export declare function checkPlugin(plugins: any[]): Promise<void>;

package/dist/checks/checkPlugin.js

@@ -0,0 +1,86 @@
+import { Logger } from "../lib/logger";
+import { isPlainObject, omit } from "../utils/util";
+export async function checkPlugin(plugins) {
+    let hasError = false;
+    const coreBuiltinNameRegexp = /^[a-z]+(?:_[a-z]+)*$/;
+    for (const plugin of plugins) {
+        try {
+            if (!isPlainObject(plugin)) {
+                Logger.warn(omit(plugin, ["handler"]), "插件导出必须是对象（export default { deps, handler }）");
+                hasError = true;
+                continue;
+            }
+            // moduleName 必须存在（用于依赖排序与运行时挂载）。
+            if (typeof plugin.moduleName !== "string" || plugin.moduleName.trim() === "") {
+                Logger.warn(omit(plugin, ["handler"]), "插件的 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");
+                hasError = true;
+                continue;
+            }
+            if (typeof plugin.enable !== "boolean") {
+                Logger.warn(omit(plugin, ["handler"]), "插件的 enable 属性必须是 boolean（true/false），不允许 0/1 等其他类型");
+                hasError = true;
+                continue;
+            }
+            // 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），用于确定插件名称");
+                    hasError = true;
+                    continue;
+                }
+                // name 必须满足：小写字母 + 下划线（不允许空格、驼峰、数字等）。
+                if (!coreBuiltinNameRegexp.test(name)) {
+                    Logger.warn(omit(plugin, ["handler"]), "core 内置插件的 name 必须满足小写字母+下划线格式（例如 logger / redis_cache），不允许空格、驼峰或其他字符");
+                    hasError = true;
+                    continue;
+                }
+                if (!coreBuiltinNameRegexp.test(plugin.moduleName)) {
+                    Logger.warn(omit(plugin, ["handler"]), "core 内置插件的 moduleName 必须满足小写字母+下划线格式（由系统生成，且必须与 name 一致）");
+                    hasError = true;
+                    continue;
+                }
+                if (name !== plugin.moduleName) {
+                    Logger.warn(omit(plugin, ["handler"]), "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> 开头），不允许通过扫描目录加载");
+                    hasError = true;
+                    continue;
+                }
+            }
+            if (!Array.isArray(plugin.deps)) {
+                Logger.warn(omit(plugin, ["handler"]), "插件的 deps 属性必须是字符串数组");
+                hasError = true;
+                continue;
+            }
+            if (plugin.deps.some((depItem) => typeof depItem !== "string")) {
+                Logger.warn(omit(plugin, ["handler"]), "插件的 deps 属性必须是字符串数组");
+                hasError = true;
+            }
+            if (typeof plugin.handler !== "function") {
+                Logger.warn(omit(plugin, ["handler"]), "插件的 handler 属性必须是函数");
+                hasError = true;
+                continue;
+            }
+        }
+        catch (error) {
+            Logger.error({
+                err: error,
+                item: plugin
+            }, "插件解析失败");
+            hasError = true;
+        }
+    }
+    if (hasError) {
+        throw new Error("插件结构检查失败");
+    }
+}

package/dist/checks/checkTable.d.ts

@@ -0,0 +1,6 @@
+import type { ScanFileResult } from "../utils/scanFiles";
+/**
+ * 检查表定义文件
+ * @throws 当检查失败时抛出异常
+ */
+export declare function checkTable(tables: ScanFileResult[]): Promise<void>;