befly 3.6.0 → 3.7.1

package/check.ts

@@ -0,0 +1,239 @@
+/**
+ * 表规则检查器 - TypeScript 版本
+ * 验证表定义文件的格式和规则
+ */
+
+import { basename } from 'pathe';
+import { Logger } from './lib/logger.js';
+import { parseRule } from './util.js';
+import { projectTableDir } from './paths.js';
+import { Addon } from './lib/addon.js';
+
+/**
+ * 表文件信息接口
+ */
+interface TableFileInfo {
+    /** 表文件路径 */
+    file: string;
+    /** 文件类型：project（项目）或 addon（组件） */
+    type: 'project' | 'addon';
+    /** 如果是 addon 类型，记录 addon 名称 */
+    addonName?: string;
+}
+
+/**
+ * 保留字段列表
+ */
+const RESERVED_FIELDS = ['id', 'created_at', 'updated_at', 'deleted_at', 'state'] as const;
+
+/**
+ * 允许的字段类型
+ */
+const FIELD_TYPES = ['string', 'number', 'text', 'array_string', 'array_text'] as const;
+
+/**
+ * 小驼峰命名正则
+ * 可选：以下划线开头（用于特殊文件，如通用字段定义）
+ * 必须以小写字母开头，后续可包含小写/数字，或多个 [大写+小写/数字] 片段
+ * 示例：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 _-]+$/;
+
+/**
+ * VARCHAR 最大长度限制
+ */
+const MAX_VARCHAR_LENGTH = 65535;
+
+/**
+ * 检查表定义文件
+ * @throws 当检查失败时抛出异常
+ */
+export const checkDefault = async function (): Promise<void> {
+    try {
+        const tablesGlob = new Bun.Glob('*.json');
+
+        // 统计信息
+        let totalFiles = 0;
+        let totalRules = 0;
+        let validFiles = 0;
+        let invalidFiles = 0;
+
+        // 收集所有表文件
+        const allTableFiles: TableFileInfo[] = [];
+
+        // 收集项目表字段定义文件
+        for await (const file of tablesGlob.scan({
+            cwd: projectTableDir,
+            absolute: true,
+            onlyFiles: true
+        })) {
+            allTableFiles.push({ file: file, type: 'project' });
+        }
+
+        // 收集 addon 表字段定义文件
+        const addons = Addon.scan();
+        for (const addonName of addons) {
+            const addonTablesDir = Addon.getDir(addonName, 'tables');
+
+            for await (const file of tablesGlob.scan({
+                cwd: addonTablesDir,
+                absolute: true,
+                onlyFiles: true
+            })) {
+                allTableFiles.push({ file: file, type: 'addon', addonName: addonName });
+            }
+        }
+
+        // 合并进行验证逻辑
+        for (const { file, type, addonName } of allTableFiles) {
+            totalFiles++;
+            const fileName = basename(file);
+            const fileBaseName = basename(file, '.json');
+            const fileType = type === 'project' ? '项目' : `组件${addonName}`;
+
+            try {
+                // 1) 文件名小驼峰校验
+                if (!LOWER_CAMEL_CASE_REGEX.test(fileBaseName)) {
+                    Logger.warn(`${fileType}表 ${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
+                    // 命名不合规，记录错误并计为无效文件，继续下一个文件
+                    invalidFiles++;
+                    continue;
+                }
+
+                // 读取并解析 JSON 文件
+                const table = await Bun.file(file).json();
+                let fileValid = true;
+                let fileRules = 0;
+
+                // 检查 table 中的每个验证规则
+                for (const [colKey, rule] of Object.entries(table)) {
+                    if (typeof rule !== 'string') {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 规则必须为字符串`);
+                        fileValid = false;
+                        continue;
+                    }
+
+                    // 验证规则格式
+                    fileRules++;
+                    totalRules++;
+
+                    // 检查是否使用了保留字段
+                    if (RESERVED_FIELDS.includes(colKey as any)) {
+                        Logger.warn(`${fileType}表 ${fileName} 文件包含保留字段 ${colKey}，` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(', ')}`);
+                        fileValid = false;
+                    }
+
+                    // 使用 parseRule 解析字段规则
+                    let parsed;
+                    try {
+                        parsed = parseRule(rule);
+                    } catch (error: any) {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段规则解析失败：${error.message}`);
+                        fileValid = false;
+                        continue;
+                    }
+
+                    const { name: fieldName, type: fieldType, min: fieldMin, max: fieldMax, default: fieldDefault, index: fieldIndex, regex: fieldRegx } = parsed;
+
+                    // 第1个值：名称必须为中文、数字、字母、下划线、短横线、空格
+                    if (!FIELD_NAME_REGEX.test(fieldName)) {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，` + `必须为中文、数字、字母、下划线、短横线、空格`);
+                        fileValid = false;
+                    }
+
+                    // 第2个值：字段类型必须为string,number,text,array_string,array_text之一
+                    if (!FIELD_TYPES.includes(fieldType as any)) {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，` + `必须为${FIELD_TYPES.join('、')}之一`);
+                        fileValid = false;
+                    }
+
+                    // 第3/4个值：需要是 null 或 数字
+                    if (!(fieldMin === null || typeof fieldMin === 'number')) {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 格式错误，必须为null或数字`);
+                        fileValid = false;
+                    }
+                    if (!(fieldMax === null || typeof fieldMax === 'number')) {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最大值 "${fieldMax}" 格式错误，必须为null或数字`);
+                        fileValid = false;
+                    }
+
+                    // 约束：当最小值与最大值均为数字时，要求最小值 <= 最大值
+                    if (fieldMin !== null && fieldMax !== null) {
+                        if (fieldMin > fieldMax) {
+                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 不能大于最大值 "${fieldMax}"`);
+                            fileValid = false;
+                        }
+                    }
+
+                    // 第6个值：是否创建索引必须为0或1
+                    if (fieldIndex !== 0 && fieldIndex !== 1) {
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 索引标识 "${fieldIndex}" 格式错误，必须为0或1`);
+                        fileValid = false;
+                    }
+
+                    // 第7个值：必须为null或正则表达式（parseRule已经验证过了）
+                    // parseRule 已经将正则字符串转换为 RegExp 或 null，这里不需要再验证
+
+                    // 第4个值与类型联动校验 + 默认值规则
+                    if (fieldType === 'text') {
+                        // text：min/max 必须为 null，默认值必须为 'null'
+                        if (fieldMin !== null) {
+                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最小值必须为 null，当前为 "${fieldMin}"`);
+                            fileValid = false;
+                        }
+                        if (fieldMax !== null) {
+                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最大长度必须为 null，当前为 "${fieldMax}"`);
+                            fileValid = false;
+                        }
+                        if (fieldDefault !== 'null') {
+                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 text 类型，默认值必须为 null，当前为 "${fieldDefault}"`);
+                            fileValid = false;
+                        }
+                    } else if (fieldType === 'string' || fieldType === 'array') {
+                        if (fieldMax === null || typeof fieldMax !== 'number') {
+                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，` + `最大长度必须为数字，当前为 "${fieldMax}"`);
+                            fileValid = false;
+                        } else if (fieldMax > MAX_VARCHAR_LENGTH) {
+                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，` + `${fieldType} 类型长度必须在 1..${MAX_VARCHAR_LENGTH} 范围内`);
+                            fileValid = false;
+                        }
+                    } else if (fieldType === 'number') {
+                        if (fieldDefault !== 'null' && typeof fieldDefault !== 'number') {
+                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或null，当前为 "${fieldDefault}"`);
+                            fileValid = false;
+                        }
+                    }
+                }
+
+                if (fileValid) {
+                    validFiles++;
+                    // Logger.info(`${fileType}表 ${fileName} 验证通过（${fileRules} 个字段）`);
+                } else {
+                    invalidFiles++;
+                }
+            } catch (error: any) {
+                Logger.error(`${fileType}表 ${fileName} 解析失败`, error);
+                invalidFiles++;
+            }
+        }
+
+        // 输出统计信息
+        // Logger.info(`  总文件数: ${totalFiles}`);
+        // Logger.info(`  总规则数: ${totalRules}`);
+        // Logger.info(`  通过文件: ${validFiles}`);
+        // Logger.info(`  失败文件: ${invalidFiles}`);
+
+        if (invalidFiles > 0) {
+            throw new Error('表定义检查失败，请修复上述错误后重试');
+        }
+    } catch (error: any) {
+        Logger.error('数据表定义检查过程中出错', error);
+        throw error;
+    }
+};

