befly 3.76.1 → 3.76.3

package/lib/redisHelper.js

@@ -1,399 +0,0 @@
-/**
- * 提供 Redis 操作的便捷方法
- */
-
-import { createError } from "../utils/error.js";
-import { Connect } from "./connect.js";
-import { Logger } from "./logger.js";
-
-/**
- * Redis 助手类
- * 约定：除构造函数与 ping 外，方法默认不抛异常；失败时返回 null/false/0/[] 并记录日志。
- */
-export class RedisHelper {
-    /**
-     * 构造函数
-     * @param prefix - Key 前缀
-     */
-    constructor(prefix = "") {
-        const client = Connect.getRedis();
-        if (!client) {
-            throw createError("Redis 客户端未初始化，请先调用 Connect.connectRedis()", { code: "runtime" });
-        }
-        this.client = client;
-        this.prefix = prefix ? `${prefix}:` : "";
-    }
-
-    /**
-     * 吞错执行：失败记录日志并返回 fallback（不抛出）
-     * @param label - 操作名（用于日志文案）
-     * @param operation - 实际操作
-     * @param fallback - 失败返回值
-     */
-    async safeCall(label, operation, fallback) {
-        try {
-            return await operation();
-        } catch (error) {
-            Logger.error(`Redis ${label} 错误`, error);
-            return fallback;
-        }
-    }
-
-    /**
-     * 设置对象到 Redis
-     * @param key - 键名
-     * @param obj - 对象
-     * @param ttl - 过期时间（秒）
-     * @returns 操作结果
-     */
-    async setObject(key, obj, ttl = null) {
-        return this.safeCall(
-            "setObject",
-            async () => {
-                const data = JSON.stringify(obj);
-                const pkey = `${this.prefix}${key}`;
-                return ttl ? this.client.setex(pkey, ttl, data) : this.client.set(pkey, data);
-            },
-            null
-        );
-    }
-
-    /**
-     * 从 Redis 获取对象
-     * @param key - 键名
-     * @returns 对象或 null
-     */
-    async getObject(key) {
-        return this.safeCall(
-            "getObject",
-            async () => {
-                const pkey = `${this.prefix}${key}`;
-                const data = await this.client.get(pkey);
-                return data ? JSON.parse(data) : null;
-            },
-            null
-        );
-    }
-
-    /**
-     * 从 Redis 删除对象
-     * @param key - 键名
-     */
-    async delObject(key) {
-        return this.safeCall("delObject", async () => {
-            const pkey = `${this.prefix}${key}`;
-            await this.client.del(pkey);
-        });
-    }
-
-    // ==================== ID 生成 ====================
-    // 注意：ID 生成功能强依赖 Redis 原子操作（INCR）保证分布式唯一性
-    // 主要被 DbHelper.insData 使用
-
-    /**
-     * 生成基于时间的唯一 ID
-     * 格式: 毫秒时间戳(13位) + 3位后缀(100-999) = 16位纯数字
-     * 每毫秒起点基于时间戳偏移，后缀分布更均匀
-     * @returns 唯一 ID (16位纯数字)
-     */
-    async genTimeID() {
-        const timestamp = Date.now();
-        const key = `${this.prefix}time_id:${timestamp}`;
-
-        const counter = await this.client.incr(key);
-        if (counter === 1) {
-            await this.client.expire(key, 1);
-        }
-
-        // 基于时间戳偏移起点，后缀 100-999 循环
-        const suffix = 100 + (((timestamp % 900) + counter - 1) % 900);
-
-        const timeId = Number(`${timestamp}${suffix}`);
-        return timeId;
-    }
-
-    /**
-     * 设置字符串值
-     * @param key - 键名
-     * @param value - 值
-     * @param ttl - 过期时间（秒）
-     */
-    async setString(key, value, ttl = null) {
-        return this.safeCall(
-            "setString",
-            async () => {
-                const pkey = `${this.prefix}${key}`;
-                return ttl ? this.client.setex(pkey, ttl, value) : this.client.set(pkey, value);
-            },
-            null
-        );
-    }
-
-    /**
-     * 获取字符串值
-     * @param key - 键名
-     */
-    async getString(key) {
-        return this.safeCall(
-            "getString",
-            async () => {
-                const pkey = `${this.prefix}${key}`;
-                return this.client.get(pkey);
-            },
-            null
-        );
-    }
-
-    /**
-     * 检查键是否存在
-     * @param key - 键名
-     * @returns 是否存在（true/false）
-     */
-    async exists(key) {
-        return this.safeCall(
-            "exists",
-            async () => {
-                const pkey = `${this.prefix}${key}`;
-                return this.client.exists(pkey);
-            },
-            false
-        );
-    }
-
-    /**
-     * 原子自增
-     * @param key - 键名
-     * @returns 自增后的值
-     */
-    async incr(key) {
-        return this.safeCall(
-            "incr",
-            async () => {
-                const pkey = `${this.prefix}${key}`;
-                return this.client.incr(pkey);
-            },
-            0
-        );
-    }
-
-    /**
-     * 原子自增并在首次自增时设置过期时间（常用于限流/计数）
-     * @param key - 键名
-     * @param seconds - 过期秒数
-     * @returns 自增后的值
-     */
-    async incrWithExpire(key, seconds) {
-        return this.safeCall(
-            "incrWithExpire",
-            async () => {
-                const pkey = `${this.prefix}${key}`;
-                const res = await this.client.incr(pkey);
-                if (res === 1) {
-                    await this.client.expire(pkey, seconds);
-                }
-                return res;
-            },
-            0
-        );
-    }
-
-    /**
-     * 设置过期时间
-     * @param key - 键名
-     * @param seconds - 秒数
-     */
-    async expire(key, seconds) {
-        return this.safeCall(
-            "expire",
-            async () => {
-                const pkey = `${this.prefix}${key}`;
-                return this.client.expire(pkey, seconds);
-            },
-            0
-        );
-    }
-
-    /**
-     * 获取剩余过期时间
-     * @param key - 键名
-     */
-    async ttl(key) {
-        return this.safeCall(
-            "ttl",
-            async () => {
-                const pkey = `${this.prefix}${key}`;
-                return this.client.ttl(pkey);
-            },
-            -1
-        );
-    }
-
-    /**
-     * 向 Set 中添加一个或多个成员
-     * @param key - 键名
-     * @param members - 成员数组
-     * @returns 成功添加的成员数量
-     */
-    async sadd(key, members) {
-        return this.safeCall(
-            "sadd",
-            async () => {
-                if (members.length === 0) return 0;
-
-                const pkey = `${this.prefix}${key}`;
-                const args = [pkey];
-                for (const member of members) {
-                    args.push(member);
-                }
-                return this.client.sadd.apply(this.client, args);
-            },
-            0
-        );
-    }
-
-    /**
-     * 判断成员是否在 Set 中
-     * @param key - 键名
-     * @param member - 成员
-     * @returns 是否存在（true/false）
-     */
-    async sismember(key, member) {
-        return this.safeCall(
-            "sismember",
-            async () => {
-                const pkey = `${this.prefix}${key}`;
-                return this.client.sismember(pkey, member);
-            },
-            false
-        );
-    }
-
-    /**
-     * 获取 Set 的成员数量
-     * @param key - 键名
-     */
-    async scard(key) {
-        return this.safeCall(
-            "scard",
-            async () => {
-                const pkey = `${this.prefix}${key}`;
-                return this.client.scard(pkey);
-            },
-            0
-        );
-    }
-
-    /**
-     * 获取 Set 的所有成员
-     * @param key - 键名
-     * @returns 成员数组
-     */
-    async smembers(key) {
-        return this.safeCall(
-            "smembers",
-            async () => {
-                const pkey = `${this.prefix}${key}`;
-                return this.client.smembers(pkey);
-            },
-            []
-        );
-    }
-
-    /**
-     * 批量向多个 Set 添加成员（利用 Bun Redis 自动管道优化）
-     * @param items - [{ key, members }] 数组
-     * @returns 成功添加的总成员数量
-     */
-    async saddBatch(items) {
-        return this.safeCall(
-            "saddBatch",
-            async () => {
-                if (items.length === 0) {
-                    return 0;
-                }
-
-                const results = await Promise.all(items.map((item) => this.sadd(item.key, item.members)));
-                return results.reduce((sum, count) => sum + count, 0);
-            },
-            0
-        );
-    }
-
-    /**
-     * 删除键
-     * @param key - 键名
-     * @returns 删除的键数量
-     */
-    async del(key) {
-        return this.safeCall(
-            "del",
-            async () => {
-                const pkey = `${this.prefix}${key}`;
-                return this.client.del(pkey);
-            },
-            0
-        );
-    }
-
-    /**
-     * 批量删除键（利用 Bun Redis 自动管道优化）
-     * @param keys - 键名数组
-     * @returns 成功删除的键数量
-     */
-    async delBatch(keys) {
-        return this.safeCall(
-            "delBatch",
-            async () => {
-                if (keys.length === 0) {
-                    return 0;
-                }
-
-                const results = await Promise.all(
-                    keys.map((key) => {
-                        const pkey = `${this.prefix}${key}`;
-                        return this.client.del(pkey);
-                    })
-                );
-                return results.reduce((sum, count) => sum + count, 0);
-            },
-            0
-        );
-    }
-
-    /**
-     * 获取 Redis INFO 文本
-     * @param section - 可选 section（如 "server"）
-     */
-    async info(section) {
-        return this.safeCall(
-            "info",
-            async () => {
-                const client = this.client;
-
-                if (typeof client.info === "function") {
-                    return client.info(section);
-                }
-
-                if (typeof client.send === "function") {
-                    return client.send("INFO", section ? [String(section)] : []);
-                }
-
-                throw createError("Redis info 不支持", { code: "runtime" });
-            },
-            ""
-        );
-    }
-
-    /**
-     * 测试 Redis 连接（异常时抛出，供调用方感知连接状态）
-     * @returns ping 响应结果
-     */
-    async ping() {
-        try {
-            return await this.client.ping();
-        } catch (error) {
-            Logger.error("Redis ping 错误", error);
-            throw createError("Redis ping 错误", { cause: error, code: "runtime", subsystem: "redis", operation: "ping" });
-        }
-    }
-}

