befly 3.76.1 → 3.76.3

package/libs/validator/compiler.js

@@ -0,0 +1,248 @@
+import { parseNode } from "./parser.js";
+import { isPlainObject } from "./util.js";
+
+const TYPE_KEYS = {
+    any: new Set(["paramType", "optional", "paramDefault"]),
+    boolean: new Set(["paramType", "optional", "paramDefault", "enum"]),
+    integer: new Set(["paramType", "optional", "paramDefault", "enum", "minValue", "maxValue"]),
+    number: new Set(["paramType", "optional", "paramDefault", "enum", "minValue", "maxValue", "precision", "scale"]),
+    string: new Set(["paramType", "optional", "paramDefault", "enum", "minValue", "maxValue", "pattern"]),
+    function: new Set(["paramType", "optional"]),
+    array: new Set(["paramType", "optional", "paramDefault", "minItem", "maxItem", "unique", "uniqueBy", "items"]),
+    object: new Set(["paramType", "optional", "paramDefault", "minItem", "maxItem", "fields", "extra", "constraints"]),
+    record: new Set(["paramType", "optional", "paramDefault", "minItem", "maxItem", "keys", "values"])
+};
+
+const SCHEMA_TYPES = new Set(Object.keys(TYPE_KEYS));
+const ANY_OF_KEYS = new Set(["anyOf", "optional", "paramDefault"]);
+const COMPARE_OPERATORS = new Set(["eq", "neq", "gt", "gte", "lt", "lte"]);
+const PRESENCE_MODES = new Set(["together", "atLeastOne", "exactlyOne"]);
+
+function schemaError(path, message) {
+    throw new TypeError(`Schema ${path.length > 0 ? path.join(".") : "(root)"} ${message}`);
+}
+
+function assertBoolean(value, path) {
+    if (value !== undefined && typeof value !== "boolean") schemaError(path, "必须是 boolean");
+}
+
+function assertLimit(value, path) {
+    if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) schemaError(path, "必须是大于等于 0 的安全整数");
+}
+
+function assertNumber(value, path) {
+    if (value !== undefined && (typeof value !== "number" || !Number.isFinite(value))) schemaError(path, "必须是有限数字");
+}
+
+function assertValueBounds(schema, path) {
+    assertNumber(schema.minValue, [...path, "minValue"]);
+    assertNumber(schema.maxValue, [...path, "maxValue"]);
+    if (schema.minValue !== undefined && schema.maxValue !== undefined && schema.minValue > schema.maxValue) schemaError(path, "minValue 不能大于 maxValue");
+}
+
+function assertStringBounds(schema, path) {
+    assertLimit(schema.minValue, [...path, "minValue"]);
+    assertLimit(schema.maxValue, [...path, "maxValue"]);
+    if (schema.minValue !== undefined && schema.maxValue !== undefined && schema.minValue > schema.maxValue) schemaError(path, "minValue 不能大于 maxValue");
+}
+
+function assertItemBounds(schema, path) {
+    assertLimit(schema.minItem, [...path, "minItem"]);
+    assertLimit(schema.maxItem, [...path, "maxItem"]);
+    if (schema.minItem !== undefined && schema.maxItem !== undefined && schema.minItem > schema.maxItem) schemaError(path, "minItem 不能大于 maxItem");
+}
+
+function isValueType(value, type) {
+    if (type === "boolean") return typeof value === "boolean";
+    if (type === "integer") return Number.isSafeInteger(value);
+    if (type === "number") return typeof value === "number" && Number.isFinite(value);
+    return typeof value === "string" && value === value.trim();
+}
+
+function compileEnum(schema, path) {
+    if (schema.enum === undefined) return null;
+    if (!Array.isArray(schema.enum) || schema.enum.length === 0) schemaError([...path, "enum"], "必须是非空数组");
+    if (schema.enum.some((value) => !isValueType(value, schema.paramType))) schemaError([...path, "enum"], `所有值必须符合 ${schema.paramType}`);
+    const values = new Set(schema.enum);
+    if (values.size !== schema.enum.length) schemaError([...path, "enum"], "不能包含重复值");
+    return values;
+}
+
+function assertObjectKeys(value, allowedKeys, path) {
+    if (!isPlainObject(value)) schemaError(path, "必须是对象");
+    for (const key of Object.keys(value)) if (!allowedKeys.has(key)) schemaError([...path, key], "是未知配置");
+}
+
+function assertFieldNames(fields, names, path) {
+    if (!Array.isArray(names) || names.length === 0) schemaError(path, "必须是非空数组");
+    const uniqueNames = new Set(names);
+    if (uniqueNames.size !== names.length) schemaError(path, "不能包含重复字段");
+    for (const name of names) if (typeof name !== "string" || !fields.has(name)) schemaError(path, `引用了不存在的字段 ${name}`);
+}
+
+function compileConstraints(schema, node, path) {
+    if (schema.constraints === undefined) return [];
+    if (!Array.isArray(schema.constraints) || schema.constraints.length === 0) schemaError([...path, "constraints"], "必须是非空数组");
+    return schema.constraints.map((constraint, index) => {
+        const constraintPath = [...path, "constraints", index];
+        assertObjectKeys(constraint, new Set(["compare", "when", "presence", "message"]), constraintPath);
+        if (constraint.message !== undefined && (typeof constraint.message !== "string" || !constraint.message.trim() || constraint.message !== constraint.message.trim())) schemaError([...constraintPath, "message"], "必须是非空无首尾空白字符串");
+        const kinds = ["compare", "when", "presence"].filter((key) => constraint[key] !== undefined);
+        if (kinds.length !== 1) schemaError(constraintPath, "必须且只能配置 compare、when、presence 中的一种");
+        const kind = kinds[0];
+        if (kind === "compare") return compileCompare(constraint.compare, constraint.message, node, [...constraintPath, "compare"]);
+        if (kind === "when") return compileWhen(constraint.when, constraint.message, node, [...constraintPath, "when"]);
+        return compilePresence(constraint.presence, constraint.message, node, [...constraintPath, "presence"]);
+    });
+}
+
+function compileCompare(compare, message, node, path) {
+    assertObjectKeys(compare, new Set(["left", "operator", "right"]), path);
+    const left = node.fieldMap.get(compare.left);
+    const right = node.fieldMap.get(compare.right);
+    if (!left) schemaError([...path, "left"], "引用字段不存在");
+    if (!right) schemaError([...path, "right"], "引用字段不存在");
+    if (compare.left === compare.right) schemaError(path, "左右字段不能相同");
+    if (!COMPARE_OPERATORS.has(compare.operator)) schemaError([...path, "operator"], "无效");
+    if (["eq", "neq"].includes(compare.operator)) {
+        if (!["boolean", "integer", "number", "string"].includes(left.kind) || left.kind !== right.kind) schemaError(path, "eq/neq 两侧必须是相同标量类型");
+    } else if (!["integer", "number"].includes(left.kind) || !["integer", "number"].includes(right.kind)) schemaError(path, "大小比较两侧必须是 integer 或 number");
+    return { kind: "compare", left: compare.left, operator: compare.operator, right: compare.right, message: message };
+}
+
+function compileWhen(when, message, node, path) {
+    assertObjectKeys(when, new Set(["field", "is", "required", "forbidden"]), path);
+    const field = node.fieldMap.get(when.field);
+    if (!field) schemaError([...path, "field"], "引用字段不存在");
+    if (!["boolean", "integer", "number", "string"].includes(field.kind) || !isValueType(when.is, field.kind)) schemaError([...path, "is"], "必须符合条件字段类型");
+    if (field.enumSet && !field.enumSet.has(when.is)) schemaError([...path, "is"], "必须属于条件字段 enum");
+    if (when.required === undefined && when.forbidden === undefined) schemaError(path, "required 和 forbidden 至少配置一项");
+    if (when.required !== undefined) assertFieldNames(node.fieldSet, when.required, [...path, "required"]);
+    if (when.forbidden !== undefined) assertFieldNames(node.fieldSet, when.forbidden, [...path, "forbidden"]);
+    const required = when.required || [];
+    const forbidden = when.forbidden || [];
+    if (required.includes(when.field) || forbidden.includes(when.field)) schemaError(path, "条件字段不能出现在 required 或 forbidden 中");
+    if (required.some((name) => forbidden.includes(name))) schemaError(path, "required 和 forbidden 不能包含相同字段");
+    return { kind: "when", field: when.field, is: when.is, required: required, forbidden: forbidden, message: message };
+}
+
+function compilePresence(presence, message, node, path) {
+    assertObjectKeys(presence, new Set(["mode", "fields"]), path);
+    if (!PRESENCE_MODES.has(presence.mode)) schemaError([...path, "mode"], "无效");
+    assertFieldNames(node.fieldSet, presence.fields, [...path, "fields"]);
+    if (presence.fields.length < 2) schemaError([...path, "fields"], "至少需要两个字段");
+    return { kind: "presence", mode: presence.mode, fields: presence.fields, message: message };
+}
+
+export function compileNode(schema, path, parents) {
+    if (!isPlainObject(schema)) schemaError(path, "必须是对象");
+    if (parents.has(schema)) schemaError(path, "存在循环引用");
+    parents.add(schema);
+
+    const isAnyOf = schema.anyOf !== undefined;
+    if (isAnyOf && schema.paramType !== undefined) schemaError(path, "不能同时配置 paramType 和 anyOf");
+    const allowedKeys = isAnyOf ? ANY_OF_KEYS : TYPE_KEYS[schema.paramType];
+    if (!isAnyOf && !SCHEMA_TYPES.has(schema.paramType)) schemaError([...path, "paramType"], "无效");
+    for (const key of Object.keys(schema)) if (!allowedKeys.has(key)) schemaError([...path, key], "是未知或不适用的配置");
+
+    assertBoolean(schema.optional, [...path, "optional"]);
+    const base = { optional: schema.optional === true, hasDefault: Object.hasOwn(schema, "paramDefault"), paramDefault: schema.paramDefault };
+
+    if (isAnyOf) {
+        if (!Array.isArray(schema.anyOf) || schema.anyOf.length < 2) schemaError([...path, "anyOf"], "至少需要两个分支");
+        const node = { ...base, kind: "anyOf", branches: schema.anyOf.map((branch, index) => compileNode(branch, [...path, "anyOf", index], parents)) };
+        parents.delete(schema);
+        compileDefault(node, path);
+        return node;
+    }
+
+    const node = { ...base, kind: schema.paramType };
+    if (["boolean", "integer", "number", "string"].includes(schema.paramType)) node.enumSet = compileEnum(schema, path);
+
+    if (schema.paramType === "integer" || schema.paramType === "number") {
+        assertValueBounds(schema, path);
+        if (schema.paramType === "integer") {
+            if (schema.minValue !== undefined && !Number.isSafeInteger(schema.minValue)) schemaError([...path, "minValue"], "必须是安全整数");
+            if (schema.maxValue !== undefined && !Number.isSafeInteger(schema.maxValue)) schemaError([...path, "maxValue"], "必须是安全整数");
+        }
+        node.minValue = schema.minValue;
+        node.maxValue = schema.maxValue;
+    }
+
+    if (schema.paramType === "number") {
+        assertLimit(schema.precision, [...path, "precision"]);
+        assertLimit(schema.scale, [...path, "scale"]);
+        if (schema.precision === 0) schemaError([...path, "precision"], "必须大于 0");
+        if (schema.scale !== undefined && schema.precision === undefined) schemaError([...path, "scale"], "需要同时配置 precision");
+        if (schema.scale !== undefined && schema.scale > schema.precision) schemaError([...path, "scale"], "不能大于 precision");
+        node.precision = schema.precision;
+        node.scale = schema.scale;
+    }
+
+    if (schema.paramType === "string") {
+        assertStringBounds(schema, path);
+        node.minValue = schema.minValue;
+        node.maxValue = schema.maxValue;
+        if (schema.pattern !== undefined && typeof schema.pattern !== "string") schemaError([...path, "pattern"], "必须是字符串");
+        if (schema.pattern !== undefined) {
+            try {
+                node.pattern = new RegExp(schema.pattern);
+            } catch {
+                schemaError([...path, "pattern"], "不是有效正则表达式");
+            }
+        }
+    }
+
+    if (schema.paramType === "array") {
+        assertItemBounds(schema, path);
+        assertBoolean(schema.unique, [...path, "unique"]);
+        node.minItem = schema.minItem;
+        node.maxItem = schema.maxItem;
+        node.unique = schema.unique === true;
+        node.items = schema.items === undefined ? null : compileNode(schema.items, [...path, "items"], parents);
+        if (schema.uniqueBy !== undefined) {
+            if (typeof schema.uniqueBy !== "string" || !schema.uniqueBy || schema.uniqueBy !== schema.uniqueBy.trim()) schemaError([...path, "uniqueBy"], "必须是非空无首尾空白字符串");
+            if (!node.items || node.items.kind !== "object" || !node.items.fieldSet.has(schema.uniqueBy)) schemaError([...path, "uniqueBy"], "必须引用 items.fields 中的字段");
+            if (node.items.fieldMap.get(schema.uniqueBy).optional) schemaError([...path, "uniqueBy"], "引用字段不能 optional");
+            node.uniqueBy = schema.uniqueBy;
+        }
+    }
+
+    if (schema.paramType === "object") {
+        assertItemBounds(schema, path);
+        if (schema.fields !== undefined && !isPlainObject(schema.fields)) schemaError([...path, "fields"], "必须是对象");
+        if (schema.extra !== undefined && typeof schema.extra !== "boolean" && !isPlainObject(schema.extra)) schemaError([...path, "extra"], "必须是 boolean 或 Schema");
+        node.minItem = schema.minItem;
+        node.maxItem = schema.maxItem;
+        node.fields = Object.entries(schema.fields || {}).map(([key, child]) => ({ key: key, node: compileNode(child, [...path, "fields", key], parents) }));
+        node.fieldMap = new Map(node.fields.map((field) => [field.key, field.node]));
+        node.fieldSet = new Set(node.fieldMap.keys());
+        node.extra = isPlainObject(schema.extra) ? compileNode(schema.extra, [...path, "extra"], parents) : schema.extra === true;
+        const requiredCount = node.fields.filter((field) => !field.node.optional && !field.node.hasDefault).length;
+        if (node.maxItem !== undefined && node.maxItem < requiredCount) schemaError([...path, "maxItem"], `不能小于必填字段数量 ${requiredCount}`);
+        if (node.extra === false && node.minItem !== undefined && node.minItem > node.fields.length) schemaError([...path, "minItem"], `不能大于 fields 数量 ${node.fields.length}`);
+        node.constraints = compileConstraints(schema, node, path);
+    }
+
+    if (schema.paramType === "record") {
+        assertItemBounds(schema, path);
+        if (schema.values === undefined) schemaError([...path, "values"], "为必填项");
+        node.minItem = schema.minItem;
+        node.maxItem = schema.maxItem;
+        node.keys = schema.keys === undefined ? null : compileNode(schema.keys, [...path, "keys"], parents);
+        if (node.keys && node.keys.kind !== "string") schemaError([...path, "keys"], "必须是 string Schema");
+        node.values = compileNode(schema.values, [...path, "values"], parents);
+    }
+
+    parents.delete(schema);
+    compileDefault(node, path);
+    return node;
+}
+
+function compileDefault(node, path) {
+    if (!node.hasDefault) return;
+    if (node.kind === "function") schemaError([...path, "paramDefault"], "function 不允许默认值");
+    const result = parseNode(node.paramDefault, { ...node, hasDefault: false }, [], false);
+    if (!result.ok) schemaError([...path, "paramDefault"], `不符合参数规则: ${result.issues.map((issue) => issue.message).join("；")}`);
+    node.paramDefault = result.data;
+}

