befly 2.0.14 → 2.1.0

package/utils/validate.js

@@ -1,28 +1,95 @@
 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('|');
+    const allParts = rule.split('⚡');
 
-    // 现在支持7个部分：显示名|类型|最小值|最大值|默认值|是否索引|正则约束
-    if (allParts.length <= 7) {
-        // 如果少于7个部分，补齐缺失的部分为 null
-        while (allParts.length < 7) {
-            allParts.push('null');
-        }
-        return allParts;
+    // 必须包含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或数字`);
     }
 
-    // 如果超过7个部分，保留前6个，剩余的合并为最后的正则约束部分
-    return [
-        allParts[0], // 显示名
-        allParts[1], // 类型
-        allParts[2], // 最小值
-        allParts[3], // 最大值
-        allParts[4], // 默认值
-        allParts[5], // 是否索引
-        allParts.slice(6).join('|') // 正则约束（可能包含管道符）
-    ];
+    // 第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;
 };
 
 /**
@@ -161,94 +228,20 @@ export class Validator {
             }
 
             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}`;
-        }
-    }
-
-    /**
-     * 判断是否为枚举格式
-     */
-    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 `${name}(${fieldName})验证出错: ${error.message}`;
         }
-
-        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;
     }
 
     /**
@@ -269,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}`;
         }
     }
 
@@ -305,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/USEAGE.md

@@ -1,5 +0,0 @@
-## 接口参数定义
-
-> 名称#类型#最小值#最大值#表达式
-
-如果`类型`为`number`，`表达式`可以为`x*3=2`的形式。

package/bin/befly.js

@@ -1,176 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Befly CLI 工具
- * 提供命令行接口来执行 befly 框架的各种脚本
- */
-
-import { spawn } from 'node:child_process';
-import { resolve, join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { existsSync, readFileSync } from 'node:fs';
-import { readdir } from 'node:fs/promises';
-import { __dirroot, __dirscript } from '../system.js';
-
-// 使用 system.js 中定义的路径变量
-const BEFLY_ROOT = __dirroot;
-const SCRIPTS_DIR = __dirscript;
-
-// 显示帮助信息
-const showHelp = async () => {
-    console.log(`
-Befly CLI 工具 v2.0.12
-
-用法:
-  befly <script-name> [args...]
-
-可用的脚本:
-`);
-
-    // 列出所有可用的脚本
-    if (existsSync(SCRIPTS_DIR)) {
-        try {
-            const fileList = await readdir(SCRIPTS_DIR);
-            const scripts = fileList
-                .filter((file) => file.endsWith('.js'))
-                .map((file) => file.replace('.js', ''))
-                .sort();
-
-            if (scripts.length > 0) {
-                scripts.forEach((script) => {
-                    console.log(`  befly ${script}`);
-                });
-            } else {
-                console.log('  (没有找到可用的脚本)');
-            }
-        } catch (error) {
-            console.log(`  (无法读取脚本目录: ${error.message})`);
-        }
-    } else {
-        console.log('  (脚本目录不存在)');
-    }
-
-    console.log(`
-选项:
-  -h, --help               显示此帮助信息
-  -v, --version            显示版本信息
-
-更多信息请访问: https://chensuiyi.me
-`);
-};
-
-// 显示版本信息
-const showVersion = () => {
-    try {
-        const packageJsonPath = join(BEFLY_ROOT, 'package.json');
-        if (existsSync(packageJsonPath)) {
-            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-            console.log(`befly v${packageJson.version}`);
-        } else {
-            console.log('befly v2.0.12');
-        }
-    } catch (error) {
-        console.log('befly v2.0.12');
-    }
-};
-
-// 执行脚本
-const runScript = (scriptName, args = []) => {
-    // 检查脚本文件是否存在
-    const scriptPath = join(SCRIPTS_DIR, `${scriptName}.js`);
-
-    if (!existsSync(scriptPath)) {
-        console.error(`❌ 错误: 脚本 '${scriptName}' 不存在`);
-        console.error(`脚本路径: ${scriptPath}`);
-        console.error('');
-        console.error('运行 "befly --help" 查看可用的脚本列表');
-        process.exit(1);
-    }
-
-    console.log(`🚀 执行脚本: ${scriptName}`);
-    console.log(`📁 脚本路径: ${scriptPath}`);
-
-    // 检测运行环境，优先使用 bun，回退到 node
-    const isWindows = process.platform === 'win32';
-    let runtime = 'bun';
-    let runtimeArgs = ['run'];
-
-    // 如果 bun 不可用，回退到 node
-    const testBun = spawn(isWindows ? 'bun.exe' : 'bun', ['--version'], {
-        stdio: 'ignore',
-        shell: isWindows
-    });
-
-    testBun.on('error', () => {
-        runtime = 'node';
-        runtimeArgs = [];
-    });
-
-    testBun.on('close', (code) => {
-        if (code !== 0) {
-            runtime = 'node';
-            runtimeArgs = [];
-        }
-
-        console.log(`⚡ 使用运行时: ${runtime}`);
-        console.log('');
-
-        // 执行脚本
-        const child = spawn(isWindows ? `${runtime}.exe` : runtime, [...runtimeArgs, scriptPath, ...args], {
-            stdio: 'inherit',
-            shell: isWindows,
-            cwd: process.cwd() // 使用调用者的工作目录
-        });
-
-        child.on('error', (error) => {
-            console.error(`❌ 执行失败: ${error.message}`);
-            process.exit(1);
-        });
-
-        child.on('close', (code) => {
-            if (code !== 0) {
-                console.error(`❌ 脚本执行失败，退出码: ${code}`);
-                process.exit(code);
-            } else {
-                console.log(`✅ 脚本执行完成`);
-            }
-        });
-    });
-};
-
-// 主函数
-const main = async () => {
-    const args = process.argv.slice(2);
-
-    // 没有参数或请求帮助
-    if (args.length === 0 || args.includes('-h') || args.includes('--help')) {
-        await showHelp();
-        return;
-    }
-
-    // 显示版本
-    if (args.includes('-v') || args.includes('--version')) {
-        showVersion();
-        return;
-    }
-
-    // 执行脚本
-    const scriptName = args[0];
-    const scriptArgs = args.slice(1);
-
-    runScript(scriptName, scriptArgs);
-};
-
-// 错误处理
-process.on('uncaughtException', (error) => {
-    console.error('❌ 未捕获的异常:', error.message);
-    process.exit(1);
-});
-
-process.on('unhandledRejection', (reason, promise) => {
-    console.error('❌ 未处理的 Promise 拒绝:', reason);
-    process.exit(1);
-});
-
-// 启动 CLI
-main();