package/lib/validator.js

@@ -1,274 +0,0 @@
-import { FIELD_RULE_DEFAULT_MAX, FIELD_RULE_DEFAULT_MIN, FIELD_RULE_INPUT_TYPES } from "../configs/constConfig.js";
-import RegexAliases from "../configs/regexpAlias.json";
-import { configSchema } from "../schemas/config.js";
-import { isFiniteNumber, isIntegerNumber, isJsonPrimitive, isNoTrimStringAllowEmpty, isNullable, isPlainObject, isRegexInput, isString, isValidTimeZone } from "../utils/is.js";
-import { getCompiledRegex } from "../utils/regexpUtil.js";
-
-const INPUT_TYPE_SET = new Set(FIELD_RULE_INPUT_TYPES);
-const FIELD_RULE_KEYS = new Set(["input", "check", "name", "min", "max", "detail"]);
-
-function addIssue(issues, path, message) {
-    issues.push({ path: Array.isArray(path) ? path : [path], message: message });
-}
-
-function isJsonScalar(value) {
-    return isJsonPrimitive(value) && (typeof value !== "number" || Number.isFinite(value));
-}
-
-function isScalarArray(value) {
-    return Array.isArray(value) && value.every((item) => isJsonScalar(item));
-}
-
-function isFlatJson(value, kind = "any") {
-    if (Array.isArray(value)) {
-        return value.every((item) => isJsonScalar(item) && (kind === "any" || (kind === "number" ? isFiniteNumber(item) : isIntegerNumber(item))));
-    }
-
-    if (!isPlainObject(value)) {
-        return false;
-    }
-
-    return Object.values(value).every((item) => isJsonScalar(item) && (kind === "any" || (kind === "number" ? isFiniteNumber(item) : isIntegerNumber(item))));
-}
-
-function toNumber(value, integer = false) {
-    if (isFiniteNumber(value) && (!integer || isIntegerNumber(value))) {
-        return { value: value, error: null };
-    }
-
-    if (!isString(value) || value.trim().length === 0) {
-        return { value: null, error: integer ? "必须是整数" : "必须是数字" };
-    }
-
-    const number = Number(value.trim());
-    if (!Number.isFinite(number) || (integer && !Number.isInteger(number))) {
-        return { value: null, error: integer ? "必须是整数" : "必须是数字" };
-    }
-
-    return { value: number, error: null };
-}
-
-function getEnumValues(check, numeric = false, integer = false) {
-    if (!isString(check) || check.length === 0) {
-        return null;
-    }
-
-    const values = check
-        .split("|")
-        .map((item) => item.trim())
-        .filter(Boolean);
-
-    if (values.length === 0) {
-        return null;
-    }
-
-    if (!numeric) {
-        return values;
-    }
-
-    const numbers = values.map(Number);
-    if (numbers.some((value) => !Number.isFinite(value) || (integer && !Number.isInteger(value)))) {
-        return null;
-    }
-
-    return numbers;
-}
-
-function checkFieldValue(value, rule) {
-    const min = isFiniteNumber(rule.min) ? rule.min : FIELD_RULE_DEFAULT_MIN;
-    const max = isFiniteNumber(rule.max) ? rule.max : FIELD_RULE_DEFAULT_MAX;
-    const input = rule.input;
-    let converted = value;
-
-    if (input === "number" || input === "integer" || input === "enumNumber" || input === "enumInteger") {
-        const parsed = toNumber(value, input === "integer" || input === "enumInteger");
-        if (parsed.error) return parsed.error;
-        converted = parsed.value;
-    } else if (input === "string" || input === "char" || input === "regexp" || input === "enum") {
-        if (!isString(value)) return "必须是字符串";
-    } else if (input === "array" || input === "arrayNumber" || input === "arrayInteger") {
-        if (!isScalarArray(value)) return "必须是仅包含基础值的一层数组";
-        if (input === "arrayNumber" && !value.every(isFiniteNumber)) return "数组元素必须是数字";
-        if (input === "arrayInteger" && !value.every(isIntegerNumber)) return "数组元素必须是整数";
-    } else if (input === "arrayObject") {
-        if (!Array.isArray(value) || !value.every((item) => isPlainObject(item) && isFlatJson(item))) return "必须是对象成员仅包含基础值的一层数组";
-    } else if (input === "json" || input === "jsonNumber" || input === "jsonInteger") {
-        const kind = input === "json" ? "any" : input === "jsonNumber" ? "number" : "integer";
-        if (!isFlatJson(value, kind)) return kind === "any" ? "必须是一层JSON对象或数组，成员只能是基础值" : `JSON值必须是${kind === "number" ? "数字" : "整数"}`;
-    }
-
-    if (input === "number" || input === "integer") {
-        if (converted < min) return `不能小于${min}`;
-        if (converted > max) return `不能大于${max}`;
-    }
-
-    if (input === "string" || input === "char" || input === "regexp" || input === "enum") {
-        if (input === "char" && converted.length !== 1) return "必须是单字符";
-        if (converted.length < min) return `长度不能少于${min}个字符`;
-        if (converted.length > max) return `长度不能超过${max}个字符`;
-
-        if (input === "regexp") {
-            if (!isRegexInput(rule.check)) return "check 规则无效";
-            const pattern = rule.check.startsWith("@") ? RegexAliases[rule.check.slice(1)] || rule.check : rule.check;
-            try {
-                if (!getCompiledRegex(pattern).test(converted)) return "格式不正确";
-            } catch {
-                return "check 规则无效";
-            }
-        }
-
-        if (input === "enum") {
-            const values = getEnumValues(rule.check);
-            if (!values) return "check 规则无效";
-            if (!values.includes(converted)) return "值不在枚举范围内";
-        }
-    }
-
-    if (input === "enumNumber" || input === "enumInteger") {
-        const values = getEnumValues(rule.check, true, input === "enumInteger");
-        if (!values) return "check 规则无效";
-        if (!values.includes(converted)) return "值不在枚举范围内";
-    }
-
-    if (input === "array" || input === "arrayNumber" || input === "arrayInteger" || input === "arrayObject") {
-        if (value.length < min) return `至少需要${min}个元素`;
-        if (value.length > max) return `最多只能有${max}个元素`;
-    }
-
-    return null;
-}
-
-function buildFieldResult(fieldErrors) {
-    const errors = Object.values(fieldErrors);
-    const errorFields = Object.keys(fieldErrors);
-    const failed = errors.length > 0;
-
-    return {
-        code: failed ? 1 : 0,
-        failed: failed,
-        firstError: failed ? errors[0] : null,
-        errors: errors,
-        errorFields: errorFields,
-        fieldErrors: fieldErrors
-    };
-}
-
-export function validateFieldRule(rule) {
-    const issues = [];
-    if (!isPlainObject(rule)) {
-        addIssue(issues, [], "验证规则必须是对象格式");
-        return issues;
-    }
-
-    for (const key of Object.keys(rule)) {
-        if (!FIELD_RULE_KEYS.has(key)) addIssue(issues, [key], "不允许出现");
-    }
-
-    if (!isString(rule.name) || rule.name.length === 0 || !isNoTrimStringAllowEmpty(rule.name)) addIssue(issues, ["name"], "必须是非空且无首尾空格的字符串");
-    if (!isString(rule.input) || !INPUT_TYPE_SET.has(rule.input)) addIssue(issues, ["input"], "不支持该类型");
-    if (rule.check !== undefined && (!isString(rule.check) || !isNoTrimStringAllowEmpty(rule.check))) addIssue(issues, ["check"], "必须是无首尾空格的字符串");
-    if (rule.detail !== undefined && !isString(rule.detail)) addIssue(issues, ["detail"], "必须是字符串");
-    if (rule.min !== undefined && rule.min !== null && !isFiniteNumber(rule.min)) addIssue(issues, ["min"], "必须是有限数字或 null");
-    if (rule.max !== undefined && rule.max !== null && !isFiniteNumber(rule.max)) addIssue(issues, ["max"], "必须是有限数字或 null");
-
-    if (issues.length > 0) return issues;
-
-    const min = rule.min === null || rule.min === undefined ? FIELD_RULE_DEFAULT_MIN : rule.min;
-    const max = rule.max === null || rule.max === undefined ? FIELD_RULE_DEFAULT_MAX : rule.max;
-    if (min > max) addIssue(issues, ["min"], "不能大于 max");
-
-    if (["regexp", "enum", "enumNumber", "enumInteger"].includes(rule.input) && !rule.check) {
-        addIssue(issues, ["check"], `${rule.input} 必须提供 check`);
-    }
-    if (rule.input === "regexp" && rule.check && !isRegexInput(rule.check)) addIssue(issues, ["check"], "regexp.check 必须是正则字面量或 @ 别名");
-    if (["enum", "enumNumber", "enumInteger"].includes(rule.input) && rule.check && !getEnumValues(rule.check, rule.input !== "enum", rule.input === "enumInteger")) {
-        addIssue(issues, ["check"], `${rule.input}.check 必须是非空枚举值列表`);
-    }
-
-    return issues;
-}
-
-export function validateFields(data, fields, required = []) {
-    const fieldErrors = {};
-    if (!isPlainObject(data)) return buildFieldResult({ rootError: "数据必须是对象格式" });
-    if (!isPlainObject(fields)) return buildFieldResult({ rootError: "验证规则必须是对象格式" });
-
-    for (const field of required) {
-        if (isNullable(data[field])) {
-            fieldErrors[field] = `${isPlainObject(fields[field]) && isString(fields[field].name) ? fields[field].name : field}为必填项`;
-        }
-    }
-
-    for (const [field, rule] of Object.entries(fields)) {
-        if (fieldErrors[field] || (isNullable(data[field]) && !required.includes(field))) continue;
-        const error = checkFieldValue(data[field], rule);
-        if (error) fieldErrors[field] = `${rule.name}${error}`;
-    }
-
-    return buildFieldResult(fieldErrors);
-}
-
-function addUnknownKeys(issues, value, allowedKeys, path) {
-    for (const key of Object.keys(value)) {
-        if (!allowedKeys.has(key)) addIssue(issues, [...path, key], "不允许出现");
-    }
-}
-
-function isConfigCheckValid(value, check) {
-    if (check === "emailOrEmpty") return value === "" || /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
-    if (check === "timeZone") return isValidTimeZone(value);
-    if (check === "redisPrefix") return !value.includes(":");
-    return false;
-}
-
-function checkConfigLeaf(issues, value, def, path) {
-    if (value === undefined) {
-        if (!def.optional) addIssue(issues, path, "为必填项");
-        return;
-    }
-
-    if (def.type === "string") {
-        if (!isString(value)) addIssue(issues, path, "必须是字符串");
-        else if (def.noTrim && !isNoTrimStringAllowEmpty(value)) addIssue(issues, path, "不允许首尾空格");
-        else if (def.min !== undefined && value.length < def.min) addIssue(issues, path, `长度不能少于${def.min}个字符`);
-    } else if (def.type === "number") {
-        if (!isFiniteNumber(value)) addIssue(issues, path, "必须是有限数字");
-        else if (def.integer && !isIntegerNumber(value)) addIssue(issues, path, "必须是整数");
-        else if (def.min !== undefined && value < def.min) addIssue(issues, path, `不能小于${def.min}`);
-        else if (def.max !== undefined && value > def.max) addIssue(issues, path, `不能大于${def.max}`);
-    } else if (def.type === "boolInt") {
-        if (![0, 1, true, false].includes(value)) addIssue(issues, path, "仅允许 0|1|true|false");
-    } else if (def.type === "values") {
-        if (!def.values.includes(value)) addIssue(issues, path, `仅允许 ${def.values.join("|")}`);
-    } else if (def.type === "stringArray") {
-        if (!Array.isArray(value) || !value.every((item) => isString(item) && (!def.noTrim || isNoTrimStringAllowEmpty(item)))) addIssue(issues, path, "必须是仅包含无首尾空格字符串的一层数组");
-    }
-
-    if (def.pattern && isString(value) && !def.pattern.test(value)) addIssue(issues, path, "格式不正确");
-    if (def.check && isString(value) && !isConfigCheckValid(value, def.check)) addIssue(issues, path, "无效值");
-}
-
-export function validateConfig(config) {
-    const issues = [];
-    if (!isPlainObject(config)) {
-        addIssue(issues, [], "配置必须是对象格式");
-        return issues;
-    }
-
-    const { root, groups } = configSchema;
-    addUnknownKeys(issues, config, new Set([...Object.keys(root), ...Object.keys(groups)]), []);
-    for (const [key, def] of Object.entries(root)) checkConfigLeaf(issues, config[key], def, [key]);
-
-    for (const [groupName, fields] of Object.entries(groups)) {
-        const group = config[groupName];
-        if (group === undefined && groupName === "email") continue;
-        if (!isPlainObject(group)) {
-            addIssue(issues, [groupName], "必须是对象格式");
-            continue;
-        }
-        addUnknownKeys(issues, group, new Set(Object.keys(fields)), [groupName]);
-        for (const [fieldName, def] of Object.entries(fields)) checkConfigLeaf(issues, group[fieldName], def, [groupName, fieldName]);
-    }
-
-    return issues;
-}