befly 3.16.8 → 3.16.10

package/dist/checks/checkApi.js

@@ -84,9 +84,24 @@ export async function checkApi(apis) {
                 hasError = true;
             }
             const auth = record["auth"];
-            if (auth !== undefined && typeof auth !== "boolean") {
-                Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "接口的 auth 属性必须是布尔值 (true=需登录, false=公开)" }));
-                hasError = true;
+            if (auth !== undefined) {
+                if (typeof auth === "boolean") {
+                    // ok
+                }
+                else if (Array.isArray(auth)) {
+                    if (auth.length === 0) {
+                        Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "接口的 auth 数组不能为空" }));
+                        hasError = true;
+                    }
+                    else if (auth.some((item) => typeof item !== "string" || item.trim() === "")) {
+                        Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "接口的 auth 数组必须为非空字符串数组（roleType 列表）" }));
+                        hasError = true;
+                    }
+                }
+                else {
+                    Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "接口的 auth 属性必须是 boolean 或 string[]" }));
+                    hasError = true;
+                }
             }
             const fields = record["fields"];
             if (fields !== undefined && fields !== null && !isPlainObject(fields)) {

package/dist/hooks/permission.d.ts

@@ -2,6 +2,7 @@ import type { Hook } from "../types/hook";
 /**
  * 权限检查钩子
  * - 接口无需权限（auth=false）：直接通过
+ * - auth 为 roleType 白名单（string[]）：登录后按 roleType 放行
  * - 用户未登录：返回 401
  * - 开发者角色（dev）：最高权限，直接通过
  * - 其他角色：检查 Redis 中的角色权限集合

package/dist/hooks/permission.js

@@ -5,6 +5,7 @@ import { ErrorResponse } from "../utils/response";
 /**
  * 权限检查钩子
  * - 接口无需权限（auth=false）：直接通过
+ * - auth 为 roleType 白名单（string[]）：登录后按 roleType 放行
  * - 用户未登录：返回 401
  * - 开发者角色（dev）：最高权限，直接通过
  * - 其他角色：检查 Redis 中的角色权限集合
@@ -20,6 +21,7 @@ const permissionHook = {
         if (ctx.api.auth === false) {
             return;
         }
+        const authRule = ctx.api.auth;
         // 2. 用户未登录
         if (typeof ctx.user.id !== "number") {
             ctx.response = ErrorResponse(ctx, "未登录", 1, null, null, "auth");
@@ -29,6 +31,18 @@ const permissionHook = {
         if (ctx.user.roleCode === "dev") {
             return;
         }
+        // 3.5 auth 为角色类型白名单时，仅做 roleType 校验
+        if (Array.isArray(authRule)) {
+            const roleType = ctx.user.roleType;
+            if (typeof roleType !== "string" || !authRule.includes(roleType)) {
+                const apiNameLabel = typeof ctx.api.name === "string" && ctx.api.name.length > 0 ? ctx.api.name : null;
+                const apiPathLabel = typeof ctx.route === "string" && ctx.route.length > 0 ? ctx.route : null;
+                const apiLabel = apiNameLabel ? apiNameLabel : apiPathLabel ? apiPathLabel : "未知接口";
+                ctx.response = ErrorResponse(ctx, `无权访问 ${apiLabel} 接口`, 1, null, { apiLabel: apiLabel }, "permission");
+                return;
+            }
+            return;
+        }
         // 4. 角色权限检查
         // apiPath 在 apiHandler 中已统一生成并写入 ctx.route
         const apiPath = ctx.route;

package/dist/lib/dbHelper.js

@@ -4,7 +4,7 @@
  */
 import { CoreError } from "../types/coreError";
 import { toNumberFromSql, toSqlParams } from "../utils/sqlUtil";
-import { arrayKeysToCamel, isPlainObject, keysToCamel, snakeCase } from "../utils/util";
+import { arrayKeysToCamel, canConvertToNumber, isPlainObject, keysToCamel, snakeCase } from "../utils/util";
 import { DbUtils } from "./dbUtils";
 import { Logger } from "./logger";
 import { SqlBuilder } from "./sqlBuilder";
@@ -35,6 +35,20 @@ class DbSqlError extends Error {
         this.sqlInfo = options.sqlInfo;
     }
 }
