befly 3.16.10 → 3.16.11

package/dist/sync/syncApi.js

@@ -1,163 +0,0 @@
-import { Logger } from "../lib/logger";
-import { CoreError } from "../types/coreError";
-import { keyBy } from "../utils/util";
-const getApiParentPath = (apiPath) => {
-    const segments = apiPath
-        .split("/")
-        .map((s) => s.trim())
-        .filter((s) => s.length > 0);
-    // segments 示例：
-    // - /api/addon/admin/sysConfig/list -> ["api","addon","admin","sysConfig","list"]
-    // - /api/app/test/hi -> ["api","app","test","hi"]
-    const seg2 = segments[1] || "";
-    const take = seg2 === "addon" ? 4 : 3;
-    const parentSegments = segments.slice(0, Math.min(take, segments.length));
-    if (parentSegments.length === 0)
-        return "";
-    return `/${parentSegments.join("/")}`;
-};
-const normalizeAuthForDb = (value) => {
-    if (value === false || value === 0 || value === "0" || value === "否") {
-        return "否";
-    }
-    if (Array.isArray(value)) {
-        const list = value
-            .filter((item) => typeof item === "string")
-            .map((item) => item.trim())
-            .filter((item) => item !== "");
-        if (list.length > 0) {
-            return list.join(",");
-        }
-        return "是";
-    }
-    if (typeof value === "string") {
-        const trimmed = value.trim();
-        if (trimmed !== "") {
-            return trimmed;
-        }
-    }
-    return "是";
-};
-export async function syncApi(ctx, apis) {
-    const tableName = "addon_admin_api";
-    if (!ctx.db) {
-        throw new CoreError({ message: "同步接口：ctx.db 未初始化", kind: "validation" });
-    }
-    if (!ctx.cache) {
-        throw new CoreError({ message: "同步接口：ctx.cache 未初始化", kind: "validation" });
-    }
-    if (!(await ctx.db.tableExists(tableName)).data) {
-        Logger.debug(`${tableName} 表不存在`);
-        return;
-    }
-    const allDbApis = await ctx.db.getAll({
-        table: tableName,
-        fields: ["id", "path", "parentPath", "name", "addonName", "auth", "state"],
-        where: { state$gte: 0 }
-    });
-    const dbLists = allDbApis.data.lists || [];
-    const allDbApiMap = keyBy(dbLists, (item) => item.path);
-    const insData = [];
-    const updData = [];
-    const delData = [];
-    // 1) 先构建当前扫描到的 path 集合（用于删除差集）
-    const apiRouteKeys = new Set();
-    // 2) 插入 / 更新（存在不一定更新：仅当 name/path/addonName/auth 任一不匹配时更新）
-    for (const api of apis) {
-        // 仅当 type **显式存在** 且不为 "api" 时才跳过，避免误把真实 API 条目过滤掉。
-        if (api.type !== "api") {
-            continue;
-        }
-        const record = api;
-        const path = record["path"];
-        const name = record["name"];
-        const addonNameRaw = record["addonName"];
-        if (typeof path !== "string" || path.trim() === "") {
-            continue;
-        }
-        if (typeof name !== "string" || name.trim() === "") {
-            continue;
-        }
-        const addonName = typeof addonNameRaw === "string" ? addonNameRaw : "";
-        // auth：运行时支持 boolean/string[]；DB 字段使用字符串（否/是/角色列表）。
-        // 统一在 syncApi 写库前做归一化，避免类型不一致导致每次启动都触发更新。
-        const authRaw = record["auth"];
-        const auth = normalizeAuthForDb(authRaw);
-        const parentPath = getApiParentPath(path);
-        apiRouteKeys.add(path);
-        const item = allDbApiMap[path];
-        if (item) {
-            const existingAuth = normalizeAuthForDb(item.auth);
-            const shouldUpdate = name !== item.name || path !== item.path || addonName !== item.addonName || parentPath !== item.parentPath || auth !== existingAuth;
-            if (shouldUpdate) {
-                updData.push({
-                    id: item.id,
-                    name: name,
-                    path: path,
-                    parentPath: parentPath,
-                    addonName: addonName,
-                    auth: auth
-                });
-            }
-        }
-        else {
-            insData.push({
-                name: name,
-                path: path,
-                parentPath: parentPath,
-                addonName: addonName,
-                auth: auth
-            });
-        }
-    }
-    // 3) 删除：用差集（DB - 当前扫描）得到要删除的 id
-    for (const record of dbLists) {
-        if (!apiRouteKeys.has(record.path)) {
-            delData.push(record.id);
-        }
-    }
-    if (updData.length > 0) {
-        try {
-            await ctx.db.updBatch(tableName, updData.map((api) => {
-                return {
-                    id: api.id,
-                    data: {
-                        name: api.name,
-                        path: api.path,
-                        parentPath: api.parentPath,
-                        addonName: api.addonName,
-                        auth: api.auth
-                    }
-                };
-            }));
-        }
-        catch (error) {
-            Logger.error({ err: error, msg: "同步接口批量更新失败" });
-        }
-    }
-    if (insData.length > 0) {
-        try {
-            await ctx.db.insBatch(tableName, insData.map((api) => {
-                return {
-                    name: api.name,
-                    path: api.path,
-                    parentPath: api.parentPath,
-                    addonName: api.addonName,
-                    auth: api.auth
-                };
-            }));
-        }
-        catch (error) {
-            Logger.error({ err: error, msg: "同步接口批量新增失败" });
-        }
-    }
-    if (delData.length > 0) {
-        try {
-            await ctx.db.delForceBatch(tableName, delData);
-        }
-        catch (error) {
-            Logger.error({ err: error, msg: "同步接口批量删除失败" });
-        }
-    }
-    // 缓存同步职责已收敛到 syncCache（启动流程单点调用），此处只负责 DB 同步。
-}

