befly 3.16.9 → 3.16.11

package/dist/checks/checkPlugin.js

@@ -1,132 +0,0 @@
-import { Logger } from "../lib/logger";
-import { CoreError } from "../types/coreError";
-import { isPlainObject, omit } from "../utils/util";
-const exportKeys = ["name", "enable", "deps", "handler"];
-export async function checkPlugin(plugins) {
-    let hasError = false;
-    // 说明：plugins 实际是 scanFiles/scanSources 的结果对象（包含元信息字段）。
-    // 这里不再对白名单枚举 metaKeys（因为它们是系统生成的），只校验“用户 default export 导出的字段”。
-    const coreBuiltinNameRegexp = /^[a-z]+(?:_[a-z]+)*$/;
-    for (const plugin of plugins) {
-        try {
-            if (!isPlainObject(plugin)) {
-                Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "插件导出必须是对象（export default { deps, handler }）" }));
-                hasError = true;
-                continue;
-            }
-            const record = plugin;
-            // moduleName 必须存在（用于依赖排序与运行时挂载）。
-            const moduleName = record["moduleName"];
-            if (typeof moduleName !== "string" || moduleName.trim() === "") {
-                Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "插件的 moduleName 必须是非空字符串（由系统生成，用于 deps 与运行时挂载）" }));
-                hasError = true;
-                continue;
-            }
-            const customKeys = record["customKeys"];
-            if (!Array.isArray(customKeys)) {
-                Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "插件扫描结果缺少 customKeys（无法判断用户导出的字段是否合法）" }));
-                hasError = true;
-                continue;
-            }
-            if (customKeys.some((k) => typeof k !== "string")) {
-                Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "插件的 customKeys 必须是 string[]（由系统生成）" }));
-                hasError = true;
-                continue;
-            }
-            // 严格字段校验：仅检查用户 default export 的字段集合，出现任何未支持字段都应视为错误。
-            const unknownCustomKeys = customKeys.filter((k) => !exportKeys.includes(k));
-            if (unknownCustomKeys.length > 0) {
-                Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: `插件导出存在不支持的属性：${unknownCustomKeys.join(", ")}；仅允许：${exportKeys.join(", ")}；当前 customKeys：${customKeys.join(", ")}` }));
-                hasError = true;
-                continue;
-            }
-            const hasCustomEnable = customKeys.includes("enable");
-            const hasCustomDeps = customKeys.includes("deps");
-            // enable 必须显式声明且只能为 boolean（true/false），不允许 0/1 等其他类型。
-            // - 允许缺省：由系统在此处补全默认值 true
-            // - 若用户显式导出 enable：必须是 boolean
-            if (hasCustomEnable) {
-                const enable = record["enable"];
-                if (typeof enable !== "boolean") {
-                    Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "插件的 enable 属性必须是 boolean（true/false），不允许 0/1 等其他类型" }));
-                    hasError = true;
-                    continue;
-                }
-            }
-            else {
-                record["enable"] = true;
-            }
-            // core 内置插件：必须来自静态注册（filePath 以 core:plugin: 开头），且 name 必须显式指定并与 moduleName 一致。
-            if (record["source"] === "core") {
-                const name = typeof record["name"] === "string" ? record["name"] : "";
-                if (name === "") {
-                    Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "core 内置插件必须显式设置 name（string），用于确定插件名称" }));
-                    hasError = true;
-                    continue;
-                }
-                // name 必须满足：小写字母 + 下划线（不允许空格、驼峰、数字等）。
-                if (!coreBuiltinNameRegexp.test(name)) {
-                    Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "core 内置插件的 name 必须满足小写字母+下划线格式（例如 logger / redis_cache），不允许空格、驼峰或其他字符" }));
-                    hasError = true;
-                    continue;
-                }
-                if (!coreBuiltinNameRegexp.test(String(record["moduleName"]))) {
-                    Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "core 内置插件的 moduleName 必须满足小写字母+下划线格式（由系统生成，且必须与 name 一致）" }));
-                    hasError = true;
-                    continue;
-                }
-                if (name !== String(record["moduleName"])) {
-                    Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "core 内置插件的 name 必须与 moduleName 完全一致" }));
-                    hasError = true;
-                    continue;
-                }
-                const filePath = record["filePath"];
-                if (typeof filePath !== "string" || !filePath.startsWith(`core:plugin:${name}`)) {
-                    Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "core 内置插件必须来自静态注册（filePath 必须以 core:plugin:<name> 开头），不允许通过扫描目录加载" }));
-                    hasError = true;
-                    continue;
-                }
-            }
-            // deps：允许缺省（补全为 []），但如果用户显式导出 deps，则必须是 string[]。
-            if (hasCustomDeps) {
-                const deps = record["deps"];
-                if (!Array.isArray(deps)) {
-                    Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "插件的 deps 属性必须是字符串数组" }));
-                    hasError = true;
-                    continue;
-                }
-                if (deps.some((depItem) => typeof depItem !== "string")) {
-                    Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "插件的 deps 属性必须是字符串数组" }));
-                    hasError = true;
-                    continue;
-                }
-            }
-            else {
-                const deps = record["deps"];
-                if (!Array.isArray(deps)) {
-                    record["deps"] = [];
-                }
-            }
-            if (typeof record["handler"] !== "function") {
-                Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "插件的 handler 属性必须是函数" }));
-                hasError = true;
-                continue;
-            }
-        }
-        catch (error) {
-            Logger.error({ err: error, item: plugin, msg: "插件解析失败" });
-            hasError = true;
-        }
-    }
-    if (hasError) {
-        throw new CoreError({
-            kind: "policy",
-            message: "插件结构检查失败",
-            logged: true,
-            meta: {
-                subsystem: "checks",
-                operation: "checkPlugin"
-            }
-        });
-    }
-}

