befly 3.10.17 → 3.10.19

package/dist/plugins/jwt.d.ts

@@ -0,0 +1,10 @@
+/**
+ * JWT 插件
+ */
+import type { BeflyContext } from "../types/befly.ts";
+import { Jwt } from "../lib/jwt.ts";
+declare const _default: {
+    deps: never[];
+    handler: (context: BeflyContext) => Jwt;
+};
+export default _default;

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

@@ -1,15 +1,10 @@
 /**
  * JWT 插件
  */
-
-import type { BeflyContext } from "../types/befly.js";
-import type { Plugin } from "../types/plugin.js";
-
 import { Jwt } from "../lib/jwt.js";
-
 export default {
     deps: [],
-    handler: (context: BeflyContext) => {
+    handler: (context) => {
         return new Jwt(context.config ? context.config.auth : undefined);
     }
-} satisfies Plugin;
+};

package/dist/plugins/logger.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 日志插件
+ * 提供全局日志功能
+ */
+import type { BeflyContext } from "../types/befly.ts";
+/**
+ * 日志插件
+ */
+declare const _default: {
+    deps: never[];
+    handler(context: BeflyContext): Promise<{
+        info(...args: [] | [msg: string, ...args: unknown[]] | [msg: string, err: Error, ...args: unknown[]] | [err: Error, msg?: string | undefined, ...args: unknown[]] | [obj: {
+            [x: string]: any;
+        }, msg?: string | undefined, ...args: unknown[]]): any;
+        warn(...args: [] | [msg: string, ...args: unknown[]] | [msg: string, err: Error, ...args: unknown[]] | [err: Error, msg?: string | undefined, ...args: unknown[]] | [obj: {
+            [x: string]: any;
+        }, msg?: string | undefined, ...args: unknown[]]): any;
+        error(...args: [] | [msg: string, ...args: unknown[]] | [msg: string, err: Error, ...args: unknown[]] | [err: Error, msg?: string | undefined, ...args: unknown[]] | [obj: {
+            [x: string]: any;
+        }, msg?: string | undefined, ...args: unknown[]]): any;
+        debug(...args: [] | [msg: string, ...args: unknown[]] | [msg: string, err: Error, ...args: unknown[]] | [err: Error, msg?: string | undefined, ...args: unknown[]] | [obj: {
+            [x: string]: any;
+        }, msg?: string | undefined, ...args: unknown[]]): any;
+        configure: typeof import("../lib/logger.ts").configure;
+        setMock: typeof import("../lib/logger.ts").setMockLogger;
+    }>;
+};
+export default _default;

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

@@ -2,22 +2,17 @@
  * 日志插件
  * 提供全局日志功能
  */
-
-import type { BeflyContext } from "../types/befly.js";
-import type { Plugin } from "../types/plugin.js";
-
 import { Logger } from "../lib/logger.js";
-
 /**
  * 日志插件
  */
 export default {
     deps: [],
-    async handler(context: BeflyContext): Promise<typeof Logger> {
+    async handler(context) {
         // 配置 Logger
         if (context.config && context.config.logger) {
             Logger.configure(context.config.logger);
         }
         return Logger;
     }
-} satisfies Plugin;
+};

package/dist/plugins/redis.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Redis 插件
+ * 初始化 Redis 连接和助手工具
+ */
+import type { BeflyContext } from "../types/befly.ts";
+import { RedisHelper } from "../lib/redisHelper.ts";
+/**
+ * Redis 插件
+ */
+declare const _default: {
+    deps: string[];
+    handler(context: BeflyContext): Promise<Record<string, never> | RedisHelper>;
+};
+export default _default;

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

@@ -2,30 +2,25 @@
  * Redis 插件
  * 初始化 Redis 连接和助手工具
  */
-
-import type { BeflyContext } from "../types/befly.js";
-import type { Plugin } from "../types/plugin.js";
-
 import { Connect } from "../lib/connect.js";
 import { Logger } from "../lib/logger.js";
 import { RedisHelper } from "../lib/redisHelper.js";
-
 /**
  * Redis 插件
  */
 export default {
     deps: ["logger"],
-    async handler(context: BeflyContext): Promise<RedisHelper | Record<string, never>> {
+    async handler(context) {
         const redisConfig = context.config && context.config.redis ? context.config.redis : {};
         try {
             // 启动期已建立 Redis 连接；这里仅校验连接存在
             Connect.getRedis();
-
             // 返回 RedisHelper 实例
             return new RedisHelper(redisConfig.prefix);
-        } catch (error: any) {
+        }
+        catch (error) {
             Logger.error({ err: error }, "Redis 初始化失败");
             throw error;
         }
     }
-} satisfies Plugin;
+};