package/lib/database.ts

@@ -94,7 +94,7 @@ export class Database {
             Logger.error('数据库连接测试失败', error);
 
             try {
-                await sql.close();
+                await sql?.close();
             } catch (cleanupError) {}
 
             throw error;
@@ -109,7 +109,7 @@ export class Database {
             try {
                 await this.sqlClient.close();
             } catch (error: any) {
-                Logger.warn('关闭 SQL 连接时出错:', error.message);
+                Logger.error('关闭 SQL 连接时出错', error);
             }
             this.sqlClient = null;
         }
@@ -200,7 +200,7 @@ export class Database {
             try {
                 this.redisClient.close();
             } catch (error: any) {
-                Logger.warn('关闭 Redis 连接时出错:', error);
+                Logger.error('关闭 Redis 连接时出错', error);
             }
             this.redisClient = null;
         }

package/lib/dbHelper.ts

@@ -410,7 +410,7 @@ export class DbHelper {
         try {
             processed.id = await this.befly.redis.genTimeID();
         } catch (error: any) {
-            throw new Error(`生成 ID 失败，Redis 可能不可用 (table: ${table}): ${error.message}`);
+            throw new Error(`生成 ID 失败，Redis 可能不可用 (table: ${table})`, error);
         }
 
         // 强制生成时间戳（不可被用户覆盖）
@@ -634,7 +634,7 @@ export class DbHelper {
                     await conn.query('ROLLBACK');
                     Logger.warn('事务已回滚');
                 } catch (rollbackError: any) {
-                    Logger.error('事务回滚失败:', rollbackError);
+                    Logger.error('事务回滚失败', rollbackError);
                 }
             }
             throw error;

package/lib/middleware.ts

@@ -132,8 +132,8 @@ export async function parsePostParams(api: ApiRoute, ctx: RequestContext): Promi
         }
 
         return true;
