befly 2.3.2 → 2.3.3

package/bin/befly.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env -S bun run
+// Befly CLI (Bun): 列出并执行 core/scripts 与 tpl/scripts 下的脚本
+
+import path from 'node:path';
+import { Glob } from 'bun';
+import { __dirscript as coreScriptsDir, getProjectDir } from '../system.js';
+
+// 解析目录（来自 system.js）
+// 核心脚本目录：core/scripts
+// 用户项目（如 tpl）的脚本目录：始终基于当前工作目录
+const tplScriptsDir = getProjectDir('scripts');
+
+function safeList(dir) {
+    try {
+        // 使用 Bun.Glob 查找当前目录下的所有 .js 文件（不递归）
+        const glob = new Glob('*.js');
+        const files = Array.from(glob.scanSync({ cwd: dir, absolute: false, onlyFiles: true, dot: false }));
+        return files.map((f) => path.basename(f, '.js')).sort();
+    } catch {
+        return [];
+    }
+}
+
+function buildScriptItems() {
+    const coreList = safeList(coreScriptsDir);
+    const tplList = safeList(tplScriptsDir);
+    const coreSet = new Set(coreList);
+
+    const items = [];
+    for (const name of coreList) {
+        items.push({
+            name: name,
+            source: 'core',
+            duplicate: tplList.includes(name),
+            path: path.resolve(coreScriptsDir, `${name}.js`)
+        });
+    }
+    for (const name of tplList) {
+        items.push({
+            name: name,
+            source: 'tpl',
+            duplicate: coreSet.has(name),
+            path: path.resolve(tplScriptsDir, `${name}.js`)
+        });
+    }
+    // 排序：名称字典序，core 在前
+    items.sort((a, b) => (a.name === b.name ? (a.source === b.source ? 0 : a.source === 'core' ? -1 : 1) : a.name.localeCompare(b.name)));
+    return items;
+}
+
+function printAllScripts() {
+    const items = buildScriptItems();
+    if (items.length === 0) {
+        console.log('  • <无>');
+        return;
+    }
+    for (const it of items) {
+        if (it.source === 'tpl' && it.duplicate) console.log(`  • ${it.name}（重复）`);
+        else console.log(`  • ${it.name}`);
+    }
+}
+
+async function resolveScriptPath(name) {
+    const base = name.endsWith('.js') ? name.slice(0, -3) : name;
+    const filename = `${base}.js`;
+    const corePath = path.resolve(coreScriptsDir, filename);
+    const tplPath = path.resolve(tplScriptsDir, filename);
+    if (await Bun.file(corePath).exists()) return corePath;
+    if (await Bun.file(tplPath).exists()) return tplPath;
+    // 回退到列表匹配（防止极端路径或大小写差异）
+    const items = buildScriptItems();
+    const hit = items.find((it) => it.name.toLowerCase() === base.toLowerCase() && it.source === 'core') || items.find((it) => it.name.toLowerCase() === base.toLowerCase());
+    return hit ? hit.path : null;
+}
+
+async function runScriptAtPath(targetPath, label, args = []) {
+    const bunExe = process.execPath || 'bun';
+    const child = Bun.spawn({
+        cmd: [bunExe, targetPath, ...args],
+        stdio: ['inherit', 'inherit', 'inherit'],
+        cwd: process.cwd(),
+        env: { ...process.env, LOG_TO_CONSOLE: '1' }
+    });
+    const code = await child.exited;
+    return code ?? 0;
+}
+
+async function main() {
+    const [, , cmd, ...args] = process.argv;
+    // 无参数：打印所有脚本
+    if (!cmd) {
+        printAllScripts();
+        process.exit(0);
+    }
+    // 按名称执行（将剩余参数透传给脚本）
+    const target = await resolveScriptPath(cmd);
+    if (!target) {
+        console.error(`未找到脚本: ${cmd}`);
+        printAllScripts();
+        process.exit(1);
+    }
+    const code = await runScriptAtPath(target, cmd, args);
+    process.exit(code ?? 0);
+}
+
+main().catch((e) => {
+    console.error('Befly CLI 执行失败:', e);
+    process.exit(1);
+});

