befly 3.10.18 → 3.11.1

package/{plugins/tool.ts → dist/plugins/tool.js}

@@ -2,11 +2,6 @@
  * 工具插件
  * 提供常用的工具函数
  */
-
-import type { RequestContext } from "../types/context.ts";
-// 类型导入
-import type { Plugin } from "../types/plugin.ts";
-
 /**
  * 成功响应
  * @param msg - 消息
@@ -14,7 +9,7 @@ import type { Plugin } from "../types/plugin.ts";
  * @param other - 其他字段（可选）
  * @returns 成功响应对象
  */
-export function Yes(msg: string, data: any = {}, other: Record<string, any> = {}) {
+export function Yes(msg, data = {}, other = {}) {
     return {
         code: 0,
         msg: msg,
@@ -22,7 +17,6 @@ export function Yes(msg: string, data: any = {}, other: Record<string, any> = {}
         ...other
     };
 }
-
 /**
  * 失败响应
  * @param msg - 消息
@@ -30,7 +24,7 @@ export function Yes(msg: string, data: any = {}, other: Record<string, any> = {}
  * @param other - 其他字段（可选）
  * @returns 失败响应对象
  */
-export function No(msg: string, data: any = null, other: Record<string, any> = {}) {
+export function No(msg, data = null, other = {}) {
     return {
         code: 1,
         msg: msg,
@@ -38,19 +32,6 @@ export function No(msg: string, data: any = null, other: Record<string, any> = {
         ...other
     };
 }
-
-/**
- * 响应选项
- */
-interface ResponseOptions {
-    /** HTTP 状态码，默认 200 */
-    status?: number;
-    /** Content-Type，默认根据 data 类型自动判断 */
-    contentType?: string;
-    /** 额外的响应头 */
-    headers?: Record<string, string>;
-}
-
 /**
  * 统一响应函数
  *
@@ -80,13 +61,11 @@ interface ResponseOptions {
  *   headers: { 'X-Custom': 'value' }
  * });
  */
-export function Raw(ctx: RequestContext, data: Record<string, any> | string, options: ResponseOptions = {}): Response {
+export function Raw(ctx, data, options = {}) {
     const { status = 200, contentType, headers = {} } = options;
-
     // 自动判断 Content-Type
     let finalContentType = contentType;
-    let body: string;
-
+    let body;
     if (typeof data === "string") {
         // 字符串类型
         body = data;
@@ -94,26 +73,26 @@ export function Raw(ctx: RequestContext, data: Record<string, any> | string, opt
             // 自动判断：XML 或纯文本
             finalContentType = data.trim().startsWith("<") ? "application/xml" : "text/plain";
         }
-    } else {
+    }
+    else {
         // 对象类型，JSON 序列化
         body = JSON.stringify(data);
         finalContentType = finalContentType || "application/json";
     }
-
     // 合并响应头
     const responseHeaders = {
         ...ctx.corsHeaders,
         "Content-Type": finalContentType,
         ...headers
     };
-
     return new Response(body, {
         status: status,
         headers: responseHeaders
     });
 }
-
 export default {
+    name: "tool",
+    enable: true,
     deps: [],
     handler: () => {
         return {
@@ -122,4 +101,4 @@ export default {
             Raw: Raw
         };
     }
-} satisfies Plugin;
+};

package/dist/router/api.d.ts

@@ -0,0 +1,14 @@
+/**
+ * API路由处理器
+ * 处理 /api/* 路径的请求
+ */
+import type { ApiRoute } from "../types/api";
+import type { BeflyContext } from "../types/befly";
+import type { Hook } from "../types/hook";
+/**
+ * API处理器工厂函数
+ * @param apis - API路由映射表
+ * @param hooks - 钩子列表
+ * @param context - 应用上下文
+ */
+export declare function apiHandler(apis: Map<string, ApiRoute>, hooks: Hook[], context: BeflyContext): (req: Request, server?: any) => Promise<Response>;

package/dist/router/api.js

@@ -0,0 +1,107 @@
+/**
+ * API路由处理器
+ * 处理 /api/* 路径的请求
+ */
+import { withCtx } from "../lib/asyncContext";
+import { Logger } from "../lib/logger";
+// 相对导入
+import { getClientIp } from "../utils/getClientIp";
+import { FinalResponse } from "../utils/response";
+import { genShortId } from "../utils/util";
+/**
+ * API处理器工厂函数
+ * @param apis - API路由映射表
+ * @param hooks - 钩子列表
+ * @param context - 应用上下文
+ */
+export function apiHandler(apis, hooks, context) {
+    return async (req, server) => {
+        // 1. 生成请求 ID
+        const requestId = genShortId();
+        // 2. 创建请求上下文
+        const url = new URL(req.url);
+        // 只用接口路径做存在性判断与匹配：不要把 method 拼进 key
+        // 说明：apisMap 的 key 来源于 scanFiles/loadApis 生成的 routePath（例如 /api/core/xxx）
+        const apiPath = url.pathname || "/";
+        const clientIp = getClientIp(req, server);
+        const now = Date.now();
+        const ctx = {
+            method: req.method,
+            body: {},
+            user: {},
+            req: req,
+            now: now,
+            ip: clientIp,
+            headers: req.headers,
+            route: apiPath,
+            requestId: requestId,
+            corsHeaders: {
+                "X-Request-ID": requestId
+            },
+            api: apis.get(apiPath),
+            response: undefined,
+            result: undefined
+        };
+        return withCtx({
+            requestId: requestId,
+            method: req.method,
+            route: apiPath,
+            ip: clientIp,
+            now: now
+        }, async () => {
+            try {
+                // 4. 串联执行所有钩子
+                for (const hook of hooks) {
+                    await hook.handler(context, ctx);
+                    // 如果钩子已经设置了 response，停止执行
+                    if (ctx.response) {
+                        return ctx.response;
+                    }
+                }
+                // hooks 全部通过后记录请求日志（拦截请求仅由 ErrorResponse 记录）
+                if (ctx.api && req.method !== "OPTIONS") {
+                    const logData = {
+                        event: "request",
+                        apiName: ctx.api.name
+                    };
+                    if (ctx.body && Object.keys(ctx.body).length > 0) {
+                        logData.body = ctx.body;
+                    }
+                    Logger.info(logData, "request");
+                }
+                // 5. 执行 API handler
+                if (!ctx.api) {
+                    if (req.method !== "OPTIONS") {
+                        ctx.response = Response.json({
+                            code: 1,
+                            msg: "接口不存在"
+                        }, {
+                            headers: ctx.corsHeaders
+                        });
+                    }
+                }
+                else if (ctx.api.handler) {
+                    const result = await ctx.api.handler(context, ctx);
+                    if (result instanceof Response) {
+                        ctx.response = result;
+                    }
+                    else {
+                        ctx.result = result;
+                    }
+                }
+                // 7. 返回响应（自动处理 response/result/日志）
+                return FinalResponse(ctx);
+            }
+            catch (err) {
+                // 全局错误处理
+                const errorPath = ctx.api ? apiPath : req.url;
+                Logger.error({ err: err, path: errorPath }, "请求错误");
+                ctx.result = {
+                    code: 1,
+                    msg: "内部服务错误"
+                };
+                return FinalResponse(ctx);
+            }
+        });
+    };
+}

package/dist/router/static.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 静态文件路由处理器
+ * 处理 /* 路径的静态文件请求
+ */
+import type { CorsConfig } from "../types/befly";
+/**
+ * 静态文件处理器工厂
+ */
+export declare function staticHandler(corsConfig?: CorsConfig | undefined): (req: Request) => Promise<Response>;

package/{router/static.ts → dist/router/static.js}

@@ -2,29 +2,21 @@
  * 静态文件路由处理器
  * 处理 /* 路径的静态文件请求
  */
-
-// 类型导入
-import type { CorsConfig } from "../types/befly.ts";
-
 // 外部依赖
 import { join } from "pathe";
-
-import { Logger } from "../lib/logger.ts";
+import { Logger } from "../lib/logger";
 // 相对导入
-import { appDir } from "../paths.ts";
-import { setCorsOptions } from "../utils/cors.ts";
-
+import { appDir } from "../paths";
+import { setCorsOptions } from "../utils/cors";
 /**
  * 静态文件处理器工厂
  */
-export function staticHandler(corsConfig: CorsConfig | undefined = undefined) {
-    return async (req: Request): Promise<Response> => {
+export function staticHandler(corsConfig = undefined) {
+    return async (req) => {
         // 设置 CORS 响应头
         const corsHeaders = setCorsOptions(req, corsConfig);
-
         const url = new URL(req.url);
         const filePath = join(appDir, "public", url.pathname);
-
         try {
             // OPTIONS预检请求
             if (req.method === "OPTIONS") {
@@ -33,7 +25,6 @@ export function staticHandler(corsConfig: CorsConfig | undefined = undefined) {
                     headers: corsHeaders
                 });
             }
-
             const file = Bun.file(filePath);
             if (await file.exists()) {
                 return new Response(file, {
@@ -42,29 +33,24 @@ export function staticHandler(corsConfig: CorsConfig | undefined = undefined) {
                         ...corsHeaders
                     }
                 });
-            } else {
-                return Response.json(
-                    {
-                        code: 1,
-                        msg: "文件未找到"
-                    },
-                    {
-                        headers: corsHeaders
-                    }
-                );
             }
-        } catch (error: any) {
-            Logger.error({ err: error }, "静态文件处理失败");
-
-            return Response.json(
-                {
+            else {
+                return Response.json({
                     code: 1,
-                    msg: "文件读取失败"
-                },
-                {
+                    msg: "文件未找到"
+                }, {
                     headers: corsHeaders
-                }
-            );
+                });
+            }
+        }
+        catch (error) {
+            Logger.error({ err: error }, "静态文件处理失败");
+            return Response.json({
+                code: 1,
+                msg: "文件读取失败"
+            }, {
+                headers: corsHeaders
+            });
         }
     };
 }

package/dist/scripts/ensureDist.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/ensureDist.js

@@ -0,0 +1,296 @@
+// 内部依赖（Node.js 内置模块）
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+function isTsSourcePath(p) {
+    // 注意：.d.ts 是构建产物，必须允许；这里仅阻断指向源码的 .ts 入口。
+    if (!p.endsWith(".ts")) {
+        return false;
+    }
+    if (p.endsWith(".d.ts") || p.endsWith(".d.mts") || p.endsWith(".d.cts")) {
+        return false;
+    }
+    return true;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function collectExportPaths(exportsValue, out) {
+    if (typeof exportsValue === "string") {
+        out.push(exportsValue);
+        return;
+    }
+    if (Array.isArray(exportsValue)) {
+        for (const item of exportsValue) {
+            collectExportPaths(item, out);
+        }
+        return;
+    }
+    if (!isRecord(exportsValue)) {
+        return;
+    }
+    for (const value of Object.values(exportsValue)) {
+        collectExportPaths(value, out);
+    }
+}
+function assertPathExists(packageRoot, relativeOrBare) {
+    if (!relativeOrBare.startsWith("./")) {
+        return;
+    }
+    if (relativeOrBare.includes("*")) {
+        const beforeStar = relativeOrBare.split("*")[0] ?? "";
+        const dirPath = resolve(packageRoot, beforeStar);
+        if (!existsSync(dirPath)) {
+            process.stderr.write(`[ensureDist] missing export directory: ${beforeStar}\n`);
+            process.exit(1);
+        }
+        const stat = statSync(dirPath);
+        if (!stat.isDirectory()) {
+            process.stderr.write(`[ensureDist] export directory is not a directory: ${beforeStar}\n`);
+            process.exit(1);
+        }
+        return;
+    }
+    const absPath = resolve(packageRoot, relativeOrBare);
+    if (!existsSync(absPath)) {
+        process.stderr.write(`[ensureDist] missing export file: ${relativeOrBare}\n`);
+        process.exit(1);
+    }
+    const stat = statSync(absPath);
+    if (!stat.isFile()) {
+        process.stderr.write(`[ensureDist] export path is not a file: ${relativeOrBare}\n`);
+        process.exit(1);
+    }
+}
+function findTsImportSpecifiers(content) {
+    const matches = [];
+    const patterns = [/from\s+["'][^"']+\.ts["']/g, /import\(\s*["'][^"']+\.ts["']\s*\)/g, /<reference\s+path=["'][^"']+\.ts["']\s*\/>/g];
+    for (const pattern of patterns) {
+        const found = content.match(pattern);
+        if (found && found.length > 0) {
+            matches.push(...found);
+        }
+    }
+    return matches;
+}
+function collectExportTypePaths(exportsValue, out) {
+    if (!isRecord(exportsValue)) {
+        return;
+    }
+    for (const value of Object.values(exportsValue)) {
+        if (typeof value === "string") {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                collectExportTypePaths(item, out);
+            }
+            continue;
+        }
+        if (!isRecord(value)) {
+            continue;
+        }
+        const typesPath = value["types"];
+        if (typeof typesPath === "string") {
+            out.push(typesPath);
+        }
+        collectExportTypePaths(value, out);
+    }
+}
+function expandDtsExportPath(packageRoot, exportPath) {
+    if (!exportPath.startsWith("./")) {
+        return [];
+    }
+    if (!exportPath.includes("*")) {
+        return [resolve(packageRoot, exportPath)];
+    }
+    const beforeStar = exportPath.split("*")[0] ?? "";
+    const dirPath = resolve(packageRoot, beforeStar);
+    if (!existsSync(dirPath)) {
+        return [];
+    }
+    const stat = statSync(dirPath);
+    if (!stat.isDirectory()) {
+        return [];
+    }
+    const files = readdirSync(dirPath);
+    return files.filter((file) => file.endsWith(".d.ts")).map((file) => resolve(dirPath, file));
+}
+function findDtsSpecifiers(content) {
+    const specifiers = [];
+    const patterns = [/from\s+["']([^"']+)["']/g, /import\(\s*["']([^"']+)["']\s*\)/g, /<reference\s+path=["']([^"']+)["']\s*\/>/g];
+    for (const pattern of patterns) {
+        for (const match of content.matchAll(pattern)) {
+            const spec = match[1];
+            if (typeof spec === "string" && spec.length > 0) {
+                specifiers.push(spec);
+            }
+        }
+    }
+    return specifiers;
+}
+function resolveLocalDtsDependency(fromDtsPath, specifier) {
+    if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+        return null;
+    }
+    if (specifier.endsWith(".json")) {
+        return null;
+    }
+    const baseDir = dirname(fromDtsPath);
+    const absNoCheck = resolve(baseDir, specifier);
+    const tryPaths = [];
+    if (specifier.endsWith(".d.ts")) {
+        tryPaths.push(absNoCheck);
+    }
+    else if (specifier.endsWith(".js") || specifier.endsWith(".mjs") || specifier.endsWith(".cjs")) {
+        const replaced = absNoCheck.replace(/\.(mjs|cjs|js)$/u, ".d.ts");
+        tryPaths.push(replaced);
+        tryPaths.push(`${absNoCheck}.d.ts`);
+    }
+    else {
+        tryPaths.push(`${absNoCheck}.d.ts`);
+    }
+    tryPaths.push(resolve(absNoCheck, "index.d.ts"));
+    for (const p of tryPaths) {
+        if (existsSync(p)) {
+            return p;
+        }
+    }
+    return null;
+}
+function collectReachableDtsFromEntrypoints(distDir, entrypoints) {
+    const visited = new Set();
+    const queue = [];
+    for (const entry of entrypoints) {
+        if (!entry.startsWith(distDir)) {
+            continue;
+        }
+        if (existsSync(entry) && entry.endsWith(".d.ts")) {
+            queue.push(entry);
+        }
+    }
+    while (queue.length > 0) {
+        const current = queue.pop();
+        if (!current) {
+            continue;
+        }
+        if (visited.has(current)) {
+            continue;
+        }
+        visited.add(current);
+        const content = readFileSync(current, { encoding: "utf8" });
+        const specifiers = findDtsSpecifiers(content);
+        for (const specifier of specifiers) {
+            const resolved = resolveLocalDtsDependency(current, specifier);
+            if (!resolved) {
+                continue;
+            }
+            if (!resolved.startsWith(distDir)) {
+                continue;
+            }
+            if (!visited.has(resolved)) {
+                queue.push(resolved);
+            }
+        }
+    }
+    return Array.from(visited);
+}
+function main() {
+    const packageRoot = process.cwd();
+    const pkgPath = resolve(packageRoot, "package.json");
+    if (!existsSync(pkgPath)) {
+        process.stderr.write("[ensureDist] package.json not found\n");
+        process.exit(1);
+    }
+    const pkg = JSON.parse(readFileSync(pkgPath, { encoding: "utf8" }));
+    // 额外一致性校验：默认入口必须走 dist 产物（JS + DTS 分离）。
+    if (typeof pkg.main !== "string" || !pkg.main.startsWith("./dist/")) {
+        process.stderr.write("[ensureDist] package.json main must be a string under ./dist/\n");
+        process.exit(1);
+    }
+    if (typeof pkg.types !== "string" || !pkg.types.startsWith("./dist/")) {
+        process.stderr.write("[ensureDist] package.json types must be a string under ./dist/\n");
+        process.exit(1);
+    }
+    if (isTsSourcePath(pkg.main) || isTsSourcePath(pkg.types)) {
+        process.stderr.write("[ensureDist] package.json main/types must not point to .ts source files\n");
+        process.exit(1);
+    }
+    if (!isRecord(pkg.exports) || !isRecord(pkg.exports["."])) {
+        process.stderr.write("[ensureDist] package.json exports['.'] must be an object with { types, default }\n");
+        process.exit(1);
+    }
+    const dotExport = pkg.exports["."];
+    const dotTypes = dotExport["types"];
+    const dotDefault = dotExport["default"];
+    if (dotTypes !== pkg.types) {
+        process.stderr.write("[ensureDist] exports['.'].types must equal package.json types\n");
+        process.exit(1);
+    }
+    if (dotDefault !== pkg.main) {
+        process.stderr.write("[ensureDist] exports['.'].default must equal package.json main\n");
+        process.exit(1);
+    }
+    if (typeof dotTypes === "string" && isTsSourcePath(dotTypes)) {
+        process.stderr.write("[ensureDist] exports['.'].types must not point to .ts source files\n");
+        process.exit(1);
+    }
+    if (typeof dotDefault === "string" && isTsSourcePath(dotDefault)) {
+        process.stderr.write("[ensureDist] exports['.'].default must not point to .ts source files\n");
+        process.exit(1);
+    }
+    const distDir = resolve(packageRoot, "dist");
+    if (!existsSync(distDir)) {
+        process.stderr.write("[ensureDist] dist/ not found (did you run build?)\n");
+        process.exit(1);
+    }
+    // dist-only 发布规范：从对外可达入口（pkg.types + exports.*.types）出发的声明闭包中，
+    // 任何 .d.ts 都不允许引用源码 .ts（防止消费者类型解析回退到源码）。
+    {
+        const exportTypePaths = [];
+        if (typeof pkg.types === "string") {
+            exportTypePaths.push(pkg.types);
+        }
+        collectExportTypePaths(pkg.exports, exportTypePaths);
+        const entryDtsAbsPaths = new Set();
+        for (const exportPath of exportTypePaths) {
+            for (const absPath of expandDtsExportPath(packageRoot, exportPath)) {
+                entryDtsAbsPaths.add(absPath);
+            }
+        }
+        if (entryDtsAbsPaths.size === 0) {
+            process.stderr.write("[ensureDist] no exported .d.ts entrypoints found (types/exports.types)\n");
+            process.exit(1);
+        }
+        const reachableDtsPaths = collectReachableDtsFromEntrypoints(distDir, Array.from(entryDtsAbsPaths));
+        if (reachableDtsPaths.length === 0) {
+            process.stderr.write("[ensureDist] no reachable .d.ts files found from exported entrypoints\n");
+            process.exit(1);
+        }
+        const offenders = [];
+        for (const absPath of reachableDtsPaths) {
+            const content = readFileSync(absPath, { encoding: "utf8" });
+            const matches = findTsImportSpecifiers(content);
+            if (matches.length > 0) {
+                offenders.push({ filePath: absPath, matches: matches });
+            }
+        }
+        if (offenders.length > 0) {
+            process.stderr.write("[ensureDist] exported declaration files must not reference .ts source files\n");
+            process.stderr.write(`${JSON.stringify(offenders, null, 4)}\n`);
+            process.exit(1);
+        }
+    }
+    const paths = [];
+    if (typeof pkg.main === "string") {
+        paths.push(pkg.main);
+    }
+    if (typeof pkg.types === "string") {
+        paths.push(pkg.types);
+    }
+    collectExportPaths(pkg.exports, paths);
+    for (const p of paths) {
+        assertPathExists(packageRoot, p);
+    }
+    process.stdout.write("[ensureDist] OK\n");
+}
+main();

package/dist/sync/syncApi.d.ts

@@ -0,0 +1,3 @@
+import type { BeflyContext } from "../types/befly";
+import type { SyncApiItem } from "../types/sync";
+export declare function syncApi(ctx: Pick<BeflyContext, "db" | "cache">, apis: SyncApiItem[]): Promise<void>;