package/dist/checks/checkTable.d.ts

@@ -1,7 +0,0 @@
-import type { BeflyOptions } from "../types/befly";
-import type { ScanFileResult } from "../utils/scanFiles";
-/**
- * 检查表定义文件
- * @throws 当检查失败时抛出异常
- */
-export declare function checkTable(tables: ScanFileResult[], config: BeflyOptions): Promise<void>;

package/dist/checks/checkTable.js

@@ -1,431 +0,0 @@
-import { Logger } from "../lib/logger";
-import { CoreError } from "../types/coreError";
-import { isDecimalDbType as isDecimalDbTypeRule, isEnumDbType as isEnumDbTypeRule, isFloatDbType as isFloatDbTypeRule, isIntDbType as isIntDbTypeRule, isJsonDbType as isJsonDbTypeRule, isNumericDbType as isNumericDbTypeRule, isStringDbType as isStringDbTypeRule, isTextDbType as isTextDbTypeRule, normalizeTypeAndInput, parseEnumRuleValues } from "../utils/dbFieldRules";
-import { formatValuePreview, isAliasInput, isEnumInput, isJsonValue, isRegexInput, snakeCase } from "../utils/util";
-/**
- * 保留字段列表
- */
-const RESERVED_FIELDS = ["id", "created_at", "updated_at", "deleted_at", "state"];
-const RESERVED_FIELD_SET = new Set(RESERVED_FIELDS);
-/**
- * 允许的数据库字段类型
- */
-const FIELD_TYPES = ["tinyint", "smallint", "mediumint", "int", "bigint", "decimal", "float", "double", "char", "varchar", "enum", "tinytext", "text", "mediumtext", "longtext", "datetime", "timestamp", "json"];
-const FIELD_TYPE_SET = new Set(FIELD_TYPES);
-/**
- * 允许的输入类型
- */
-const INPUT_TYPES = ["number", "integer", "string", "char", "array", "array_number", "array_integer", "json", "json_number", "json_integer"];
-const INPUT_TYPE_SET = new Set(INPUT_TYPES);
-/**
- * 允许的字段属性列表
- */
-const ALLOWED_FIELD_PROPERTIES = ["name", "type", "input", "min", "max", "default", "detail", "precision", "scale", "index", "unique", "nullable", "unsigned"];
-const ALLOWED_FIELD_PROPERTY_SET = new Set(ALLOWED_FIELD_PROPERTIES);
-/**
- * 小驼峰命名正则
- * 可选：以下划线开头（用于特殊文件，如通用字段定义）
- * 必须以小写字母开头，后续可包含小写/数字，或多个 [大写+小写/数字] 片段
- * 示例：userTable、testCustomers、common
- */
-const LOWER_CAMEL_CASE_REGEX = /^_?[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/;
-/**
- * 字段名称正则
- * 必须为中文、数字、字母、下划线、短横线、空格
- */
-const FIELD_NAME_REGEX = /^[\u4e00-\u9fa5a-zA-Z0-9 _-]+$/;
-// MySQL VARCHAR 最大长度（utf8mb4 下受行大小限制；本项目采用保守上限，用于表定义校验）
-const MAX_VARCHAR_LENGTH = 16383;
-// 项目索引策略（更简单、更保守）：
-// - index=true: 只允许 max<=500
-// - unique=true: 只允许 max<=180
-const MAX_INDEX_STRING_LENGTH_FOR_INDEX = 500;
-const MAX_INDEX_STRING_LENGTH_FOR_UNIQUE = 180;
-/**
- * 检查表定义文件
- * @throws 当检查失败时抛出异常
- */
-export async function checkTable(tables, config) {
-    // 收集所有表文件
-    let hasError = false;
-    // 合并进行验证逻辑
-    for (const item of tables) {
-        if (item.type !== "table") {
-            continue;
-        }
-        const sourceName = typeof item.sourceName === "string" ? item.sourceName : "";
-        const tablePrefix = sourceName ? `${sourceName}表 ` : "表 ";
-        try {
-            const fileName = item.fileName;
-            // 前置约束（供 syncTable 直接假设成立）：
-            // - addon 表必须有 addonName
-            // - 表定义必须是对象（非 null/数组）
-            if (item.source === "addon" && String(item.addonName).trim() === "") {
-                Logger.warn(`${tablePrefix}${fileName} addon 表缺少 addonName`);
-                hasError = true;
-                continue;
-            }
-            const table = item.content;
-            if (typeof table !== "object" || table === null || Array.isArray(table)) {
-                Logger.warn(`${tablePrefix}${fileName} 表定义无效：必须为对象`);
-                hasError = true;
-                continue;
-            }
-            // 1) 文件名小驼峰校验
-            if (!LOWER_CAMEL_CASE_REGEX.test(fileName)) {
-                Logger.warn(`${tablePrefix}${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
-                hasError = true;
-                continue;
-            }
-            // 检查 table 中的每个验证规则
-            for (const [colKey, fieldDef] of Object.entries(table)) {
-                if (typeof fieldDef !== "object" || fieldDef === null || Array.isArray(fieldDef)) {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 规则必须为对象`);
-                    hasError = true;
-                    continue;
-                }
-                // 检查是否使用了保留字段
-                const dbFieldName = snakeCase(colKey);
-                if (RESERVED_FIELD_SET.has(colKey) || RESERVED_FIELD_SET.has(dbFieldName)) {
-                    Logger.warn(`${tablePrefix}${fileName} 文件包含保留字段 ${colKey}（映射列名: ${dbFieldName}），` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(", ")}`);
-                    hasError = true;
-                }
-                // 直接使用字段对象
-                const field = fieldDef;
-                // 检查是否存在非法属性
-                const fieldKeys = Object.keys(field);
-                const illegalProps = fieldKeys.filter((key) => !ALLOWED_FIELD_PROPERTY_SET.has(key));
-                if (illegalProps.length > 0) {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 包含非法属性: ${illegalProps.join(", ")}，` + `允许的属性为: ${ALLOWED_FIELD_PROPERTIES.join(", ")}`);
-                    hasError = true;
-                }
-                // 检查必填字段：name, type
-                if (!field.name || typeof field.name !== "string") {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 缺少必填字段 name 或类型错误`);
-                    hasError = true;
-                    continue;
-                }
-                if (!field.type || typeof field.type !== "string") {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 缺少必填字段 type 或类型错误`);
-                    hasError = true;
-                    continue;
-                }
-                if (field.input !== undefined && typeof field.input !== "string") {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 input 类型错误，必须为字符串`);
-                    hasError = true;
-                }
-                // 检查可选字段的类型
-                if (field.min !== undefined && !(field.min === null || typeof field.min === "number")) {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 min 类型错误，必须为 null 或数字`);
-                    hasError = true;
-                }
-                if (field.max !== undefined && !(field.max === null || typeof field.max === "number")) {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 max 类型错误，必须为 null 或数字`);
-                    hasError = true;
-                }
-                if (field.detail !== undefined && typeof field.detail !== "string") {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 detail 类型错误，必须为字符串`);
-                    hasError = true;
-                }
-                if (field.precision !== undefined && !(field.precision === null || typeof field.precision === "number")) {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 precision 类型错误，必须为 null 或数字`);
-                    hasError = true;
-                }
-                if (field.scale !== undefined && !(field.scale === null || typeof field.scale === "number")) {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 scale 类型错误，必须为 null 或数字`);
-                    hasError = true;
-                }
-                if (field.index !== undefined && typeof field.index !== "boolean") {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 index 类型错误，必须为布尔值`);
-                    hasError = true;
-                }
-                if (field.unique !== undefined && typeof field.unique !== "boolean") {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 unique 类型错误，必须为布尔值`);
-                    hasError = true;
-                }
-                if (field.nullable !== undefined && typeof field.nullable !== "boolean") {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 nullable 类型错误，必须为布尔值`);
-                    hasError = true;
-                }
-                if (field.unsigned !== undefined && typeof field.unsigned !== "boolean") {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 unsigned 类型错误，必须为布尔值`);
-                    hasError = true;
-                }
-                const normalizedTypeInput = normalizeTypeAndInput(field.type, field.input || "");
-                const effectiveType = normalizedTypeInput.type;
-                const effectiveInput = normalizedTypeInput.input;
-                // 约束：default 若存在，必须可 JSON 序列化（避免 syncTable 运行期再做防御判断）
-                if (field.default !== undefined && field.default !== null && !isJsonValue(field.default)) {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 default 类型错误，必须为可 JSON 序列化的值或 null` + `（typeof=${typeof field.default}，value=${formatValuePreview(field.default)}）`);
-                    hasError = true;
-                }
-                // 字段名称必须为中文、数字、字母、下划线、短横线、空格
-                if (config.strict) {
-                    if (!FIELD_NAME_REGEX.test(field.name)) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段名称 "${field.name}" 格式错误，` + `必须为中文、数字、字母、下划线、短横线、空格`);
-                        hasError = true;
-                    }
-                }
-                // 字段类型必须为 FIELD_TYPES 之一
-                if (!FIELD_TYPE_SET.has(effectiveType)) {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段类型 "${effectiveType}" 格式错误，` + `必须为${FIELD_TYPES.join("、")}之一`);
-                    hasError = true;
-                }
-                const normalizedInput = effectiveInput.trim();
-                if (normalizedInput === "") {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 input 无法推导`);
-                    hasError = true;
-                }
-                else if (!INPUT_TYPE_SET.has(normalizedInput) && !isRegexInput(normalizedInput) && !isEnumInput(normalizedInput) && !isAliasInput(normalizedInput)) {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 input "${normalizedInput}" 不合法，` + `必须为${INPUT_TYPES.join("、")}之一，或正则/枚举/正则别名`);
-                    hasError = true;
-                }
-                const isDecimalDbType = isDecimalDbTypeRule(effectiveType);
-                const isFloatDbType = isFloatDbTypeRule(effectiveType);
-                const isJsonDbType = isJsonDbTypeRule(effectiveType);
-                const isEnumDbType = isEnumDbTypeRule(effectiveType);
-                const isNumericDbType = isNumericDbTypeRule(effectiveType);
-                const isStringDbTypeNormalized = isStringDbTypeRule(effectiveType);
-                const isTextDbTypeNormalized = isTextDbTypeRule(effectiveType);
-                const isIntDbTypeNormalized = isIntDbTypeRule(effectiveType);
-                if (isEnumDbType) {
-                    if (normalizedInput.trim() === "") {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，必须设置 input 枚举规则（例如 a|b|c）`);
-                        hasError = true;
-                    }
-                    else if (!isEnumInput(normalizedInput)) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，input 必须为枚举规则（例如 a|b|c），当前为 ${formatValuePreview(normalizedInput)}`);
-                        hasError = true;
-                    }
-                }
-                if (isRegexInput(normalizedInput) || isEnumInput(normalizedInput) || isAliasInput(normalizedInput)) {
-                    if (!isStringDbTypeNormalized) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 input 使用正则/枚举/正则别名，仅允许字符串类字段（char/varchar/enum/text）`);
-                        hasError = true;
-                    }
-                }
-                if (normalizedInput === "number" || normalizedInput === "integer") {
-                    if (normalizedInput === "integer" && !isIntDbTypeNormalized) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 input=${normalizedInput} 仅允许整数类字段（tinyint/smallint/mediumint/int/bigint）`);
-                        hasError = true;
-                    }
-                    if (normalizedInput === "number" && !isNumericDbType) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 input=${normalizedInput} 仅允许数值类字段（tinyint/smallint/mediumint/int/bigint/decimal）`);
-                        hasError = true;
-                    }
-                }
-                if (normalizedInput === "array" || normalizedInput === "array_number" || normalizedInput === "array_integer") {
-                    if (!isStringDbTypeNormalized) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 input=${normalizedInput} 仅允许字符串类字段（char/varchar/text）`);
-                        hasError = true;
-                    }
-                }
-                if (normalizedInput === "json" || normalizedInput === "json_number" || normalizedInput === "json_integer") {
-                    if (!(isJsonDbType || isTextDbTypeNormalized)) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段 input=${normalizedInput} 仅允许 json 或 text 类字段`);
-                        hasError = true;
-                    }
-                }
-                // unsigned 仅对 number 类型有效（且仅 MySQL 语义上生效）
-                if (!isNumericDbType && field.unsigned !== undefined) {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 字段类型为 ${effectiveType}，不允许设置 unsigned（仅数值类型有效）`);
-                    hasError = true;
-                }
-                // 约束：unique 与 index 不能同时为 true（否则会重复索引），必须阻断启动。
-                if (field.unique === true && field.index === true) {
-                    Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 同时设置了 unique=true 和 index=true，` + `unique 和 index 不能同时设置，请删除其一（否则会创建重复索引）`);
-                    hasError = true;
-                }
-                // 约束：当最小值与最大值均为数字时，要求最小值 <= 最大值
-                if (field.min !== undefined && field.max !== undefined && field.min !== null && field.max !== null) {
-                    if (field.min > field.max) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 最小值 "${field.min}" 不能大于最大值 "${field.max}"`);
-                        hasError = true;
-                    }
-                }
-                // 类型联动校验 + 默认值规则
-                if (isTextDbTypeNormalized || isJsonDbType) {
-                    // text/json：min/max 必须为 null，默认值必须为 null，且不支持索引/唯一约束
-                    if (field.min !== undefined && field.min !== null) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 的 ${effectiveType} 类型最小值应为 null，当前为 "${field.min}"`);
-                        hasError = true;
-                    }
-                    if (field.max !== undefined && field.max !== null) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 的 ${effectiveType} 类型最大长度应为 null，当前为 "${field.max}"`);
-                        hasError = true;
-                    }
-                    if (field.default !== undefined && field.default !== null) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${effectiveType} 类型，默认值必须为 null，当前为 "${field.default}"`);
-                        hasError = true;
-                    }
-                    if (field.index === true) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${effectiveType} 类型，不支持创建索引（index=true 无效）`);
-                        hasError = true;
-                    }
-                    if (field.unique === true) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${effectiveType} 类型，不支持唯一约束（unique=true 无效）`);
-                        hasError = true;
-                    }
-                }
-                else if (effectiveType === "datetime" || effectiveType === "timestamp") {
-                    // datetime/timestamp：对应 MySQL DATETIME/TIMESTAMP（到秒）
-                    // - min/max 必须为 null
-                    // - default 必须为 null（避免把 DDL 表达式当作运行期默认值）
-                    // - 不允许 unsigned
-                    if (field.min !== undefined && field.min !== null) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${effectiveType} 类型，min 必须为 null，当前为 "${field.min}"`);
-                        hasError = true;
-                    }
-                    if (field.max !== undefined && field.max !== null) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${effectiveType} 类型，max 必须为 null，当前为 "${field.max}"`);
-                        hasError = true;
-                    }
-                    if (field.default !== undefined && field.default !== null) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${effectiveType} 类型，默认值必须为 null（如需当前时间，请在业务写入时赋值）。当前为 ${formatValuePreview(field.default)}`);
-                        hasError = true;
-                    }
-                    if (field.unsigned !== undefined) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${effectiveType} 类型，不允许设置 unsigned`);
-                        hasError = true;
-                    }
-                }
-                else if (effectiveType === "enum") {
-                    // enum：对应 MySQL ENUM('a','b',...)。
-                    // 约束：必须提供 input 枚举规则（a|b|c），由上方 isEnumDbType 分支保证。
-                    // - min/max/precision/scale 必须为 null
-                    // - default 若提供，必须为枚举值之一
-                    // - 若 nullable!=true，则必须提供 default（避免 NOT NULL 无默认值导致写入失败）
-                    // - 不允许 unsigned
-                    if (field.min !== undefined && field.min !== null) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，min 必须为 null，当前为 "${field.min}"`);
-                        hasError = true;
-                    }
-                    if (field.max !== undefined && field.max !== null) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，max 必须为 null，当前为 "${field.max}"`);
-                        hasError = true;
-                    }
-                    if (field.precision !== undefined && field.precision !== null) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，不允许设置 precision`);
-                        hasError = true;
-                    }
-                    if (field.scale !== undefined && field.scale !== null) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，不允许设置 scale`);
-                        hasError = true;
-                    }
-                    if (field.unsigned !== undefined) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，不允许设置 unsigned`);
-                        hasError = true;
-                    }
-                    const enumValues = parseEnumRuleValues(normalizedInput);
-                    if (field.default === undefined || field.default === null) {
-                        if (field.nullable !== true) {
-                            Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，nullable!=true 时必须设置 default（且 default 必须为枚举值之一）`);
-                            hasError = true;
-                        }
-                    }
-                    else if (typeof field.default !== "string") {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，默认值必须为字符串或 null` + `（typeof=${typeof field.default}，value=${formatValuePreview(field.default)}）`);
-                        hasError = true;
-                    }
-                    else if (!enumValues.includes(field.default)) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 enum 类型，默认值不在枚举范围内（default=${formatValuePreview(field.default)}，enums=${formatValuePreview(normalizedInput)}）`);
-                        hasError = true;
-                    }
-                }
-                else if (isDecimalDbType) {
-                    // decimal：对应 MySQL DECIMAL(precision, scale)
-                    // - precision/scale 必须为数字
-                    // - precision: 1..65
-                    // - scale: 0..30 且 <= precision
-                    const precision = field.precision;
-                    const scale = field.scale;
-                    if (typeof precision !== "number") {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 decimal 类型，必须设置 precision（总位数）`);
-                        hasError = true;
-                    }
-                    else if (precision < 1 || precision > 65) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 decimal 类型，precision 必须在 1..65 范围内，当前为 ${precision}`);
-                        hasError = true;
-                    }
-                    if (typeof scale !== "number") {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 decimal 类型，必须设置 scale（小数位数）`);
-                        hasError = true;
-                    }
-                    else if (scale < 0 || scale > 30) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 decimal 类型，scale 必须在 0..30 范围内，当前为 ${scale}`);
-                        hasError = true;
-                    }
-                    if (typeof precision === "number" && typeof scale === "number" && scale > precision) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 decimal 类型，scale 不能大于 precision（precision=${precision}, scale=${scale}）`);
-                        hasError = true;
-                    }
-                    if (field.default !== undefined && field.default !== null && typeof field.default !== "number") {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 decimal 类型，默认值必须为数字或 null` + `（typeof=${typeof field.default}，value=${formatValuePreview(field.default)}）`);
-                        hasError = true;
-                    }
-                }
-                else if (effectiveType === "char" || effectiveType === "varchar") {
-                    // 约束：char/varchar 必须声明 max。
-                    // 说明：当 input 为 array/array_number/array_integer 时，max 表示单个元素长度。
-                    if (field.max === undefined || field.max === null || typeof field.max !== "number") {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${effectiveType} 类型，` + `必须设置 max 且类型为数字，当前为 "${field.max}"`);
-                        hasError = true;
-                    }
-                    else if (field.max > MAX_VARCHAR_LENGTH) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 最大长度 ${field.max} 越界，` + `${effectiveType} 类型长度必须在 1..${MAX_VARCHAR_LENGTH} 范围内`);
-                        hasError = true;
-                    }
-                    else {
-                        if (field.index === true && field.max > MAX_INDEX_STRING_LENGTH_FOR_INDEX) {
-                            Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 设置了 index=true，` + `但 max=${field.max} 超出允许范围（要求 <= ${MAX_INDEX_STRING_LENGTH_FOR_INDEX}）`);
-                            hasError = true;
-                        }
-                        if (field.unique === true && field.max > MAX_INDEX_STRING_LENGTH_FOR_UNIQUE) {
-                            Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 设置了 unique=true，` + `但 max=${field.max} 超出允许范围（要求 <= ${MAX_INDEX_STRING_LENGTH_FOR_UNIQUE}）`);
-                            hasError = true;
-                        }
-                    }
-                    // input=char 时，max 必须为 1
-                    if (normalizedInput === "char" && typeof field.max === "number" && field.max > 1) {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} input=char 时 max 必须为 1，当前为 ${field.max}`);
-                        hasError = true;
-                    }
-                    // default 规则：默认值必须为 string 或 null
-                    if (field.default !== undefined && field.default !== null && typeof field.default !== "string") {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${effectiveType} 类型，默认值必须为字符串或 null` + `（typeof=${typeof field.default}，value=${formatValuePreview(field.default)}）`);
-                        hasError = true;
-                    }
-                }
-                else if (isIntDbTypeNormalized) {
-                    // 整数类型：default 如果存在，必须为 null 或 number
-                    if (field.default !== undefined && field.default !== null && typeof field.default !== "number") {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${effectiveType} 类型，默认值必须为数字或 null` + `（typeof=${typeof field.default}，value=${formatValuePreview(field.default)}）`);
-                        hasError = true;
-                    }
-                }
-                else if (isFloatDbType) {
-                    // float/double：default 如果存在，必须为 null 或 number
-                    if (field.default !== undefined && field.default !== null && typeof field.default !== "number") {
-                        Logger.warn(`${tablePrefix}${fileName} 文件 ${colKey} 为 ${effectiveType} 类型，默认值必须为数字或 null` + `（typeof=${typeof field.default}，value=${formatValuePreview(field.default)}）`);
-                        hasError = true;
-                    }
-                }
-            }
-        }
-        catch (error) {
-            Logger.error({ msg: `${tablePrefix}${item.fileName} 解析失败`, err: error });
-            hasError = true;
-        }
-    }
-    if (hasError) {
-        throw new CoreError({
-            kind: "policy",
-            message: "表结构检查失败",
-            logged: true,
-            meta: {
-                subsystem: "checks",
-                operation: "checkTable"
-            }
-        });
-    }
-}