befly 3.8.8 → 3.8.10

package/.prettierignore

@@ -0,0 +1,2 @@
+LICENSE
+LICENSE.md

package/.prettierrc

@@ -0,0 +1,12 @@
+{
+    "trailingComma": "none",
+    "tabWidth": 4,
+    "semi": true,
+    "singleQuote": true,
+    "printWidth": 1024,
+    "bracketSpacing": true,
+    "useTabs": false,
+    "arrowParens": "always",
+    "endOfLine": "lf",
+    "plugins": ["@prettier/plugin-oxc"]
+}

package/bunfig.toml

@@ -0,0 +1,3 @@
+[install]
+# 使用隔离模式
+linker = "isolated"

package/check.ts

@@ -63,6 +63,7 @@ export const checkTable = async function (): Promise<boolean> {
 
         // 收集所有表文件
         const allTableFiles: TableFileInfo[] = [];
+        let hasError = false;
 
         // 收集项目表字段定义文件
         for await (const file of tablesGlob.scan({
@@ -105,6 +106,7 @@ export const checkTable = async function (): Promise<boolean> {
                 // 1) 文件名小驼峰校验
                 if (!LOWER_CAMEL_CASE_REGEX.test(fileBaseName)) {
                     Logger.warn(`${item.typeName}表 ${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
+                    hasError = true;
                     continue;
                 }
 
@@ -116,12 +118,14 @@ export const checkTable = async function (): Promise<boolean> {
                 for (const [colKey, fieldDef] of Object.entries(table)) {
                     if (typeof fieldDef !== 'object' || fieldDef === null || Array.isArray(fieldDef)) {
                         Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 规则必须为对象`);
+                        hasError = true;
                         continue;
                     }
 
                     // 检查是否使用了保留字段
                     if (RESERVED_FIELDS.includes(colKey as any)) {
                         Logger.warn(`${item.typeName}表 ${fileName} 文件包含保留字段 ${colKey}，` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(', ')}`);
+                        hasError = true;
                     }
 
                     // 直接使用字段对象
@@ -130,37 +134,47 @@ export const checkTable = async function (): Promise<boolean> {
                     // 检查必填字段：name, type
                     if (!field.name || typeof field.name !== 'string') {
                         Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 缺少必填字段 name 或类型错误`);
+                        hasError = true;
                         continue;
                     }
                     if (!field.type || typeof field.type !== 'string') {
                         Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 缺少必填字段 type 或类型错误`);
+                        hasError = true;
                         continue;
                     }
 
                     // 检查可选字段的类型
                     if (field.min !== undefined && !(field.min === null || typeof field.min === 'number')) {
                         Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 min 类型错误，必须为 null 或数字`);
+                        hasError = true;
                     }
                     if (field.max !== undefined && !(field.max === null || typeof field.max === 'number')) {
                         Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 max 类型错误，必须为 null 或数字`);
+                        hasError = true;
                     }
                     if (field.detail !== undefined && typeof field.detail !== 'string') {
                         Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 detail 类型错误，必须为字符串`);
+                        hasError = true;
                     }
                     if (field.index !== undefined && typeof field.index !== 'boolean') {
                         Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 index 类型错误，必须为布尔值`);
+                        hasError = true;
                     }
                     if (field.unique !== undefined && typeof field.unique !== 'boolean') {
                         Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 unique 类型错误，必须为布尔值`);
+                        hasError = true;
                     }
                     if (field.nullable !== undefined && typeof field.nullable !== 'boolean') {
                         Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 nullable 类型错误，必须为布尔值`);
+                        hasError = true;
                     }
                     if (field.unsigned !== undefined && typeof field.unsigned !== 'boolean') {
                         Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 unsigned 类型错误，必须为布尔值`);
+                        hasError = true;
                     }
                     if (field.regexp !== undefined && field.regexp !== null && typeof field.regexp !== 'string') {
                         Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 regexp 类型错误，必须为 null 或字符串`);
+                        hasError = true;
                     }
 
                     const { name: fieldName, type: fieldType, min: fieldMin, max: fieldMax, default: fieldDefault } = field;
@@ -168,17 +182,20 @@ export const checkTable = async function (): Promise<boolean> {
                     // 字段名称必须为中文、数字、字母、下划线、短横线、空格
                     if (!FIELD_NAME_REGEX.test(fieldName)) {
                         Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，` + `必须为中文、数字、字母、下划线、短横线、空格`);
