befly 3.8.31 → 3.8.33

package/befly.config.ts

@@ -0,0 +1,90 @@
+/**
+ * Befly 配置模块
+ * 自动加载 configs 目录下的配置文件并与默认配置合并
+ * 支持环境分离：befly.common.json + befly.dev/prod.json + befly.local.json
+ */
+import { scanConfig } from 'befly-shared/scanConfig';
+
+import type { BeflyOptions } from './types/befly.js';
+
+/** 默认配置 */
+const defaultOptions: BeflyOptions = {
+    // ========== 核心参数 ==========
+    nodeEnv: (process.env.NODE_ENV as any) || 'development',
+    appName: '野蜂飞舞',
+    appPort: 3000,
+    appHost: '127.0.0.1',
+    devEmail: 'dev@qq.com',
+    devPassword: 'beflydev123456',
+    bodyLimit: 1048576, // 1MB
+    tz: 'Asia/Shanghai',
+
+    // ========== 日志配置 ==========
+    logger: {
+        debug: 1,
+        excludeFields: 'password,token,secret',
+        dir: './logs',
+        console: 1,
+        maxSize: 10485760 // 10MB
+    },
+
+    // ========== 数据库配置 ==========
+    db: {
+        type: 'mysql',
+        host: '127.0.0.1',
+        port: 3306,
+        username: 'root',
+        password: 'root',
+        database: 'befly_demo',
+        poolMax: 10
+    },
+
+    // ========== Redis 配置 ==========
+    redis: {
+        host: '127.0.0.1',
+        port: 6379,
+        username: '',
+        password: '',
+        db: 0,
+        prefix: 'befly_demo:'
+    },
+
+    // ========== 认证配置 ==========
+    auth: {
+        secret: 'befly-secret',
+        expiresIn: '7d',
+        algorithm: 'HS256'
+    },
+
+    // ========== CORS 配置 ==========
+    cors: {
+        origin: '*',
+        methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
+        allowedHeaders: 'Content-Type,Authorization',
+        exposedHeaders: '',
+        maxAge: 86400,
+        credentials: 'true'
+    },
+
+    // ========== 禁用配置 ==========
+    disableHooks: [],
+    disablePlugins: [],
+    hiddenMenus: [],
+
+    // ========== Addon 配置 ==========
+    addons: {}
+};
+
+// 确定环境
+const nodeEnv = process.env.NODE_ENV || 'development';
+const envSuffix = nodeEnv === 'production' ? 'prod' : 'dev';
+
+// 使用 scanConfig 一次性加载并合并所有配置文件
+// 合并顺序：defaultOptions ← befly.common.json ← befly.dev/prod.json ← befly.local.json
+export const beflyConfig = (await scanConfig({
+    dirs: ['configs'],
+    files: ['befly.common', `befly.${envSuffix}`, 'befly.local'],
+    extensions: ['.json'],
+    mode: 'merge',
+    defaults: defaultOptions
+})) as BeflyOptions;

package/lib/redisHelper.ts

