befly 3.72.0 → 3.73.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");