befly 3.17.0 → 3.17.2

package/utils/processInfo.js

@@ -0,0 +1,39 @@
+/**
+ * 进程角色信息
+ */
+
+/**
+ * 获取当前进程角色信息
+ * @returns 进程角色、实例 ID 和运行环境
+ */
+export function getProcessRole(env) {
+    const runtimeEnv = env || {};
+
+    const bunWorkerId = runtimeEnv["BUN_WORKER_ID"];
+    const pm2InstanceId = runtimeEnv["PM2_INSTANCE_ID"];
+
+    // Bun 集群模式
+    if (bunWorkerId !== undefined) {
+        return {
+            role: bunWorkerId === "" ? "primary" : "worker",
+            instanceId: bunWorkerId || "0",
+            env: "bun-cluster"
+        };
+    }
+
+    // PM2 集群模式
+    if (pm2InstanceId !== undefined) {
+        return {
+            role: pm2InstanceId === "0" ? "primary" : "worker",
+            instanceId: pm2InstanceId,
+            env: "pm2-cluster"
+        };
+    }
+
+    // 单进程模式
+    return {
+        role: "primary",
+        instanceId: null,
+        env: "standalone"
+    };
+}

package/utils/regexpUtil.js

@@ -0,0 +1,52 @@
+import { isMinLengthString } from "./is.js";
+import RegexAliases from "../configs/regexpAlias.json";
+
+const regexCache = new Map();
+
+export function getRegex(name) {
+    if (name.startsWith("@")) {
+        const alias = name.slice(1);
+        return RegexAliases[alias] || name;
+    }
+    return name;
+}
+
+function parseRegexLiteral(pattern) {
+    const trimmed = String(pattern || "").trim();
+    if (!isMinLengthString(trimmed, 2)) return null;
+    if (!trimmed.startsWith("/")) return null;
+
+    const lastSlash = trimmed.lastIndexOf("/");
+    if (lastSlash <= 0) return null;
+
+    const flags = trimmed.slice(lastSlash + 1);
+    if (flags !== "" && !/^[gimsuy]+$/.test(flags)) return null;
+
+    return { source: trimmed.slice(1, lastSlash), flags: flags };
+}
+
+export function getCompiledRegex(pattern, flags) {
+    const literal = parseRegexLiteral(pattern);
+    const regexStr = literal ? literal.source : getRegex(pattern);
+    const useFlags = literal && literal.flags !== "" ? literal.flags : flags || "";
+    const cacheKey = `${regexStr}:${useFlags}`;
+
+    let cached = regexCache.get(cacheKey);
+    if (!cached) {
+        cached = new RegExp(regexStr, useFlags);
+        regexCache.set(cacheKey, cached);
+    }
+    return cached;
+}
+
+export function matchRegex(value, pattern) {
+    return getCompiledRegex(pattern).test(value);
+}
+
+export function clearRegexCache() {
+    regexCache.clear();
+}
+
+export function getRegexCacheSize() {
+    return regexCache.size;
+}

package/utils/response.js

