befly 3.72.0 → 3.74.0

package/checks/api.js

@@ -1,125 +1,68 @@
-import * as z from "zod";
-
-import { FIELD_RULE_DEFAULT_MAX, FIELD_RULE_DEFAULT_MIN, FIELD_RULE_INPUT_TYPES } from "../configs/constConfig.js";
 import { Logger } from "../lib/logger.js";
-import { formatZodIssues } from "../utils/formatZodIssues.js";
-import { isNoTrimStringAllowEmpty, isNullable, isRegexInput } from "../utils/is.js";
-
-z.config(z.locales.zhCN());
+import { validateFieldRule } from "../lib/validator.js";
+import { formatValidationIssues } from "../utils/formatValidationIssues.js";
+import { isBoolean, isFunction, isPlainObject, isString } from "../utils/is.js";
 
-const noTrimString = z.string().refine(isNoTrimStringAllowEmpty, "不允许首尾空格");
 const lowerCamelRegex = /^_?[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/;
 const apiPathRegex = /^\/api\/[a-z][a-zA-Z0-9]*(?:\/[a-z][a-zA-Z0-9]*)*$/;
+const apiKeys = new Set(["source", "type", "filePath", "relativePath", "fileName", "name", "handler", "apiPath", "method", "body", "auth", "fields", "required"]);
 
-function addIssue(context, path, message) {
-    context.addIssue({
-        path: path,
-        message: message
-    });
+function checkNoTrimString(issues, value, path, min = 0, max = Number.MAX_SAFE_INTEGER) {
+    if (!isString(value)) {
+        issues.push({ path: path, message: "必须是字符串" });
+        return;
+    }
+    if (value !== "" && value.trim() !== value) issues.push({ path: path, message: "不允许首尾空格" });
+    if (value.length < min) issues.push({ path: path, message: `长度不能少于${min}个字符` });
+    if (value.length > max) issues.push({ path: path, message: `长度不能超过${max}个字符` });
 }
 
-const fieldSchema = z
-    .object({
-        name: noTrimString.min(1),
-        input: z.enum(FIELD_RULE_INPUT_TYPES),
-        check: noTrimString.optional(),
-        min: z.number().nullable().optional(),
-        max: z.number().nullable().optional(),
-        detail: z.string().optional()
-    })
-    .strict()
-    .superRefine((value, context) => {
-        const min = isNullable(value.min) ? FIELD_RULE_DEFAULT_MIN : value.min;
-        const max = isNullable(value.max) ? FIELD_RULE_DEFAULT_MAX : value.max;
-        if (min > max) {
-            addIssue(context, ["min"], "min 不能大于 max");
-        }
-
-        const checkValue = value.check;
-        const input = value.input;
-
-        if ((input === "enum" || input === "enumNumber" || input === "enumInteger" || input === "regexp") && (!checkValue || checkValue.length === 0)) {
-            addIssue(context, ["check"], `${input} 必须提供 check`);
-            return;
-        }
-
-        if (input === "regexp" && checkValue && !isRegexInput(checkValue)) {
-            addIssue(context, ["check"], "regexp.check 必须是正则字面量或 @ 别名");
-            return;
-        }
-
-        if ((input === "enum" || input === "enumNumber" || input === "enumInteger") && checkValue) {
-            const items = String(checkValue)
-                .split("|")
-                .map((item) => item.trim())
-                .filter((item) => item.length > 0);
-
-            if (items.length === 0) {
-                addIssue(context, ["check"], `${input}.check 必须是非空枚举值列表`);
-                return;
-            }
-
-            if (input === "enumNumber" || input === "enumInteger") {
-                for (const item of items) {
-                    const num = Number(item);
-                    if (!Number.isFinite(num)) {
-                        addIssue(context, ["check"], `${input}.check 存在非法数字值: ${item}`);
-                        return;
-                    }
-                    if (input === "enumInteger" && !Number.isInteger(num)) {
-                        addIssue(context, ["check"], `${input}.check 存在非法整数值: ${item}`);
-                        return;
-                    }
-                }
-            }
-        }
-    });
-
-const fieldsSchema = z.record(z.string().regex(lowerCamelRegex), fieldSchema);
+function checkApiItem(api, index) {
+    const issues = [];
+    if (!isPlainObject(api)) {
+        issues.push({ path: [index], message: "必须是对象格式" });
+        return issues;
+    }
 
-const apiSchema = z
-    .object({
-        source: noTrimString.min(1),
-        type: noTrimString.min(1),
-        filePath: noTrimString.min(1),
-        relativePath: noTrimString.min(1),
-        fileName: z.string().min(1).regex(lowerCamelRegex),
-        name: noTrimString.min(1).max(100),
-        handler: z.custom((value) => typeof value === "function"),
-        apiPath: noTrimString.regex(apiPathRegex),
-        method: z.enum(["GET", "POST", "ALL"]),
-        body: z.enum(["none", "raw"]),
-        auth: z.union([z.boolean(), z.array(noTrimString).min(1)]),
-        fields: fieldsSchema,
-        required: z.array(noTrimString)
-    })
-    .strict()
-    .superRefine((value, context) => {
-        if (value.source !== "app") {
-            return;
-        }
+    for (const key of Object.keys(api)) {
+        if (!apiKeys.has(key)) issues.push({ path: [index, key], message: "不允许出现" });
+    }
+    for (const key of ["source", "type", "filePath", "relativePath"]) checkNoTrimString(issues, api[key], [index, key], 1);
+    checkNoTrimString(issues, api.name, [index, "name"], 1, 100);
+    if (!isString(api.fileName) || !lowerCamelRegex.test(api.fileName)) issues.push({ path: [index, "fileName"], message: "必须是 lowerCamelCase" });
+    if (!isFunction(api.handler)) issues.push({ path: [index, "handler"], message: "必须是函数" });
+    if (!isString(api.apiPath) || !apiPathRegex.test(api.apiPath)) issues.push({ path: [index, "apiPath"], message: "路径格式无效" });
+    if (!["GET", "POST", "ALL"].includes(api.method)) issues.push({ path: [index, "method"], message: "仅允许 GET|POST|ALL" });
+    if (!["none", "raw"].includes(api.body)) issues.push({ path: [index, "body"], message: "仅允许 none|raw" });
+
+    if (!isBoolean(api.auth) && (!Array.isArray(api.auth) || api.auth.length === 0 || api.auth.some((item) => !isString(item) || (item !== "" && item.trim() !== item)))) {
+        issues.push({ path: [index, "auth"], message: "必须是 boolean 或非空字符串数组" });
+    }
 
-        if (value.relativePath.split("/")[0] !== "core") {
-            return;
+    if (!isPlainObject(api.fields)) {
+        issues.push({ path: [index, "fields"], message: "必须是对象格式" });
+    } else {
+        for (const [fieldName, rule] of Object.entries(api.fields)) {
+            if (!lowerCamelRegex.test(fieldName)) issues.push({ path: [index, "fields", fieldName], message: "字段名必须为 lowerCamelCase" });
+            for (const issue of validateFieldRule(rule)) issues.push({ path: [index, "fields", fieldName, ...issue.path], message: issue.message });
         }
+    }
 
-        addIssue(context, ["relativePath"], "app API 不能使用 core 作为一级目录，避免占用 /api/core 命名空间");
-    });
+    if (!Array.isArray(api.required) || api.required.some((item) => !isString(item) || (item !== "" && item.trim() !== item))) issues.push({ path: [index, "required"], message: "必须是字符串数组" });
+    if (api.source === "app" && isString(api.relativePath) && api.relativePath.split("/")[0] === "core") issues.push({ path: [index, "relativePath"], message: "app API 不能使用 core 作为一级目录，避免占用 /api/core 命名空间" });
 
-const apiListSchema = z.array(apiSchema);
+    return issues;
+}
 
 export async function checkApi(apis) {
-    const result = apiListSchema.safeParse(apis);
-    if (result.success) {
-        return false;
+    const issues = [];
+    if (!Array.isArray(apis)) {
+        issues.push({ path: [], message: "必须是数组" });
+    } else {
+        apis.forEach((api, index) => issues.push(...checkApiItem(api, index)));
     }
 
-    Logger.warn(
-        "接口校验失败",
-        {
-            errors: formatZodIssues(result.error.issues, { items: apis, itemLabel: "api" })
-        },
-        false
-    );
+    if (issues.length === 0) return false;
+    Logger.warn("接口校验失败", { errors: formatValidationIssues(issues, { items: apis, itemLabel: "api" }) }, false);
     return true;
 }

package/checks/config.js

@@ -1,143 +1,15 @@
-import * as z from "zod";
-
-import { RUN_MODE_VALUES } from "../configs/constConfig.js";
 import { Logger } from "../lib/logger.js";
-import { formatZodIssues } from "../utils/formatZodIssues.js";
-import { isNoTrimStringAllowEmpty, isValidTimeZone } from "../utils/is.js";
-
-z.config(z.locales.zhCN());
-
-const boolIntSchema = z.union([z.literal(0), z.literal(1), z.literal(true), z.literal(false)]);
-const noTrimString = z.string().refine(isNoTrimStringAllowEmpty, "不允许首尾空格");
-const beflyModeSchema = z.union([z.literal("manual"), z.literal("auto")]);
-const uploadExtensionListSchema = noTrimString.regex(/^\.[a-z0-9]+(?:,\.[a-z0-9]+)*$/);
-const uploadMimeTypeListSchema = noTrimString.regex(/^[a-z0-9][a-z0-9.+-]*\/[a-z0-9][a-z0-9.+-]*(?:,[a-z0-9][a-z0-9.+-]*\/[a-z0-9][a-z0-9.+-]*)*$/);
-const configSchema = z
-    .object({
-        runMode: z.enum(RUN_MODE_VALUES),
-        appName: noTrimString,
-        appPort: z.int().min(1).max(65535),
-        appHost: noTrimString,
-        apiHost: noTrimString,
-        devEmail: z.union([z.literal(""), z.email()]),
-        devPassword: z.string().min(6),
-        bodyLimit: z.int().min(1),
-        upload: z
-            .object({
-                maxSize: z.int().min(1),
-                publicDir: noTrimString.min(1),
-                publicHost: noTrimString,
-                allowedExtensions: uploadExtensionListSchema,
-                allowedMimeTypes: uploadMimeTypeListSchema,
-                forceDownloadExtensions: z.union([z.literal(""), uploadExtensionListSchema])
-            })
-            .strict(),
-        tz: z.string().refine((value) => isValidTimeZone(value), "无效的时区"),
-        excludeApisLog: z.array(noTrimString),
-
-        logger: z
-            .object({
-                debug: boolIntSchema,
-                excludeFields: z.array(noTrimString)
-            })
-            .strict(),
-
-        mysql: z
-            .object({
-                hostname: noTrimString,
-                port: z.int().min(1).max(65535),
-                username: noTrimString,
-                password: noTrimString,
-                database: noTrimString,
-                max: z.number().min(1),
-                beflyMode: beflyModeSchema.optional(),
-                idleTimeout: z.number().min(1).optional(),
-                maxLifetime: z.number().min(0).optional(),
-                connectionTimeout: z.number().min(1).optional()
-            })
-            .strict(),
-
-        redis: z
-            .object({
-                hostname: noTrimString,
-                port: z.int().min(1).max(65535),
-                username: noTrimString,
-                password: noTrimString,
-                db: z.int().min(0).max(16),
-                prefix: noTrimString.regex(/^[^:]*$/)
-            })
-            .strict(),
-
-        session: z
-            .object({
-                expireDays: z.int().min(1)
-            })
-            .strict(),
-
-        email: z
-            .object({
-                host: noTrimString,
-                port: z.int().min(1).max(65535),
-                secure: z.union([z.literal(0), z.literal(1), z.literal(true), z.literal(false)]),
-                user: noTrimString,
-                pass: noTrimString,
-                label: noTrimString.optional()
-            })
-            .strict()
-            .optional(),
-
-        cors: z
-            .object({
-                origin: noTrimString,
-                methods: noTrimString,
-                allowedHeaders: noTrimString,
-                exposedHeaders: noTrimString,
-                maxAge: z.int().min(0),
-                credentials: z.union([z.literal("true"), z.literal("false"), z.literal(true), z.literal(false)])
-            })
-            .strict()
-            .superRefine((cors, ctx) => {
-                if (cors.origin !== "*" || (cors.credentials !== true && cors.credentials !== "true")) {
-                    return;
-                }
-
-                ctx.addIssue({
-                    code: "custom",
-                    message: "cors.credentials 为 true 时 cors.origin 不能为 *",
-                    path: ["credentials"]
-                });
-            }),
-
-        rateLimit: z
-            .object({
-                enable: boolIntSchema,
-                defaultLimit: z.int().min(1),
-                defaultWindow: z.int().min(1),
-                key: noTrimString,
-                skipRoutes: z.array(noTrimString),
-                rules: z.array(z.object({}).passthrough())
-            })
-            .strict()
-    })
-    .strict();
+import { validateConfig } from "../lib/validator.js";
+import { formatValidationIssues } from "../utils/formatValidationIssues.js";
 
-/**
- * 配置检查（启动期强校验）
- *
- * 说明：
- * - checkTable/checkApi 等校验的是“扫描到的源码/表定义”。
- * - checkConfig 校验的是“最终合并后的运行时配置对象”，用于阻断错误配置带病启动。
- */
 export async function checkConfig(config) {
-    const result = configSchema.safeParse(config);
-    if (result.success) {
-        return false;
-    }
+    const issues = validateConfig(config);
+    if (issues.length === 0) return false;
 
     Logger.warn(
         "配置校验失败",
         {
-            errors: formatZodIssues(result.error.issues, { item: config, itemLabel: "config" })
+            errors: formatValidationIssues(issues, { item: config, itemLabel: "config" })
         },
         false
     );

package/checks/hook.js

@@ -1,42 +1,39 @@
-import * as z from "zod";
-
 import { Logger } from "../lib/logger.js";
-import { formatZodIssues } from "../utils/formatZodIssues.js";
-import { isNoTrimStringAllowEmpty } from "../utils/is.js";
+import { formatValidationIssues } from "../utils/formatValidationIssues.js";
+import { isFiniteNumber, isFunction, isPlainObject, isString } from "../utils/is.js";
 
-z.config(z.locales.zhCN());
+const hookKeys = new Set(["source", "type", "filePath", "relativePath", "fileName", "apiPath", "handler", "order"]);
 
-const noTrimString = z.string().refine(isNoTrimStringAllowEmpty, "不允许首尾空格");
+function checkHookItem(hook) {
+    const issues = [];
+    if (!isPlainObject(hook)) {
+        issues.push({ path: [], message: "必须是对象格式" });
+        return issues;
+    }
 
-const hookSchema = z
-    .object({
-        source: noTrimString.min(1),
-        type: noTrimString.min(1),
-        filePath: noTrimString.min(1),
-        relativePath: noTrimString.min(1),
-        fileName: noTrimString.min(1),
-        apiPath: noTrimString.min(1),
-        handler: z.custom((value) => typeof value === "function"),
-        order: z.number()
-    })
-    .strict();
+    for (const key of Object.keys(hook)) {
+        if (!hookKeys.has(key)) issues.push({ path: [key], message: "不允许出现" });
+    }
+    for (const key of ["source", "type", "filePath", "relativePath", "fileName", "apiPath"]) {
+        if (!isString(hook[key]) || hook[key].length === 0 || hook[key].trim() !== hook[key]) issues.push({ path: [key], message: "必须是非空且无首尾空格的字符串" });
+    }
+    if (!isFunction(hook.handler)) issues.push({ path: ["handler"], message: "必须是函数" });
+    if (!isFiniteNumber(hook.order)) issues.push({ path: ["order"], message: "必须是有限数字" });
+    return issues;
+}
 
 export async function checkHook(hooks) {
-    let hasError = false;
+    if (!Array.isArray(hooks)) {
+        Logger.warn("钩子校验失败", { errors: formatValidationIssues([{ path: [], message: "必须是数组" }], { item: hooks, itemLabel: "hook" }) }, false);
+        return true;
+    }
 
+    let hasError = false;
     for (const hook of hooks) {
-        const result = hookSchema.safeParse(hook);
-        if (!result.success) {
-            Logger.warn(
-                "钩子校验失败",
-                {
-                    errors: formatZodIssues(result.error.issues, { item: hook, itemLabel: "hook" })
-                },
-                false
-            );
-            hasError = true;
-        }
+        const issues = checkHookItem(hook);
+        if (issues.length === 0) continue;
+        Logger.warn("钩子校验失败", { errors: formatValidationIssues(issues, { item: hook, itemLabel: "hook" }) }, false);
+        hasError = true;
     }
-
     return hasError;
 }

package/checks/menu.js

@@ -1,62 +1,48 @@
-import * as z from "zod";
-
 import { Logger } from "../lib/logger.js";
-import { formatZodIssues } from "../utils/formatZodIssues.js";
-
-z.config(z.locales.zhCN());
+import { formatValidationIssues } from "../utils/formatValidationIssues.js";
+import { isFiniteNumber, isPlainObject, isString } from "../utils/is.js";
 
 const menuPathSegmentRegexSource = "[a-z][a-z0-9]*(?:-[a-z0-9]+)*";
 const fullMenuPathRegex = new RegExp(`^/(?:core(?:/${menuPathSegmentRegexSource})*|(?:${menuPathSegmentRegexSource}(?:/${menuPathSegmentRegexSource})*)?)$`);
 const childMenuPathRegex = new RegExp(`^/${menuPathSegmentRegexSource}$`);
+const menuKeys = new Set(["path", "name", "sort", "children"]);
 
-const childMenuSchema = z
-    .object({
-        path: z.string().regex(childMenuPathRegex),
-        name: z.string().regex(/^\S(?:.*\S)?$/),
-        sort: z.number(),
-        children: z.array(z.any()).max(0).optional()
-    })
-    .strict();
-
-const menuSchema = z
-    .object({
-        path: z.string().regex(fullMenuPathRegex),
-        name: z.string().regex(/^\S(?:.*\S)?$/),
-        sort: z.number(),
-        children: z.array(childMenuSchema).optional()
-    })
-    .strict();
+function checkMenuItem(issues, menu, path, child = false) {
+    if (!isPlainObject(menu)) {
+        issues.push({ path: path, message: "必须是对象格式" });
+        return;
+    }
+    for (const key of Object.keys(menu)) {
+        if (!menuKeys.has(key)) issues.push({ path: [...path, key], message: "不允许出现" });
+    }
+    const pathRegex = child ? childMenuPathRegex : fullMenuPathRegex;
+    if (!isString(menu.path) || !pathRegex.test(menu.path)) issues.push({ path: [...path, "path"], message: "路径格式无效" });
+    if (!isString(menu.name) || menu.name.trim() !== menu.name || menu.name.length === 0) issues.push({ path: [...path, "name"], message: "必须是非空且无首尾空格的字符串" });
+    if (!isFiniteNumber(menu.sort)) issues.push({ path: [...path, "sort"], message: "必须是有限数字" });
+
+    if (child) {
+        if (menu.children !== undefined && (!Array.isArray(menu.children) || menu.children.length > 0)) issues.push({ path: [...path, "children"], message: "只能为空数组" });
+        return;
+    }
 
-const menuListSchema = z.array(menuSchema).superRefine((menuList, refineCtx) => {
-    for (let menuIndex = 0; menuIndex < menuList.length; menuIndex++) {
-        const menu = menuList[menuIndex];
-        const children = Array.isArray(menu.children) ? menu.children : [];
-        for (let childIndex = 0; childIndex < children.length; childIndex++) {
-            const child = children[childIndex];
-            const childFullPath = `${menu.path}${child.path}`;
-            if (!fullMenuPathRegex.test(childFullPath)) {
-                refineCtx.addIssue({
-                    code: "custom",
-                    message: "菜单完整路径必须是 /core/xxx 或无前缀路径",
-                    path: [menuIndex, "children", childIndex, "path"]
-                });
-            }
+    if (menu.children !== undefined && !Array.isArray(menu.children)) {
+        issues.push({ path: [...path, "children"], message: "必须是数组" });
+        return;
+    }
+    for (const [index, item] of (menu.children || []).entries()) {
+        checkMenuItem(issues, item, [...path, "children", index], true);
+        if (isPlainObject(item) && isString(menu.path) && isString(item.path) && !fullMenuPathRegex.test(`${menu.path}${item.path}`)) {
+            issues.push({ path: [...path, "children", index, "path"], message: "菜单完整路径必须是 /core/xxx 或无前缀路径" });
         }
     }
-});
+}
 
-export const checkMenu = async (menus) => {
-    const result = menuListSchema.safeParse(menus);
-    if (result.success) {
-        return false;
-    }
+export async function checkMenu(menus) {
+    const issues = [];
+    if (!Array.isArray(menus)) issues.push({ path: [], message: "必须是数组" });
+    else menus.forEach((menu, index) => checkMenuItem(issues, menu, [index]));
 
-    Logger.warn(
-        "菜单校验失败",
-        {
-            errors: formatZodIssues(result.error.issues, { items: menus, itemLabel: "menus" })
-        },
-        false
-    );
+    if (issues.length === 0) return false;
+    Logger.warn("菜单校验失败", { errors: formatValidationIssues(issues, { items: menus, itemLabel: "menus" }) }, false);
     return true;
-};
+}

package/checks/plugin.js

@@ -1,42 +1,39 @@
-import * as z from "zod";
-
 import { Logger } from "../lib/logger.js";
-import { formatZodIssues } from "../utils/formatZodIssues.js";
-import { isNoTrimStringAllowEmpty } from "../utils/is.js";
+import { formatValidationIssues } from "../utils/formatValidationIssues.js";
+import { isFunction, isFiniteNumber, isPlainObject, isString } from "../utils/is.js";
 
-z.config(z.locales.zhCN());
+const pluginKeys = new Set(["source", "type", "filePath", "relativePath", "fileName", "apiPath", "handler", "order"]);
 
-const noTrimString = z.string().refine(isNoTrimStringAllowEmpty, "不允许首尾空格");
+function checkPluginItem(plugin) {
+    const issues = [];
+    if (!isPlainObject(plugin)) {
+        issues.push({ path: [], message: "必须是对象格式" });
+        return issues;
+    }
 
-const pluginSchema = z
-    .object({
-        source: noTrimString.min(1),
-        type: noTrimString.min(1),
-        filePath: noTrimString.min(1),
-        relativePath: noTrimString.min(1),
-        fileName: noTrimString.min(1),
-        apiPath: noTrimString.min(1),
-        handler: z.custom((value) => typeof value === "function"),
-        order: z.number()
-    })
-    .strict();
+    for (const key of Object.keys(plugin)) {
+        if (!pluginKeys.has(key)) issues.push({ path: [key], message: "不允许出现" });
+    }
+    for (const key of ["source", "type", "filePath", "relativePath", "fileName", "apiPath"]) {
+        if (!isString(plugin[key]) || plugin[key].length === 0 || plugin[key].trim() !== plugin[key]) issues.push({ path: [key], message: "必须是非空且无首尾空格的字符串" });
+    }
+    if (!isFunction(plugin.handler)) issues.push({ path: ["handler"], message: "必须是函数" });
+    if (!isFiniteNumber(plugin.order)) issues.push({ path: ["order"], message: "必须是有限数字" });
+    return issues;
+}
 
 export async function checkPlugin(plugins) {
-    let hasError = false;
+    if (!Array.isArray(plugins)) {
+        Logger.warn("插件校验失败", { errors: formatValidationIssues([{ path: [], message: "必须是数组" }], { item: plugins, itemLabel: "plugin" }) }, false);
+        return true;
+    }
 
+    let hasError = false;
     for (const plugin of plugins) {
-        const result = pluginSchema.safeParse(plugin);
-        if (!result.success) {
-            Logger.warn(
-                "插件校验失败",
-                {
-                    errors: formatZodIssues(result.error.issues, { item: plugin, itemLabel: "plugin" })
-                },
-                false
-            );
-            hasError = true;
-        }
+        const issues = checkPluginItem(plugin);
+        if (issues.length === 0) continue;
+        Logger.warn("插件校验失败", { errors: formatValidationIssues(issues, { item: plugin, itemLabel: "plugin" }) }, false);
+        hasError = true;
     }
-
     return hasError;
 }