befly 3.13.9 → 3.14.0

package/dist/checks/checkApi.js

@@ -14,28 +14,28 @@ export async function checkApi(apis) {
                 hasError = true;
                 continue;
             }
-            // routePath / routePrefix 由 scanFiles 系统生成：必须是严格的 pathname
-            if (typeof api?.routePath !== "string" || api.routePath.trim() === "") {
-                Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 routePath 属性必须是非空字符串（由系统生成）" }));
+            // path / routePrefix 由 scanFiles 系统生成：必须是严格的 pathname
+            if (typeof api?.path !== "string" || api.path.trim() === "") {
+                Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 path 属性必须是非空字符串（由系统生成）" }));
                 hasError = true;
             }
             else {
-                const routePath = api.routePath.trim();
+                const path = api.path.trim();
                 // 不允许出现 "POST/api/..." 等 method 前缀
-                if (/^(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\b/i.test(routePath)) {
-                    Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 routePath 不允许包含 method 前缀，应为 url.pathname（例如 /api/app/xxx）" }));
+                if (/^(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\b/i.test(path)) {
+                    Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 path 不允许包含 method 前缀，应为 url.pathname（例如 /api/app/xxx）" }));
                     hasError = true;
                 }
-                if (!routePath.startsWith("/api/")) {
-                    Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 routePath 必须以 /api/ 开头" }));
+                if (!path.startsWith("/api/")) {
+                    Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 path 必须以 /api/ 开头" }));
                     hasError = true;
                 }
-                if (routePath.includes(" ")) {
-                    Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 routePath 不允许包含空格" }));
+                if (path.includes(" ")) {
+                    Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 path 不允许包含空格" }));
                     hasError = true;
                 }
-                if (routePath.includes("/api//")) {
-                    Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 routePath 不允许出现 /api//（重复斜杠）" }));
+                if (path.includes("/api//")) {
+                    Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "接口的 path 不允许出现 /api//（重复斜杠）" }));
                     hasError = true;
                 }
             }

package/dist/index.js

@@ -48,16 +48,15 @@ export class Befly {
      * 启动完整的生命周期流程
      * @returns HTTP 服务器实例
      */
-    async start(env) {
+    async start(env = {}) {
         try {
             const serverStartTime = Bun.nanoseconds();
-            const runtimeEnv = env || {};
             // 0. 加载配置
-            this.config = await loadBeflyConfig(runtimeEnv.NODE_ENV);
+            this.config = await loadBeflyConfig(env.NODE_ENV || "development");
             // 将配置注入到 ctx，供插件/Hook/sync 等按需读取
             this.context.config = this.config;
             // 给插件/Hook/sync 一个统一读取 env 的入口（只从 start 入参注入）
-            this.context.env = runtimeEnv;
+            this.context.env = env;
             const { apis, tables, plugins, hooks, addons } = await scanSources();
             // 让后续 syncMenu 能拿到 addon 的 views 路径等信息
             this.context.addons = addons;
@@ -131,7 +130,7 @@ export class Befly {
                 }
             });
             const finalStartupTime = calcPerfTime(serverStartTime);
-            const processRole = getProcessRole(runtimeEnv);
+            const processRole = getProcessRole(env);
             const roleLabel = processRole.role === "primary" ? "主进程" : `工作进程 #${processRole.instanceId}`;
             const envLabel = processRole.env === "standalone" ? "" : ` [${processRole.env}]`;
             Logger.info(`${this.config.appName} 启动成功! (${roleLabel}${envLabel})`);

package/dist/loader/loadApis.js

@@ -12,17 +12,16 @@ import { processAtSymbol } from "../utils/processAtSymbol";
 export async function loadApis(apis) {
     const apisMap = new Map();
     for (const api of apis) {
-        const apiType = api.type;
         // 兼容：scanFiles 的结果或测试构造数据可能缺少 type 字段；缺少时默认按 API 处理。
         // 仅在 type 显式存在且不等于 "api" 时跳过，避免错误过滤。
-        if (apiType && apiType !== "api") {
+        if (api.type !== "api") {
             continue;
         }
         try {
             const apiRoute = api;
             // 处理字段定义，将 @ 引用替换为实际字段定义
-            apiRoute.fields = processAtSymbol(apiRoute.fields || {}, apiRoute.name, apiRoute.routePath);
-            apisMap.set(apiRoute.routePath, apiRoute);
+            apiRoute.fields = processAtSymbol(apiRoute.fields || {}, apiRoute.name, apiRoute.path);
+            apisMap.set(apiRoute.path, apiRoute);
         }
         catch (error) {
             Logger.error({ err: error, api: api.relativePath, file: api.filePath, msg: "接口加载失败" });

package/dist/router/api.js

@@ -21,7 +21,7 @@ export function apiHandler(apis, hooks, context) {
         // 2. 创建请求上下文
         const url = new URL(req.url);
         // 只用接口路径做存在性判断与匹配：不要把 method 拼进 key
-        // 说明：apisMap 的 key 来源于 scanFiles/loadApis 生成的 routePath（例如 /api/core/xxx）
+        // 说明：apisMap 的 key 来源于 scanFiles/loadApis 生成的 path（例如 /api/core/xxx）
         const apiPath = url.pathname || "/";
         const clientIp = getClientIp(req, server);
         const now = Date.now();

package/dist/sync/syncApi.js

@@ -1,5 +1,20 @@
 import { Logger } from "../lib/logger";
 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("/")}`;
+};
 export async function syncApi(ctx, apis) {
     const tableName = "addon_admin_api";
     if (!ctx.db) {
@@ -14,61 +29,68 @@ export async function syncApi(ctx, apis) {
     }
     const allDbApis = await ctx.db.getAll({
         table: tableName,
-        fields: ["id", "routePath", "name", "addonName", "auth", "state"],
+        fields: ["id", "path", "parentPath", "name", "addonName", "auth", "state"],
         where: { state$gte: 0 }
     });
     const dbLists = allDbApis.data.lists || [];
-    const allDbApiMap = keyBy(dbLists, (item) => item.routePath);
+    const allDbApiMap = keyBy(dbLists, (item) => item.path);
     const insData = [];
     const updData = [];
     const delData = [];
-    // 1) 先构建当前扫描到的 routePath 集合（用于删除差集）
+    // 1) 先构建当前扫描到的 path 集合（用于删除差集）
     const apiRouteKeys = new Set();
-    // 2) 插入 / 更新（存在不一定更新：仅当 name/routePath/addonName/auth 任一不匹配时更新）
+    // 2) 插入 / 更新（存在不一定更新：仅当 name/path/addonName/auth 任一不匹配时更新）
     for (const api of apis) {
-        const apiType = api.type;
-        // 兼容：历史/测试构造的数据可能没有 type 字段；此时应按 API 处理。
-        // 因此仅当 type **显式存在** 且不为 "api" 时才跳过，避免误把真实 API 条目过滤掉。
-        if (apiType && apiType !== "api") {
+        // 仅当 type **显式存在** 且不为 "api" 时才跳过，避免误把真实 API 条目过滤掉。
+        if (api.type !== "api") {
             continue;
         }
-        const normalizedAuth = api.auth === 0 || api.auth === false ? 0 : 1;
-        const normalizedApi = {
-            name: api.name,
-            routePath: api.routePath,
-            addonName: api.addonName,
-            auth: normalizedAuth
-        };
-        const routePath = normalizedApi.routePath;
-        apiRouteKeys.add(routePath);
-        const item = allDbApiMap[routePath];
+        // auth：运行时 API 定义使用 boolean；DB 字段使用 0/1。
+        // 统一在 syncApi 写库前做归一化，避免类型不一致导致每次启动都触发更新。
+        const auth = api.auth === false || api.auth === 0 ? 0 : 1;
+        const parentPath = getApiParentPath(api.path);
+        apiRouteKeys.add(api.path);
+        const item = allDbApiMap[api.path];
         if (item) {
-            const dbAuth = item.auth === 0 || item.auth === false ? 0 : 1;
-            const shouldUpdate = normalizedApi.name !== item.name || normalizedApi.routePath !== item.routePath || normalizedApi.addonName !== item.addonName || normalizedAuth !== dbAuth;
+            const shouldUpdate = api.name !== item.name || api.path !== item.path || api.addonName !== item.addonName || parentPath !== item.parentPath || auth !== item.auth;
             if (shouldUpdate) {
-                updData.push({ id: item.id, api: normalizedApi });
+                updData.push({
+                    id: item.id,
+                    name: api.name,
+                    path: api.path,
+                    parentPath: parentPath,
+                    addonName: api.addonName,
+                    auth: auth
+                });
             }
         }
         else {
-            insData.push(normalizedApi);
+            insData.push({
+                name: api.name,
+                path: api.path,
+                parentPath: parentPath,
+                addonName: api.addonName,
+                auth: auth
+            });
         }
     }
     // 3) 删除：用差集（DB - 当前扫描）得到要删除的 id
     for (const record of dbLists) {
-        if (!apiRouteKeys.has(record.routePath)) {
+        if (!apiRouteKeys.has(record.path)) {
             delData.push(record.id);
         }
     }
     if (updData.length > 0) {
         try {
-            await ctx.db.updBatch(tableName, updData.map((item) => {
+            await ctx.db.updBatch(tableName, updData.map((api) => {
                 return {
-                    id: item.id,
+                    id: api.id,
                     data: {
-                        name: item.api.name,
-                        routePath: item.api.routePath,
-                        addonName: item.api.addonName,
-                        auth: item.api.auth === 0 || item.api.auth === false ? 0 : 1
+                        name: api.name,
+                        path: api.path,
+                        parentPath: api.parentPath,
+                        addonName: api.addonName,
+                        auth: api.auth
                     }
                 };
             }));
@@ -82,9 +104,10 @@ export async function syncApi(ctx, apis) {
             await ctx.db.insBatch(tableName, insData.map((api) => {
                 return {
                     name: api.name,
-                    routePath: api.routePath,
+                    path: api.path,
+                    parentPath: api.parentPath,
                     addonName: api.addonName,
-                    auth: api.auth === 0 || api.auth === false ? 0 : 1
+                    auth: api.auth
                 };
             }));
         }

package/dist/sync/syncDev.js

@@ -4,7 +4,6 @@ export async function syncDev(ctx, config = {}) {
     if (!config.devPassword) {
         return;
     }
-    const devEmail = typeof config.devEmail === "string" && config.devEmail.length > 0 ? config.devEmail : "dev@qq.com";
     if (!ctx.db) {
         throw new Error("syncDev: ctx.db 未初始化（Db 插件未加载或注入失败）");
     }
@@ -23,140 +22,132 @@ export async function syncDev(ctx, config = {}) {
         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 menuPaths = Array.from(new Set((allMenus.data.lists || []).map((m) => (typeof m?.path === "string" ? m.path.trim() : "")).filter((p) => p.length > 0)));
-    const existApi = await ctx.db.tableExists("addon_admin_api");
-    let apiPaths = [];
-    if (existApi.data) {
-        const allApis = await ctx.db.getAll({
-            table: "addon_admin_api",
-            fields: ["routePath"],
-            where: { state$gte: 0 },
-            orderBy: ["id#ASC"]
-        });
-        apiPaths = Array.from(new Set((allApis.data.lists || []).map((a) => {
-            if (typeof a?.routePath !== "string") {
-                throw new Error("syncDev: addon_admin_api.routePath 必须是字符串");
-            }
-            const routePath = a.routePath.trim();
-            if (routePath.length === 0) {
-                throw new Error("syncDev: addon_admin_api.routePath 不允许为空字符串");
+    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) => v),
+        apis: allApis.data.lists.map((item) => item.path).filter((v) => v),
+        sort: 0
+    };
+    if (devRole.data) {
+        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
             }
-            if (!routePath.startsWith("/")) {
-                throw new Error(`syncDev: addon_admin_api.routePath 必须是 pathname（以 / 开头），当前值=${routePath}`);
+        });
+    }
+    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 (devAdmin.data) {
+        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
             }
-            return routePath;
-        })));
+        });
+    }
+    else {
+        await ctx.db.insData({
+            table: "addon_admin_admin",
+            data: devAdminData
+        });
     }
     const roles = [
-        {
-            code: "dev",
-            name: "开发者角色",
-            description: "拥有所有菜单和接口权限的开发者角色",
-            menus: menuPaths,
-            apis: apiPaths,
-            sort: 0
-        },
         {
             code: "user",
             name: "用户角色",
             description: "普通用户角色",
-            menus: [],
-            apis: [],
             sort: 1
         },
         {
             code: "admin",
             name: "管理员角色",
             description: "管理员角色",
-            menus: [],
-            apis: [],
             sort: 2
         },
         {
             code: "guest",
             name: "访客角色",
             description: "访客角色",
-            menus: [],
-            apis: [],
             sort: 3
         }
     ];
-    let devRole = null;
     for (const roleConfig of roles) {
         const existingRole = await ctx.db.getOne({
             table: "addon_admin_role",
             where: { code: roleConfig.code }
         });
-        if (existingRole.data) {
-            const nextMenus = roleConfig.menus;
-            const nextApis = roleConfig.apis;
-            const existingMenus = Array.isArray(existingRole.data.menus) ? existingRole.data.menus : [];
-            const existingApis = Array.isArray(existingRole.data.apis) ? existingRole.data.apis : [];
-            const menusChanged = existingMenus.length !== nextMenus.length || existingMenus.some((v, i) => v !== nextMenus[i]);
-            const apisChanged = existingApis.length !== nextApis.length || existingApis.some((v, i) => v !== nextApis[i]);
-            const hasChanges = existingRole.data.name !== roleConfig.name || existingRole.data.description !== roleConfig.description || menusChanged || apisChanged || existingRole.data.sort !== roleConfig.sort;
-            if (hasChanges) {
-                await ctx.db.updData({
-                    table: "addon_admin_role",
-                    where: { code: roleConfig.code },
-                    data: {
-                        name: roleConfig.name,
-                        description: roleConfig.description,
-                        menus: roleConfig.menus,
-                        apis: roleConfig.apis,
-                        sort: roleConfig.sort
-                    }
-                });
-            }
-            if (roleConfig.code === "dev") {
-                devRole = existingRole.data;
-            }
+        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 {
-            const roleId = await ctx.db.insData({
+            await ctx.db.insData({
                 table: "addon_admin_role",
-                data: roleConfig
+                data: {
+                    code: roleConfig.code,
+                    name: roleConfig.name,
+                    description: roleConfig.description,
+                    sort: roleConfig.sort
+                }
             });
-            if (roleConfig.code === "dev") {
-                devRole = { id: roleId.data };
-            }
         }
     }
-    if (!devRole) {
-        Logger.error("dev 角色不存在，无法创建开发者账号");
-        return;
-    }
-    const sha256Hashed = Cipher.sha256(config.devPassword + "befly");
-    const hashed = await Cipher.hashPassword(sha256Hashed);
-    const devData = {
-        nickname: "开发者",
-        email: devEmail,
-        username: "dev",
-        password: hashed,
-        roleCode: "dev",
-        roleType: "admin"
-    };
-    const existing = await ctx.db.getOne({
-        table: "addon_admin_admin",
-        where: { email: devEmail }
-    });
-    if (existing.data) {
-        await ctx.db.updData({
-            table: "addon_admin_admin",
-            where: { email: devEmail },
-            data: devData
-        });
-    }
-    else {
-        await ctx.db.insData({
-            table: "addon_admin_admin",
-            data: devData
-        });
-    }
 }

package/dist/types/sync.d.ts

@@ -61,7 +61,8 @@ export interface SyncApiItem {
     name: string;
     /** 是否需要登录：0=免登录，1=需登录（同步时会归一化为 0/1） */
     auth?: 0 | 1 | boolean;
-    routePath: string;
+    path: string;
+    parentPath: string;
     addonName: string;
     [key: string]: any;
 }

package/dist/utils/processAtSymbol.d.ts

@@ -1,4 +1,4 @@
 /**
  * 处理字段定义：将 @ 符号引用替换为实际字段定义
  */
-export declare function processAtSymbol(fields: Record<string, any>, apiName: string, routePath: string): Record<string, any>;
+export declare function processAtSymbol(fields: Record<string, any>, apiName: string, path: string): Record<string, any>;

package/dist/utils/processAtSymbol.js

@@ -2,7 +2,7 @@ import { presetFields } from "../configs/presetFields";
 /**
  * 处理字段定义：将 @ 符号引用替换为实际字段定义
  */
-export function processAtSymbol(fields, apiName, routePath) {
+export function processAtSymbol(fields, apiName, path) {
     if (!fields || typeof fields !== "object")
         return fields;
     const processed = {};
@@ -13,7 +13,7 @@ export function processAtSymbol(fields, apiName, routePath) {
                 continue;
             }
             const validKeys = Object.keys(presetFields).join(", ");
-            throw new Error(`API [${apiName}] (${routePath}) 字段 [${key}] 引用了未定义的预设字段 "${value}"。可用的预设字段有: ${validKeys}`);
+            throw new Error(`API [${apiName}] (${path}) 字段 [${key}] 引用了未定义的预设字段 "${value}"。可用的预设字段有: ${validKeys}`);
         }
         processed[key] = value;
     }

package/dist/utils/scanFiles.js

@@ -102,6 +102,10 @@ export async function scanFiles(dir, source, type, pattern) {
                 continue;
             }
             if (type === "api") {
+                // 运行时 auth 必须是 boolean：
+                // - checkApi 会校验 auth 类型
+                // - permission hook 以 ctx.api.auth === false 判断公开接口
+                // DB 存储的 0/1 由 syncApi 负责转换写入。
                 base.auth = true;
                 base.rawBody = false;
                 base.method = "POST";
@@ -118,7 +122,7 @@ export async function scanFiles(dir, source, type, pattern) {
             });
             if (type === "api") {
                 base.routePrefix = source === "app" ? "/app" : `/addon/${addonName}`;
-                base.routePath = `/api${base.routePrefix}/${relativePath}`;
+                base.path = `/api${base.routePrefix}/${relativePath}`;
             }
             results.push(base);
         }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "befly",
-    "version": "3.13.9",
-    "gitHead": "990c7108a9a791b9816c447309ec586d08b96ab4",
+    "version": "3.14.0",
+    "gitHead": "0d60e323a83a1fc53822147de877af19cdb972c0",
     "private": false,
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "keywords": [