@@ -86,53 +86,42 @@ export class RedisHelper {
 
     /**
      * 生成基于时间的唯一 ID
-     * 格式: 秒级时间戳(10位) + 4位自增 = 14位纯数字
-     * 容量: 10000/秒 = 864,000,000/天
-     * 范围: 到 2286年9月
-     * @returns 唯一 ID (14位纯数字)
+     * 格式: 毫秒时间戳(13位) + 3位自增 = 16位纯数字
+     * 容量: 1000/毫秒 = 1,000,000/秒
+     * 范围: 到 2286年
+     * @returns 唯一 ID (16位纯数字)
      */
     async genTimeID(): Promise<number> {
-        const timestamp = Math.floor(Date.now() / 1000); // 秒级时间戳
-        const key = `${this.prefix}time_id_counter:${timestamp}`;
-
-        const counter = await this.client.incr(key);
-        await this.client.expire(key, 1);
-
-        const counterSuffix = (counter % 10000).toString().padStart(4, '0');
-
-        return Number(`${timestamp}${counterSuffix}`);
+        const ids = await this.genTimeIDBatch(1);
+        return ids[0];
     }
 
     /**
      * 批量生成基于时间的唯一 ID
-     * 格式: 秒级时间戳(10位) + 4位自增 = 14位纯数字
+     * 格式: 毫秒时间戳(13位) + 3位自增 = 16位纯数字
      * @param count - 需要生成的 ID 数量
-     * @returns ID 数组 (14位纯数字)
+     * @returns ID 数组 (16位纯数字)
      */
     async genTimeIDBatch(count: number): Promise<number[]> {
         if (count <= 0) {
             return [];
         }
 
-        // 限制单次批量生成数量（每秒最多10000个）
-        const MAX_BATCH_SIZE = 10000;
+        const MAX_BATCH_SIZE = 1000;
         if (count > MAX_BATCH_SIZE) {
             throw new Error(`批量大小 ${count} 超过最大限制 ${MAX_BATCH_SIZE}`);
         }
 
-        const timestamp = Math.floor(Date.now() / 1000); // 秒级时间戳
+        const timestamp = Date.now();
         const key = `${this.prefix}time_id_counter:${timestamp}`;
-
-        // 使用 INCRBY 一次性获取 N 个连续计数
-        const startCounter = await this.client.incrby(key, count);
+        const endCounter = await this.client.incrby(key, count);
         await this.client.expire(key, 1);
 
-        // 生成 ID 数组
         const ids: number[] = [];
         for (let i = 0; i < count; i++) {
-            const counter = startCounter - count + i + 1; // 计算每个 ID 的计数值
-            const counterSuffix = (counter % 10000).toString().padStart(4, '0');
-            ids.push(Number(`${timestamp}${counterSuffix}`));
+            const counter = endCounter - count + i + 1;
+            const suffix = (counter % 1000).toString().padStart(3, '0');
+            ids.push(Number(`${timestamp}${suffix}`));
         }
 
         return ids;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.8.31",
+    "version": "3.8.33",
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "type": "module",
     "private": false,
@@ -50,15 +50,15 @@
         ".npmrc",
         ".prettierignore",
         ".prettierrc",
+        "befly.config.ts",
         "bunfig.toml",
-        "config.ts",
         "LICENSE",
         "main.ts",
         "paths.ts",
         "package.json",
         "README.md",
         "tsconfig.json",
-        "LICENSE"
+        "util.ts"
     ],
     "engines": {
         "bun": ">=1.3.0"
@@ -67,13 +67,13 @@
         "befly-shared": "^1.1.2",
         "chalk": "^5.6.2",
         "es-toolkit": "^1.42.0",
-        "fast-jwt": "^6.0.2",
+        "fast-jwt": "^6.1.0",
         "fast-xml-parser": "^5.3.2",
         "pathe": "^2.0.3",
         "pino": "^10.1.0",
         "pino-roll": "^4.0.0"
     },
-    "gitHead": "d9a4c57539f6eb692d7db6c7fd800e021891a07c",
+    "gitHead": "d470173b6ce7461cf8b66adbebe2ec7888e7b32d",
     "devDependencies": {
         "typescript": "^5.9.3"
     }

package/sync/syncDb/table.ts

@@ -124,7 +124,7 @@ export async function modifyTable(sql: SQL, tableName: string, fields: Record<st
             }
         } else {
             const lenPart = isStringOrArrayType(fieldDef.type) ? ` 长度:${parseInt(String(fieldDef.max))}` : '';
-            Logger.debug(`  + 新增字段 ${dbFieldName} (${fieldDef.type}${lenPart})`);
+            // Logger.debug(`  + 新增字段 ${dbFieldName} (${fieldDef.type}${lenPart})`);
             addClauses.push(generateDDLClause(fieldKey, fieldDef, true));
             changed = true;
         }

package/tests/redisHelper.test.ts

