befly 3.72.0 → 3.74.0

package/checks/table.js

@@ -1,126 +1,42 @@
-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";
+import { validateFieldRule } from "../lib/validator.js";
+import { formatValidationIssues } from "../utils/formatValidationIssues.js";
+import { isPlainObject } from "../utils/is.js";
 import { snakeCase } from "../utils/util.js";
 
-z.config(z.locales.zhCN());
-
 const lowerCamelRegex = /^_?[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/;
 const lowerSnakeRegex = /^_?[a-z][a-z0-9]*(?:_[a-z0-9]+)+$/;
-const noTrimString = z.string().refine(isNoTrimStringAllowEmpty, "不允许首尾空格");
-const inputSchema = z.enum(FIELD_RULE_INPUT_TYPES);
 
 function isValidFieldName(fieldName) {
-    if (String(fieldName).includes("_")) {
-        return lowerSnakeRegex.test(fieldName);
-    }
-
-    return lowerCamelRegex.test(fieldName);
-}
-
-function addIssue(context, path, message) {
-    context.addIssue({
-        path: path,
-        message: message
-    });
+    return fieldName.includes("_") ? lowerSnakeRegex.test(fieldName) : lowerCamelRegex.test(fieldName);
 }
 
-const fieldDefSchema = z
-    .object({
-        name: z.string().min(1),
-        input: inputSchema,
-        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;
-                    }
-                }
+export async function checkTable(tables) {
+    const issues = [];
+    if (!isPlainObject(tables)) {
+        issues.push({ path: [], message: "必须是对象格式" });
+    } else {
+        for (const [tableName, fields] of Object.entries(tables)) {
+            if (!lowerCamelRegex.test(tableName)) issues.push({ path: [tableName], message: "表名必须为 lowerCamelCase" });
+            if (!isPlainObject(fields)) {
+                issues.push({ path: [tableName], message: "必须是对象格式" });
+                continue;
             }
-        }
-    });
 
-const tableContentSchema = z.record(z.string().refine(isValidFieldName, "字段名必须为 lowerCamelCase 或 snake_case"), fieldDefSchema).superRefine((value, context) => {
-    const fieldNameMap = new Map();
+            const fieldNameMap = new Map();
+            for (const [fieldName, rule] of Object.entries(fields)) {
+                if (!isValidFieldName(fieldName)) issues.push({ path: [tableName, fieldName], message: "字段名必须为 lowerCamelCase 或 snake_case" });
+                for (const issue of validateFieldRule(rule)) issues.push({ path: [tableName, fieldName, ...issue.path], message: issue.message });
 
-    for (const fieldName of Object.keys(value)) {
-        const dbFieldName = snakeCase(fieldName);
-        const previousFieldName = fieldNameMap.get(dbFieldName);
-
-        if (previousFieldName) {
-            addIssue(context, [fieldName], `字段名 ${fieldName} 与 ${previousFieldName} 指向同一数据库字段 ${dbFieldName}`);
-            continue;
+                const dbFieldName = snakeCase(fieldName);
+                const previousFieldName = fieldNameMap.get(dbFieldName);
+                if (previousFieldName) issues.push({ path: [tableName, fieldName], message: `字段名 ${fieldName} 与 ${previousFieldName} 指向同一数据库字段 ${dbFieldName}` });
+                else fieldNameMap.set(dbFieldName, fieldName);
+            }
         }
-
-        fieldNameMap.set(dbFieldName, fieldName);
-    }
-});
-const tableRegistrySchema = z.record(z.string().regex(lowerCamelRegex), tableContentSchema);
-
-/**
- * 检查表定义文件
- * @throws 当检查失败时抛出异常
- */
-export async function checkTable(tables) {
-    const result = tableRegistrySchema.safeParse(tables);
-    if (result.success) {
-        return false;
     }
 
-    Logger.warn(
-        "表结构校验失败",
-        {
-            errors: formatZodIssues(result.error.issues, {
-                items: tables,
-                itemLabel: "table"
-            })
-        },
-        false
-    );
+    if (issues.length === 0) return false;
+    Logger.warn("表结构校验失败", { errors: formatValidationIssues(issues, { item: tables, itemLabel: "table" }) }, false);
     return true;
 }

package/configs/beflyConfig.json

@@ -55,7 +55,6 @@
     },
 
     "cors": {
-        "origin": "*",
         "methods": "GET,HEAD,PUT,PATCH,POST,DELETE",
         "allowedHeaders": "Content-Type,Authorization",
         "exposedHeaders": "",
@@ -68,7 +67,6 @@
         "defaultLimit": 1000,
         "defaultWindow": 60,
         "key": "ip",
-        "skipRoutes": [],
-        "rules": []
+        "skipRoutes": []
     }
 }