package/dist/sync/syncCache.d.ts

@@ -1,2 +0,0 @@
-import type { BeflyContext } from "../types/befly";
-export declare function syncCache(ctx: Pick<BeflyContext, "cache">): Promise<void>;

package/dist/sync/syncCache.js

@@ -1,14 +0,0 @@
-import { CoreError } from "../types/coreError";
-export async function syncCache(ctx) {
-    if (!ctx.cache) {
-        throw new CoreError({ message: "同步缓存：ctx.cache 未初始化", kind: "validation" });
-    }
-    // 1) 缓存接口列表
-    await ctx.cache.cacheApis();
-    // 2) 缓存菜单列表
-    await ctx.cache.cacheMenus();
-    // 3) 重建角色权限缓存（严格模式下要求 role.apis 必须为 pathname 字符串数组）
-    await ctx.cache.rebuildRoleApiPermissions();
-    // 4) 重建角色菜单权限缓存（role.menus 为 menu.path 字符串数组）
-    await ctx.cache.rebuildRoleMenuPermissions();
-}

package/dist/sync/syncDev.d.ts

@@ -1,6 +0,0 @@
-import type { BeflyContext } from "../types/befly";
-export type SyncDevConfig = {
-    devEmail?: string;
-    devPassword?: string;
-};
-export declare function syncDev(ctx: BeflyContext, config?: SyncDevConfig): Promise<void>;

package/dist/sync/syncDev.js