-    } catch (err: any) {
-        Logger.error('处理请求参数时发生错误', err);
+    } catch (error: any) {
+        Logger.error('处理请求参数时发生错误', error);
         return false;
     }
 }

package/lifecycle/checker.ts

@@ -4,6 +4,7 @@
  */
 
 import { join, basename } from 'pathe';
+import { existsSync, statSync } from 'node:fs';
 import { Logger } from '../lib/logger.js';
 import { calcPerfTime } from '../util.js';
 import { projectCheckDir } from '../paths.js';
@@ -36,8 +37,10 @@ export class Checker {
             // 检查目录列表：先项目，后 addons
             const checkDirs: Array<{ path: string; type: 'app' | 'addon'; addonName?: string }> = [];
 
-            // 添加项目 checks 目录
-            checkDirs.push({ path: projectCheckDir, type: 'app' });
+            // 添加项目 checks 目录（如果存在）
+            if (existsSync(projectCheckDir) && statSync(projectCheckDir).isDirectory()) {
+                checkDirs.push({ path: projectCheckDir, type: 'app' });
+            }
 
             // 添加所有 addon 的 checks 目录
             const addons = Addon.scan();

package/lifecycle/lifecycle.ts

@@ -53,7 +53,6 @@ export class Lifecycle {
 
         // 4. 启动 HTTP 服务器
         const totalStartupTime = calcPerfTime(serverStartTime);
-        Logger.info(`✓ 服务器启动准备完成，总耗时: ${totalStartupTime}`);
 
         return await Bootstrap.start(
             {

package/lifecycle/loader.ts

@@ -145,7 +145,6 @@ export class Loader {
                 }
             }
             const corePluginsInitTime = calcPerfTime(corePluginsInitStart);
-            Logger.info(`✓ 核心插件加载完成: ${corePlugins.length} 个，耗时: ${corePluginsScanTime}`);
 
             // 扫描 addon 插件目录
             const addons = Addon.scan();
@@ -213,7 +212,6 @@ export class Loader {
                         }
                     }
                     const addonPluginsInitTime = calcPerfTime(addonPluginsInitStart);
-                    Logger.info(`✓ 组件插件加载完成: ${addonPlugins.length} 个，耗时: ${addonPluginsScanTime}`);
                 }
             }
 
@@ -276,12 +274,10 @@ export class Loader {
                     }
                 }
                 const userPluginsInitTime = calcPerfTime(userPluginsInitStart);
-                Logger.info(`✓ 用户插件加载完成: ${sortedUserPlugins.length} 个，耗时: ${userPluginsInitTime}`);
             }
 
             const totalLoadTime = calcPerfTime(loadStartTime);
             const totalPluginCount = sortedCorePlugins.length + addonPlugins.length + sortedUserPlugins.length;
