befly 3.16.10 → 3.17.0

package/dist/plugins/tool.d.ts

@@ -1,75 +0,0 @@
-/**
- * 工具插件
- * 提供常用的工具函数
- */
-import type { JsonValue } from "../types/common";
-import type { RequestContext } from "../types/context";
-import type { Plugin } from "../types/plugin";
-type ToolExtra = Record<string, JsonValue | undefined>;
-/**
- * 成功响应
- * @param msg - 消息
- * @param data - 数据（可选）
- * @param other - 其他字段（可选）
- * @returns 成功响应对象
- */
-export declare function Yes<TData extends JsonValue = JsonValue, TOther extends ToolExtra = ToolExtra>(msg: string, data?: TData, other?: TOther): {
-    code: 0;
-    msg: string;
-    data: TData;
-} & TOther;
-/**
- * 失败响应
- * @param msg - 消息
- * @param data - 数据（可选）
- * @param other - 其他字段（可选）
- * @returns 失败响应对象
- */
-export declare function No<TData extends JsonValue = JsonValue, TOther extends ToolExtra = ToolExtra>(msg: string, data?: TData, other?: TOther): {
-    code: 1;
-    msg: string;
-    data: TData;
-} & TOther;
-/**
- * 响应选项
- */
-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: JsonValue | string, options?: ResponseOptions): Response;
-declare const toolPlugin: Plugin;
-export default toolPlugin;

package/dist/plugins/tool.js

@@ -1,105 +0,0 @@
-/**
- * 工具插件
- * 提供常用的工具函数
- */
-/**
- * 成功响应
- * @param msg - 消息
- * @param data - 数据（可选）
- * @param other - 其他字段（可选）
- * @returns 成功响应对象
- */
-export function Yes(msg, data = {}, other = {}) {
-    return {
-        code: 0,
-        msg: msg,
-        data: data,
-        ...other
-    };
-}
-/**
- * 失败响应
- * @param msg - 消息
- * @param data - 数据（可选）
- * @param other - 其他字段（可选）
- * @returns 失败响应对象
- */
-export function No(msg, data = null, other = {}) {
-    return {
-        code: 1,
-        msg: msg,
-        data: data,
-        ...other
-    };
-}
-/**
- * 统一响应函数
- *
- * 自动识别数据类型并设置正确的 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 function Raw(ctx, data, options = {}) {
-    const { status = 200, contentType, headers = {} } = options;
-    // 自动判断 Content-Type
-    let finalContentType = contentType;
-    let body;
-    if (typeof data === "string") {
-        // 字符串类型
-        body = data;
-        if (!finalContentType) {
-            // 自动判断：XML 或纯文本
-            finalContentType = data.trim().startsWith("<") ? "application/xml" : "text/plain";
-        }
-    }
-    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
-    });
-}
-const toolPlugin = {
-    name: "tool",
-    enable: true,
-    deps: [],
-    handler: () => {
-        return {
-            Yes: Yes,
-            No: No,
-            Raw: Raw
-        };
-    }
-};
-export default toolPlugin;

package/dist/router/api.d.ts

@@ -1,14 +0,0 @@
-/**
- * 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

@@ -1,109 +0,0 @@
-/**
- * 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 生成的 path（例如 /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
-            }
-        };
-        const api = apis.get(apiPath);
-        if (api) {
-            ctx.api = api;
-        }
-        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;
-                    }
-                    logData["msg"] = "request";
-                    Logger.info(logData);
-                }
-                // 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, msg: "请求错误" });
-                ctx.result = {
-                    code: 1,
-                    msg: "内部服务错误"
-                };
-                return FinalResponse(ctx);
-            }
-        });
-    };
-}

package/dist/router/static.d.ts

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

package/dist/router/static.js

@@ -1,56 +0,0 @@
-/**
- * 静态文件路由处理器
- * 处理 /* 路径的静态文件请求
- */
-// 外部依赖
-import { join } from "pathe";
-import { Logger } from "../lib/logger";
-// 相对导入
-import { appDir } from "../paths";
-import { setCorsOptions } from "../utils/cors";
-/**
- * 静态文件处理器工厂
- */
-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") {
-                return new Response(null, {
-                    status: 204,
-                    headers: corsHeaders
-                });
-            }
-            const file = Bun.file(filePath);
-            if (await file.exists()) {
-                return new Response(file, {
-                    headers: {
-                        "Content-Type": file.type || "application/octet-stream",
-                        ...corsHeaders
-                    }
-                });
-            }
-            else {
-                return Response.json({
-                    code: 1,
-                    msg: "文件未找到"
-                }, {
-                    headers: corsHeaders
-                });
-            }
-        }
-        catch (error) {
-            Logger.error({ err: error, msg: "静态文件处理失败" });
-            return Response.json({
-                code: 1,
-                msg: "文件读取失败"
-            }, {
-                headers: corsHeaders
-            });
-        }
-    };
-}

package/dist/scripts/ensureDist.d.ts

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

package/dist/scripts/ensureDist.js

@@ -1,296 +0,0 @@
-// 内部依赖（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

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