@@ -1,166 +0,0 @@
-import { Cipher } from "../lib/cipher";
-import { Logger } from "../lib/logger";
-import { CoreError } from "../types/coreError";
-export async function syncDev(ctx, config = {}) {
-    if (!config.devPassword) {
-        return;
-    }
-    if (!ctx.db) {
-        throw new CoreError({
-            message: "同步开发：ctx.db 未初始化",
-            kind: "validation",
-            noLog: true,
-            meta: { subsystem: "syncDev", operation: "precheck" }
-        });
-    }
-    if (!ctx.cache) {
-        throw new CoreError({
-            message: "同步开发：ctx.cache 未初始化",
-            kind: "validation",
-            noLog: true,
-            meta: { subsystem: "syncDev", operation: "precheck" }
-        });
-    }
-    if (!(await ctx.db.tableExists("addon_admin_admin")).data) {
-        Logger.debug(`addon_admin_admin 表不存在`);
-        return;
-    }
-    if (!(await ctx.db.tableExists("addon_admin_role")).data) {
-        Logger.debug(`addon_admin_role 表不存在`);
-        return;
-    }
-    if (!(await ctx.db.tableExists("addon_admin_menu")).data) {
-        Logger.debug(`addon_admin_menu 表不存在`);
-        return;
-    }
-    if (!(await ctx.db.tableExists("addon_admin_api")).data) {
-        Logger.debug(`addon_admin_api 表不存在`);
-        return;
-    }
-    const allMenus = await ctx.db.getAll({
-        table: "addon_admin_menu",
-        fields: ["path"],
-        where: { state$gte: 0 },
-        orderBy: ["id#ASC"]
-    });
-    const allApis = await ctx.db.getAll({
-        table: "addon_admin_api",
-        fields: ["path"],
-        where: { state$gte: 0 },
-        orderBy: ["id#ASC"]
-    });
-    const devRole = await ctx.db.getOne({
-        table: "addon_admin_role",
-        where: { code: "dev" }
-    });
-    const devRoleData = {
-        code: "dev",
-        name: "开发者角色",
-        description: "拥有所有菜单和接口权限的开发者角色",
-        menus: allMenus.data.lists.map((item) => item.path).filter((v) => typeof v === "string" && v.length > 0),
-        apis: allApis.data.lists.map((item) => item.path).filter((v) => typeof v === "string" && v.length > 0),
-        sort: 0
-    };
-    if (typeof devRole.data.id === "number") {
-        await ctx.db.updData({
-            table: "addon_admin_role",
-            where: { code: "dev" },
-            data: {
-                name: devRoleData.name,
-                description: devRoleData.description,
-                menus: devRoleData.menus,
-                apis: devRoleData.apis,
-                sort: devRoleData.sort
-            }
-        });
-    }
-    else {
-        await ctx.db.insData({
-            table: "addon_admin_role",
-            data: devRoleData
-        });
-    }
-    const devAdminData = {
-        nickname: "开发者",
-        email: config.devEmail || "dev@qq.com",
-        username: "dev",
-        password: await Cipher.hashPassword(Cipher.sha256(config.devPassword + "befly")),
-        roleCode: "dev",
-        roleType: "admin"
-    };
-    const devAdmin = await ctx.db.getOne({
-        table: "addon_admin_admin",
-        where: { username: "dev" }
-    });
-    if (typeof devAdmin.data.id === "number") {
-        await ctx.db.updData({
-            table: "addon_admin_admin",
-            where: { username: "dev" },
-            data: {
-                nickname: devAdminData.nickname,
-                email: devAdminData.email,
-                username: devAdminData.username,
-                password: devAdminData.password,
-                roleCode: devAdminData.roleCode,
-                roleType: devAdminData.roleType
-            }
-        });
-    }
-    else {
-        await ctx.db.insData({
-            table: "addon_admin_admin",
-            data: devAdminData
-        });
-    }
-    const roles = [
-        {
-            code: "user",
-            name: "用户角色",
-            description: "普通用户角色",
-            sort: 1
-        },
-        {
-            code: "admin",
-            name: "管理员角色",
-            description: "管理员角色",
-            sort: 2
-        },
-        {
-            code: "guest",
-            name: "访客角色",
-            description: "访客角色",
-            sort: 3
-        }
-    ];
-    for (const roleConfig of roles) {
-        const existingRole = await ctx.db.getOne({
-            table: "addon_admin_role",
-            where: { code: roleConfig.code }
-        });
-        if (existingRole.data?.id) {
-            // 角色存在则强制更新（不做差异判断）
-            await ctx.db.updData({
-                table: "addon_admin_role",
-                where: { code: roleConfig.code },
-                data: {
-                    name: roleConfig.name,
-                    description: roleConfig.description,
-                    sort: roleConfig.sort
-                }
-            });
-        }
-        else {
-            await ctx.db.insData({
-                table: "addon_admin_role",
-                data: {
-                    code: roleConfig.code,
-                    name: roleConfig.name,
-                    description: roleConfig.description,
-                    menus: [],
-                    apis: [],
-                    sort: roleConfig.sort
-                }
-            });
-        }
-    }
-}

package/dist/sync/syncMenu.d.ts