@@ -0,0 +1,114 @@
+import { Logger } from "../lib/logger.js";
+import { isString } from "./is.js";
+
+/**
+ * 创建错误响应（专用于 Hook 中间件）
+ * 在钩子中提前拦截请求时使用
+ * @param ctx - 请求上下文
+ * @param msg - 错误消息
+ * @param code - 错误码，默认 1
+ * @param data - 附加数据，默认 null
+ * @param detail - 详细信息，用于标记具体提示位置，默认 null
+ * @param reasonCode - 拦截原因标识（用于统计/聚合），默认 null
+ * @returns Response 对象
+ */
+export function ErrorResponse(ctx, msg, code = 1, data = null, detail = null, reasonCode = null) {
+    // 记录拦截日志
+    if (ctx.requestId) {
+        // requestId/apiPath/user/duration 等字段由调用方显式写入日志上下文，避免在 msg 中重复拼接
+        Logger.info("请求已拦截", {
+            event: "request_blocked",
+            reason: msg,
+            reasonCode: reasonCode,
+            code: code,
+            detail: detail
+        });
+    }
+
+    return Response.json(
+        {
+            code: code,
+            msg: msg,
+            data: data,
+            detail: detail
+        },
+        {
+            headers: ctx.corsHeaders
+        }
+    );
+}
+
+/**
+ * 创建最终响应（专用于 API 路由结尾）
+ * 自动处理 ctx.response/ctx.result，并记录请求日志
+ * @param ctx - 请求上下文
+ * @returns Response 对象
+ */
+export function FinalResponse(ctx) {
+    // 记录请求日志
+    if (ctx.apiPath && ctx.requestId) {
+        // requestId/apiPath/user/duration 等字段由调用方显式写入日志上下文，避免在 msg 中重复拼接
+        Logger.info("请求完成", {
+            event: "request_done"
+        });
+    }
+
+    // 1. 如果已经有 response，直接返回
+    if (ctx.response) {
+        return ctx.response;
+    }
+
+    // 2. 如果有 result，格式化为响应
+    if (ctx.result !== undefined) {
+        let result = ctx.result;
+
+        // 如果是字符串，自动包裹为成功响应
+        if (isString(result)) {
+            result = {
+                code: 0,
+                msg: result
+            };
+        }
+        // 如果是对象，自动补充 code: 0
+        else if (result && typeof result === "object") {
+            if (!("code" in result)) {
+                const merged = { code: 0 };
+                for (const key of Object.keys(result)) {
+                    merged[key] = result[key];
+                }
+                result = merged;
+            }
+        }
+
+        // 处理 BigInt 序列化问题
+        if (result && typeof result === "object") {
+            const jsonString = JSON.stringify(result, (key, value) => (typeof value === "bigint" ? value.toString() : value));
+            const headers = {};
+            const cors = ctx.corsHeaders;
+            if (cors && typeof cors === "object") {
+                for (const key of Object.keys(cors)) {
+                    headers[key] = cors[key];
+                }
+            }
+            headers["Content-Type"] = "application/json";
+            return new Response(jsonString, {
+                headers: headers
+            });
+        } else {
+            return Response.json(result, {
+                headers: ctx.corsHeaders
+            });
+        }
+    }
+
+    // 3. 默认响应：没有生成响应
+    return Response.json(
+        {
+            code: 1,
+            msg: "未生成响应"
+        },
+        {
+            headers: ctx.corsHeaders
+        }
+    );
+}

package/utils/scanFiles.js