package/hooks/rateLimit.js

@@ -5,72 +5,13 @@ import { ErrorResponse } from "../utils/response.js";
 
 const RATE_LIMIT_ENABLED_VALUES = new Set([1, true, "1", "true"]);
 
-function isRateLimitEnabled(value) {
-    return RATE_LIMIT_ENABLED_VALUES.has(value);
-}
-
 function toPositiveInt(value, fallbackValue) {
-    const num = Number(value);
-
-    if (!Number.isFinite(num) || num <= 0) {
-        return fallbackValue;
-    }
-
-    return Math.floor(num);
+    const number = Number(value);
+    return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallbackValue;
 }
 
 function toSafeString(value, fallbackValue) {
-    if (typeof value !== "string") {
-        return fallbackValue;
-    }
-
-    const trimmed = value.trim();
-
-    if (!trimmed) {
-        return fallbackValue;
-    }
-
-    return trimmed;
-}
-
-function toRuleMethods(rule) {
-    if (Array.isArray(rule?.methods)) {
-        const values = [];
-
-        for (const method of rule.methods) {
-            const text = toSafeString(method, "");
-            if (!text) {
-                continue;
-            }
-
-            values.push(text.toUpperCase());
-        }
-
-        return values;
-    }
-
-    if (typeof rule?.method === "string") {
-        const value = toSafeString(rule.method, "");
-        if (value) {
-            return [value.toUpperCase()];
-        }
-    }
-
-    return [];
-}
-
-function normalizeRule(rawRule, defaultLimit, defaultWindow, defaultKeyType) {
-    const rule = rawRule && typeof rawRule === "object" ? rawRule : {};
-    const pathPattern = toSafeString(rule.path || rule.apiPath || rule.route, "");
-    const methods = toRuleMethods(rule);
-
-    return {
-        pathPattern: pathPattern,
-        methods: methods,
-        limit: toPositiveInt(rule.limit, defaultLimit),
-        window: toPositiveInt(rule.window, defaultWindow),
-        keyType: toSafeString(rule.key, defaultKeyType)
-    };
+    return typeof value === "string" && value.trim() ? value.trim() : fallbackValue;
 }
 
 function createMatcher(pattern) {
@@ -82,117 +23,31 @@ function createMatcher(pattern) {
 }
 
 function normalizeConfig(config) {
-    const defaultLimit = toPositiveInt(config?.defaultLimit, 1000);
-    const defaultWindow = toPositiveInt(config?.defaultWindow, 60);
-    const defaultKeyType = toSafeString(config?.key, "ip");
-
     const skipMatchers = [];
-    const skipRoutes = Array.isArray(config?.skipRoutes) ? config.skipRoutes : [];
-
-    for (const route of skipRoutes) {
-        const pattern = toSafeString(route, "");
-        if (!pattern) {
-            continue;
-        }
-
-        const matcher = createMatcher(pattern);
-        if (!matcher) {
-            continue;
-        }
-
-        skipMatchers.push(matcher);
-    }
-
-    const rules = [];
-    const rawRules = Array.isArray(config?.rules) ? config.rules : [];
-
-    for (const rawRule of rawRules) {
-        const normalizedRule = normalizeRule(rawRule, defaultLimit, defaultWindow, defaultKeyType);
-
-        if (!normalizedRule.pathPattern) {
-            continue;
-        }
-
-        const matcher = createMatcher(normalizedRule.pathPattern);
-        if (!matcher) {
-            continue;
-        }
-
-        rules.push({
-            matcher: matcher,
-            methods: normalizedRule.methods,
-            limit: normalizedRule.limit,
-            window: normalizedRule.window,
-            keyType: normalizedRule.keyType
-        });
+    for (const route of Array.isArray(config?.skipRoutes) ? config.skipRoutes : []) {
+        const matcher = createMatcher(toSafeString(route, ""));
+        if (matcher) skipMatchers.push(matcher);
     }
 
     return {
-        enabled: isRateLimitEnabled(config?.enable),
-        defaultLimit: defaultLimit,
-        defaultWindow: defaultWindow,
-        defaultKeyType: defaultKeyType,
-        skipMatchers: skipMatchers,
-        rules: rules
+        enabled: RATE_LIMIT_ENABLED_VALUES.has(config?.enable),
+        limit: toPositiveInt(config?.defaultLimit, 1000),
+        window: toPositiveInt(config?.defaultWindow, 60),
+        keyType: toSafeString(config?.key, "ip"),
+        skipMatchers: skipMatchers
     };
 }
 
 function resolveScopeByKeyType(keyType, ctx) {
-    if (keyType === "userId") {
-        if (isValidPositiveInt(ctx.userId)) {
-            return `user:${ctx.userId}`;
-        }
-
-        return `ip:${ctx.ip || "unknown"}`;
-    }
-
-    if (keyType === "roleCode") {
-        return `role:${ctx.roleCode || "guest"}`;
-    }
-
-    if (keyType === "apiPath") {
-        return `path:${ctx.apiPath || "unknown"}`;
-    }
-
-    if (keyType === "global") {
-        return "global";
-    }
-
+    if (keyType === "userId") return isValidPositiveInt(ctx.userId) ? `user:${ctx.userId}` : `ip:${ctx.ip || "unknown"}`;
+    if (keyType === "roleCode") return `role:${ctx.roleCode || "guest"}`;
+    if (keyType === "apiPath") return `path:${ctx.apiPath || "unknown"}`;
+    if (keyType === "global") return "global";
     return `ip:${ctx.ip || "unknown"}`;
 }
 
-function resolveRateRule(normalized, ctx) {
-    for (const rule of normalized.rules) {
-        if (!rule.matcher(ctx.apiPath)) {
-            continue;
-        }
-
-        if (rule.methods.length > 0 && !rule.methods.includes(ctx.method)) {
-            continue;
-        }
-
-        return {
-            limit: rule.limit,
-            window: rule.window,
-            keyType: rule.keyType
-        };
-    }
-
-    return {
-        limit: normalized.defaultLimit,
-        window: normalized.defaultWindow,
-        keyType: normalized.defaultKeyType
-    };
-}
-
 function shouldSkipRateLimit(normalized, ctx) {
-    for (const matcher of normalized.skipMatchers) {
-        if (matcher(ctx.apiPath)) {
-            return true;
-        }
-    }
-
-    return false;
+    return normalized.skipMatchers.some((matcher) => matcher(ctx.apiPath));
 }
 
 function buildRateLimitRedisKey(ctx, keyType, scope) {
@@ -202,42 +57,26 @@ function buildRateLimitRedisKey(ctx, keyType, scope) {
 export default {
     order: 1.5,
     handler: async (befly, ctx) => {
-        const normalized = normalizeConfig(befly?.config?.rateLimit);
-
-        if (!normalized.enabled) {
-            return;
-        }
-
-        if (!befly?.redis || typeof befly.redis.incrWithExpire !== "function") {
-            return;
-        }
-
-        if (shouldSkipRateLimit(normalized, ctx)) {
-            return;
-        }
-
-        const rateRule = resolveRateRule(normalized, ctx);
-        const scope = resolveScopeByKeyType(rateRule.keyType, ctx);
-        const redisKey = buildRateLimitRedisKey(ctx, rateRule.keyType, scope);
-        const current = await befly.redis.incrWithExpire(redisKey, rateRule.window);
+        const rateLimit = normalizeConfig(befly?.config?.rateLimit);
+        if (!rateLimit.enabled || !befly?.redis || typeof befly.redis.incrWithExpire !== "function" || shouldSkipRateLimit(rateLimit, ctx)) return;
 
-        if (current <= rateRule.limit) {
-            return;
-        }
+        const scope = resolveScopeByKeyType(rateLimit.keyType, ctx);
+        const current = await befly.redis.incrWithExpire(buildRateLimitRedisKey(ctx, rateLimit.keyType, scope), rateLimit.window);
+        if (current <= rateLimit.limit) return;
 
         ctx.corsHeaders = ctx.corsHeaders || {};
-        ctx.corsHeaders["Retry-After"] = String(rateRule.window);
+        ctx.corsHeaders["Retry-After"] = String(rateLimit.window);
         ctx.response = ErrorResponse(
             ctx,
             "请求过于频繁，请稍后再试",
             1,
             null,
             {
-                limit: rateRule.limit,
-                window: rateRule.window,
+                limit: rateLimit.limit,
+                window: rateLimit.window,
                 current: current,
                 apiPath: ctx.apiPath,
-                key: rateRule.keyType
+                key: rateLimit.keyType
             },
             "rateLimit"
         );

package/hooks/validator.js

@@ -1,5 +1,5 @@
 // 相对导入
-import { Validator } from "../lib/validator.js";
+import { validateFields } from "../lib/validator.js";
 import { isPlainObject, isString } from "../utils/is.js";
 import { ErrorResponse } from "../utils/response.js";
 import { snakeCase } from "../utils/util.js";
@@ -37,7 +37,7 @@ export default {
         ctx.body = nextBody;
 
         // 验证参数
-        const result = Validator.validate(ctx.body, ctx.apiFields, ctx.apiRequired);
+        const result = validateFields(ctx.body, ctx.apiFields, ctx.apiRequired);
 
         if (result.code !== 0) {
             ctx.response = ErrorResponse(ctx, result.firstError || "参数验证失败", 1, null, result.fieldErrors, "validator");

package/index.js

@@ -55,7 +55,7 @@ function prefixMenuPaths(menus, prefix) {
     });
 }
 
-async function ensureSyncPrerequisites(ctx) {
+async function syncReady(ctx) {
     const missingCtxKeys = ["ctx.redis", "ctx.mysql", "ctx.cache"].filter((key) => !ctx[key.slice(4)]);
     if (missingCtxKeys.length > 0) {
         throw new Error(`启动失败：${missingCtxKeys.join("、")} 未初始化`, {
@@ -88,6 +88,7 @@ async function ensureSyncPrerequisites(ctx) {
 }
 
 export async function createBefly(config = {}, menus = []) {
+    const mergeStartTime = Bun.nanoseconds();
     const mergedConfig = deepMerge(beflyConfig, config);
     const mergedMenus = deepMerge(prefixMenuPaths(beflyMenus, "core"), menus);
 
@@ -95,15 +96,35 @@ export async function createBefly(config = {}, menus = []) {
         runtimeEnv: mergedConfig.runMode,
         ...mergedConfig.logger
     });
+    Logger.info(`启动 合并配置 耗时 ${calcPerfTime(mergeStartTime)}`);
 
+    let stageStartTime = Bun.nanoseconds();
     const configHasError = await checkConfig(mergedConfig);
+    Logger.info(`启动 检查配置 耗时 ${calcPerfTime(stageStartTime)}`);
+
+    stageStartTime = Bun.nanoseconds();
     const { apis, tables, plugins, hooks } = await scanSources();
+    Logger.info(`启动 扫描源码 耗时 ${calcPerfTime(stageStartTime)}`);
 
+    stageStartTime = Bun.nanoseconds();
     const apiHasError = await checkApi(apis);
+    Logger.info(`启动 检查接口 耗时 ${calcPerfTime(stageStartTime)}`);
+
+    stageStartTime = Bun.nanoseconds();
     const tableHasError = await checkTable(tables);
+    Logger.info(`启动 检查表 耗时 ${calcPerfTime(stageStartTime)}`);
+
+    stageStartTime = Bun.nanoseconds();
     const pluginHasError = await checkPlugin(plugins);
+    Logger.info(`启动 检查插件 耗时 ${calcPerfTime(stageStartTime)}`);
+
+    stageStartTime = Bun.nanoseconds();
     const hookHasError = await checkHook(hooks);
+    Logger.info(`启动 检查钩子 耗时 ${calcPerfTime(stageStartTime)}`);
+
+    stageStartTime = Bun.nanoseconds();
     const menuHasError = await checkMenu(mergedMenus);
+    Logger.info(`启动 检查菜单 耗时 ${calcPerfTime(stageStartTime)}`);
 
     if (configHasError || apiHasError || tableHasError || pluginHasError || hookHasError || menuHasError) {
         throw new Error("检查失败：存在配置/结构问题", {
@@ -167,24 +188,46 @@ export class Befly {
 
             // 启动期建立基础连接（SQL + Redis）
             // 说明：连接职责收敛到启动期单点；插件只消费已连接实例（Connect.getSql/getRedis）。
+            let stageStartTime = Bun.nanoseconds();
             await Connect.connectRedis(this.context.config.redis);
+            Logger.info(`启动 连接 Redis 耗时 ${calcPerfTime(stageStartTime)}`);
+
+            stageStartTime = Bun.nanoseconds();
             await Connect.connectMysql(this.context.config.mysql);
+            Logger.info(`启动 连接 Mysql 耗时 ${calcPerfTime(stageStartTime)}`);
 
             // 加载插件
             for (const item of this.plugins.toSorted((a, b) => a.order - b.order)) {
+                const pluginStartTime = Bun.nanoseconds();
                 this.context[item.fileName] = await item.handler(this.context);
+                Logger.info(`启动 插件 ${item.fileName} 耗时 ${calcPerfTime(pluginStartTime)}`);
             }
-            await ensureSyncPrerequisites(this.context);
+
+            stageStartTime = Bun.nanoseconds();
+            await syncReady(this.context);
+            Logger.info(`启动 同步就绪 耗时 ${calcPerfTime(stageStartTime)}`);
 
             // 自动同步（PM2 cluster：主进程执行，其它进程等待同步完成）
             if (isPrimaryProcess()) {
+                stageStartTime = Bun.nanoseconds();
                 await syncApi(this.context, this.apis);
+                Logger.info(`启动 同步接口 耗时 ${calcPerfTime(stageStartTime)}`);
+
+                stageStartTime = Bun.nanoseconds();
                 await syncMenu(this.context, this.menus);
+                Logger.info(`启动 同步菜单 耗时 ${calcPerfTime(stageStartTime)}`);
+
+                stageStartTime = Bun.nanoseconds();
                 await syncDev(this.context);
+                Logger.info(`启动 同步开发账号 耗时 ${calcPerfTime(stageStartTime)}`);
+
+                stageStartTime = Bun.nanoseconds();
                 await syncCache(this.context);
+                Logger.info(`启动 同步缓存 耗时 ${calcPerfTime(stageStartTime)}`);
             }
 
             // 加载钩子
+            stageStartTime = Bun.nanoseconds();
             this.hooks = this.hooks.toSorted((a, b) => a.order - b.order);
 
             // 加载所有 API
@@ -193,7 +236,9 @@ export class Befly {
             // 启动 HTTP服务器
             const apiFetch = apiHandler(this.apis, this.hooks, this.context);
             const staticFetch = staticHandler(this.context.config.cors, this.context.config.upload);
+            Logger.info(`启动 装配接口 耗时 ${calcPerfTime(stageStartTime)}`);
 
+            stageStartTime = Bun.nanoseconds();
             const server = Bun.serve({
                 port: this.context.config.appPort || 3000,
                 hostname: this.context.config.appHost || "0.0.0.0",
@@ -230,6 +275,7 @@ export class Befly {
                     return Response.json({ code: 1, msg: "内部服务器错误" }, { status: 200 });
                 }
             });
+            Logger.info(`启动 监听服务 耗时 ${calcPerfTime(stageStartTime)}`);
 
             const finalStartupTime = calcPerfTime(serverStartTime);
 

package/lib/connect.js

@@ -88,7 +88,6 @@ export class Connect {
             });
 
             await this.mysqlClient`SELECT 1`;
-            Logger.info(`Mysql 连接成功 (${config.hostname})`);
         } catch (error) {
             await this.handleConnectError("mysqlClient", "Mysql", "mysql", config.hostname, error);
         }
@@ -101,11 +100,6 @@ export class Connect {
     static async connectRedis(config) {
         try {
             this.redisClient = new RedisClient(buildRedisUrl(config));
-            // Called when successfully connected to Redis server
-            this.redisClient.onconnect = () => {
-                Logger.info(`Redis 连接成功 (${config.hostname})`);
-            };
-
             // Called when disconnected from Redis server
             this.redisClient.onclose = (error) => {
                 if (error) {

package/lib/dbHelper.js

@@ -1052,20 +1052,11 @@ class DbHelper {
     }
 
     async trans(callback) {
-        const abortMark = "__beflyTransAbort";
-
         if (this.isTransaction) {
-            const result = await callback(this);
-            if (result?.code !== undefined && result.code !== 0) {
-                const abortError = new Error("TRANSACTION_ABORT", {
-                    cause: null,
-                    code: "runtime"
-                });
-                abortError[abortMark] = true;
-                abortError.payload = result;
-                throw abortError;
-            }
-            return result;
+            throw new Error("不支持嵌套事务", {
+                cause: null,
+                code: "policy"
+            });
         }
 
         if (typeof this.sql?.begin !== "function") {
@@ -1075,34 +1066,17 @@ class DbHelper {
             });
         }
 
-        try {
-            return await this.sql.begin(async (tx) => {
-                const trans = new this.constructor({
-                    redis: this.redis,
-                    dbName: this.dbName,
-                    sql: tx,
-                    isTransaction: true,
-                    beflyMode: this.beflyMode,
-                    tables: this.tables
-                });
-                const result = await callback(trans);
-                if (result?.code !== undefined && result.code !== 0) {
-                    const abortError = new Error("TRANSACTION_ABORT", {
-                        cause: null,
-                        code: "runtime"
-                    });
-                    abortError[abortMark] = true;
-                    abortError.payload = result;
-                    throw abortError;
-                }
-                return result;
+        return await this.sql.begin(async (tx) => {
+            const trans = new this.constructor({
+                redis: this.redis,
+                dbName: this.dbName,
+                sql: tx,
+                isTransaction: true,
+                beflyMode: this.beflyMode,
+                tables: this.tables
             });
-        } catch (error) {
-            if (error && error[abortMark] === true) {
-                return error.payload;
-            }
-            throw error;
-        }
+            return await callback(trans);
+        });
     }
 }