befly 3.9.38 → 3.9.40

package/router/api.ts

@@ -1,20 +1,21 @@
-/**
+/**
  * API路由处理器
  * 处理 /api/* 路径的请求
  */
 
-// 外部依赖
-import { genShortId } from 'befly-shared/genShortId';
+import type { ApiRoute } from "../types/api.js";
+import type { BeflyContext } from "../types/befly.js";
+// 类型导入
+import type { RequestContext } from "../types/context.js";
+import type { Hook } from "../types/hook.js";
 
+import { withCtx } from "../lib/asyncContext.js";
+import { Logger } from "../lib/logger.js";
 // 相对导入
-import { FinalResponse } from '../util.js';
-import { Logger } from '../lib/logger.js';
-
-// 类型导入
-import type { RequestContext } from '../types/context.js';
-import type { ApiRoute } from '../types/api.js';
-import type { Hook } from '../types/hook.js';
-import type { BeflyContext } from '../types/befly.js';
+import { genShortId } from "../utils/genShortId.js";
+import { getClientIp } from "../utils/getClientIp.js";
+import { FinalResponse } from "../utils/response.js";
+import { makeRouteKey } from "../utils/route.js";
 
 /**
  * API处理器工厂函数
@@ -23,78 +24,106 @@ import type { BeflyContext } from '../types/befly.js';
  * @param context - 应用上下文
  */
 export function apiHandler(apis: Map<string, ApiRoute>, hooks: Hook[], context: BeflyContext) {
-    return async (req: Request): Promise<Response> => {
+    return async (req: Request, server?: any): Promise<Response> => {
         // 1. 生成请求 ID
         const requestId = genShortId();
 
         // 2. 创建请求上下文
         const url = new URL(req.url);
-        const apiPath = `${req.method}${url.pathname}`;
-        const clientIp = req.headers.get('x-forwarded-for')?.split(',')[0]?.trim() || req.headers.get('x-real-ip') || 'unknown';
+        const apiPath = makeRouteKey(req.method, url.pathname);
+
+        const clientIp = getClientIp(req, server);
+
+        const now = Date.now();
 
         const ctx: RequestContext = {
             method: req.method,
             body: {},
             user: {},
             req: req,
-            now: Date.now(),
+            now: now,
             ip: clientIp,
             headers: req.headers,
             route: apiPath,
             requestId: requestId,
             corsHeaders: {
-                'X-Request-ID': requestId
+                "X-Request-ID": requestId
             },
             api: apis.get(apiPath),
             response: undefined,
             result: undefined
         };
 
-        try {
-            // 4. 串联执行所有钩子
-            for (const hook of hooks) {
-                await hook.handler(context, ctx);
+        return withCtx(
+            {
+                requestId: requestId,
+                method: req.method,
+                route: apiPath,
+                ip: clientIp,
+                now: now
+            },
+            async () => {
+                try {
+                    // 4. 串联执行所有钩子
+                    for (const hook of hooks) {
+                        await hook.handler(context, ctx);
 
-                // 如果钩子已经设置了 response，停止执行
-                if (ctx.response) {
-                    return ctx.response;
-                }
-            }
+                        // 如果钩子已经设置了 response，停止执行
+                        if (ctx.response) {
+                            return ctx.response;
+                        }
+                    }
+
+                    // hooks 全部通过后记录请求日志（拦截请求仅由 ErrorResponse 记录）
+                    if (ctx.api && req.method !== "OPTIONS") {
+                        const logData: Record<string, any> = {
+                            event: "request",
+                            apiName: ctx.api.name
+                        };
 
-            // 5. 执行 API handler
-            if (!ctx.api) {
-                if (req.method !== 'OPTIONS') {
-                    ctx.response = Response.json(
-                        {
-                            code: 1,
-                            msg: '接口不存在'
-                        },
-                        {
-                            headers: ctx.corsHeaders
+                        if (ctx.body && Object.keys(ctx.body).length > 0) {
+                            logData.body = ctx.body;
                         }
-                    );
-                }
-            } else if (ctx.api.handler) {
-                const result = await ctx.api.handler(context, ctx);
 
-                if (result instanceof Response) {
-                    ctx.response = result;
-                } else {
-                    ctx.result = result;
+                        Logger.info(logData, "request");
+                    }
+
+                    // 5. 执行 API handler
+                    if (!ctx.api) {
+                        if (req.method !== "OPTIONS") {
+                            ctx.response = Response.json(
+                                {
+                                    code: 1,
+                                    msg: "接口不存在"
+                                },
+                                {
+                                    headers: ctx.corsHeaders
+                                }
+                            );
+                        }
+                    } else if (ctx.api.handler) {
+                        const result = await ctx.api.handler(context, ctx);
+
+                        if (result instanceof Response) {
+                            ctx.response = result;
+                        } else {
+                            ctx.result = result;
+                        }
+                    }
+
+                    // 7. 返回响应（自动处理 response/result/日志）
+                    return FinalResponse(ctx);
+                } catch (err: any) {
+                    // 全局错误处理
+                    const errorPath = ctx.api ? apiPath : req.url;
+                    Logger.error({ err: err, path: errorPath }, "请求错误");
+                    ctx.result = {
+                        code: 1,
+                        msg: "内部服务错误"
+                    };
+                    return FinalResponse(ctx);
                 }
             }
-
-            // 7. 返回响应（自动处理 response/result/日志）
-            return FinalResponse(ctx);
-        } catch (err: any) {
-            // 全局错误处理
-            const errorPath = ctx.api ? apiPath : req.url;
-            Logger.error({ err: err, path: errorPath }, '请求错误');
-            ctx.result = {
-                code: 1,
-                msg: '内部服务错误'
-            };
-            return FinalResponse(ctx);
-        }
+        );
     };
 }

package/router/static.ts

@@ -1,16 +1,16 @@
-/**
+/**
  * 静态文件路由处理器
  * 处理 /* 路径的静态文件请求
  */
 
 // 外部依赖
-import { join } from 'pathe';
+import { join } from "pathe";
 
+import { beflyConfig } from "../befly.config.js";
+import { Logger } from "../lib/logger.js";
 // 相对导入
-import { projectDir } from '../paths.js';
-import { Logger } from '../lib/logger.js';
-import { setCorsOptions } from '../util.js';
-import { beflyConfig } from '../befly.config.js';
+import { projectDir } from "../paths.js";
+import { setCorsOptions } from "../utils/cors.js";
 
 /**
  * 静态文件处理器工厂
@@ -21,11 +21,11 @@ export function staticHandler() {
         const corsHeaders = setCorsOptions(req, beflyConfig.cors);
 
         const url = new URL(req.url);
-        const filePath = join(projectDir, 'public', url.pathname);
+        const filePath = join(projectDir, "public", url.pathname);
 
         try {
             // OPTIONS预检请求
-            if (req.method === 'OPTIONS') {
+            if (req.method === "OPTIONS") {
                 return new Response(null, {
                     status: 204,
                     headers: corsHeaders
@@ -36,7 +36,7 @@ export function staticHandler() {
             if (await file.exists()) {
                 return new Response(file, {
                     headers: {
-                        'Content-Type': file.type || 'application/octet-stream',
+                        "Content-Type": file.type || "application/octet-stream",
                         ...corsHeaders
                     }
                 });
@@ -44,7 +44,7 @@ export function staticHandler() {
                 return Response.json(
                     {
                         code: 1,
-                        msg: '文件未找到'
+                        msg: "文件未找到"
                     },
                     {
                         headers: corsHeaders
@@ -52,12 +52,12 @@ export function staticHandler() {
                 );
             }
         } catch (error: any) {
-            Logger.error({ err: error }, '静态文件处理失败');
+            Logger.error({ err: error }, "静态文件处理失败");
 
             return Response.json(
                 {
                     code: 1,
-                    msg: '文件读取失败'
+                    msg: "文件读取失败"
                 },
                 {
                     headers: corsHeaders

package/sync/syncAll.ts

@@ -1,16 +1,16 @@
-/**
+/**
  * Sync 命令 - 一次性执行所有同步操作
- * 按顺序执行：syncDb → syncApi → syncMenu → syncDev
+ * 按顺序执行：syncDb → syncApi → syncMenu → syncDev（syncDev 内会重建角色接口权限缓存）
  */
 
-import { checkApp } from '../checks/checkApp.js';
-import { Logger } from '../lib/logger.js';
-import { syncDbCommand } from './syncDb.js';
-import { syncApiCommand } from './syncApi.js';
-import { syncMenuCommand } from './syncMenu.js';
-import { syncDevCommand } from './syncDev.js';
-import { beflyConfig } from '../befly.config.js';
-import type { SyncOptions } from '../types/index.js';
+import type { SyncOptions } from "../types/sync.js";
+
+import { checkApp } from "../checks/checkApp.js";
+import { Logger } from "../lib/logger.js";
+import { syncApiCommand } from "./syncApi.js";
+import { syncDbCommand } from "./syncDb.js";
+import { syncDevCommand } from "./syncDev.js";
+import { syncMenuCommand } from "./syncMenu.js";
 
 export async function syncAllCommand(options: SyncOptions = {}) {
     try {
@@ -26,10 +26,10 @@ export async function syncAllCommand(options: SyncOptions = {}) {
         // 3. 同步菜单（并缓存）
         await syncMenuCommand();
 
-        // 4. 同步开发管理员（并缓存角色权限）
+        // 4. 同步开发管理员（syncDev 内会重建角色接口权限缓存）
         await syncDevCommand();
     } catch (error: any) {
-        Logger.error({ err: error }, '同步过程中发生错误');
+        Logger.error({ err: error }, "同步过程中发生错误");
         throw error;
     }
 }

package/sync/syncApi.ts

@@ -1,4 +1,4 @@
-/**
+/**
  * SyncApi 命令 - 同步 API 接口数据到数据库
  * 说明：遍历所有 API 文件，收集接口路由信息并同步到 addon_admin_api 表
  *
@@ -10,27 +10,25 @@
  * 5. 存在则更新，不存在则新增
  * 6. 删除配置中不存在的接口记录
  */
-import { readdirSync, statSync } from 'node:fs';
-import { join, dirname, relative, basename } from 'pathe';
-import { Connect } from '../lib/connect.js';
-import { DbHelper } from '../lib/dbHelper.js';
-import { RedisHelper } from '../lib/redisHelper.js';
-import { RedisKeys } from 'befly-shared/redisKeys';
-import { scanFiles } from 'befly-shared/scanFiles';
-import { scanAddons, addonDirExists, getAddonDir } from 'befly-shared/addonHelper';
+import type { SyncApiOptions, ApiInfo } from "../types/sync.js";
 
-import { Logger } from '../lib/logger.js';
-import { projectDir } from '../paths.js';
-import { beflyConfig } from '../befly.config.js';
+import { join, relative } from "pathe";
 
-import type { SyncApiOptions, ApiInfo } from '../types/index.js';
+import { CacheHelper } from "../lib/cacheHelper.js";
+import { Connect } from "../lib/connect.js";
+import { DbHelper } from "../lib/dbHelper.js";
+import { Logger } from "../lib/logger.js";
+import { RedisHelper } from "../lib/redisHelper.js";
+import { projectDir } from "../paths.js";
+import { scanAddons, addonDirExists, getAddonDir } from "../utils/addonHelper.js";
+import { scanFiles } from "../utils/scanFiles.js";
 
 /**
  * 从 API 文件中提取接口信息
  */
-async function extractApiInfo(filePath: string, apiRoot: string, type: 'app' | 'addon', addonName: string = '', addonTitle: string = ''): Promise<ApiInfo | null> {
+async function extractApiInfo(filePath: string, apiRoot: string, type: "app" | "addon", addonName: string = "", addonTitle: string = ""): Promise<ApiInfo | null> {
     try {
-        const normalizedFilePath = filePath.replace(/\\/g, '/');
+        const normalizedFilePath = filePath.replace(/\\/g, "/");
         const apiModule = await import(normalizedFilePath);
         const apiConfig = apiModule.default;
 
@@ -38,32 +36,32 @@ async function extractApiInfo(filePath: string, apiRoot: string, type: 'app' | '
             return null;
         }
 
-        let apiPath = '';
+        let apiPath = "";
 
-        if (type === 'addon') {
+        if (type === "addon") {
             // Addon 接口：保留完整目录层级
             // 例: apis/menu/list.ts → /api/addon/admin/menu/list
             const relativePath = relative(apiRoot, filePath);
-            const pathWithoutExt = relativePath.replace(/\.(ts|js)$/, '');
+            const pathWithoutExt = relativePath.replace(/\.(ts|js)$/, "");
             apiPath = `/api/addon/${addonName}/${pathWithoutExt}`;
         } else {
             // 项目接口：保留完整目录层级
             // 例: apis/user/list.ts → /api/user/list
             const relativePath = relative(apiRoot, filePath);
-            const pathWithoutExt = relativePath.replace(/\.(ts|js)$/, '');
+            const pathWithoutExt = relativePath.replace(/\.(ts|js)$/, "");
             apiPath = `/api/${pathWithoutExt}`;
         }
 
         return {
-            name: apiConfig.name || '',
+            name: apiConfig.name || "",
             path: apiPath,
-            method: apiConfig.method || 'POST',
-            description: apiConfig.description || '',
+            method: apiConfig.method || "POST",
+            description: apiConfig.description || "",
             addonName: addonName,
             addonTitle: addonTitle || addonName
         };
     } catch (error: any) {
-        Logger.error({ err: error }, '同步 API 失败');
+        Logger.error({ err: error }, "同步 API 失败");
         throw error;
     }
 }
@@ -71,12 +69,12 @@ async function extractApiInfo(filePath: string, apiRoot: string, type: 'app' | '
 /**
  * 扫描所有 API 文件
  */
-async function scanAllApis(projectRoot: string): Promise<ApiInfo[]> {
+async function scanAllApis(): Promise<ApiInfo[]> {
     const apis: ApiInfo[] = [];
 
     // 1. 扫描项目 API（只扫描 apis 目录）
     try {
-        const projectApisDir = join(projectDir, 'apis');
+        const projectApisDir = join(projectDir, "apis");
 
         // 扫描项目 API 文件
         const projectApiFiles: string[] = [];
@@ -90,7 +88,7 @@ async function scanAllApis(projectRoot: string): Promise<ApiInfo[]> {
         }
 
         for (const filePath of projectApiFiles) {
-            const apiInfo = await extractApiInfo(filePath, projectApisDir, 'app', '', '项目接口');
+            const apiInfo = await extractApiInfo(filePath, projectApisDir, "app", "", "项目接口");
             if (apiInfo) {
                 apis.push(apiInfo);
             }
@@ -103,19 +101,19 @@ async function scanAllApis(projectRoot: string): Promise<ApiInfo[]> {
             // addonName 格式: admin, demo 等
 
             // 检查 apis 子目录是否存在
-            if (!addonDirExists(addonName, 'apis')) {
+            if (!addonDirExists(addonName, "apis")) {
                 continue;
             }
 
-            const addonApisDir = getAddonDir(addonName, 'apis');
+            const addonApisDir = getAddonDir(addonName, "apis");
 
             // 读取 addon 配置
-            const addonPackageJsonPath = getAddonDir(addonName, 'package.json');
+            const addonPackageJsonPath = getAddonDir(addonName, "package.json");
             let addonTitle = addonName;
             try {
-                const packageJson = await import(addonPackageJsonPath, { with: { type: 'json' } });
+                const packageJson = await import(addonPackageJsonPath, { with: { type: "json" } });
                 addonTitle = packageJson.default?.title || addonName;
-            } catch (error) {
+            } catch {
                 // 忽略配置读取错误
             }
 
@@ -131,7 +129,7 @@ async function scanAllApis(projectRoot: string): Promise<ApiInfo[]> {
             }
 
             for (const filePath of addonApiFiles) {
-                const apiInfo = await extractApiInfo(filePath, addonApisDir, 'addon', addonName, addonTitle);
+                const apiInfo = await extractApiInfo(filePath, addonApisDir, "addon", addonName, addonTitle);
                 if (apiInfo) {
                     apis.push(apiInfo);
                 }
@@ -140,7 +138,7 @@ async function scanAllApis(projectRoot: string): Promise<ApiInfo[]> {
 
         return apis;
     } catch (error: any) {
-        Logger.error({ err: error }, '接口扫描失败');
+        Logger.error({ err: error }, "接口扫描失败");
         return apis;
     }
 }
@@ -153,7 +151,7 @@ async function syncApis(helper: any, apis: ApiInfo[]): Promise<void> {
         try {
             // 根据 path 查询是否存在
             const existing = await helper.getOne({
-                table: 'addon_admin_api',
+                table: "addon_admin_api",
                 where: { path: api.path }
             });
 
@@ -163,7 +161,7 @@ async function syncApis(helper: any, apis: ApiInfo[]): Promise<void> {
 
                 if (needUpdate) {
                     await helper.updData({
-                        table: 'addon_admin_api',
+                        table: "addon_admin_api",
                         where: { id: existing.id },
                         data: {
                             name: api.name,
@@ -176,7 +174,7 @@ async function syncApis(helper: any, apis: ApiInfo[]): Promise<void> {
                 }
             } else {
                 await helper.insData({
-                    table: 'addon_admin_api',
+                    table: "addon_admin_api",
                     data: {
                         name: api.name,
                         path: api.path,
@@ -188,7 +186,7 @@ async function syncApis(helper: any, apis: ApiInfo[]): Promise<void> {
                 });
             }
         } catch (error: any) {
-            Logger.error({ err: error, api: api.name }, '同步接口失败');
+            Logger.error({ err: error, api: api.name }, "同步接口失败");
         }
     }
 }
@@ -198,14 +196,14 @@ async function syncApis(helper: any, apis: ApiInfo[]): Promise<void> {
  */
 async function deleteObsoleteRecords(helper: any, apiPaths: Set<string>): Promise<void> {
     const allRecords = await helper.getAll({
-        table: 'addon_admin_api',
+        table: "addon_admin_api",
         where: { state$gte: 0 }
     });
 
     for (const record of allRecords.lists) {
         if (record.path && !apiPaths.has(record.path)) {
             await helper.delForce({
-                table: 'addon_admin_api',
+                table: "addon_admin_api",
                 where: { id: record.id }
             });
         }
@@ -218,25 +216,27 @@ async function deleteObsoleteRecords(helper: any, apiPaths: Set<string>): Promis
 export async function syncApiCommand(options: SyncApiOptions = {}): Promise<void> {
     try {
         if (options.plan) {
-            Logger.debug('[计划] 同步 API 接口到数据库（plan 模式不执行）');
+            Logger.debug("[计划] 同步 API 接口到数据库（plan 模式不执行）");
             return;
         }
 
         // 连接数据库（SQL + Redis）
         await Connect.connect();
 
-        const helper = new DbHelper({ redis: new RedisHelper() } as any, Connect.getSql());
+        const redisHelper = new RedisHelper();
+        const helper = new DbHelper({ redis: redisHelper } as any, Connect.getSql());
+        const cacheHelper = new CacheHelper({ db: helper, redis: redisHelper } as any);
 
         // 1. 检查表是否存在（addon_admin_api 来自 addon-admin 组件）
-        const exists = await helper.tableExists('addon_admin_api');
+        const exists = await helper.tableExists("addon_admin_api");
 
         if (!exists) {
-            Logger.debug('表 addon_admin_api 不存在，跳过 API 同步（需要安装 addon-admin 组件）');
+            Logger.debug("表 addon_admin_api 不存在，跳过 API 同步（需要安装 addon-admin 组件）");
             return;
         }
 
         // 2. 扫描所有 API 文件
-        const apis = await scanAllApis(projectDir);
+        const apis = await scanAllApis();
         const apiPaths = new Set(apis.map((api) => api.path));
 
         // 3. 同步 API 数据
@@ -247,18 +247,21 @@ export async function syncApiCommand(options: SyncApiOptions = {}): Promise<void
 
         // 5. 缓存接口数据到 Redis
         try {
-            const apiList = await helper.getAll({
-                table: 'addon_admin_api',
-                orderBy: ['id#ASC']
-            });
+            await cacheHelper.cacheApis();
+        } catch {
+            // 忽略缓存错误
+        }
 
-            const redisHelper = new RedisHelper();
-            await redisHelper.setObject(RedisKeys.apisAll(), apiList.lists);
+        // 6. API 表发生变更后，重建角色接口权限缓存（不使用定时器）
+        // 说明：role permission set 的成员是 METHOD/path，API 的 method/path 变更会影响所有角色权限。
+        try {
+            await cacheHelper.rebuildRoleApiPermissions();
         } catch (error: any) {
-            // 忽略缓存错误
+            // 不阻塞 syncApi 主流程，但记录日志
+            Logger.warn({ err: error }, "API 同步完成，但重建角色权限缓存失败");
         }
     } catch (error: any) {
-        Logger.error({ err: error }, 'API 同步失败');
+        Logger.error({ err: error }, "API 同步失败");
         throw error;
     } finally {
         await Connect.disconnect();