+                        hasError = true;
                     }
 
                     // 字段类型必须为string,number,text,array_string,array_text之一
                     if (!FIELD_TYPES.includes(fieldType as any)) {
                         Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，` + `必须为${FIELD_TYPES.join('、')}之一`);
+                        hasError = true;
                     }
 
                     // 约束：当最小值与最大值均为数字时，要求最小值 <= 最大值
                     if (fieldMin !== undefined && fieldMax !== undefined && fieldMin !== null && fieldMax !== null) {
                         if (fieldMin > fieldMax) {
                             Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 不能大于最大值 "${fieldMax}"`);
+                            hasError = true;
                         }
                     }
 
@@ -187,32 +204,39 @@ export const checkTable = async function (): Promise<boolean> {
                         // text：min/max 应该为 null，默认值必须为 null
                         if (fieldMin !== undefined && fieldMin !== null) {
                             Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 的 text 类型最小值应为 null，当前为 "${fieldMin}"`);
+                            hasError = true;
                         }
                         if (fieldMax !== undefined && fieldMax !== null) {
                             Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 的 text 类型最大长度应为 null，当前为 "${fieldMax}"`);
+                            hasError = true;
                         }
                         if (fieldDefault !== undefined && fieldDefault !== null) {
                             Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 为 text 类型，默认值必须为 null，当前为 "${fieldDefault}"`);
+                            hasError = true;
                         }
                     } else if (fieldType === 'string' || fieldType === 'array_string') {
                         if (fieldMax !== undefined && (fieldMax === null || typeof fieldMax !== 'number')) {
                             Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，` + `最大长度必须为数字，当前为 "${fieldMax}"`);
+                            hasError = true;
                         } else if (fieldMax !== undefined && fieldMax > MAX_VARCHAR_LENGTH) {
                             Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，` + `${fieldType} 类型长度必须在 1..${MAX_VARCHAR_LENGTH} 范围内`);
+                            hasError = true;
                         }
                     } else if (fieldType === 'number') {
                         // number 类型：default 如果存在，必须为 null 或 number
                         if (fieldDefault !== undefined && fieldDefault !== null && typeof fieldDefault !== 'number') {
                             Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或 null，当前为 "${fieldDefault}"`);
+                            hasError = true;
                         }
                     }
                 }
             } catch (error: any) {
                 Logger.error(`${item.typeName}表 ${fileName} 解析失败`, error);
+                hasError = true;
             }
         }
 