package/checks/table.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { Logger } from '../utils/logger.js';
-import { parseFieldRule, validateFieldName, validateFieldType, validateMinMax, validateDefaultValue, validateIndex, validateRegex } from '../utils/index.js';
+import { parseRule } from '../utils/index.js';
 import { __dirtables, getProjectDir } from '../system.js';
 
 // 所有校验函数均复用 utils/index.js 导出的实现
@@ -65,8 +65,9 @@ export const checkTable = async () => {
                 const lowerCamelCaseRegex = /^[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/;
                 if (!lowerCamelCaseRegex.test(fileBaseName)) {
                     Logger.error(`${fileType}表 ${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
-                    // 命名不合规，直接标记为无效文件
-                    throw new Error('文件命名不符合小驼峰规范');
+                    // 命名不合规，按保留字段处理模式：记录错误并计为无效文件，继续下一个文件
+                    invalidFiles++;
+                    continue;
                 }
 
                 // 读取并解析 JSON 文件
@@ -75,126 +76,110 @@ export const checkTable = async () => {
                 let fileRules = 0;
 
                 // 检查 table 中的每个验证规则
-                for (const [fieldName, rule] of Object.entries(table)) {
-                    fileRules++;
-                    totalRules++;
-
-                    // 检查是否使用了保留字段
-                    if (reservedFields.includes(fieldName)) {
-                        Logger.error(`${fileType}表 ${fileName} 文件包含保留字段 ${fieldName}，不能在表定义中使用以下字段: ${reservedFields.join(', ')}`);
-                        fileValid = false;
-                        continue;
-                    }
-
+                for (const [colKey, rule] of Object.entries(table)) {
                     // 验证规则格式
                     try {
-                        const ruleParts = parseFieldRule(rule);
+                        fileRules++;
+                        totalRules++;
 
-                        if (ruleParts.length !== 7) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${fieldName} 验证规则错误，应包含 7 个部分，但包含 ${ruleParts.length} 个部分`);
+                        // 检查是否使用了保留字段
+                        if (reservedFields.includes(colKey)) {
+                            Logger.error(`${fileType}表 ${fileName} 文件包含保留字段 ${colKey}，不能在表定义中使用以下字段: ${reservedFields.join(', ')}`);
                             fileValid = false;
-                            continue;
                         }
 
-                        const [name, type, minStr, maxStr, defaultValue, isIndexStr, regexConstraint] = ruleParts;
+                        const allParts = rule.split('⚡');
+
+                        // 必须包含7个部分：显示名⚡类型⚡最小值⚡最大值⚡默认值⚡是否索引⚡正则约束
+                        if (allParts.length !== 7) {
+                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 字段规则格式错误，必须包含7个部分，当前包含${allParts.length}个部分`);
+                            fileValid = false;
+                        }
+
+                        const [fieldName, fieldType, fieldMin, fieldMax, fieldDefault, fieldIndex, fieldRegx] = allParts;
 
-                        // 使用新的验证函数进行严格验证
                         // 第1个值：名称必须为中文、数字、字母
-                        if (!validateFieldName(name)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 名称 "${name}" 格式错误，必须为中文、数字、字母`);
+                        if (!/^[\u4e00-\u9fa5a-zA-Z0-9 _-]+$/.test(fieldName)) {
+                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，必须为中文、数字、字母、下划线、短横线`);
                             fileValid = false;
-                            continue;
                         }
 
                         // 第2个值：字段类型必须为string,number,text,array之一
-                        if (!validateFieldType(type)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 类型 "${type}" 格式错误，必须为string、number、text、array之一`);
+                        if (!['string', 'number', 'text', 'array'].includes(fieldType)) {
+                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，必须为string、number、text、array之一`);
                             fileValid = false;
-                            continue;
                         }
 
-                        // 第3个值：最小值必须为null或数字
-                        if (!validateMinMax(minStr)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最小值 "${minStr}" 格式错误，必须为null或数字`);
+                        // 第3/4个值：需要是 null 或 数字（并包含最小值<=最大值的约束）
+                        if (!(fieldMin === 'null' || !Number.isNaN(Number(fieldMin)))) {
+                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 格式错误，必须为null或数字`);
+                            fileValid = false;
+                        }
+                        if (!(fieldMax === 'null' || !Number.isNaN(Number(fieldMax)))) {
+                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 最大值 "${fieldMax}" 格式错误，必须为null或数字`);
                             fileValid = false;
-                            continue;
                         }
 
-                        // 第4个值与类型联动校验
-                        if (type === 'text') {
-                            // text 类型：不允许设置最小/最大长度与默认值（均需为 null）
-                            if (minStr !== 'null') {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 的 text 类型最小值必须为 null，当前为 "${minStr}"`);
+                        // 约束：当最小值与最大值均为数字时，要求最小值 <= 最大值
+                        if (fieldMin !== 'null' && fieldMax !== 'null') {
+                            if (Number(fieldMin) > Number(fieldMax)) {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 不能大于最大值 "${fieldMax}"`);
                                 fileValid = false;
-                                continue;
                             }
-                            if (maxStr !== 'null') {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 的 text 类型最大长度必须为 null，当前为 "${maxStr}"`);
+                        }
+
+                        // 第6个值：是否创建索引必须为0或1
+                        if (fieldIndex !== '0' && fieldIndex !== '1') {
+                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 索引标识 "${fieldIndex}" 格式错误，必须为0或1`);
+                            fileValid = false;
+                        }
+
+                        // 第7个值：必须为null或正则表达式
+                        if (fieldRegx !== 'null') {
+                            try {
+                                // 仅尝试构造以校验有效性
+                                // eslint-disable-next-line no-new
+                                new RegExp(fieldRegx);
+                            } catch (_) {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 正则约束 "${fieldRegx}" 格式错误，必须为null或有效的正则表达式`);
                                 fileValid = false;
-                                continue;
                             }
-                        } else if (type === 'string') {
-                            // string：最大长度必为具体数字，且 1..65535
-                            if (maxStr === 'null' || !validateMinMax(maxStr)) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最大长度 "${maxStr}" 格式错误，string 类型必须为具体数字`);
+                        }
+
+                        // 第4个值与类型联动校验 + 默认值规则（精简实现）
+                        if (fieldType === 'text') {
+                            // text：min/max 必须为 null，默认值必须为 'null'
+                            if (fieldMin !== 'null') {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最小值必须为 null，当前为 "${fieldMin}"`);
                                 fileValid = false;
-                                continue;
                             }
-                            const maxVal = parseInt(maxStr, 10);
-                            if (!(maxVal > 0 && maxVal <= 65535)) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最大长度 ${maxStr} 越界，string 类型长度必须在 1..65535 范围内`);
+                            if (fieldMax !== 'null') {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最大长度必须为 null，当前为 "${fieldMax}"`);
                                 fileValid = false;
-                                continue;
                             }
-                        } else if (type === 'array') {
-                            // array：最大长度必为数字（用于JSON字符串长度限制）
-                            if (maxStr === 'null' || !validateMinMax(maxStr)) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最大长度 "${maxStr}" 格式错误，array 类型必须为具体数字`);
+                            if (fieldDefault !== 'null') {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 为 text 类型，默认值必须为 null，当前为 "${fieldDefault}"`);
                                 fileValid = false;
-                                continue;
                             }
-                        } else {
-                            // number 等其他：允许 null 或数字
-                            if (!validateMinMax(maxStr)) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最大值 "${maxStr}" 格式错误，必须为null或数字`);
+                        } else if (fieldType === 'string' || fieldType === 'array') {
+                            if (Number.isNaN(Number(fieldMax))) {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 为 string,array 类型，最大长度必须为数字，当前为 "${fieldMax}"`);
                                 fileValid = false;
-                                continue;
                             }
-                        }
-
-                        // 第5个值：默认值校验
-                        if (type === 'text') {
-                            // text 不允许默认值
-                            if (defaultValue !== 'null') {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 为 text 类型，默认值必须为 null，当前为 "${defaultValue}"`);
+                            const maxVal = parseInt(fieldMax, 10);
+                            if (maxVal > 65535) {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，string,array 类型长度必须在 1..65535 范围内`);
                                 fileValid = false;
-                                continue;
                             }
-                        } else {
-                            if (!validateDefaultValue(defaultValue)) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 默认值 "${defaultValue}" 格式错误，必须为null、字符串或数字`);
+                        } else if (fieldType === 'number') {
+                            if (Number.isNaN(Number(fieldDefault))) {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 为 number 类型，默认值必须为数字，当前为 "${fieldDefault}"`);
                                 fileValid = false;
-                                continue;
                             }
                         }
-
-                        // 第6个值：是否创建索引必须为0或1
-                        if (!validateIndex(isIndexStr)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 索引标识 "${isIndexStr}" 格式错误，必须为0或1`);
-                            fileValid = false;
-                            continue;
-                        }
-
-                        // 第7个值：必须为null或正则表达式
-                        if (!validateRegex(regexConstraint)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 正则约束 "${regexConstraint}" 格式错误，必须为null或有效的正则表达式`);
-                            fileValid = false;
-                            continue;
-                        }
                     } catch (error) {
-                        Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 验证规则解析失败: ${error.message}`);
+                        Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 验证规则解析失败: ${error.message}`);
                         fileValid = false;
-                        continue;
                     }
                 }
 

package/config/env.js

@@ -24,14 +24,16 @@ export const Env = {
     // 时区
     TZ: process.env.TZ,
     // 数据库配置
-    MYSQL_ENABLE: Number(process.env.MYSQL_ENABLE),
-    MYSQL_HOST: process.env.MYSQL_HOST,
-    MYSQL_PORT: Number(process.env.MYSQL_PORT),
-    MYSQL_DB: process.env.MYSQL_DB,
-    MYSQL_USER: process.env.MYSQL_USER,
-    MYSQL_PASSWORD: process.env.MYSQL_PASSWORD,
-    MYSQL_DEBUG: Number(process.env.MYSQL_DEBUG),
-    MYSQL_POOL_MAX: Number(process.env.MYSQL_POOL_MAX),
+    DB_ENABLE: Number(process.env.DB_ENABLE),
+    // 通用数据库连接参数
+    DB_TYPE: process.env.DB_TYPE, // sqlite | mysql | postgresql
+    DB_HOST: process.env.DB_HOST,
+    DB_PORT: Number(process.env.DB_PORT),
+    DB_USER: process.env.DB_USER,
+    DB_PASS: process.env.DB_PASS,
+    DB_NAME: process.env.DB_NAME,
+    DB_DEBUG: Number(process.env.DB_DEBUG),
+    DB_POOL_MAX: Number(process.env.DB_POOL_MAX),
     // Redis配置
     REDIS_URL: process.env.REDIS_URL,
     REDIS_ENABLE: Number(process.env.REDIS_ENABLE),

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "befly",
-    "version": "2.3.2",
-    "description": "Buma - 为 Bun 专属打造的 API 接口框架核心引擎",
+    "version": "2.3.3",
+    "description": "Befly - 为 Bun 专属打造的 API 接口框架核心引擎",
     "type": "module",
     "private": false,
     "publishConfig": {
@@ -12,11 +12,10 @@
     "exports": {
         ".": "./main.js"
     },
-    "scripts": {
-        "ra": "bun run ../release.js --major",
-        "rb": "bun run ../release.js --minor",
-        "rc": "bun run ../release.js --patch"
+    "bin": {
+        "befly": "./bin/befly.js"
     },
+    "scripts": {},
     "keywords": [
         "bun",
         "api",
@@ -31,6 +30,7 @@
     "homepage": "https://chensuiyi.me",
     "license": "Apache-2.0",
     "files": [
+        "bin/",
         "apis/",
         "checks/",
         "config/",
@@ -51,12 +51,5 @@
         "system.js",
         "package.json",
         "README.md"
-    ],
-    "simple-git-hooks": {
-        "pre-commit": "bunx --bun lint-staged"
-    },
-    "lint-staged": {
-        "*.{js,css,scss,less,ts,jsx,vue,html,json,md,yaml}": "bunx --bun prettier --write --cache --ignore-unknown"
-    },
-    "gitHead": "1dc5f118a723969456559e758e2ba889f4601224"
+    ]
 }

package/plugins/db.js

@@ -11,7 +11,7 @@ export default {
         let sql = null;
 
         try {
-            if (Env.MYSQL_ENABLE === 1) {
+            if (Env.DB_ENABLE === 1) {
                 // 创建 Bun SQL 客户端（内置连接池），并确保连接验证成功后再继续
                 sql = await createSqlClient();
 
@@ -20,7 +20,7 @@ export default {
 
                 return dbManager;
             } else {
-                Logger.warn(`MySQL 未启用，跳过初始化`);
+                Logger.warn(`数据库未启用（DB_ENABLE≠1），跳过初始化`);
                 return {};
             }
         } catch (error) {