befly 3.9.39 → 3.10.0

package/sync/syncApi.ts

@@ -1,269 +1,114 @@
-/**
- * SyncApi 命令 - 同步 API 接口数据到数据库
- * 说明：遍历所有 API 文件，收集接口路由信息并同步到 addon_admin_api 表
- *
- * 流程：
- * 1. 扫描项目 apis 目录下所有项目 API 文件
- * 2. 扫描 node_modules/@befly-addon/* 目录下所有组件 API 文件
- * 3. 提取每个 API 的 name、method、auth 等信息
- * 4. 根据接口路径检查是否存在
- * 5. 存在则更新，不存在则新增
- * 6. 删除配置中不存在的接口记录
- */
-import type { SyncApiOptions, ApiInfo } from "../types/sync.js";
+import type { BeflyContext } from "../types/befly.js";
+import type { SyncApiItem } from "../types/sync.js";
 
-import { join, relative } from "pathe";
+import { keyBy } from "es-toolkit/array";
 
-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> {
-    try {
-        const normalizedFilePath = filePath.replace(/\\/g, "/");
-        const apiModule = await import(normalizedFilePath);
-        const apiConfig = apiModule.default;
+export async function syncApi(ctx: Pick<BeflyContext, "db" | "cache">, apis: SyncApiItem[]): Promise<void> {
+    const tableName = "addon_admin_api";
 
-        if (!apiConfig || !apiConfig.name) {
-            return null;
-        }
-
-        let apiPath = "";
-
-        if (type === "addon") {
-            // Addon 接口：保留完整目录层级
-            // 例: apis/menu/list.ts → /api/addon/admin/menu/list
-            const relativePath = relative(apiRoot, filePath);
-            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)$/, "");
-            apiPath = `/api/${pathWithoutExt}`;
-        }
-
-        return {
-            name: apiConfig.name || "",
-            path: apiPath,
-            method: apiConfig.method || "POST",
-            description: apiConfig.description || "",
-            addonName: addonName,
-            addonTitle: addonTitle || addonName
-        };
-    } catch (error: any) {
-        Logger.error({ err: error }, "同步 API 失败");
-        throw error;
+    if (!ctx.db) {
+        throw new Error("syncApi: ctx.db 未初始化（Db 插件未加载或注入失败）");
     }
-}
-
-/**
- * 扫描所有 API 文件
- */
-async function scanAllApis(): Promise<ApiInfo[]> {
-    const apis: ApiInfo[] = [];
-
-    // 1. 扫描项目 API（只扫描 apis 目录）
-    try {
-        const projectApisDir = join(projectDir, "apis");
-
-        // 扫描项目 API 文件
-        const projectApiFiles: string[] = [];
-        try {
-            const files = await scanFiles(projectApisDir);
-            for (const { filePath } of files) {
-                projectApiFiles.push(filePath);
-            }
-        } catch (error: any) {
-            Logger.warn(`扫描项目 API 目录失败: ${projectApisDir} - ${error.message}`);
-        }
 
-        for (const filePath of projectApiFiles) {
-            const apiInfo = await extractApiInfo(filePath, projectApisDir, "app", "", "项目接口");
-            if (apiInfo) {
-                apis.push(apiInfo);
-            }
-        }
+    if (!ctx.cache) {
+        throw new Error("syncApi: ctx.cache 未初始化（cache 插件未加载或注入失败）");
+    }
 
-        // 2. 扫描组件 API (node_modules/@befly-addon/*)
-        const addonNames = scanAddons();
+    if (!(await ctx.db.tableExists(tableName))) {
+        Logger.debug(`${tableName} 表不存在`);
+        return;
+    }
 
-        for (const addonName of addonNames) {
-            // addonName 格式: admin, demo 等
+    const allDbApis = await ctx.db.getAll({
+        table: tableName,
+        fields: ["id", "routePath", "name", "addonName", "state"],
+        where: { state$gte: 0 }
+    } as any);
 
-            // 检查 apis 子目录是否存在
-            if (!addonDirExists(addonName, "apis")) {
-                continue;
-            }
+    const dbLists = allDbApis.lists || [];
+    const allDbApiMap = keyBy(dbLists, (item: any) => item.routePath);
 
-            const addonApisDir = getAddonDir(addonName, "apis");
+    const insData: SyncApiItem[] = [];
+    const updData: Array<{ id: number; api: SyncApiItem }> = [];
+    const delData: number[] = [];
 
-            // 读取 addon 配置
-            const addonPackageJsonPath = getAddonDir(addonName, "package.json");
-            let addonTitle = addonName;
-            try {
-                const packageJson = await import(addonPackageJsonPath, { with: { type: "json" } });
-                addonTitle = packageJson.default?.title || addonName;
-            } catch {
-                // 忽略配置读取错误
-            }
+    // 1) 先构建当前扫描到的 routePath 集合（用于删除差集）
+    const apiRouteKeys = new Set<string>();
 
-            // 扫描 addon API 文件
-            const addonApiFiles: string[] = [];
-            try {
-                const files = await scanFiles(addonApisDir);
-                for (const { filePath } of files) {
-                    addonApiFiles.push(filePath);
-                }
-            } catch (error: any) {
-                Logger.warn(`扫描 addon API 目录失败: ${addonApisDir} - ${error.message}`);
-            }
+    // 2) 插入 / 更新（存在不一定更新：仅当 name/routePath/addonName 任一不匹配时更新）
+    for (const api of apis) {
+        const apiType = api.type;
+        // 兼容：历史/测试构造的数据可能没有 type 字段；此时应按 API 处理。
+        // 因此仅当 type **显式存在** 且不为 "api" 时才跳过，避免误把真实 API 条目过滤掉。
+        if (apiType && apiType !== "api") {
+            continue;
+        }
 
-            for (const filePath of addonApiFiles) {
-                const apiInfo = await extractApiInfo(filePath, addonApisDir, "addon", addonName, addonTitle);
-                if (apiInfo) {
-                    apis.push(apiInfo);
-                }
+        const routePath = api.routePath;
+        apiRouteKeys.add(api.routePath);
+        const item = (allDbApiMap as any)[routePath];
+        if (item) {
+            const shouldUpdate = api.name !== item.name || api.routePath !== item.routePath || api.addonName !== item.addonName;
+            if (shouldUpdate) {
+                updData.push({ id: item.id, api: api });
             }
+        } else {
+            insData.push(api);
         }
+    }
 
-        return apis;
-    } catch (error: any) {
-        Logger.error({ err: error }, "接口扫描失败");
-        return apis;
+    // 3) 删除：用差集（DB - 当前扫描）得到要删除的 id
+    for (const record of dbLists) {
+        if (!apiRouteKeys.has(record.routePath)) {
+            delData.push(record.id);
+        }
     }
-}
 
-/**
- * 同步 API 数据到数据库
- */
-async function syncApis(helper: any, apis: ApiInfo[]): Promise<void> {
-    for (const api of apis) {
+    if (updData.length > 0) {
         try {
-            // 根据 path 查询是否存在
-            const existing = await helper.getOne({
-                table: "addon_admin_api",
-                where: { path: api.path }
-            });
-
-            if (existing) {
-                // 检查是否需要更新
-                const needUpdate = existing.name !== api.name || existing.method !== api.method || existing.description !== api.description || existing.addonName !== api.addonName || existing.addonTitle !== api.addonTitle;
-
-                if (needUpdate) {
-                    await helper.updData({
-                        table: "addon_admin_api",
-                        where: { id: existing.id },
+            await ctx.db.updBatch(
+                tableName,
+                updData.map((item) => {
+                    return {
+                        id: item.id,
                         data: {
-                            name: api.name,
-                            method: api.method,
-                            description: api.description,
-                            addonName: api.addonName,
-                            addonTitle: api.addonTitle
+                            name: item.api.name,
+                            routePath: item.api.routePath,
+                            addonName: item.api.addonName
                         }
-                    });
-                }
-            } else {
-                await helper.insData({
-                    table: "addon_admin_api",
-                    data: {
-                        name: api.name,
-                        path: api.path,
-                        method: api.method,
-                        description: api.description,
-                        addonName: api.addonName,
-                        addonTitle: api.addonTitle
-                    }
-                });
-            }
+                    };
+                })
+            );
         } catch (error: any) {
-            Logger.error({ err: error, api: api.name }, "同步接口失败");
+            Logger.error({ err: error }, "同步接口批量更新失败");
         }
     }
-}
-
-/**
- * 删除配置中不存在的记录
- */
-async function deleteObsoleteRecords(helper: any, apiPaths: Set<string>): Promise<void> {
-    const allRecords = await helper.getAll({
-        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",
-                where: { id: record.id }
-            });
-        }
-    }
-}
 
-/**
- * SyncApi 命令主函数
- */
-export async function syncApiCommand(options: SyncApiOptions = {}): Promise<void> {
-    try {
-        if (options.plan) {
-            Logger.debug("[计划] 同步 API 接口到数据库（plan 模式不执行）");
-            return;
-        }
-
-        // 连接数据库（SQL + Redis）
-        await Connect.connect();
-
-        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");
-
-        if (!exists) {
-            Logger.debug("表 addon_admin_api 不存在，跳过 API 同步（需要安装 addon-admin 组件）");
-            return;
-        }
-
-        // 2. 扫描所有 API 文件
-        const apis = await scanAllApis();
-        const apiPaths = new Set(apis.map((api) => api.path));
-
-        // 3. 同步 API 数据
-        await syncApis(helper, apis);
-
-        // 4. 删除文件中不存在的接口
-        await deleteObsoleteRecords(helper, apiPaths);
-
-        // 5. 缓存接口数据到 Redis
+    if (insData.length > 0) {
         try {
-            await cacheHelper.cacheApis();
-        } catch {
-            // 忽略缓存错误
+            await ctx.db.insBatch(
+                tableName,
+                insData.map((api) => {
+                    return {
+                        name: api.name,
+                        routePath: api.routePath,
+                        addonName: api.addonName
+                    };
+                })
+            );
+        } catch (error: any) {
+            Logger.error({ err: error }, "同步接口批量新增失败");
         }
+    }
 
-        // 6. API 表发生变更后，重建角色接口权限缓存（不使用定时器）
-        // 说明：role permission set 的成员是 METHOD/path，API 的 method/path 变更会影响所有角色权限。
+    if (delData.length > 0) {
         try {
-            await cacheHelper.rebuildRoleApiPermissions();
+            await ctx.db.delForceBatch(tableName, delData);
         } catch (error: any) {
-            // 不阻塞 syncApi 主流程，但记录日志
-            Logger.warn({ err: error }, "API 同步完成，但重建角色权限缓存失败");
+            Logger.error({ err: error }, "同步接口批量删除失败");
         }
-    } catch (error: any) {
-        Logger.error({ err: error }, "API 同步失败");
-        throw error;
-    } finally {
-        await Connect.disconnect();
     }
+    // 缓存同步职责已收敛到 syncCache（启动流程单点调用），此处只负责 DB 同步。
 }

package/sync/syncCache.ts

@@ -0,0 +1,16 @@
+import type { BeflyContext } from "../types/befly.js";
+
+export async function syncCache(ctx: Pick<BeflyContext, "cache">): Promise<void> {
+    if (!ctx.cache) {
+        throw new Error("syncCache: ctx.cache 未初始化（cache 插件未加载或注入失败）");
+    }
+
+    // 1) 缓存接口列表
+    await ctx.cache.cacheApis();
+
+    // 2) 缓存菜单列表
+    await ctx.cache.cacheMenus();
+
+    // 3) 重建角色权限缓存（严格模式下要求 role.apis 必须为 pathname 字符串数组）
+    await ctx.cache.rebuildRoleApiPermissions();
+}