package/dist/plugins/tool.d.ts

@@ -0,0 +1,79 @@
+/**
+ * 工具插件
+ * 提供常用的工具函数
+ */
+import type { RequestContext } from "../types/context.ts";
+/**
+ * 成功响应
+ * @param msg - 消息
+ * @param data - 数据（可选）
+ * @param other - 其他字段（可选）
+ * @returns 成功响应对象
+ */
+export declare function Yes(msg: string, data?: any, other?: Record<string, any>): {
+    code: number;
+    msg: string;
+    data: any;
+};
+/**
+ * 失败响应
+ * @param msg - 消息
+ * @param data - 数据（可选）
+ * @param other - 其他字段（可选）
+ * @returns 失败响应对象
+ */
+export declare function No(msg: string, data?: any, other?: Record<string, any>): {
+    code: number;
+    msg: string;
+    data: any;
+};
+/**
+ * 响应选项
+ */
+interface ResponseOptions {
+    /** HTTP 状态码，默认 200 */
+    status?: number;
+    /** Content-Type，默认根据 data 类型自动判断 */
+    contentType?: string;
+    /** 额外的响应头 */
+    headers?: Record<string, string>;
+}
+/**
+ * 统一响应函数
+ *
+ * 自动识别数据类型并设置正确的 Content-Type：
+ * - 对象 → application/json
+ * - 字符串 → text/plain
+ * - 可通过 options.contentType 手动指定
+ *
+ * @param ctx 请求上下文
+ * @param data 响应数据（对象或字符串）
+ * @param options 响应选项
+ * @returns Response 对象
+ *
+ * @example
+ * // JSON 响应（自动）
+ * return Raw(ctx, { code: 'SUCCESS', message: '成功' });
+ *
+ * // 纯文本响应（自动）
+ * return Raw(ctx, 'success');
+ *
+ * // XML 响应（手动指定）
+ * return Raw(ctx, xmlString, { contentType: 'application/xml' });
+ *
+ * // 自定义状态码和额外头
+ * return Raw(ctx, { error: 'Not Found' }, {
+ *   status: 404,
+ *   headers: { 'X-Custom': 'value' }
+ * });
+ */
+export declare function Raw(ctx: RequestContext, data: Record<string, any> | string, options?: ResponseOptions): Response;
+declare const _default: {
+    deps: never[];
+    handler: () => {
+        Yes: typeof Yes;
+        No: typeof No;
+        Raw: typeof Raw;
+    };
+};
+export default _default;

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

@@ -2,11 +2,6 @@
  * 工具插件
  * 提供常用的工具函数
  */
-
-import type { RequestContext } from "../types/context.js";
-// 类型导入
-import type { Plugin } from "../types/plugin.js";
-
 /**
  * 成功响应
  * @param msg - 消息
@@ -14,7 +9,7 @@ import type { Plugin } from "../types/plugin.js";
  * @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,25 +73,23 @@ 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 {
     deps: [],
     handler: () => {
@@ -122,4 +99,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.ts";
+import type { BeflyContext } from "../types/befly.ts";
+import type { Hook } from "../types/hook.ts";
+/**
+ * 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.js";
+import { Logger } from "../lib/logger.js";
+// 相对导入
+import { genShortId } from "../utils/genShortId.js";
+import { getClientIp } from "../utils/getClientIp.js";
+import { FinalResponse } from "../utils/response.js";
+/**
+ * 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.ts";
+/**
+ * 静态文件处理器工厂
+ */
+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.js";
-
 // 外部依赖
 import { join } from "pathe";
-
 import { Logger } from "../lib/logger.js";
 // 相对导入
 import { appDir } from "../paths.js";
 import { setCorsOptions } from "../utils/cors.js";
-
 /**
  * 静态文件处理器工厂
  */
-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,80 @@
+// 内部依赖（Node.js 内置模块）
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+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 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" }));
+    const distDir = resolve(packageRoot, "dist");
+    if (!existsSync(distDir)) {
+        process.stderr.write("[ensureDist] dist/ not found (did you run build?)\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.ts";
+import type { SyncApiItem } from "../types/sync.ts";
+export declare function syncApi(ctx: Pick<BeflyContext, "db" | "cache">, apis: SyncApiItem[]): Promise<void>;