@@ -461,7 +461,7 @@ describe('RedisHelper - ID 生成', () => {
         expect(typeof id1).toBe('number');
         expect(typeof id2).toBe('number');
         expect(id1).not.toBe(id2);
-        expect(id1.toString().length).toBe(14);
+        expect(id1.toString().length).toBe(16);
     });
 
     test('genTimeIDBatch - 批量生成 ID', async () => {
@@ -469,7 +469,7 @@ describe('RedisHelper - ID 生成', () => {
 
         expect(ids.length).toBe(10);
         expect(ids.every((id) => typeof id === 'number')).toBe(true);
-        expect(ids.every((id) => id.toString().length === 14)).toBe(true);
+        expect(ids.every((id) => id.toString().length === 16)).toBe(true);
 
         // 验证 ID 唯一性
         const uniqueIds = new Set(ids);
@@ -483,7 +483,7 @@ describe('RedisHelper - ID 生成', () => {
 
     test('genTimeIDBatch - 超过最大限制', async () => {
         try {
-            await redis.genTimeIDBatch(10001);
+            await redis.genTimeIDBatch(1001);
             expect(true).toBe(false); // 不应该执行到这里
         } catch (error: any) {
             expect(error.message).toContain('超过最大限制');

package/util.ts

@@ -0,0 +1,283 @@
+/**
+ * 核心工具函数
+ */
+
+// 内部依赖
+import { existsSync } from 'node:fs';
+
+/**
+ * 进程角色信息
+ */
+export interface ProcessRole {
+    /** 进程角色：primary（主进程）或 worker（工作进程） */
+    role: 'primary' | 'worker';
+    /** 实例 ID（PM2 或 Bun Worker） */
+    instanceId: string | null;
+    /** 运行环境：bun-cluster、pm2-cluster 或 standalone */
+    env: 'bun-cluster' | 'pm2-cluster' | 'standalone';
+}
+
+/**
+ * 获取当前进程角色信息
+ * @returns 进程角色、实例 ID 和运行环境
+ */
+export function getProcessRole(): ProcessRole {
+    const bunWorkerId = process.env.BUN_WORKER_ID;
+    const pm2InstanceId = process.env.PM2_INSTANCE_ID;
+
+    // Bun 集群模式
+    if (bunWorkerId !== undefined) {
+        return {
+            role: bunWorkerId === '' ? 'primary' : 'worker',
+            instanceId: bunWorkerId || '0',
+            env: 'bun-cluster'
+        };
+    }
+
+    // PM2 集群模式
+    if (pm2InstanceId !== undefined) {
+        return {
+            role: pm2InstanceId === '0' ? 'primary' : 'worker',
+            instanceId: pm2InstanceId,
+            env: 'pm2-cluster'
+        };
+    }
+
+    // 单进程模式
+    return {
+        role: 'primary',
+        instanceId: null,
+        env: 'standalone'
+    };
+}
+
+/**
+ * 检测当前进程是否为主进程
+ * 用于集群模式下避免重复执行同步任务
+ * - Bun 集群：BUN_WORKER_ID 为空时是主进程
+ * - PM2 集群：PM2_INSTANCE_ID 为 '0' 或不存在时是主进程
+ * @returns 是否为主进程
+ */
+export function isPrimaryProcess(): boolean {
+    return getProcessRole().role === 'primary';
+}
+
+// 外部依赖
+import { camelCase } from 'es-toolkit/string';
+import { scanFiles } from 'befly-shared/scanFiles';
+
+// 相对导入
+import { Logger } from './lib/logger.js';
+
+// 类型导入
+import type { Plugin } from './types/plugin.js';
+import type { Hook } from './types/hook.js';
+import type { CorsConfig, BeflyContext } from './types/befly.js';
+import type { RequestContext } from './types/context.js';
+import type { PluginRequestHook, Next } from './types/plugin.js';
+
+/**
+ * 创建错误响应（专用于 Hook 中间件）
+ * 在钩子中提前拦截请求时使用
+ * @param ctx - 请求上下文
+ * @param msg - 错误消息
+ * @param code - 错误码，默认 1
+ * @param data - 附加数据，默认 null
+ * @param detail - 详细信息，用于标记具体提示位置，默认 null
+ * @returns Response 对象
+ */
+export function ErrorResponse(ctx: RequestContext, msg: string, code: number = 1, data: any = null, detail: any = null): Response {
+    // 记录拦截日志
+    if (ctx.requestId) {
+        const duration = Date.now() - ctx.now;
+        const user = ctx.user?.id ? `[User:${ctx.user.id}]` : '[Guest]';
+        Logger.info(`[${ctx.requestId}] ${ctx.route} ${user} ${duration}ms [${msg}]`);
+    }
+
+    return Response.json(
+        {
+            code: code,
+            msg: msg,
+            data: data,
+            detail: detail
+        },
+        {
+            headers: ctx.corsHeaders
+        }
+    );
+}
+
+/**
+ * 创建最终响应（专用于 API 路由结尾）
+ * 自动处理 ctx.response/ctx.result，并记录请求日志
+ * @param ctx - 请求上下文
+ * @returns Response 对象
+ */
+export function FinalResponse(ctx: RequestContext): Response {
+    // 记录请求日志
+    if (ctx.api && ctx.requestId) {
+        const duration = Date.now() - ctx.now;
+        const user = ctx.user?.id ? `[User:${ctx.user.id}]` : '[Guest]';
+        Logger.info(`[${ctx.requestId}] ${ctx.route} ${user} ${duration}ms`);
+    }
+
+    // 1. 如果已经有 response，直接返回
+    if (ctx.response) {
+        return ctx.response;
+    }
+
+    // 2. 如果有 result，格式化为响应
+    if (ctx.result !== undefined) {
+        let result = ctx.result;
+
+        // 如果是字符串，自动包裹为成功响应
+        if (typeof result === 'string') {
+            result = {
+                code: 0,
+                msg: result
+            };
+        }
+        // 如果是对象，自动补充 code: 0
+        else if (result && typeof result === 'object') {
+            if (!('code' in result)) {
+                result = {
+                    code: 0,
+                    ...result
+                };
+            }
+        }
+
+        // 处理 BigInt 序列化问题
+        if (result && typeof result === 'object') {
+            const jsonString = JSON.stringify(result, (key, value) => (typeof value === 'bigint' ? value.toString() : value));
+            return new Response(jsonString, {
+                headers: {
+                    ...ctx.corsHeaders,
+                    'Content-Type': 'application/json'
+                }
+            });
+        } else {
+            return Response.json(result, {
+                headers: ctx.corsHeaders
+            });
+        }
+    }
+
+    // 3. 默认响应：没有生成响应
+    return Response.json(
+        {
+            code: 1,
+            msg: '未生成响应'
+        },
+        {
+            headers: ctx.corsHeaders
+        }
+    );
+}
+
+/**
+ * 设置 CORS 响应头
+ * @param req - 请求对象
+ * @param config - CORS 配置（可选）
+ * @returns CORS 响应头对象
+ */
+export function setCorsOptions(req: Request, config: CorsConfig = {}): Record<string, string> {
+    const origin = config.origin || '*';
+    return {
+        'Access-Control-Allow-Origin': origin === '*' ? req.headers.get('origin') || '*' : origin,
+        'Access-Control-Allow-Methods': config.methods || 'GET, POST, PUT, DELETE, OPTIONS',
+        'Access-Control-Allow-Headers': config.allowedHeaders || 'Content-Type, Authorization, authorization, token',
+        'Access-Control-Expose-Headers': config.exposedHeaders || 'Content-Range, X-Content-Range, Authorization, authorization, token',
+        'Access-Control-Max-Age': String(config.maxAge || 86400),
+        'Access-Control-Allow-Credentials': config.credentials || 'true'
+    };
+}
+
+/**
+ * 扫描模块（插件或钩子）
+ * @param dir - 目录路径
+ * @param type - 模块类型（core/addon/app）
+ * @param moduleLabel - 模块标签（如"插件"、"钩子"）
+ * @param addonName - 组件名称（仅 type='addon' 时需要）
+ * @returns 模块列表
+ */
+export async function scanModules<T extends Plugin | Hook>(dir: string, type: 'core' | 'addon' | 'app', moduleLabel: string, addonName?: string): Promise<T[]> {
+    if (!existsSync(dir)) return [];
+
+    const items: T[] = [];
+    const files = await scanFiles(dir, '*.{ts,js}');
+
+    for (const { filePath, fileName } of files) {
+        // 生成模块名称
+        const name = camelCase(fileName);
+        const moduleName = type === 'core' ? name : type === 'addon' ? `addon_${camelCase(addonName!)}_${name}` : `app_${name}`;
+
+        try {
+            const normalizedFilePath = filePath.replace(/\\/g, '/');
+            const moduleImport = await import(normalizedFilePath);
+            const item = moduleImport.default;
+
+            item.name = moduleName;
+            // 为 addon 模块记录 addon 名称
+            if (type === 'addon' && addonName) {
+                item.addonName = addonName;
+            }
+            items.push(item);
+        } catch (err: any) {
+            const typeLabel = type === 'core' ? '核心' : type === 'addon' ? `组件${addonName}` : '项目';
+            Logger.error({ err: err, module: fileName }, `${typeLabel}${moduleLabel} 导入失败`);
+            process.exit(1);
+        }
+    }
+
+    return items;
+}
+
+/**
+ * 排序模块（根据依赖关系）
+ * @param modules - 待排序的模块列表
+ * @returns 排序后的模块列表，如果存在循环依赖或依赖不存在则返回 false
+ */
+export function sortModules<T extends { name?: string; after?: string[] }>(modules: T[]): T[] | false {
+    const result: T[] = [];
+    const visited = new Set<string>();
+    const visiting = new Set<string>();
+    const moduleMap: Record<string, T> = Object.fromEntries(modules.map((m) => [m.name!, m]));
+    let isPass = true;
+
+    // 检查依赖是否存在
+    for (const module of modules) {
+        if (module.after) {
+            for (const dep of module.after) {
+                if (!moduleMap[dep]) {
+                    Logger.error({ module: module.name, dependency: dep }, '依赖的模块未找到');
+                    isPass = false;
+                }
+            }
+        }
+    }
+
+    if (!isPass) return false;
+
+    const visit = (name: string): void => {
+        if (visited.has(name)) return;
+        if (visiting.has(name)) {
+            Logger.error({ module: name }, '模块循环依赖');
+            isPass = false;
+            return;
+        }
+
+        const module = moduleMap[name];
+        if (!module) return;
+
+        visiting.add(name);
+        (module.after || []).forEach(visit);
+        visiting.delete(name);
+        visited.add(name);
+        result.push(module);
+    };
+
+    modules.forEach((m) => visit(m.name!));
+
+    return isPass ? result : false;
+}