befly 3.8.30 → 3.8.31

package/lib/validator.ts

@@ -1,462 +1,227 @@
 /**
  * 数据验证器 - Befly 项目专用
- * 内置 RegexAliases，支持对象格式的字段定义
- * 使用正则缓存优化性能
+ * 纯静态类设计，简洁易用
  */
 
-import type { ValidationResult, ValidationError } from '../types/validator';
 import { RegexAliases, getCompiledRegex } from 'befly-shared/regex';
-import type { TableDefinition, FieldDefinition } from 'befly-shared/types';
+import type { TableDefinition, FieldDefinition, ValidateResult, SingleResult } from 'befly-shared/types';
 
 /**
- * 验证器类（Befly 项目专用）
- * 内置 RegexAliases，直接使用 util.ts 中的 parseRule
+ * 验证器类
+ *
+ * @example
+ * const result = Validator.validate(data, rules, ['email', 'name']);
+ * if (result.failed) {
+ *     console.log(result.firstError);
+ *     console.log(result.errors);
+ *     console.log(result.errorFields);
+ * }
+ *
+ * const single = Validator.single(value, fieldDef);
+ * if (!single.error) {
+ *     console.log(single.value);
+ * }
  */
 export class Validator {
-    /** 正则别名映射（内置） */
-    private readonly regexAliases: Record<string, string> = RegexAliases;
-
     /**
-     * 验证数据
-     * @param data - 要验证的数据对象
-     * @param rules - 验证规则对象
-     * @param required - 必传字段数组
-     * @returns 验证结果 { code: 0|1, fields: {} }
+     * 验证数据对象
      */
-    validate(data: Record<string, any>, rules: TableDefinition, required: string[] = []): ValidationResult {
-        const result: ValidationResult = {
-            code: 0,
-            fields: {}
-        };
+    static validate(data: Record<string, any>, rules: TableDefinition, required: string[] = []): ValidateResult {
+        const fieldErrors: Record<string, string> = {};
 
         // 参数检查
-        if (!this.checkParams(data, rules, required, result)) {
-            return result;
-        }
-
-        // 检查必传字段
-        this.checkRequiredFields(data, rules, required, result);
-
-        // 验证所有在规则中定义的字段
-        this.validateFields(data, rules, required, result);
-
-        return result;
-    }
-
-    /**
-     * 检查参数有效性
-     */
-    private checkParams(data: any, rules: any, required: any, result: ValidationResult): boolean {
         if (!data || typeof data !== 'object' || Array.isArray(data)) {
-            result.code = 1;
-            result.fields.error = '数据必须是对象格式';
-            return false;
+            return this.buildResult({ _error: '数据必须是对象格式' });
         }
-
         if (!rules || typeof rules !== 'object') {
-            result.code = 1;
-            result.fields.error = '验证规则必须是对象格式';
-            return false;
+            return this.buildResult({ _error: '验证规则必须是对象格式' });
         }
 
-        if (!Array.isArray(required)) {
-            result.code = 1;
-            result.fields.error = '必传字段必须是数组格式';
-            return false;
+        // 检查必填字段
+        for (const field of required) {
+            const value = data[field];
+            if (value === undefined || value === null || value === '') {
+                const label = rules[field]?.name || field;
+                fieldErrors[field] = `${label}为必填项`;
+            }
         }
 
-        return true;
-    }
+        // 验证有值的字段
+        for (const [field, rule] of Object.entries(rules)) {
+            if (fieldErrors[field]) continue;
+            if (!(field in data) && !required.includes(field)) continue;
 
-    /**
-     * 检查必传字段
-     */
-    private checkRequiredFields(data: Record<string, any>, rules: TableDefinition, required: string[], result: ValidationResult): void {
-        for (const fieldName of required) {
-            const value = data[fieldName];
-            if (!(fieldName in data) || value === undefined || value === null || value === '') {
-                result.code = 1;
-                const fieldDef = rules[fieldName];
-                const fieldLabel = fieldDef?.name || fieldName;
-                result.fields[fieldName] = `${fieldLabel}(${fieldName})为必填项`;
-            }
+            const error = this.checkField(data[field], rule, field);
+            if (error) fieldErrors[field] = error;
         }
+
+        return this.buildResult(fieldErrors);
     }
 
     /**
-     * 验证所有字段
+     * 验证单个值（带类型转换）
      */
-    private validateFields(data: Record<string, any>, rules: TableDefinition, required: string[], result: ValidationResult): void {
-        for (const [fieldName, rule] of Object.entries(rules)) {
-            // 如果字段不存在且不是必传字段，跳过验证
-            if (!(fieldName in data) && !required.includes(fieldName)) {
-                continue;
-            }
-
-            // 如果必传验证已经失败，跳过后续验证
-            if (result.fields[fieldName]) {
-                continue;
-            }
+    static single(value: any, fieldDef: FieldDefinition): SingleResult {
+        const { type, default: defaultValue } = fieldDef;
 
-            const value = data[fieldName];
-            const error = this.validateFieldValue(value, rules[fieldName], fieldName);
-
-            if (error) {
-                result.code = 1;
-                result.fields[fieldName] = error;
-            }
+        // 处理空值
+        if (value === undefined || value === null || value === '') {
+            return { value: this.defaultFor(type, defaultValue), error: null };
         }
-    }
 
-    /**
-     * 解析 regex 别名
-     */
-    private resolveRegexAlias(regex: string | null): string | null {
-        if (!regex || typeof regex !== 'string') {
-            return regex;
+        // 类型转换
+        const converted = this.convert(value, type);
+        if (converted.error) {
+            return { value: null, error: converted.error };
         }
 
-        if (regex.startsWith('@')) {
-            const aliasName = regex.substring(1);
-            const resolvedRegex = this.regexAliases[aliasName];
-            if (resolvedRegex) {
-                return resolvedRegex;
-            }
-            return regex;
+        // 规则验证
+        const error = this.checkRule(converted.value, fieldDef);
+        if (error) {
+            return { value: null, error: error };
         }
 
-        return regex;
+        return { value: converted.value, error: null };
     }
 
-    /**
-     * 验证单个字段的值
-     */
-    private validateFieldValue(value: any, fieldDef: FieldDefinition, fieldName: string): ValidationError {
-        let { name, type, min, max, regexp } = fieldDef;
+    // ========== 私有方法 ==========
 
-        regexp = this.resolveRegexAlias(regexp);
+    /** 构建结果对象 */
+    private static buildResult(fieldErrors: Record<string, string>): ValidateResult {
+        const errors = Object.values(fieldErrors);
+        const errorFields = Object.keys(fieldErrors);
+        const failed = errors.length > 0;
 
-        switch (type.toLowerCase()) {
-            case 'number':
-                return this.validateNumber(value, name, min, max, regexp, fieldName);
-            case 'string':
-            case 'text':
-                return this.validateString(value, name, min, max, regexp, fieldName);
-            case 'array_string':
-            case 'array_text':
-                return this.validateArray(value, name, min, max, regexp, fieldName);
-            default:
-                return `字段 ${fieldName} 的类型 ${type} 不支持`;
-        }
+        return {
+            code: failed ? 1 : 0,
+            failed: failed,
+            firstError: failed ? errors[0] : null,
+            errors: errors,
+            errorFields: errorFields,
+            fieldErrors: fieldErrors
+        };
     }
 
-    /**
-     * 验证数字类型
-     */
-    private validateNumber(value: any, name: string, min: number | null, max: number | null, spec: string | null, fieldName: string): ValidationError {
-        try {
-            // 允许数字类型的字符串
-            let numValue = value;
-            if (typeof value === 'string') {
-                numValue = Number(value);
-                if (Number.isNaN(numValue) || !isFinite(numValue)) {
-                    return `${name}(${fieldName})必须是数字`;
-                }
-            } else if (typeof numValue !== 'number' || Number.isNaN(numValue) || !isFinite(numValue)) {
-                return `${name}(${fieldName})必须是数字`;
-            }
-
-            if (min !== null && numValue < min) {
-                return `${name}(${fieldName})不能小于${min}`;
-            }
-
-            if (max !== null && max > 0 && numValue > max) {
-                return `${name}(${fieldName})不能大于${max}`;
-            }
-
-            if (spec && spec.trim() !== '') {
-                try {
-                    const regExp = getCompiledRegex(spec);
-                    if (!regExp.test(String(numValue))) {
-                        return `${name}(${fieldName})格式不正确`;
-                    }
-                } catch (error: any) {
-                    return `${name}(${fieldName})的正则表达式格式错误`;
-                }
-            }
+    /** 验证单个字段 */
+    private static checkField(value: any, fieldDef: FieldDefinition, fieldName: string): string | null {
+        const label = fieldDef.name || fieldName;
 
-            return null;
-        } catch (error: any) {
-            return `${name}(${fieldName})验证出错: ${error.message}`;
+        const converted = this.convert(value, fieldDef.type);
+        if (converted.error) {
+            return `${label}${converted.error}`;
         }
-    }
 
-    /**
-     * 验证字符串类型
-     */
-    private validateString(value: any, name: string, min: number | null, max: number | null, spec: string | null, fieldName: string): ValidationError {
-        try {
-            if (typeof value !== 'string') {
-                return `${name}(${fieldName})必须是字符串`;
-            }
-
-            if (min !== null && value.length < min) {
-                return `${name}(${fieldName})长度不能少于${min}个字符`;
-            }
-
-            if (max !== null && max > 0 && value.length > max) {
-                return `${name}(${fieldName})长度不能超过${max}个字符`;
-            }
-
-            if (spec && spec.trim() !== '') {
-                try {
-                    const regExp = getCompiledRegex(spec);
-                    if (!regExp.test(value)) {
-                        return `${name}(${fieldName})格式不正确`;
-                    }
-                } catch (error: any) {
-                    return `${name}(${fieldName})的正则表达式格式错误`;
-                }
-            }
-
-            return null;
-        } catch (error: any) {
-            return `${name}(${fieldName})验证出错: ${error.message}`;
-        }
+        const error = this.checkRule(converted.value, fieldDef);
+        return error ? `${label}${error}` : null;
     }
 
-    /**
-     * 验证数组类型
-     */
-    private validateArray(value: any, name: string, min: number | null, max: number | null, spec: string | null, fieldName: string): ValidationError {
-        try {
-            if (!Array.isArray(value)) {
-                return `${name}(${fieldName})必须是数组`;
-            }
-
-            if (min !== null && value.length < min) {
-                return `${name}(${fieldName})至少需要${min}个元素`;
-            }
-
-            if (max !== null && max > 0 && value.length > max) {
-                return `${name}(${fieldName})最多只能有${max}个元素`;
-            }
-
-            if (spec && spec.trim() !== '') {
-                try {
-                    const regExp = getCompiledRegex(spec);
-                    for (const item of value) {
-                        if (!regExp.test(String(item))) {
-                            return `${name}(${fieldName})中的元素"${item}"格式不正确`;
-                        }
-                    }
-                } catch (error: any) {
-                    return `${name}(${fieldName})的正则表达式格式错误`;
+    /** 类型转换 */
+    private static convert(value: any, type: string): { value: any; error: string | null } {
+        switch (type.toLowerCase()) {
+            case 'number':
+                if (typeof value === 'number') {
+                    return Number.isNaN(value) || !isFinite(value) ? { value: null, error: '必须是有效数字' } : { value: value, error: null };
                 }
-            }
-
-            return null;
-        } catch (error: any) {
-            return `${name}(${fieldName})验证出错: ${error.message}`;
-        }
-    }
+                if (typeof value === 'string') {
+                    const num = Number(value);
+                    return Number.isNaN(num) || !isFinite(num) ? { value: null, error: '必须是数字' } : { value: num, error: null };
+                }
+                return { value: null, error: '必须是数字' };
 
-    /**
-     * 验证单个值（支持对象格式字段定义）
-     */
-    validateSingleValue(value: any, fieldDef: FieldDefinition): { valid: boolean; value: any; errors: string[] } {
-        let { name, type, min, max, regexp, default: defaultValue } = fieldDef;
+            case 'string':
+            case 'text':
+                return typeof value === 'string' ? { value: value, error: null } : { value: null, error: '必须是字符串' };
 
-        regexp = this.resolveRegexAlias(regexp);
+            case 'array_string':
+            case 'array_text':
+                return Array.isArray(value) ? { value: value, error: null } : { value: null, error: '必须是数组' };
 
-        // 处理 undefined/null 值，使用默认值
-        if (value === undefined || value === null) {
-            if (defaultValue !== null) {
-                if ((type === 'array_string' || type === 'array_text') && typeof defaultValue === 'string') {
-                    if (defaultValue === '[]') {
-                        return { valid: true, value: [], errors: [] };
-                    }
-                    try {
-                        const parsedArray = JSON.parse(defaultValue);
-                        if (Array.isArray(parsedArray)) {
-                            return { valid: true, value: parsedArray, errors: [] };
-                        }
-                    } catch {
-                        return { valid: true, value: [], errors: [] };
-                    }
-                }
-                // 数字类型默认值转换
-                if (type === 'number' && typeof defaultValue === 'string') {
-                    const numValue = Number(defaultValue);
-                    if (!isNaN(numValue)) {
-                        return { valid: true, value: numValue, errors: [] };
-                    }
-                }
-                return { valid: true, value: defaultValue, errors: [] };
-            }
-            if (type === 'number') {
-                return { valid: true, value: 0, errors: [] };
-            } else if (type === 'array_string' || type === 'array_text') {
-                return { valid: true, value: [], errors: [] };
-            } else if (type === 'string' || type === 'text') {
-                return { valid: true, value: '', errors: [] };
-            }
+            default:
+                return { value: value, error: null };
         }
+    }
 
-        const errors: string[] = [];
+    /** 规则验证 */
+    private static checkRule(value: any, fieldDef: FieldDefinition): string | null {
+        const { type, min, max, regexp } = fieldDef;
+        const regex = this.resolveRegex(regexp);
 
-        // 类型转换
-        let convertedValue = value;
-        if (type === 'number' && typeof value === 'string') {
-            convertedValue = Number(value);
-            if (isNaN(convertedValue)) {
-                errors.push(`${name || '值'}必须是有效的数字`);
-                return { valid: false, value: null, errors };
-            }
-        }
-
-        // 类型验证
         switch (type.toLowerCase()) {
             case 'number':
-                if (typeof convertedValue !== 'number' || Number.isNaN(convertedValue)) {
-                    errors.push(`${name || '值'}必须是数字`);
-                }
-                if (min !== null && convertedValue < min) {
-                    errors.push(`${name || '值'}不能小于${min}`);
-                }
-                if (max !== null && max > 0 && convertedValue > max) {
-                    errors.push(`${name || '值'}不能大于${max}`);
-                }
-                if (regexp && regexp.trim() !== '') {
-                    try {
-                        const regExp = getCompiledRegex(regexp);
-                        if (!regExp.test(String(convertedValue))) {
-                            errors.push(`${name || '值'}格式不正确`);
-                        }
-                    } catch (e: any) {
-                        errors.push(`${name || '值'}的正则表达式格式错误: ${e.message}`);
-                    }
-                }
+                if (min !== null && value < min) return `不能小于${min}`;
+                if (max !== null && max > 0 && value > max) return `不能大于${max}`;
+                if (regex && !this.testRegex(regex, String(value))) return '格式不正确';
                 break;
 
             case 'string':
             case 'text':
-                if (typeof convertedValue !== 'string') {
-                    errors.push(`${name || '值'}必须是字符串`);
-                }
-                if (min !== null && convertedValue.length < min) {
-                    errors.push(`${name || '值'}长度不能少于${min}个字符`);
-                }
-                if (max !== null && max > 0 && convertedValue.length > max) {
-                    errors.push(`${name || '值'}长度不能超过${max}个字符`);
-                }
-                if (regexp && regexp.trim() !== '') {
-                    try {
-                        const regExp = getCompiledRegex(regexp);
-                        if (!regExp.test(convertedValue)) {
-                            errors.push(`${name || '值'}格式不正确`);
-                        }
-                    } catch {
-                        errors.push(`${name || '值'}的正则表达式格式错误`);
-                    }
-                }
+                if (min !== null && value.length < min) return `长度不能少于${min}个字符`;
+                if (max !== null && max > 0 && value.length > max) return `长度不能超过${max}个字符`;
+                if (regex && !this.testRegex(regex, value)) return '格式不正确';
                 break;
 
             case 'array_string':
             case 'array_text':
-                if (!Array.isArray(convertedValue)) {
-                    errors.push(`${name || '值'}必须是数组`);
-                }
-                if (min !== null && convertedValue.length < min) {
-                    errors.push(`${name || '值'}元素数量不能少于${min}个`);
-                }
-                if (max !== null && max > 0 && convertedValue.length > max) {
-                    errors.push(`${name || '值'}元素数量不能超过${max}个`);
-                }
-                if (regexp && regexp.trim() !== '') {
-                    try {
-                        const regExp = getCompiledRegex(regexp);
-                        for (const item of convertedValue) {
-                            if (!regExp.test(String(item))) {
-                                errors.push(`${name || '值'}的元素格式不正确`);
-                                break;
-                            }
-                        }
-                    } catch {
-                        errors.push(`${name || '值'}的正则表达式格式错误`);
+                if (min !== null && value.length < min) return `至少需要${min}个元素`;
+                if (max !== null && max > 0 && value.length > max) return `最多只能有${max}个元素`;
+                if (regex) {
+                    for (const item of value) {
+                        if (!this.testRegex(regex, String(item))) return '元素格式不正确';
                     }
                 }
                 break;
         }
-
-        return {
-            valid: errors.length === 0,
-            value: errors.length === 0 ? convertedValue : null,
-            errors
-        };
+        return null;
     }
 
-    /**
-     * 静态方法：快速验证
-     */
-    static validate(data: Record<string, any>, rules: TableDefinition, required?: string[]): ValidationResult;
-    static validate(value: any, fieldDef: FieldDefinition): { valid: boolean; value: any; errors: string[] };
-    static validate(dataOrValue: any, rulesOrFieldDef: any, required?: string[]): any {
-        const validator = new Validator();
-
-        if (rulesOrFieldDef && 'type' in rulesOrFieldDef) {
-            return validator.validateSingleValue(dataOrValue, rulesOrFieldDef);
+    /** 解析正则别名 */
+    private static resolveRegex(regexp: string | null): string | null {
+        if (!regexp) return null;
+        if (regexp.startsWith('@')) {
+            return RegexAliases[regexp.substring(1)] || regexp;
         }
-
-        return validator.validate(dataOrValue, rulesOrFieldDef, required || []);
+        return regexp;
     }
 
-    /**
-     * 检查验证是否通过
-     */
-    static isPassed(result: ValidationResult | { valid: boolean; value: any; errors: string[] }): boolean {
-        if ('valid' in result) {
-            return result.valid === true;
+    /** 测试正则 */
+    private static testRegex(pattern: string, value: string): boolean {
+        try {
+            return getCompiledRegex(pattern).test(value);
+        } catch {
+            return false;
         }
-        return result.code === 0;
     }
 
-    /**
-     * 检查验证是否失败
-     */
-    static isFailed(result: ValidationResult): boolean {
-        return result.code === 1;
-    }
-
-    /**
-     * 获取第一个错误信息
-     */
-    static getFirstError(result: ValidationResult | { valid: boolean; value: any; errors: string[] }): string | null {
-        if ('valid' in result) {
-            return result.errors.length > 0 ? result.errors[0] : null;
+    /** 获取默认值 */
+    private static defaultFor(type: string, defaultValue: any): any {
+        if (defaultValue !== null && defaultValue !== undefined) {
+            // 数组默认值
+            if ((type === 'array_string' || type === 'array_text') && typeof defaultValue === 'string') {
+                if (defaultValue === '[]') return [];
+                try {
+                    const parsed = JSON.parse(defaultValue);
+                    return Array.isArray(parsed) ? parsed : [];
+                } catch {
+                    return [];
+                }
+            }
+            // 数字默认值
+            if (type === 'number' && typeof defaultValue === 'string') {
+                const num = Number(defaultValue);
+                return isNaN(num) ? 0 : num;
+            }
+            return defaultValue;
         }
-        if (result.code === 0) return null;
-        if (!result.fields) return null;
-        const errors = Object.values(result.fields);
-        return errors.length > 0 ? errors[0] : null;
-    }
 
-    /**
-     * 获取所有错误信息
-     */
-    static getAllErrors(result: ValidationResult | { valid: boolean; value: any; errors: string[] }): string[] {
-        if ('valid' in result) {
-            return result.errors;
+        // 类型默认值
+        switch (type.toLowerCase()) {
+            case 'number':
+                return 0;
+            case 'array_string':
+            case 'array_text':
+                return [];
+            default:
+                return '';
         }
-        if (result.code === 0) return [];
-        if (!result.fields) return [];
-        return Object.values(result.fields);
-    }
-
-    /**
-     * 获取错误字段列表
-     */
-    static getErrorFields(result: ValidationResult): string[] {
-        return result.code === 0 ? [] : Object.keys(result.fields);
     }
 }

package/loader/loadHooks.ts

@@ -7,17 +7,18 @@
 import { Logger } from '../lib/logger.js';
 import { coreHookDir } from '../paths.js';
 import { scanModules } from '../util.js';
+import { beflyConfig } from '../befly.config.js';
 
 // 类型导入
 import type { Hook } from '../types/hook.js';
 
-export async function loadHooks(pluginsConfig: Record<string, any> | undefined, hooks: Hook[]): Promise<void> {
+export async function loadHooks(hooks: Hook[]): Promise<void> {
     try {
         // 1. 扫描核心钩子
-        const coreHooks = await scanModules<Hook>(coreHookDir, 'core', '钩子', pluginsConfig);
+        const coreHooks = await scanModules<Hook>(coreHookDir, 'core', '钩子');
 
         // 2. 过滤禁用的钩子
-        const disableHooks = (pluginsConfig as any)?.disableHooks || [];
+        const disableHooks = beflyConfig.disableHooks || [];
         const enabledHooks = coreHooks.filter((hook) => !disableHooks.includes(hook.name));
 
         if (disableHooks.length > 0) {