+class TransAbortError extends Error {
+    payload;
+    constructor(payload) {
+        super("TRANSACTION_ABORT");
+        this.payload = payload;
+    }
+}
+function isBeflyResponse(value) {
+    if (!isPlainObject(value)) {
+        return false;
+    }
+    const record = value;
+    return typeof record["code"] === "number" && typeof record["msg"] === "string";
+}
 /**
  * 数据库助手类
  */
@@ -95,8 +109,9 @@ export class DbHelper {
                             }
                         }
                         if (bigintValue !== null) {
-                            if (bigintValue <= MAX_SAFE_INTEGER_BIGINT && bigintValue >= MIN_SAFE_INTEGER_BIGINT) {
-                                nextValue = Number(bigintValue);
+                            const convertedNumber = canConvertToNumber(bigintValue);
+                            if (convertedNumber !== null) {
+                                nextValue = convertedNumber;
                             }
                         }
                     }
@@ -892,7 +907,11 @@ export class DbHelper {
     async trans(callback) {
         if (this.isTransaction) {
             // 已经在事务中，直接执行回调
-            return await callback(this);
+            const innerResult = await callback(this);
+            if (isBeflyResponse(innerResult) && innerResult.code !== 0) {
+                throw new TransAbortError(innerResult);
+            }
+            return innerResult;
         }
         const sql = this.sql;
         if (!sql) {
@@ -903,10 +922,22 @@ export class DbHelper {
         }
         // 使用 Bun SQL 的 begin 方法开启事务
         // begin 方法会自动处理 commit/rollback
-        return await sql.begin(async (tx) => {
-            const trans = new DbHelper({ redis: this.redis, dbName: this.dbName, sql: tx, idMode: this.idMode });
-            return await callback(trans);
-        });
+        try {
+            return await sql.begin(async (tx) => {
+                const trans = new DbHelper({ redis: this.redis, dbName: this.dbName, sql: tx, idMode: this.idMode });
+                const result = await callback(trans);
+                if (isBeflyResponse(result) && result.code !== 0) {
+                    throw new TransAbortError(result);
+                }
+                return result;
+            });
+        }
+        catch (error) {
+            if (error instanceof TransAbortError) {
+                return error.payload;
+            }
+            throw error;
+        }
     }
     /**
      * 执行原始 SQL

package/dist/sync/syncApi.js

@@ -16,6 +16,28 @@ const getApiParentPath = (apiPath) => {
         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) {
@@ -57,15 +79,16 @@ export async function syncApi(ctx, apis) {
             continue;
         }
         const addonName = typeof addonNameRaw === "string" ? addonNameRaw : "";
-        // auth：运行时 API 定义使用 boolean；DB 字段使用 0/1。
+        // auth：运行时支持 boolean/string[]；DB 字段使用字符串（否/是/角色列表）。
         // 统一在 syncApi 写库前做归一化，避免类型不一致导致每次启动都触发更新。
         const authRaw = record["auth"];
-        const auth = authRaw === false || authRaw === 0 ? 0 : 1;
+        const auth = normalizeAuthForDb(authRaw);
         const parentPath = getApiParentPath(path);
         apiRouteKeys.add(path);
         const item = allDbApiMap[path];
         if (item) {
-            const shouldUpdate = name !== item.name || path !== item.path || addonName !== item.addonName || parentPath !== item.parentPath || auth !== item.auth;
+            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,

package/dist/types/api.d.ts

@@ -22,11 +22,12 @@ export interface UserInfo {
     [key: string]: JsonValue | undefined;
 }
 /**
- * 认证类型（运行时仅支持布尔值）
+ * 认证类型
  * - false: 不需要认证
  * - true: 需要认证（验证 token）
+ * - string[]: 需要认证，且仅允许 roleType 在数组中
  */
-export type AuthType = boolean;
+export type AuthType = boolean | string[];
 /**
  * API 处理器函数类型
  */
@@ -37,8 +38,8 @@ export type ApiHandler<TBody = Record<string, JsonValue>, R = JsonValue> = (befl
 export interface ApiOptions<TBody = Record<string, JsonValue>, R = JsonValue> {
     /** HTTP 方法 */
     method: HttpMethod;
-    /** 是否需要认证（true/false） */
-    auth?: boolean;
+    /** 认证规则（true/false/string[]） */
+    auth?: AuthType;
     /** 字段定义（验证规则） */
     fields?: TableDefinition;
     /** 必填字段 */
@@ -59,8 +60,9 @@ export interface ApiRoute<TBody = Record<string, JsonValue>, R = JsonValue> {
     /** 认证类型（可选，默认 true)
      * - true: 需要登录
      * - false: 公开访问（无需登录）
+     * - string[]: 需要登录，且 roleType 必须在数组中
      */
-    auth?: boolean;
+    auth?: AuthType;
     /** 字段定义（验证规则）（可选，默认 {}） */
     fields?: TableDefinition;
     /** 必填字段（可选，默认 []） */
@@ -84,7 +86,7 @@ export interface ApiBuilder {
     /** 设置描述 */
     description(desc: string): this;
     /** 设置认证 */
-    auth(auth: boolean): this;
+    auth(auth: AuthType): this;
     /** 设置验证规则 */
     rules(rules: KeyValue<string>): this;
     /** 设置必填字段 */

package/dist/types/sync.d.ts

@@ -59,8 +59,8 @@ export interface MenuConfig {
 export interface SyncApiItem {
     type?: "api" | string;
     name: string;
-    /** 是否需要登录：0=免登录，1=需登录（同步时会归一化为 0/1） */
-    auth?: 0 | 1 | boolean;
+    /** 是否需要登录：运行时支持 boolean/string[]；同步写库为字符串（否/是/角色列表） */
+    auth?: boolean | string[] | string;
     path: string;
     parentPath: string;
     addonName: string;

package/dist/utils/scanFiles.js

@@ -90,8 +90,8 @@ export async function scanFiles(dir, source, type, pattern) {
                 continue;
             }
             if (type === "api") {
-                // 运行时 auth 必须是 boolean：
-                // - checkApi 会校验 auth 类型
+                // auth 默认 true：
+                // - checkApi 会校验 auth 类型（boolean | string[]）
                 // - permission hook 以 ctx.api.auth === false 判断公开接口
                 // DB 存储的 0/1 由 syncApi 负责转换写入。
                 base["auth"] = true;

package/dist/utils/util.d.ts

@@ -31,6 +31,12 @@ export declare function isFiniteNumber(value: unknown): value is number;
  * 判断值是否为有限整数。
  */
 export declare function isIntegerNumber(value: unknown): value is number;
+/**
+ * 判断 bigint 是否可安全转换为 number。
+ * - 超出安全整数范围则不可转换
+ * - 转换后若是科学计数法表示则不可转换
+ */
+export declare function canConvertToNumber(value: bigint): number | null;
 /**
  * 安全格式化值用于日志预览（截断长文本，避免抛错）。
  */

package/dist/utils/util.js

@@ -83,6 +83,27 @@ export function isFiniteNumber(value) {
 export function isIntegerNumber(value) {
     return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value);
 }
+/**
+ * 判断 bigint 是否可安全转换为 number。
+ * - 超出安全整数范围则不可转换
+ * - 转换后若是科学计数法表示则不可转换
+ */
+export function canConvertToNumber(value) {
+    const maxSafe = BigInt(Number.MAX_SAFE_INTEGER);
+    const minSafe = BigInt(Number.MIN_SAFE_INTEGER);
+    if (value > maxSafe || value < minSafe) {
+        return null;
+    }
+    const asNumber = Number(value);
+    if (!Number.isSafeInteger(asNumber)) {
+        return null;
+    }
+    const text = String(asNumber);
+    if (text.includes("e") || text.includes("E")) {
+        return null;
+    }
+    return asNumber;
+}
 /**
  * 安全格式化值用于日志预览（截断长文本，避免抛错）。
  */

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "befly",
-    "version": "3.16.8",
-    "gitHead": "957e5590e9b4cb4a58958eeaa97b3ace7085bcd5",
+    "version": "3.16.10",
+    "gitHead": "3e9154027578c8eb3ba49141eef7c6ea3b385d7f",
     "private": false,
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "keywords": [