package/libs/validator/index.js

@@ -0,0 +1,10 @@
+import { compileNode } from "./compiler.js";
+import { parseNode } from "./parser.js";
+
+/**
+ * 编译固定 JSON 参数协议。编译阶段验证 Schema，返回可重复执行的解析函数。
+ */
+export function compile(schema) {
+    const node = compileNode(schema, [], new Set());
+    return (value) => parseNode(value, node, []);
+}

package/libs/validator/parser.js

@@ -0,0 +1,173 @@
+import { isPlainObject } from "./util.js";
+
+function addIssue(issues, path, code, message) {
+    issues.push({ path: path, code: code, message: message });
+}
+
+function typeMessage(kind) {
+    if (kind === "boolean") return "必须是 boolean";
+    if (kind === "integer") return "必须是安全整数";
+    if (kind === "number") return "必须是有限数字";
+    if (kind === "string") return "必须是字符串";
+    if (kind === "function") return "必须是函数";
+    if (kind === "array") return "必须是数组";
+    return "必须是对象";
+}
+
+function checkNumberPrecision(value, node, path, issues) {
+    if (node.precision === undefined) return;
+    const text = String(value).replace(/^-/, "");
+    if (/e/i.test(text)) {
+        addIssue(issues, path, "precision", "不能使用科学计数法");
+        return;
+    }
+    const [integerPart, decimalPart = ""] = text.split(".");
+    if (decimalPart.length > (node.scale || 0)) addIssue(issues, path, "scale", `小数位不能超过${node.scale || 0}位`);
+    if (integerPart.replace(/^0+/, "").length + decimalPart.length > node.precision) addIssue(issues, path, "precision", `总位数不能超过${node.precision}位`);
+}
+
+function cloneDefault(value) {
+    return value && typeof value === "object" ? structuredClone(value) : value;
+}
+
+function success(data) {
+    return { ok: true, data: data, issues: [] };
+}
+
+function failure(issues) {
+    return { ok: false, issues: issues };
+}
+
+export function parseNode(value, node, path, useDefault = true) {
+    if (value === undefined && useDefault && node.hasDefault) value = cloneDefault(node.paramDefault);
+    if (value === undefined) return node.optional ? success() : failure([{ path: path, code: "missing", message: "为必填项" }]);
+    if (value === null) return failure([{ path: path, code: "null", message: "不允许为 null" }]);
+
+    if (node.kind === "anyOf") {
+        for (const branch of node.branches) {
+            const result = parseNode(value, branch, path);
+            if (result.ok) return result;
+        }
+        return failure([{ path: path, code: "anyOf", message: "不符合任一允许类型" }]);
+    }
+
+    if (node.kind === "any") return success(value);
+    if (node.kind === "boolean" && typeof value !== "boolean") return failure([{ path: path, code: "type", message: typeMessage(node.kind) }]);
+    if (node.kind === "integer" && !Number.isSafeInteger(value)) return failure([{ path: path, code: "type", message: typeMessage(node.kind) }]);
+    if (node.kind === "number" && (typeof value !== "number" || !Number.isFinite(value))) return failure([{ path: path, code: "type", message: typeMessage(node.kind) }]);
+    if (node.kind === "string" && typeof value !== "string") return failure([{ path: path, code: "type", message: typeMessage(node.kind) }]);
+    if (node.kind === "function" && typeof value !== "function") return failure([{ path: path, code: "type", message: typeMessage(node.kind) }]);
+    if (node.kind === "array" && !Array.isArray(value)) return failure([{ path: path, code: "type", message: typeMessage(node.kind) }]);
+    if ((node.kind === "object" || node.kind === "record") && !isPlainObject(value)) return failure([{ path: path, code: "type", message: typeMessage(node.kind) }]);
+
+    const issues = [];
+    if (node.enumSet && !node.enumSet.has(value)) addIssue(issues, path, "enum", `仅允许 ${[...node.enumSet].join("|")}`);
+
+    if (node.kind === "integer" || node.kind === "number") {
+        if (node.minValue !== undefined && value < node.minValue) addIssue(issues, path, "minValue", `不能小于${node.minValue}`);
+        if (node.maxValue !== undefined && value > node.maxValue) addIssue(issues, path, "maxValue", `不能大于${node.maxValue}`);
+        if (node.kind === "number") checkNumberPrecision(value, node, path, issues);
+        return issues.length > 0 ? failure(issues) : success(value);
+    }
+
+    if (node.kind === "string") {
+        if (value !== value.trim()) addIssue(issues, path, "trim", "不允许首尾空白");
+        if (node.minValue !== undefined && value.length < node.minValue) addIssue(issues, path, "minValue", `长度不能少于${node.minValue}个字符`);
+        if (node.maxValue !== undefined && value.length > node.maxValue) addIssue(issues, path, "maxValue", `长度不能超过${node.maxValue}个字符`);
+        if (node.pattern && !node.pattern.test(value)) addIssue(issues, path, "pattern", "格式不正确");
+        return issues.length > 0 ? failure(issues) : success(value);
+    }
+
+    if (node.kind === "array") {
+        if (node.minItem !== undefined && value.length < node.minItem) addIssue(issues, path, "minItem", `至少需要${node.minItem}项`);
+        if (node.maxItem !== undefined && value.length > node.maxItem) addIssue(issues, path, "maxItem", `最多允许${node.maxItem}项`);
+        if (node.unique && new Set(value).size !== value.length) addIssue(issues, path, "unique", "数组项不能重复");
+        if (node.uniqueBy) {
+            const seen = new Set();
+            value.forEach((item, index) => {
+                if (!isPlainObject(item) || item[node.uniqueBy] === undefined) return;
+                if (seen.has(item[node.uniqueBy])) addIssue(issues, [...path, index, node.uniqueBy], "uniqueBy", `${node.uniqueBy} ${item[node.uniqueBy]} 重复`);
+                else seen.add(item[node.uniqueBy]);
+            });
+        }
+        const data = [];
+        if (node.items) {
+            value.forEach((item, index) => {
+                const result = parseNode(item, node.items, [...path, index]);
+                if (result.ok) data.push(result.data);
+                else issues.push(...result.issues);
+            });
+        } else data.push(...value);
+        return issues.length > 0 ? failure(issues) : success(data);
+    }
+
+    if (node.kind === "object") return parseObject(value, node, path);
+    if (node.kind === "record") {
+        const keys = Object.keys(value);
+        if (node.minItem !== undefined && keys.length < node.minItem) addIssue(issues, path, "minItem", `至少需要${node.minItem}项`);
+        if (node.maxItem !== undefined && keys.length > node.maxItem) addIssue(issues, path, "maxItem", `最多允许${node.maxItem}项`);
+        const data = {};
+        for (const [key, item] of Object.entries(value)) {
+            if (node.keys) {
+                const keyResult = parseNode(key, node.keys, [...path, key]);
+                if (!keyResult.ok) issues.push(...keyResult.issues);
+            }
+            const valueResult = parseNode(item, node.values, [...path, key]);
+            if (valueResult.ok) data[key] = valueResult.data;
+            else issues.push(...valueResult.issues);
+        }
+        return issues.length > 0 ? failure(issues) : success(data);
+    }
+
+    return success(value);
+}
+
+function parseObject(value, node, path) {
+    const issues = [];
+    const data = {};
+    const validFields = new Set();
+    for (const { key, node: child } of node.fields) {
+        const result = parseNode(value[key], child, [...path, key]);
+        if (result.ok) {
+            if (result.data !== undefined) data[key] = result.data;
+            validFields.add(key);
+        } else issues.push(...result.issues);
+    }
+    for (const [key, item] of Object.entries(value)) {
+        if (node.fieldSet.has(key)) continue;
+        if (node.extra === false) addIssue(issues, [...path, key], "extra", "不允许出现");
+        else if (node.extra === true) data[key] = item;
+        else {
+            const result = parseNode(item, node.extra, [...path, key]);
+            if (result.ok) data[key] = result.data;
+            else issues.push(...result.issues);
+        }
+    }
+    const itemCount = Object.keys(data).length;
+    if (node.minItem !== undefined && itemCount < node.minItem) addIssue(issues, path, "minItem", `至少需要${node.minItem}项`);
+    if (node.maxItem !== undefined && itemCount > node.maxItem) addIssue(issues, path, "maxItem", `最多允许${node.maxItem}项`);
+    validateConstraints(data, node, path, validFields, issues);
+    return issues.length > 0 ? failure(issues) : success(data);
+}
+
+function validateConstraints(data, node, path, validFields, issues) {
+    for (const constraint of node.constraints) {
+        if (constraint.kind === "compare") {
+            if (!validFields.has(constraint.left) || !validFields.has(constraint.right) || data[constraint.left] === undefined || data[constraint.right] === undefined) continue;
+            const left = data[constraint.left];
+            const right = data[constraint.right];
+            const passed = constraint.operator === "eq" ? Object.is(left, right) : constraint.operator === "neq" ? !Object.is(left, right) : constraint.operator === "gt" ? left > right : constraint.operator === "gte" ? left >= right : constraint.operator === "lt" ? left < right : left <= right;
+            if (!passed) addIssue(issues, [...path, constraint.right], "constraint.compare", constraint.message || "字段关系不符合要求");
+            continue;
+        }
+        if (constraint.kind === "when") {
+            if (!validFields.has(constraint.field) || !Object.is(data[constraint.field], constraint.is)) continue;
+            for (const field of constraint.required) if (data[field] === undefined) addIssue(issues, [...path, field], "constraint.when", constraint.message || "条件成立时为必填项");
+            for (const field of constraint.forbidden) if (data[field] !== undefined) addIssue(issues, [...path, field], "constraint.when", constraint.message || "条件成立时不允许出现");
+            continue;
+        }
+        const existsCount = constraint.fields.filter((field) => data[field] !== undefined).length;
+        const passed = constraint.mode === "together" ? existsCount === 0 || existsCount === constraint.fields.length : constraint.mode === "atLeastOne" ? existsCount >= 1 : existsCount === 1;
+        if (!passed) addIssue(issues, path, "constraint.presence", constraint.message || "字段存在关系不符合要求");
+    }
+}