@@ -0,0 +1,124 @@
+import { existsSync } from "node:fs";
+
+import { relative, normalize, parse, join } from "pathe";
+
+import { importDefault } from "./importDefault.js";
+import { isPlainObject } from "./is.js";
+
+// [ hooks ]-112 {
+//   source: "core",
+//   type: "hook",
+//   filePath: "D:/codes/befly/packages/core/hooks/auth.js",
+//   relativePath: "auth",
+//   fileName: "auth",
+//   apiPath: "/api/core/auth",
+//   name: "auth",
+//   deps: [ "cors" ],
+//   handler: [AsyncFunction: handler],
+// }
+// 🔥[ plugins ]-112 {
+//   source: "core",
+//   type: "plugin",
+//   filePath: "D:/codes/befly/packages/core/plugins/cache.js",
+//   relativePath: "cache",
+//   fileName: "cache",
+//   apiPath: "/api/core/cache",
+//   name: "cache",
+//   deps: [ "logger", "redis", "mysql" ],
+//   handler: [AsyncFunction: handler],
+// }
+// 🔥[ tables ]-112 {
+//   source: "core",
+//   type: "table",
+//   filePath: "D:/codes/befly/packages/core/tables/admin.json",
+//   relativePath: "admin",
+//   fileName: "admin",
+//   apiPath: "/api/core/admin",
+//     "lastLoginTime", "lastLoginIp"
+//   ],
+//   name: "admin",
+// }
+// 🔥[ apis ]-112 {
+//   source: "core",
+//   type: "api",
+//   filePath: "D:/codes/befly/packages/core/apis/sysConfig/all.js",
+//   relativePath: "sysConfig/all",
+//   fileName: "all",
+//   apiPath: "/api/core/sysConfig/all",
+//   name: "all",
+//   method: "POST",
+//   body: "none",
+//   auth: true,
+//   fields: {},
+//   required: [],
+//   handler: [AsyncFunction: handler],
+// }
+
+/**
+ * 扫描指定目录下的文件
+ * @param dir 目录路径
+ * @param source 文件来源（app/core）
+ * @param type 文件类型（api/table/plugin/hook）
+ * @param pattern Glob模式
+ */
+export async function scanFiles(dir, source, type, pattern) {
+    try {
+        const glob = new Bun.Glob(pattern);
+        if (!existsSync(dir)) return [];
+
+        const results = [];
+
+        const files = await glob.scan({
+            cwd: dir,
+            onlyFiles: true,
+            absolute: true,
+            followSymlinks: true
+        });
+
+        for await (const file of files) {
+            // 使用 pathe.normalize 统一路径分隔符为 /
+            const filePath = normalize(file);
+            const parsedFile = parse(filePath);
+
+            // 获取文件名（去除扩展名）
+            const fileName = parsedFile.name;
+
+            // 计算相对路径（去除扩展名）
+            const parsedRelativePath = parse(relative(dir, filePath));
+            const relativePath = parsedRelativePath.dir ? join(parsedRelativePath.dir, parsedRelativePath.name) : parsedRelativePath.name;
+
+            // 固定默认过滤（不可关闭）：忽略下划线开头的文件/目录
+            if (relativePath.split("/").some((part) => part.startsWith("_"))) continue;
+            const content = await importDefault(filePath, {});
+            const contentObj = isPlainObject(content) ? content : {};
+
+            const base = {
+                source: source,
+                type: type,
+                filePath: filePath,
+                relativePath: relativePath,
+                fileName: fileName,
+                apiPath: `/api/${source}/${relativePath}`
+            };
+            if (type === "table") {
+                base["fieldsDef"] = contentObj;
+            }
+            if (type === "api") {
+                base["name"] = "";
+            }
+            if (type !== "table") {
+                for (const [key, value] of Object.entries(contentObj)) {
+                    if (base[key]) continue;
+                    base[key] = value;
+                }
+            }
+            results.push(base);
+        }
+        return results;
+    } catch (error) {
+        throw new Error(`扫描失败: source=${source} type=${type} dir=${dir} pattern=${pattern}`, {
+            cause: error,
+            code: "runtime"
+        });
+    }
+}

package/utils/scanSources.js