-            Logger.info(`✓ 所有插件加载完成: ${totalPluginCount} 个，总耗时: ${totalLoadTime}`);
 
             // 核心插件失败 → 关键错误，必须退出
             if (hadCorePluginError) {
@@ -413,7 +409,6 @@ export class Loader {
             }
 
             const totalLoadTime = calcPerfTime(loadStartTime);
-            Logger.info(`✓ ${dirDisplayName}接口加载完成: ${loadedApis}/${totalApis}，耗时: ${totalLoadTime}`);
 
             // 检查是否有加载失败的 API（理论上不会到达这里，因为上面已经 critical 退出）
             if (failedApis > 0) {

package/main.ts

@@ -14,6 +14,7 @@ import { coreDir } from './paths.js';
 import { DbHelper } from './lib/dbHelper.js';
 import { RedisHelper } from './lib/redisHelper.js';
 import { Addon } from './lib/addon.js';
+import { checkDefault } from './check.js';
 
 import type { Server } from 'bun';
 import type { BeflyContext, BeflyOptions } from './types/befly.js';
@@ -40,23 +41,20 @@ export class Befly {
     async listen(callback?: (server: Server) => void): Promise<Server> {
         const server = await this.lifecycle.start(this.appContext, callback);
 
-        // 注册优雅关闭信号处理器
         const gracefulShutdown = async (signal: string) => {
-            Logger.info(`\n收到 ${signal} 信号，开始优雅关闭...`);
-
             // 1. 停止接收新请求
             server.stop(true);
-            Logger.info('✅ HTTP 服务器已停止');
+            Logger.info('HTTP 服务器已停止');
 
             // 2. 关闭数据库连接
             try {
                 await Database.disconnect();
-                Logger.info('✅ 数据库连接已关闭');
+                Logger.info('数据库连接已关闭');
             } catch (error: any) {
-                Logger.warn('⚠️ 关闭数据库连接时出错:', error.message);
+                Logger.err('关闭数据库连接时出错:', error);
             }
 
-            Logger.info('✅ 服务器已优雅关闭');
+            Logger.info('服务器已优雅关闭');
             process.exit(0);
         };
 
@@ -76,9 +74,10 @@ export {
     Jwt,
     Yes,
     No,
-    coreDir,
     Database,
     DbHelper,
     RedisHelper,
-    Addon
+    Addon,
+    coreDir,
+    checkDefault
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.6.0",
+    "version": "3.7.1",
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "type": "module",
     "private": false,
@@ -38,14 +38,10 @@
     "homepage": "https://chensuiyi.me",
     "license": "Apache-2.0",
     "files": [
-        "apis/",
-        "checks/",
-        "config/",
         "lib/",
         "lifecycle/",
         "plugins/",
         "router/",
-        "tables/",
         "types/",
         ".gitignore",
         ".npmignore",
@@ -58,8 +54,8 @@
         "tsconfig.json",
         "LICENSE",
         "main.ts",
+        "check.ts",
         "env.ts",
-        "entry.ts",
         "menu.json",
         "paths.ts",
         "util.ts",
@@ -73,5 +69,5 @@
         "es-toolkit": "^1.41.0",
         "pathe": "^2.0.3"
     },
-    "gitHead": "e6d6cd5dd4098fc9b4cf537b0dcdc7e781c0e80e"
+    "gitHead": "131c2482f3668346adbbd153e14d5b74cd19e725"
 }

package/plugins/cache.ts

@@ -176,7 +176,6 @@ const cachePlugin: Plugin = {
     async onInit(befly: BeflyContext): Promise<CacheManager> {
         try {
             const cacheManager = new CacheManager(befly);
-            Logger.info('缓存插件初始化成功');
             return cacheManager;
         } catch (error: any) {
             throw error;

package/plugins/db.ts

@@ -33,7 +33,6 @@ const dbPlugin: Plugin = {
                 // 创建数据库管理器实例，直接传入 sql 对象
                 const dbManager = new DbHelper(befly, sql);
 
-                Logger.info('数据库插件初始化成功');
                 return dbManager;
             } else {
                 Logger.warn('数据库未启用（DB_ENABLE≠1），跳过初始化');

package/plugins/logger.ts

@@ -16,7 +16,6 @@ const loggerPlugin: Plugin = {
 
     async onInit(befly: BeflyContext): Promise<typeof Logger> {
         try {
-            Logger.info('日志插件初始化成功');
             return Logger;
         } catch (error: any) {
             // 插件内禁止直接退出进程，抛出异常交由主流程统一处理

package/plugins/redis.ts

@@ -23,12 +23,6 @@ const redisPlugin: Plugin = {
                 // 初始化 Redis 客户端（统一使用 database.ts 的连接管理）
                 await Database.connectRedis();
 
-                Logger.info('Redis 插件初始化成功', {
-                    host: Env.REDIS_HOST,
-                    port: Env.REDIS_PORT,
-                    db: Env.REDIS_DB
-                });
-
                 // 返回工具对象，向下游以相同 API 暴露
                 return RedisHelper;
             } else {

package/router/api.ts

@@ -115,7 +115,7 @@ export function apiHandler(apiRoutes: Map<string, ApiRoute>, pluginLists: Plugin
             }
         } catch (error: any) {
             // 记录详细的错误日志
-            Logger.warn(api ? `接口 [${api.name}] 执行失败` : '处理接口请求时发生错误', error);
+            Logger.error(api ? `接口 [${api.name}] 执行失败` : '处理接口请求时发生错误', error);
 
             return Response.json(No('内部服务器错误'), {
                 headers: corsOptions.headers

package/entry.ts

@@ -1,9 +0,0 @@
-/**
- * Befly 默认入口文件
- * 当用户项目没有自定义 main.ts 时使用此文件
- */
-
-import { Befly } from 'befly';
-
-const app = new Befly();
-await app.listen();