befly 2.0.12 → 2.1.0

package/utils/validate.js

@@ -1,4 +1,96 @@
-import { ruleSplit, isType } from './util.js';
+import { isType } from './util.js';
+
+// 验证字段名称是否为中文、数字、字母
+const validateFieldName = (name) => {
+    const nameRegex = /^[\u4e00-\u9fa5a-zA-Z0-9]+$/;
+    return nameRegex.test(name);
+};
+
+// 验证字段类型是否为指定的四种类型之一
+const validateFieldType = (type) => {
+    const validTypes = ['string', 'number', 'text', 'array'];
+    return validTypes.includes(type);
+};
+
+// 验证最小值/最大值是否为null或数字
+const validateMinMax = (value) => {
+    return value === 'null' || (!isNaN(parseFloat(value)) && isFinite(parseFloat(value)));
+};
+
+// 验证默认值是否为null、字符串或数字
+const validateDefaultValue = (value) => {
+    if (value === 'null') return true;
+    // 检查是否为数字
+    if (!isNaN(parseFloat(value)) && isFinite(parseFloat(value))) return true;
+    // 其他情况视为字符串，都是有效的
+    return true;
+};
+
+// 验证索引标识是否为0或1
+const validateIndex = (value) => {
+    return value === '0' || value === '1';
+};
+
+// 验证正则表达式是否有效
+const validateRegex = (value) => {
+    if (value === 'null') return true;
+    try {
+        new RegExp(value);
+        return true;
+    } catch (e) {
+        return false;
+    }
+};
+
+// 专门用于处理⚡分隔的字段规则
+const parseFieldRule = (rule) => {
+    const allParts = rule.split('⚡');
+
+    // 必须包含7个部分：显示名⚡类型⚡最小值⚡最大值⚡默认值⚡是否索引⚡正则约束
+    if (allParts.length !== 7) {
+        throw new Error(`字段规则格式错误，必须包含7个部分，当前包含${allParts.length}个部分`);
+    }
+
+    // 验证各个部分的格式
+    const [name, type, minValue, maxValue, defaultValue, isIndex, regexConstraint] = allParts;
+
+    // 第1个值：名称必须为中文、数字、字母
+    if (!validateFieldName(name)) {
+        throw new Error(`字段名称 "${name}" 格式错误，必须为中文、数字、字母`);
+    }
+
+    // 第2个值：字段类型必须为string,number,text,array之一
+    if (!validateFieldType(type)) {
+        throw new Error(`字段类型 "${type}" 格式错误，必须为string、number、text、array之一`);
+    }
+
+    // 第3个值：最小值必须为null或数字
+    if (!validateMinMax(minValue)) {
+        throw new Error(`最小值 "${minValue}" 格式错误，必须为null或数字`);
+    }
+
+    // 第4个值：最大值必须为null或数字
+    if (!validateMinMax(maxValue)) {
+        throw new Error(`最大值 "${maxValue}" 格式错误，必须为null或数字`);
+    }
+
+    // 第5个值：默认值必须为null、字符串或数字
+    if (!validateDefaultValue(defaultValue)) {
+        throw new Error(`默认值 "${defaultValue}" 格式错误，必须为null、字符串或数字`);
+    }
+
+    // 第6个值：是否创建索引必须为0或1
+    if (!validateIndex(isIndex)) {
+        throw new Error(`索引标识 "${isIndex}" 格式错误，必须为0或1`);
+    }
+
+    // 第7个值：必须为null或正则表达式
+    if (!validateRegex(regexConstraint)) {
+        throw new Error(`正则约束 "${regexConstraint}" 格式错误，必须为null或有效的正则表达式`);
+    }
+
+    return allParts;
+};
 
 /**
  * 验证器类
@@ -63,7 +155,7 @@ export class Validator {
         for (const fieldName of required) {
             if (!(fieldName in data) || data[fieldName] === undefined || data[fieldName] === null || data[fieldName] === '') {
                 result.code = 1;
-                const ruleParts = rules[fieldName]?.split(',') || [];
+                const ruleParts = parseFieldRule(rules[fieldName] || '');
                 const fieldLabel = ruleParts[0] || fieldName;
                 result.fields[fieldName] = `${fieldLabel}(${fieldName})为必填项`;
             }
@@ -99,16 +191,18 @@ export class Validator {
      * 验证单个字段的值
      */
     validateFieldValue(value, rule, fieldName) {
-        const [name, type, minStr, maxStr, specStr] = ruleSplit(rule);
+        const [name, type, minStr, maxStr, defaultValue, isIndexStr, regexConstraint] = parseFieldRule(rule);
         const min = minStr === 'null' ? null : parseInt(minStr) || 0;
         const max = maxStr === 'null' ? null : parseInt(maxStr) || 0;
-        const spec = specStr === 'null' ? null : specStr.trim();
+        const spec = regexConstraint === 'null' ? null : regexConstraint.trim();
 
         switch (type.toLowerCase()) {
             case 'number':
                 return this.validateNumber(value, name, min, max, spec, fieldName);
             case 'string':
                 return this.validateString(value, name, min, max, spec, fieldName);
+            case 'text':
+                return this.validateString(value, name, min, max, spec, fieldName);
             case 'array':
                 return this.validateArray(value, name, min, max, spec, fieldName);
             default:
@@ -129,101 +223,27 @@ export class Validator {
                 return `${name}(${fieldName})不能小于${min}`;
             }
 
-            if (min !== null && max > 0 && value > max) {
+            if (max !== null && max > 0 && value > max) {
                 return `${name}(${fieldName})不能大于${max}`;
             }
 
             if (spec && spec.trim() !== '') {
-                // 检查是否为枚举格式
-                if (this.isEnumSpec(spec)) {
-                    return this.validateEnum(value, spec, name, fieldName, 'number');
-                } else {
-                    // 原有的表达式验证逻辑
-                    return this.validateNumberExpression(value, name, spec, fieldName);
+                try {
+                    const regExp = new RegExp(spec);
+                    if (!regExp.test(String(value))) {
+                        return `${name}(${fieldName})格式不正确`;
+                    }
+                } catch (error) {
+                    return `${name}(${fieldName})的正则表达式格式错误`;
                 }
             }
 
             return null;
         } catch (error) {
-            return `${name}(${fieldName})的计算规则格式错误: ${error.message}`;
+            return `${name}(${fieldName})验证出错: ${error.message}`;
         }
     }
 
-    /**
-     * 判断是否为枚举格式
-     */
-    isEnumSpec(spec) {
-        return spec && spec.startsWith('enum#');
-    }
-
-    /**
-     * 验证枚举值
-     */
-    validateEnum(value, spec, name, fieldName, type) {
-        // 解析枚举值 "enum#1,2,3" -> ["1", "2", "3"]
-        const enumValues = spec
-            .substring(5)
-            .split(',')
-            .map((v) => v.trim());
-
-        if (type === 'number') {
-            // 数字类型：转换枚举值为数字进行比较
-            const numericEnumValues = enumValues.map((v) => parseFloat(v));
-            if (!numericEnumValues.includes(value)) {
-                return `${name}(${fieldName})必须是以下值之一: ${enumValues.join(', ')}`;
-            }
-        } else if (type === 'string') {
-            // 字符串类型：直接比较
-            if (!enumValues.includes(value)) {
-                return `${name}(${fieldName})必须是以下值之一: ${enumValues.join(', ')}`;
-            }
-        } else if (type === 'array') {
-            // 数组类型：检查每个元素是否在枚举值中
-            for (const item of value) {
-                if (!enumValues.includes(String(item))) {
-                    return `${name}(${fieldName})中的元素"${item}"必须是以下值之一: ${enumValues.join(', ')}`;
-                }
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * 验证数字表达式
-     */
-    validateNumberExpression(value, name, spec, fieldName) {
-        const parts = spec.split('=');
-        if (parts.length !== 2) {
-            return `${name}(${fieldName})的计算规则必须包含等号`;
-        }
-
-        const leftExpression = parts[0].trim();
-        const rightValue = parseFloat(parts[1].trim());
-
-        if (isNaN(rightValue)) {
-            return `${name}(${fieldName})的计算规则右边必须是数字`;
-        }
-
-        const safePattern = /^[x\d\+\-\*\/\(\)\.\s]+$/;
-        if (!safePattern.test(leftExpression)) {
-            return `${name}(${fieldName})的表达式包含不安全的字符`;
-        }
-
-        let processedExpression = leftExpression.replace(/x/g, value.toString());
-        const leftResult = new Function('return ' + processedExpression)();
-
-        if (typeof leftResult !== 'number' || !isFinite(leftResult)) {
-            return `${name}(${fieldName})的表达式计算结果不是有效数字`;
-        }
-
-        if (Math.abs(leftResult - rightValue) > Number.EPSILON) {
-            return `${name}(${fieldName})不满足计算条件 ${spec}`;
-        }
-
-        return null;
-    }
-
     /**
      * 验证字符串类型
      */
@@ -242,21 +262,19 @@ export class Validator {
             }
 
             if (spec && spec.trim() !== '') {
-                // 检查是否为枚举格式
-                if (this.isEnumSpec(spec)) {
-                    return this.validateEnum(value, spec, name, fieldName, 'string');
-                } else {
-                    // 原有的正则表达式验证逻辑
+                try {
                     const regExp = new RegExp(spec);
                     if (!regExp.test(value)) {
                         return `${name}(${fieldName})格式不正确`;
                     }
+                } catch (error) {
+                    return `${name}(${fieldName})的正则表达式格式错误`;
                 }
             }
 
             return null;
         } catch (error) {
-            return `${name}(${fieldName})的正则表达式格式错误`;
+            return `${name}(${fieldName})验证出错: ${error.message}`;
         }
     }
 
@@ -278,23 +296,21 @@ export class Validator {
             }
 
             if (spec && spec.trim() !== '') {
-                // 检查是否为枚举格式
-                if (this.isEnumSpec(spec)) {
-                    return this.validateEnum(value, spec, name, fieldName, 'array');
-                } else {
-                    // 原有的正则表达式验证逻辑
+                try {
                     const regExp = new RegExp(spec);
                     for (const item of value) {
                         if (!regExp.test(String(item))) {
                             return `${name}(${fieldName})中的元素"${item}"格式不正确`;
                         }
                     }
+                } catch (error) {
+                    return `${name}(${fieldName})的正则表达式格式错误`;
                 }
             }
 
             return null;
         } catch (error) {
-            return `${name}(${fieldName})的正则表达式格式错误: ${error.message}`;
+            return `${name}(${fieldName})验证出错: ${error.message}`;
         }
     }
 }

package/checks/schema.js

@@ -1,132 +0,0 @@
-import path from 'node:path';
-import { ruleSplit } from '../utils/util.js';
-import { Logger } from '../utils/Logger.js';
-
-export default async () => {
-    try {
-        const schemaGlob = new Bun.Glob('*.json');
-        const coreSchemaDir = path.join(__dirname, '..', 'schema');
-        const userSchemaDir = path.join(process.cwd(), 'schema');
-
-        // 统计信息
-        let totalFiles = 0;
-        let totalRules = 0;
-        let validFiles = 0;
-        let invalidFiles = 0;
-
-        const validateFile = async (file) => {
-            totalFiles++;
-            const fileName = path.basename(file);
-            try {
-                // 读取并解析 JSON 文件
-                const schema = await Bun.file(file).json();
-                let fileValid = true;
-                let fileRules = 0;
-
-                // 检查 schema 中的每个验证规则
-                for (const [fieldName, rule] of Object.entries(schema)) {
-                    fileRules++;
-                    totalRules++;
-
-                    // 验证规则格式
-                    const ruleParts = ruleSplit(rule);
-
-                    if (ruleParts.length !== 5) {
-                        Logger.warn(`${fileName} 文件 ${fieldName} 验证规则错误，应包含 5 个部分，但包含 ${ruleParts.length} 个部分`);
-                        fileValid = false;
-                        continue;
-                    }
-
-                    const [name, type, minStr, maxStr, spec] = ruleParts;
-
-                    // 验证类型（必须严格使用小写类型名称）
-                    const validTypes = ['number', 'string', 'array'];
-                    if (!validTypes.includes(type)) {
-                        Logger.warn(`${fileName} 文件 ${fieldName} 类型 ${type} 不支持，应为小写的 number、string 或 array`);
-                        fileValid = false;
-                        continue;
-                    }
-
-                    // 验证最小值/最大值
-                    if (minStr !== 'null' && isNaN(parseInt(minStr))) {
-                        Logger.warn(`${fileName} 文件 ${fieldName} 最小值 ${minStr} 应为数字或 "null"`);
-                        fileValid = false;
-                        continue;
-                    }
-
-                    if (maxStr !== 'null' && isNaN(parseInt(maxStr))) {
-                        Logger.warn(`${fileName} 文件 ${fieldName} 最大值 ${maxStr} 应为数字或 "null"`);
-                        fileValid = false;
-                        continue;
-                    }
-
-                    // 验证特殊规则
-                    if (spec !== 'null') {
-                        if (type === 'number' && spec.includes('=')) {
-                            // 数字计算表达式应包含安全字符
-                            const safePattern = /^[x\d\+\-\*\/\(\)\.\s\%]+$/;
-                            const expressionPart = spec.split('=')[0].trim();
-
-                            if (!safePattern.test(expressionPart)) {
-                                Logger.warn(`${fileName} 文件 ${fieldName} 表达式 ${expressionPart} 包含不安全的字符`);
-                                fileValid = false;
-                                continue;
-                            }
-
-                            // 验证等号右侧是否为数字
-                            const rightPart = spec.split('=')[1].trim();
-                            if (isNaN(parseFloat(rightPart))) {
-                                Logger.error(`${fileName} 文件 ${fieldName} 计算规则右边必须是数字，而不是 ${rightPart}`);
-                                fileValid = false;
-                                continue;
-                            }
-                        } else if (type === 'string' || type === 'array') {
-                            // 尝试编译正则表达式以检查是否有效
-                            try {
-                                new RegExp(spec);
-                            } catch (e) {
-                                Logger.error(`${fileName} 文件 ${fieldName} 正则表达式 ${spec} 无效: ${e.message}`);
-                                fileValid = false;
-                                continue;
-                            }
-                        }
-                    }
-                }
-
-                if (fileValid) {
-                    validFiles++;
-                } else {
-                    invalidFiles++;
-                }
-            } catch (error) {
-                Logger.error(`Schema ${fileName} 解析失败: ${error.message}`);
-                invalidFiles++;
-            }
-        };
-
-        for await (const file of schemaGlob.scan({
-            cwd: coreSchemaDir,
-            absolute: true,
-            onlyFiles: true
-        })) {
-            await validateFile(file);
-        }
-
-        for await (const file of schemaGlob.scan({
-            cwd: userSchemaDir,
-            absolute: true,
-            onlyFiles: true
-        })) {
-            await validateFile(file);
-        }
-
-        if (invalidFiles > 0) {
-            return false;
-        } else {
-            return true;
-        }
-    } catch (error) {
-        Logger.error(`Schema 检查过程中出错:`, error);
-        return false;
-    }
-};

package/schema/common.json

@@ -1,17 +0,0 @@
-{
-    "id": "ID,number,1,999999999,x%2=0",
-    "email": "邮箱,string,5,100,^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
-    "phone": "手机号,string,11,11,^1[3-9]\\d{9}$",
-    "page": "页码,number,1,9999,null",
-    "limit": "每页数量,number,1,100,null",
-    "title": "标题,string,1,200,null",
-    "description": "描述,string,0,500,null",
-    "keyword": "关键词,string,1,50,null",
-    "status": "状态,string,1,20,null",
-    "enabled": "启用状态,number,0,1,null",
-    "date": "日期,string,10,10,^\\d{4}-\\d{2}-\\d{2}$",
-    "datetime": "日期时间,string,19,25,^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}",
-    "filename": "文件名,string,1,255,null",
-    "url": "网址,string,5,500,^https?://",
-    "tag": "标签,array,0,10,null"
-}

package/schema/debug.json

@@ -1 +0,0 @@
-{}

package/schema/health.json

@@ -1 +0,0 @@
-{}

package/schema/tool.json

@@ -1,6 +0,0 @@
-{
-    "filename": "文件名,string,1,255,null",
-    "content": "内容,string,0,1000000,null",
-    "type": "类型,string,0,50,null",
-    "path": "路径,string,1,500,null"
-}