package/libs/validator/util.js

@@ -0,0 +1,5 @@
+export function isPlainObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.76.1",
+    "version": "3.76.3",
     "gitHead": "49c39d36695036e85fc64083cc43c1652fff96cb",
     "private": false,
     "description": "Befly - 为 Bun 专属打造的 JavaScript API 接口框架核心引擎",
@@ -23,16 +23,17 @@
         "checks",
         "configs",
         "hooks",
-        "lib",
+        "libs",
         "plugins",
         "router",
         "schemas",
         "scripts",
-        "sql",
         "sync",
         "tables",
         "utils",
         "index.js",
+        "Befly.js",
+        "exports.js",
         "paths.js",
         "LICENSE",
         "README.md"
@@ -46,6 +47,10 @@
         ".": {
             "import": "./index.js",
             "default": "./index.js"
+        },
+        "./exports": {
+            "import": "./exports.js",
+            "default": "./exports.js"
         }
     },
     "publishConfig": {
@@ -55,11 +60,8 @@
     "scripts": {
         "test": "bun test"
     },
-    "dependencies": {
-        "pathe": "^2.0.3",
-        "picomatch": "^4.0.5"
-    },
+    "dependencies": {},
     "engines": {
-        "bun": ">=1.3.0"
+        "bun": ">=1.4.0"
     }
 }