-        return true;
+        return !hasError;
     } catch (error: any) {
         Logger.error('数据表定义检查过程中出错', error);
         return false;

package/env.ts

@@ -22,7 +22,6 @@ const coreEnv: EnvConfig = {
     DEV_EMAIL: 'dev@qq.com',
     DEV_PASSWORD: '123456',
     BODY_LIMIT: 10485760, // 10MB
-    PARAMS_CHECK: false,
 
     // ========== 日志配置 ==========
     LOG_DEBUG: 0,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.8.8",
+    "version": "3.8.10",
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "type": "module",
     "private": false,
@@ -40,13 +40,9 @@
     "files": [
         "lib/",
         "loader/",
-        "middleware/",
+        "plugins/",
         "router/",
         "types/",
-        ".gitignore",
-        ".npmignore",
-        ".bunignore",
-        ".editorconfig",
         ".npmrc",
         ".prettierignore",
         ".prettierrc",
@@ -56,11 +52,11 @@
         "main.ts",
         "check.ts",
         "env.ts",
-        "menu.json",
         "paths.ts",
         "util.ts",
         "package.json",
-        "README.md"
+        "README.md",
+        "LICENSE"
     ],
     "engines": {
         "bun": ">=1.3.0"
@@ -69,5 +65,5 @@
         "es-toolkit": "^1.41.0",
         "pathe": "^2.0.3"
     },
-    "gitHead": "c8c0c2b5e7905cf3a01b77fd3d87b8f225fa9254"
+    "gitHead": "492e46d692787e6d141659fba27c26e030cd1181"
 }

package/plugins/cache.ts

@@ -0,0 +1,22 @@
+/**
+ * 缓存插件 - TypeScript 版本
+ * 负责在服务器启动时缓存接口、菜单和角色权限到 Redis
+ */
+
+import { CacheHelper } from '../lib/cacheHelper.js';
+import type { Plugin } from '../types/plugin.js';
+import type { BeflyContext } from '../types/befly.js';
+
+/**
+ * 缓存插件
+ */
+const cachePlugin: Plugin = {
+    name: '_cache',
+    after: ['_db', '_redis'],
+
+    async onInit(befly: BeflyContext): Promise<CacheHelper> {
+        return new CacheHelper(befly);
+    }
+};
+
+export default cachePlugin;

package/plugins/db.ts

@@ -0,0 +1,59 @@
+/**
+ * 数据库插件 - TypeScript 版本
+ * 初始化数据库连接和 SQL 管理器
+ */
+
+import { Env } from '../env.js';
+import { Logger } from '../lib/logger.js';
+import { Database } from '../lib/database.js';
+import { DbHelper } from '../lib/dbHelper.js';
+import type { Plugin } from '../types/plugin.js';
+import type { BeflyContext } from '../types/befly.js';
+
+/**
+ * 数据库插件
+ */
+const dbPlugin: Plugin = {
+    name: '_db',
+    after: ['_redis'],
+
+    async onInit(befly: BeflyContext): Promise<DbHelper | Record<string, never>> {
+        let sql: any = null;
+
+        try {
+            if (Env.DB_ENABLE === 1) {
+                // 创建 Bun SQL 客户端（内置连接池），并确保连接验证成功后再继续
+                // 从环境变量读取连接超时配置
+                const connectionTimeout = Env.DB_CONNECTION_TIMEOUT ? parseInt(Env.DB_CONNECTION_TIMEOUT) : 30000;
+
+                sql = await Database.connectSql({
+                    connectionTimeout
+                });
+
+                // 创建数据库管理器实例，直接传入 sql 对象
+                const dbManager = new DbHelper(befly, sql);
+
+                return dbManager;
+            } else {
+                Logger.warn('数据库未启用（DB_ENABLE≠1），跳过初始化');
+                return {};
+            }
+        } catch (error: any) {
+            Logger.error('数据库初始化失败', error);
+
+            // 清理资源
+            if (sql) {
+                try {
+                    await sql.close();
+                } catch (cleanupError: any) {
+                    Logger.error('清理连接池失败:', cleanupError);
+                }
+            }
+
+            // 插件内禁止直接退出进程，抛出异常交由主流程统一处理
+            throw error;
+        }
+    }
+};
+
+export default dbPlugin;

package/plugins/logger.ts

@@ -0,0 +1,27 @@
+/**
+ * 日志插件 - TypeScript 版本
+ * 提供全局日志功能
+ */
+
+import { Logger } from '../lib/logger.js';
+import type { Plugin } from '../types/plugin.js';
+import type { BeflyContext } from '../types/befly.js';
+
+/**
+ * 日志插件
+ */
+const loggerPlugin: Plugin = {
+    name: '_logger',
+    after: [],
+
+    async onInit(befly: BeflyContext): Promise<typeof Logger> {
+        try {
+            return Logger;
+        } catch (error: any) {
+            // 插件内禁止直接退出进程，抛出异常交由主流程统一处理
+            throw error;
+        }
+    }
+};
+
+export default loggerPlugin;

package/plugins/redis.ts

@@ -0,0 +1,41 @@
+/**
+ * Redis 插件 - TypeScript 版本
+ * 初始化 Redis 连接和助手工具
+ */
+
+import { Env } from '../env.js';
+import { Logger } from '../lib/logger.js';
+import { RedisHelper } from '../lib/redisHelper.js';
+import { Database } from '../lib/database.js';
+import type { Plugin } from '../types/plugin.js';
+import type { BeflyContext } from '../types/befly.js';
+
+/**
+ * Redis 插件
+ */
+const redisPlugin: Plugin = {
+    name: '_redis',
+    after: ['_logger'],
+
+    async onInit(befly: BeflyContext): Promise<RedisHelper | Record<string, never>> {
+        try {
+            if (Env.REDIS_ENABLE === 1) {
+                // 初始化 Redis 客户端（统一使用 database.ts 的连接管理）
+                await Database.connectRedis();
+
+                // 返回 RedisHelper 实例
+                return new RedisHelper();
+            } else {
+                Logger.warn('Redis 未启用，跳过初始化');
+                return {};
+            }
+        } catch (error: any) {
+            Logger.error('Redis 初始化失败', error);
+
+            // 插件内禁止直接退出进程，抛出异常交由主流程统一处理
+            throw error;
+        }
+    }
+};
+
+export default redisPlugin;