@@ -0,0 +1,68 @@
+import { join } from "pathe";
+
+import {
+    //
+    coreTableDir,
+    appTableDir,
+    corePluginDir,
+    appPluginDir,
+    coreHookDir,
+    appHookDir,
+    coreApiDir,
+    appApiDir
+} from "../paths.js";
+import { scanFiles } from "./scanFiles.js";
+
+export const scanSources = async () => {
+    const apis = [];
+    const plugins = [];
+    const hooks = [];
+    const tables = [];
+
+    // 处理表格
+    const allCoreTables = await scanFiles(coreTableDir, "core", "table", "*.json");
+    for (const item of allCoreTables) {
+        tables.push(item);
+    }
+    const allAppTables = await scanFiles(appTableDir, "app", "table", "*.json");
+    for (const item of allAppTables) {
+        tables.push(item);
+    }
+
+    // 处理插件
+    const allCorePlugins = await scanFiles(corePluginDir, "core", "plugin", "*.js");
+    for (const item of allCorePlugins) {
+        plugins.push(item);
+    }
+    const allAppPlugins = await scanFiles(appPluginDir, "app", "plugin", "*.js");
+    for (const item of allAppPlugins) {
+        plugins.push(item);
+    }
+
+    // 处理钩子
+    const allCoreHooks = await scanFiles(coreHookDir, "core", "hook", "*.js");
+    for (const item of allCoreHooks) {
+        hooks.push(item);
+    }
+    const allAppHooks = await scanFiles(appHookDir, "app", "hook", "*.js");
+    for (const item of allAppHooks) {
+        hooks.push(item);
+    }
+
+    // 处理接口
+    const allCoreApis = await scanFiles(coreApiDir, "core", "api", "**/*.js");
+    for (const item of allCoreApis) {
+        apis.push(item);
+    }
+    const allAppApis = await scanFiles(appApiDir, "app", "api", "**/*.js");
+    for (const item of allAppApis) {
+        apis.push(item);
+    }
+
+    return {
+        hooks: hooks,
+        plugins: plugins,
+        apis: apis,
+        tables: tables
+    };
+};

package/utils/sortModules.js

@@ -0,0 +1,75 @@
+import { Logger } from "../lib/logger.js";
+
+/**
+ * 按 deps 拓扑排序 scanSources 扫描得到的插件/钩子。
+ *
+ * 说明：
+ * - 输入为 scanSources/scanFiles 的条目数组：每个条目包含 fileName 与 deps。
+ * - deps 里的字符串会与 fileName 匹配。
+ * - 若出现：重复 name、缺失依赖、循环依赖，则返回 false。
+ */
+export function sortModules(items) {
+    const result = [];
+    const visited = new Set();
+    const visiting = new Set();
+
+    const nameToItem = {};
+    let isPass = true;
+
+    // 1) 建表 + 重名检查
+    for (const item of items) {
+        if (nameToItem[item.fileName]) {
+            Logger.error("模块 名称重复，无法根据 deps 唯一定位", null, {
+                name: item.fileName,
+                first: nameToItem[item.fileName],
+                second: item
+            });
+            isPass = false;
+            continue;
+        }
+
+        nameToItem[item.fileName] = item;
+    }
+
+    if (!isPass) return false;
+
+    // 2) 依赖存在性检查
+    for (const item of items) {
+        for (const dep of item.deps) {
+            if (!nameToItem[dep]) {
+                Logger.error("模块 依赖未找到", null, { module: item.fileName, dependency: dep });
+                isPass = false;
+            }
+        }
+    }
+
+    if (!isPass) return false;
+
+    // 3) 拓扑排序（DFS）
+    const visit = (name) => {
+        if (visited.has(name)) return;
+        if (visiting.has(name)) {
+            Logger.error("模块 循环依赖", null, { module: name });
+            isPass = false;
+            return;
+        }
+
+        const item = nameToItem[name];
+        if (!item) return;
+
+        visiting.add(name);
+        for (const dep of item.deps) {
+            visit(dep);
+        }
+        visiting.delete(name);
+
+        visited.add(name);
+        result.push(item);
+    };
+
+    for (const item of items) {
+        visit(item.fileName);
+    }
+
+    return isPass ? result : false;
+}

package/utils/toSessionTtlSeconds.js

@@ -0,0 +1,14 @@
+export function toSessionTtlSeconds(ttlDays) {
+    if (typeof ttlDays === "number" && Number.isFinite(ttlDays) && ttlDays > 0) {
+        return Math.floor(ttlDays * 24 * 60 * 60);
+    }
+
+    if (typeof ttlDays === "string") {
+        const parsed = Number(ttlDays.trim());
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return Math.floor(parsed * 24 * 60 * 60);
+        }
+    }
+
+    return 7 * 24 * 60 * 60;
+}