@@ -1,14 +0,0 @@
-import type { BeflyContext } from "../types/befly";
-import type { MenuConfig } from "../types/sync";
-type MenuDef = {
-    path: string;
-    name: string;
-    sort: number;
-    parentPath: string;
-};
-export declare function syncMenu(ctx: BeflyContext, mergedMenus: MenuConfig[]): Promise<void>;
-export declare const __test__: {
-    scanViewsDir: (viewsDir: string, prefix: string, parentPath?: string) => Promise<MenuConfig[]>;
-    flattenMenusToDefMap: (mergedMenus: MenuConfig[]) => Map<string, MenuDef>;
-};
-export {};

package/dist/sync/syncMenu.js

@@ -1,308 +0,0 @@
-import { Logger } from "../lib/logger";
-import { CoreError } from "../types/coreError";
-import { getParentPath } from "../utils/loadMenuConfigs";
-function createDisableMenuMatcher(ctx) {
-    const rawRules = ctx.config?.disableMenus;
-    const rules = Array.isArray(rawRules) ? rawRules : [];
-    const patterns = [];
-    for (const rule of rules) {
-        if (typeof rule !== "string") {
-            continue;
-        }
-        const trimmed = rule.trim();
-        if (!trimmed) {
-            continue;
-        }
-        patterns.push(trimmed);
-    }
-    if (patterns.length === 0) {
-        return () => false;
-    }
-    const globs = patterns.map((p) => new Bun.Glob(p));
-    return (path) => {
-        if (typeof path !== "string") {
-            return false;
-        }
-        const trimmed = path.trim();
-        if (!trimmed) {
-            return false;
-        }
-        // Bun.Glob 在不同场景下可能以 "/a/b" 或 "a/b" 参与匹配；这里双候选兜底。
-        const candidates = [];
-        candidates.push(trimmed);
-        if (trimmed.startsWith("/")) {
-            candidates.push(trimmed.slice(1));
-        }
-        else {
-            candidates.push(`/${trimmed}`);
-        }
-        for (const glob of globs) {
-            const match = typeof glob === "object" && glob !== null && "match" in glob ? glob.match : undefined;
-            if (typeof match !== "function") {
-                throw new Error("同步菜单：当前 Bun 版本不支持 Bun.Glob.match，无法按 disableMenus 做 glob 匹配");
-            }
-            const matchFn = match;
-            for (const candidate of candidates) {
-                if (matchFn.call(glob, candidate)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    };
-}
-function filterMenusByDisableMenus(menus, isDisabledPath) {
-    const out = [];
-    for (const menu of menus) {
-        if (menu === null || typeof menu !== "object") {
-            continue;
-        }
-        const path = typeof menu.path === "string" ? String(menu.path).trim() : "";
-        if (path && isDisabledPath(path)) {
-            // 节点被禁用：整棵子树直接忽略
-            continue;
-        }
-        const children = menu.children;
-        const nextChildren = Array.isArray(children) && children.length > 0 ? filterMenusByDisableMenus(children, isDisabledPath) : [];
-        // 只保留 syncMenu 需要的最小字段，避免引入扩展运算符/不必要的字段复制
-        const next = {};
-        if (typeof menu.name === "string") {
-            next.name = menu.name;
-        }
-        if (typeof menu.path === "string") {
-            next.path = menu.path;
-        }
-        if (typeof menu.sort === "number") {
-            next.sort = menu.sort;
-        }
-        if (typeof menu.parentPath === "string") {
-            next.parentPath = menu.parentPath;
-        }
-        if (nextChildren.length > 0) {
-            next.children = nextChildren;
-        }
-        out.push(next);
-    }
-    return out;
-}
-function flattenMenusToDefMap(mergedMenus) {
-    // 读取配置菜单：扁平化为 path => { name, sort, parentPath }
-    // - 以 path 为唯一键：后出现的覆盖先出现的（与旧逻辑“同 path 多次同步同一条记录”一致）
-    // parentPath 规则：
-    // 1) 若 menu 显式携带 parentPath（包括空字符串），以其为准
-    // 2) 否则使用“树结构”推导的父级（由 children 嵌套关系决定；根级为 ""）
-    // 3) 保底：若无法推导（极端情况），回退到 getParentPath(path)
-    const menuDefMap = new Map();
-    const stack = [];
-    for (const m of mergedMenus) {
-        stack.push({ menu: m, parentPathFromTree: "" });
-    }
-    while (stack.length > 0) {
-        const item = stack.pop();
-        const menu = item ? item.menu : null;
-        if (!menu) {
-            continue;
-        }
-        const path = typeof menu.path === "string" ? menu.path : "";
-        const rawChildren = menu.children;
-        if (rawChildren && Array.isArray(rawChildren) && rawChildren.length > 0) {
-            const nextParentPathFromTree = typeof path === "string" ? path : "";
-            for (const child of rawChildren) {
-                stack.push({ menu: child, parentPathFromTree: nextParentPathFromTree });
-            }
-        }
-        if (!path) {
-            continue;
-        }
-        const name = typeof menu.name === "string" ? menu.name : "";
-        if (!name) {
-            continue;
-        }
-        const sort = typeof menu.sort === "number" ? menu.sort : 999999;
-        const hasExplicitParentPath = typeof menu.parentPath === "string";
-        const parentPath = hasExplicitParentPath ? menu.parentPath : typeof item?.parentPathFromTree === "string" ? item.parentPathFromTree : getParentPath(path);
-        menuDefMap.set(path, {
-            path: path,
-            name: name,
-            sort: sort,
-            parentPath: parentPath
-        });
-    }
-    return menuDefMap;
-}
-export async function syncMenu(ctx, mergedMenus) {
-    if (!ctx.db) {
-        throw new CoreError({ message: "同步菜单：ctx.db 未初始化", kind: "validation" });
-    }
-    if (!ctx.cache) {
-        throw new CoreError({ message: "同步菜单：ctx.cache 未初始化", kind: "validation" });
-    }
-    if (!ctx.config) {
-        throw new CoreError({ message: "同步菜单：ctx.config 未初始化", kind: "validation" });
-    }
-    if (!(await ctx.db.tableExists("addon_admin_menu")).data) {
-        Logger.debug(`addon_admin_menu 表不存在`);
-        return;
-    }
-    const isDisabledPath = createDisableMenuMatcher(ctx);
-    const filteredMenus = filterMenusByDisableMenus(mergedMenus, isDisabledPath);
-    const menuDefMap = flattenMenusToDefMap(filteredMenus);
-    const configPaths = new Set();
-    for (const p of menuDefMap.keys()) {
-        configPaths.add(p);
-    }
-    const tableName = "addon_admin_menu";
-    // 2) 批量同步（事务内）：按 path diff 执行批量 insert/update/delete
-    await ctx.db.trans(async (trans) => {
-        // 读取全部菜单（用于清理 disableMenus 命中菜单：不分 state）
-        const allExistingMenusAllState = await trans.getAll({
-            table: tableName,
-            fields: ["id", "name", "path", "parentPath", "sort", "state"]
-        });
-        const existingListAllState = allExistingMenusAllState.data.lists || [];
-        const existingList = existingListAllState.filter((m) => typeof m?.state === "number" && m.state >= 0);
-        const existingMenuMap = new Map();
-        const duplicateIdSet = new Set();
-        const duplicatePathInfoMap = new Map();
-        for (const record of existingList) {
-            if (typeof record?.path !== "string" || !record.path) {
-                continue;
-            }
-            if (typeof record?.id !== "number") {
-                continue;
-            }
-            // disableMenus 命中的记录会在后续强制删除；这里跳过可减少无意义告警
-            if (isDisabledPath(record.path)) {
-                continue;
-            }
-            const existing = existingMenuMap.get(record.path);
-            if (!existing) {
-                existingMenuMap.set(record.path, record);
-                continue;
-            }
-            const existingId = typeof existing?.id === "number" ? existing.id : 0;
-            const recordId = record.id;
-            // 保留 id 最大的一条（genTimeID 越大通常越新），其余标记为重复并清理
-            if (recordId > existingId) {
-                existingMenuMap.set(record.path, record);
-                if (existingId > 0) {
-                    duplicateIdSet.add(existingId);
-                }
-                const info = duplicatePathInfoMap.get(record.path) || { keptId: recordId, removedIds: [] };
-                info.keptId = recordId;
-                if (existingId > 0) {
-                    info.removedIds.push(existingId);
-                }
-                duplicatePathInfoMap.set(record.path, info);
-            }
-            else {
-                if (recordId > 0) {
-                    duplicateIdSet.add(recordId);
-                }
-                const info = duplicatePathInfoMap.get(record.path) || { keptId: existingId, removedIds: [] };
-                info.keptId = existingId;
-                if (recordId > 0) {
-                    info.removedIds.push(recordId);
-                }
-                duplicatePathInfoMap.set(record.path, info);
-            }
-        }
-        if (duplicatePathInfoMap.size > 0) {
-            const examples = [];
-            for (const entry of duplicatePathInfoMap.entries()) {
-                const path = entry[0];
-                const info = entry[1];
-                examples.push({ path: path, keptId: info.keptId, removedIds: info.removedIds });
-                if (examples.length >= 10) {
-                    break;
-                }
-            }
-            Logger.warn({
-                table: tableName,
-                duplicatePaths: duplicatePathInfoMap.size,
-                duplicateIds: duplicateIdSet.size,
-                examples: examples,
-                msg: "addon_admin_menu 检测到重复 path 记录：已保留 id 最大的一条并删除其余记录"
-            });
-        }
-        // 2) 一次性算出 insert/update（仅依赖 path diff，不使用 pid，不预生成 id）
-        const updList = [];
-        const insList = [];
-        for (const def of menuDefMap.values()) {
-            const existing = existingMenuMap.get(def.path);
-            if (existing) {
-                const existingParentPath = typeof existing.parentPath === "string" ? existing.parentPath : "";
-                const needUpdate = existing.name !== def.name || existing.sort !== def.sort || existingParentPath !== def.parentPath;
-                if (needUpdate) {
-                    updList.push({
-                        id: existing.id,
-                        data: {
-                            name: def.name,
-                            path: def.path,
-                            parentPath: def.parentPath,
-                            sort: def.sort
-                        }
-                    });
-                }
-            }
-            else {
-                insList.push({
-                    name: def.name,
-                    path: def.path,
-                    parentPath: def.parentPath,
-                    sort: def.sort
-                });
-            }
-        }
-        if (updList.length > 0) {
-            await trans.updBatch(tableName, updList);
-        }
-        if (insList.length > 0) {
-            await trans.insBatch(tableName, insList);
-        }
-        // 3) 删除差集（DB - 配置，仅 state>=0） + 删除重复 path 的多余记录 + 删除 disableMenus 命中菜单（不分 state）
-        const delIdSet = new Set();
-        for (const record of existingList) {
-            if (typeof record?.path !== "string" || !record.path) {
-                continue;
-            }
-            if (!configPaths.has(record.path)) {
-                if (typeof record?.id === "number") {
-                    delIdSet.add(record.id);
-                }
-            }
-        }
-        for (const id of duplicateIdSet) {
-            if (typeof id === "number" && id > 0) {
-                delIdSet.add(id);
-            }
-        }
-        // 删除 disableMenus 命中的菜单：不分 state（包括 state=-1 的历史/禁用数据也一并清理）
-        for (const record of existingListAllState) {
-            if (typeof record?.path !== "string" || !record.path) {
-                continue;
-            }
-            if (!isDisabledPath(record.path)) {
-                continue;
-            }
-            if (typeof record?.id === "number" && record.id > 0) {
-                delIdSet.add(record.id);
-            }
-        }
-        const delIds = Array.from(delIdSet);
-        if (delIds.length > 0) {
-            await trans.delForceBatch(tableName, delIds);
-        }
-    });
-    // 缓存同步职责已收敛到 syncCache（启动流程单点调用），此处只负责 DB 同步。
-}
-// 仅测试用（避免将内部扫描逻辑变成稳定 API）
-export const __test__ = {
-    scanViewsDir: async (viewsDir, prefix, parentPath = "") => {
-        const mod = await import("../utils/loadMenuConfigs");
-        return await mod.scanViewsDirToMenuConfigs(viewsDir, prefix, parentPath);
-    },
-    flattenMenusToDefMap: (mergedMenus) => {
-        return flattenMenusToDefMap(mergedMenus);
-    }
-};