package/paths.js

@@ -10,10 +10,9 @@
  *
  */
 
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { dirname, isAbsolute, join, normalize, resolve } from "pathe";
-
 // 当前文件的路径信息
 const moduleFilePath = fileURLToPath(import.meta.url);
 const moduleDir = dirname(moduleFilePath);
@@ -30,7 +29,7 @@ export const coreDir = moduleDir;
  * Core 框架 dist 目录
  * @description 源码态为 packages/core/dist；dist 运行态为 packages/core/dist
  */
-export const coreDistDir = normalize(moduleDir).endsWith("/dist") ? moduleDir : join(moduleDir, "dist");
+export const coreDistDir = basename(moduleDir) === "dist" ? moduleDir : join(moduleDir, "dist");
 
 /**
  * Core 框架检查目录

package/plugins/cache.js

@@ -2,12 +2,13 @@ import { PLUGIN_ORDER } from "../configs/constConfig.js";
 /**
  * 负责在服务器启动时缓存接口、菜单和角色权限到 Redis
  */
-import { CacheHelper } from "../lib/cacheHelper.js";
+import { CacheHelper } from "../libs/cacheHelper.js";
 
 /**
  * 缓存插件
  */
 export default {
+    name: "缓存",
     order: PLUGIN_ORDER.CACHE,
     handler: async function (befly) {
         return new CacheHelper({ mysql: befly.mysql, redis: befly.redis });

package/plugins/email.js

@@ -1,14 +1,14 @@
-import { Logger } from "#befly/lib/logger.js";
-import { sendSmtpTextMail } from "#befly/lib/smtpText.js";
-import { hasEmailConfig } from "#befly/utils/email.js";
+import { Logger } from "#befly/libs/logger/index.js";
+import { sendSmtpTextMail } from "#befly/libs/smtpText.js";
 
 import { PLUGIN_ORDER } from "../configs/constConfig.js";
 
 export default {
+    name: "邮件",
     order: PLUGIN_ORDER.EMAIL,
     handler: async function (befly) {
         const config = befly?.config?.email || {};
-        const enabled = hasEmailConfig(config);
+        const enabled = config.host && config.user && config.pass;
 
         const sendMail = async function (options) {
             if (!enabled) {

package/plugins/mysql.js

@@ -1,30 +1,20 @@
+import { createMysql } from "#befly/libs/mysql/index.js";
+
 import { PLUGIN_ORDER } from "../configs/constConfig.js";
-/**
- * 数据库插件
- * 初始化数据库连接和 SQL 管理器
- */
-import { Connect } from "../lib/connect.js";
-import { DbHelper } from "../lib/dbHelper.js";
 import { createError } from "../utils/error.js";
 
 /**
  * 数据库插件
  */
 export default {
+    name: "MySQL",
     order: PLUGIN_ORDER.MYSQL,
     handler: async function (befly) {
         try {
-            // 创建数据库管理器实例
-            const dbManager = new DbHelper({
-                redis: befly.redis,
-                dbName: befly.config?.mysql?.database,
-                sql: Connect.getMysql(),
-                beflyMode: befly.config?.mysql?.beflyMode,
-                queryTimeout: befly.config?.mysql?.queryTimeout,
+            return await createMysql({
+                ...befly.config.mysql,
                 tables: befly.tables
             });
-
-            return dbManager;
         } catch (error) {
             throw createError("数据库初始化失败", { cause: error, code: "runtime", subsystem: "db", operation: "init" });
         }

package/plugins/redis.js

@@ -1,25 +1,17 @@
+import { createRedis } from "#befly/libs/redis/index.js";
+
 import { PLUGIN_ORDER } from "../configs/constConfig.js";
-/**
- * Redis 插件
- * 初始化 Redis 连接和助手工具
- */
-import { Connect } from "../lib/connect.js";
-import { RedisHelper } from "../lib/redisHelper.js";
 import { createError } from "../utils/error.js";
 
 /**
  * Redis 插件
  */
 export default {
+    name: "Redis",
     order: PLUGIN_ORDER.REDIS,
     handler: async function (befly) {
-        const redisPrefix = befly.config?.redis?.prefix;
         try {
-            // 启动期已建立 Redis 连接；这里仅校验连接存在
-            Connect.getRedis();
-
-            // 返回 RedisHelper 实例
-            return new RedisHelper(redisPrefix);
+            return await createRedis(befly.config.redis);
         } catch (error) {
             throw createError("Redis 初始化失败", { cause: error, code: "runtime", subsystem: "redis", operation: "init" });
         }