befly 3.9.40 → 3.10.0

package/utils/sortModules.ts

@@ -0,0 +1,137 @@
+import { camelCase } from "es-toolkit/string";
+
+import { Logger } from "../lib/logger.js";
+
+export type SortModulesByDepsOptions<T> = {
+    /**
+     * 用于日志的模块标签（如："插件"、"钩子"）
+     */
+    moduleLabel?: string;
+
+    /**
+     * 生成模块名（用于 deps 解析与排序 key）。
+     * 默认：camelCase(item.fileName)
+     */
+    getName?: (item: T) => string;
+
+    /**
+     * 获取 deps。
+     * 默认：item.deps
+     */
+    getDeps?: (item: T) => string[];
+};
+
+/**
+ * 按 deps 拓扑排序 scanSources 扫描得到的插件/钩子。
+ *
+ * 说明：
+ * - 输入为 scanSources/scanFiles 的条目数组：每个条目包含 fileName 与 deps。
+ * - deps 里的字符串会与 getName(item) 的结果匹配。
+ * - 若出现：重复 name、缺失依赖、循环依赖，则返回 false。
+ */
+export function sortModules<T extends { fileName: string; deps?: any }>(items: T[], options: SortModulesByDepsOptions<T> = {}): T[] | false {
+    const moduleLabel = options.moduleLabel || "模块";
+    const getName =
+        options.getName ||
+        ((item: T) => {
+            const moduleName = (item as any).moduleName;
+            if (typeof moduleName === "string" && moduleName.trim() !== "") {
+                return moduleName;
+            }
+            return camelCase(item.fileName);
+        });
+    const getDeps = options.getDeps || ((item: T) => (item as any).deps);
+
+    const result: T[] = [];
+    const visited = new Set<string>();
+    const visiting = new Set<string>();
+
+    const nameToItem: Record<string, T> = {};
+    let isPass = true;
+
+    // 1) 建表 + 重名检查
+    for (const item of items) {
+        const name = getName(item);
+
+        if (typeof name !== "string" || name.trim() === "") {
+            Logger.error({ item: item }, `${moduleLabel} 名称解析失败（getName 返回空字符串）`);
+            isPass = false;
+            continue;
+        }
+
+        if (nameToItem[name]) {
+            Logger.error(
+                {
+                    name: name,
+                    first: nameToItem[name],
+                    second: item
+                },
+                `${moduleLabel} 名称重复，无法根据 deps 唯一定位`
+            );
+            isPass = false;
+            continue;
+        }
+
+        nameToItem[name] = item;
+    }
+
+    if (!isPass) return false;
+
+    // 2) 依赖存在性检查 + deps 类型检查
+    for (const item of items) {
+        const name = getName(item);
+        const deps = getDeps(item);
+
+        if (!Array.isArray(deps)) {
+            Logger.error({ module: name, item: item }, `${moduleLabel} 的 deps 必须是数组`);
+            isPass = false;
+            continue;
+        }
+
+        for (const dep of deps) {
+            if (typeof dep !== "string") {
+                Logger.error({ module: name, dependency: dep, item: item }, `${moduleLabel} 的 deps 必须是字符串数组`);
+                isPass = false;
+                continue;
+            }
+
+            if (!nameToItem[dep]) {
+                Logger.error({ module: name, dependency: dep }, `${moduleLabel} 依赖未找到`);
+                isPass = false;
+            }
+        }
+    }
+
+    if (!isPass) return false;
+
+    // 3) 拓扑排序（DFS）
+    const visit = (name: string): void => {
+        if (visited.has(name)) return;
+        if (visiting.has(name)) {
+            Logger.error({ module: name }, `${moduleLabel} 循环依赖`);
+            isPass = false;
+            return;
+        }
+
+        const item = nameToItem[name];
+        if (!item) return;
+
+        const deps = getDeps(item) as string[];
+
+        visiting.add(name);
+        for (const dep of deps) {
+            visit(dep);
+        }
+        visiting.delete(name);
+
+        visited.add(name);
+        result.push(item);
+    };
+
+    for (const item of items) {
+        const name = getName(item);
+        visit(name);
+    }
+
+    return isPass ? result : false;
+}

package/checks/checkApp.ts

@@ -1,55 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-// 内部依赖
-import { join } from "node:path";
-
-// 相对导入
-import { Logger } from "../lib/logger.js";
-import { projectApiDir, projectDir } from "../paths.js";
-
-/**
- * 检查项目结构
- */
-export async function checkApp(): Promise<void> {
-    try {
-        // 检查项目 apis 目录下是否存在名为 addon 的目录
-        if (existsSync(projectApiDir)) {
-            const addonDir = join(projectApiDir, "addon");
-            if (existsSync(addonDir)) {
-                throw new Error("项目 apis 目录下不能存在名为 addon 的目录，addon 是保留名称，用于组件接口路由");
-            }
-        }
-
-        // 检查并创建 logs 目录
-        const logsDir = join(projectDir, "logs");
-        if (!existsSync(logsDir)) {
-            mkdirSync(logsDir, { recursive: true });
-        }
-
-        // 检查并创建 configs 目录和配置文件
-        const configsDir = join(projectDir, "configs");
-        if (!existsSync(configsDir)) {
-            mkdirSync(configsDir, { recursive: true });
-        }
-
-        // 检查并创建 befly.common.json
-        const beflyJsonPath = join(configsDir, "befly.common.json");
-        if (!existsSync(beflyJsonPath)) {
-            writeFileSync(beflyJsonPath, "{}", "utf-8");
-        }
-
-        // 检查并创建 befly.development.json
-        const beflyDevelopmentJsonPath = join(configsDir, "befly.development.json");
-        if (!existsSync(beflyDevelopmentJsonPath)) {
-            writeFileSync(beflyDevelopmentJsonPath, "{}", "utf-8");
-        }
-
-        // 检查并创建 befly.production.json
-        const beflyProductionJsonPath = join(configsDir, "befly.production.json");
-        if (!existsSync(beflyProductionJsonPath)) {
-            writeFileSync(beflyProductionJsonPath, "{}", "utf-8");
-        }
-    } catch (error: any) {
-        Logger.error("项目结构检查过程中出错", error);
-        throw error;
-    }
-}

package/hooks/rateLimit.ts

@@ -1,276 +0,0 @@
-// 类型导入
-import type { Hook } from "../types/hook.js";
-
-import { beflyConfig } from "../befly.config.js";
-// 相对导入
-import { ErrorResponse } from "../utils/response.js";
-
-/**
- * 限流 key 维度
- * - ip: 仅按 IP
- * - user: 仅按用户（缺失 ctx.user.id 时回退为按 IP，避免匿名共享同一计数桶）
- * - ip_user: IP + 用户（缺失用户时视为 anonymous）
- */
-type RateLimitKeyMode = "ip" | "user" | "ip_user";
-
-/**
- * 单条限流规则
- * route 匹配串：
- * - 精确："POST/api/auth/login"
- * - 前缀："POST/api/auth/*" 或 "/api/auth/*"
- * - 全量："*"
- */
-type RateLimitRule = {
-    route: string;
-    /** 窗口期内允许次数 */
-    limit: number;
-    /** 窗口期秒数 */
-    window: number;
-    /** 计数维度（默认 ip） */
-    key?: RateLimitKeyMode;
-};
-
-/** 全局请求限流配置（Hook） */
-type RateLimitConfig = {
-    /** 是否启用 (0/1) */
-    enable?: number;
-    /** 未命中 rules 时的默认次数（<=0 表示不启用默认规则） */
-    defaultLimit?: number;
-    /** 未命中 rules 时的默认窗口秒数（<=0 表示不启用默认规则） */
-    defaultWindow?: number;
-    /** 默认计数维度（默认 ip） */
-    key?: RateLimitKeyMode;
-    /**
-     * 直接跳过限流的路由列表（优先级最高）
-     * - 精确："POST/api/health" 或 "/api/health"
-     * - 前缀："POST/api/health/*" 或 "/api/health/*"
-     */
-    skipRoutes?: string[];
-    /** 路由规则列表 */
-    rules?: RateLimitRule[];
-};
-
-type MemoryBucket = {
-    count: number;
-    resetAt: number;
-};
-
-const memoryBuckets = new Map<string, MemoryBucket>();
-let nextSweepAt = 0;
-
-function matchRoute(ruleRoute: string, actualRoute: string): boolean {
-    if (ruleRoute === "*") return true;
-
-    if (ruleRoute.endsWith("*")) {
-        const prefix = ruleRoute.slice(0, -1);
-        if (prefix.startsWith("/")) {
-            return actualRoute.includes(prefix);
-        }
-        return actualRoute.startsWith(prefix);
-    }
-
-    if (ruleRoute.startsWith("/")) {
-        return actualRoute.endsWith(ruleRoute);
-    }
-
-    return actualRoute === ruleRoute;
-}
-
-function calcRouteMatchScore(ruleRoute: string, actualRoute: string): number {
-    if (!ruleRoute || typeof ruleRoute !== "string") return -1;
-
-    // 兜底通配：最低优先级
-    if (ruleRoute === "*") return 0;
-
-    // 完全精确：最高优先级
-    if (ruleRoute === actualRoute) return 400000 + ruleRoute.length;
-
-    // 以 / 开头：只匹配 path（忽略 method），用于 /api/* 这类
-    if (ruleRoute.startsWith("/")) {
-        if (ruleRoute.endsWith("*")) {
-            const prefix = ruleRoute.slice(0, -1);
-            if (actualRoute.includes(prefix)) {
-                return 100000 + prefix.length;
-            }
-            return -1;
-        }
-
-        if (actualRoute.endsWith(ruleRoute)) {
-            return 300000 + ruleRoute.length;
-        }
-
-        return -1;
-    }
-
-    // 不以 / 开头：匹配包含 method 的完整串，如 POST/api/auth/*
-    if (ruleRoute.endsWith("*")) {
-        const prefix = ruleRoute.slice(0, -1);
-        if (actualRoute.startsWith(prefix)) {
-            return 200000 + prefix.length;
-        }
-        return -1;
-    }
-
-    // 其他兜底（理论上到不了，因为精确已在上面处理；这里为了兼容 matchRoute 的未来扩展）
-    if (matchRoute(ruleRoute, actualRoute)) {
-        return 50000 + ruleRoute.length;
-    }
-
-    return -1;
-}
-
-function shouldSkip(config: RateLimitConfig, actualRoute: string): boolean {
-    const skipRoutes = Array.isArray(config.skipRoutes) ? config.skipRoutes : [];
-    if (skipRoutes.length === 0) return false;
-
-    for (const skip of skipRoutes) {
-        if (typeof skip !== "string" || !skip) continue;
-        if (matchRoute(skip, actualRoute)) return true;
-    }
-
-    return false;
-}
-
-function pickRule(config: RateLimitConfig, actualRoute: string): RateLimitRule | null {
-    const rules = Array.isArray(config.rules) ? config.rules : [];
-
-    let bestRule: RateLimitRule | null = null;
-    let bestScore = -1;
-
-    // 多条命中时，优先更“具体”的规则（精确 > 前缀 > 通配）；同等具体度按 rules 的先后顺序
-    for (const rule of rules) {
-        if (!rule || typeof rule.route !== "string") continue;
-
-        const score = calcRouteMatchScore(rule.route, actualRoute);
-        if (score > bestScore) {
-            bestRule = rule;
-            bestScore = score;
-        }
-    }
-
-    if (bestRule) return bestRule;
-
-    const defaultLimit = typeof config.defaultLimit === "number" ? config.defaultLimit : 0;
-    const defaultWindow = typeof config.defaultWindow === "number" ? config.defaultWindow : 0;
-
-    if (defaultLimit > 0 && defaultWindow > 0) {
-        return {
-            route: "*",
-            limit: defaultLimit,
-            window: defaultWindow,
-            key: config.key
-        };
-    }
-
-    return null;
-}
-
-function buildIdentity(ctx: any, mode: RateLimitKeyMode): string {
-    const ip = typeof ctx.ip === "string" ? ctx.ip : "unknown";
-
-    const userIdValue = ctx.user && (typeof ctx.user.id === "number" || typeof ctx.user.id === "string") ? ctx.user.id : null;
-    const userId = userIdValue !== null ? String(userIdValue) : "";
-
-    if (mode === "ip") {
-        return `ip:${ip}`;
-    }
-
-    if (mode === "user") {
-        // 未登录/无 userId：回退为按 IP 计数，避免所有匿名用户共享同一 bucket
-        if (userId) return `user:${userId}`;
-        return `ip:${ip}`;
-    }
-
-    if (mode === "ip_user") {
-        if (userId) {
-            return `ip:${ip}:user:${userId}`;
-        }
-        return `ip:${ip}:user:anonymous`;
-    }
-
-    return `ip:${ip}`;
-}
-
-function hitMemoryBucket(key: string, windowSeconds: number): number {
-    const now = Date.now();
-
-    if (now >= nextSweepAt) {
-        nextSweepAt = now + 60_000;
-        for (const [k, v] of memoryBuckets.entries()) {
-            if (!v || typeof v.resetAt !== "number") {
-                memoryBuckets.delete(k);
-                continue;
-            }
-            if (v.resetAt <= now) {
-                memoryBuckets.delete(k);
-            }
-        }
-    }
-
-    const existing = memoryBuckets.get(key);
-    if (!existing || existing.resetAt <= now) {
-        const bucket: MemoryBucket = {
-            count: 1,
-            resetAt: now + windowSeconds * 1000
-        };
-        memoryBuckets.set(key, bucket);
-        return bucket.count;
-    }
-
-    existing.count += 1;
-    return existing.count;
-}
-
-/**
- * 请求限流钩子（全局）
- * - 通过 beflyConfig.rateLimit 开启/配置
- * - 默认启用：可通过配置禁用或调整阈值
- */
-const hook: Hook = {
-    order: 7,
-    handler: async (befly, ctx) => {
-        const config = beflyConfig.rateLimit as RateLimitConfig | undefined;
-
-        if (!config || config.enable !== 1) return;
-        if (!ctx.api) return;
-        if (ctx.req && ctx.req.method === "OPTIONS") return;
-
-        // 跳过名单：命中后不计数也不拦截（优先级最高）
-        if (shouldSkip(config, ctx.route)) return;
-
-        const rule = pickRule(config, ctx.route);
-        if (!rule) return;
-
-        const limit = typeof rule.limit === "number" ? rule.limit : 0;
-        const windowSeconds = typeof rule.window === "number" ? rule.window : 0;
-        if (limit <= 0 || windowSeconds <= 0) return;
-
-        const keyMode = rule.key || config.key || "ip";
-        const identity = buildIdentity(ctx, keyMode);
-        const counterKey = `rate_limit:${ctx.route}:${identity}`;
-
-        let count = 0;
-        if (befly.redis) {
-            count = await befly.redis.incrWithExpire(counterKey, windowSeconds);
-        } else {
-            count = hitMemoryBucket(counterKey, windowSeconds);
-        }
-
-        if (count > limit) {
-            ctx.response = ErrorResponse(
-                ctx,
-                "请求过于频繁，请稍后再试",
-                1,
-                null,
-                {
-                    limit: limit,
-                    window: windowSeconds
-                },
-                "rateLimit"
-            );
-            return;
-        }
-    }
-};
-
-export default hook;

package/sync/syncAll.ts

@@ -1,35 +0,0 @@
-/**
- * Sync 命令 - 一次性执行所有同步操作
- * 按顺序执行：syncDb → syncApi → syncMenu → syncDev（syncDev 内会重建角色接口权限缓存）
- */
-
-import type { SyncOptions } from "../types/sync.js";
-
-import { checkApp } from "../checks/checkApp.js";
-import { Logger } from "../lib/logger.js";
-import { syncApiCommand } from "./syncApi.js";
-import { syncDbCommand } from "./syncDb.js";
-import { syncDevCommand } from "./syncDev.js";
-import { syncMenuCommand } from "./syncMenu.js";
-
-export async function syncAllCommand(options: SyncOptions = {}) {
-    try {
-        // 0. 检查项目结构
-        await checkApp();
-
-        // 1. 同步数据库表结构
-        await syncDbCommand({ dryRun: false, force: options.force || false });
-
-        // 2. 同步接口（并缓存）
-        await syncApiCommand();
-
-        // 3. 同步菜单（并缓存）
-        await syncMenuCommand();
-
-        // 4. 同步开发管理员（syncDev 内会重建角色接口权限缓存）
-        await syncDevCommand();
-    } catch (error: any) {
-        Logger.error({ err: error }, "同步过程中发生错误");
-        throw error;
-    }
-}

package/sync/syncDb/apply.ts

@@ -1,192 +0,0 @@
-/**
- * syncDb 变更应用模块
- *
- * 包含：
- * - 比较字段定义变化
- * - 应用表结构变更计划
- */
-
-import type { FieldChange, TablePlan, ColumnInfo } from "../../types/sync.js";
-import type { FieldDefinition } from "../../types/validate.js";
-import type { SQL } from "bun";
-
-import { Logger } from "../../lib/logger.js";
-import { isMySQL, isPG, isSQLite, IS_PLAN, getTypeMapping } from "./constants.js";
-import { executeDDLSafely, buildIndexSQL } from "./ddl.js";
-import { rebuildSqliteTable } from "./sqlite.js";
-import { isStringOrArrayType, resolveDefaultValue } from "./types.js";
-
-/**
- * 构建 ALTER TABLE SQL 语句
- *
- * 根据数据库类型构建相应的 ALTER TABLE 语句：
- * - MySQL: 添加 ALGORITHM=INSTANT, LOCK=NONE 优化参数
- * - PostgreSQL/SQLite: 使用双引号标识符
- *
- * @param tableName - 表名
- * @param clauses - SQL 子句数组
- * @returns 完整的 ALTER TABLE 语句
- */
-function buildAlterTableSQL(tableName: string, clauses: string[]): string {
-    if (isMySQL()) {
-        return `ALTER TABLE \`${tableName}\` ${clauses.join(", ")}, ALGORITHM=INSTANT, LOCK=NONE`;
-    }
-    return `ALTER TABLE "${tableName}" ${clauses.join(", ")}`;
-}
-
-/**
- * 比较字段定义变化
- *
- * 对比现有列信息和新的字段规则，识别变化类型：
- * - 长度变化（string/array 类型）
- * - 注释变化（MySQL/PG）
- * - 数据类型变化
- * - 默认值变化
- *
- * @param existingColumn - 现有列信息
- * @param fieldDef - 新的字段定义对象
- * @param colName - 列名（未使用，保留参数兼容性）
- * @returns 变化数组
- */
-export function compareFieldDefinition(existingColumn: ColumnInfo, fieldDef: FieldDefinition): FieldChange[] {
-    const changes: FieldChange[] = [];
-
-    // 检查长度变化（string和array类型） - SQLite 不比较长度
-    if (!isSQLite() && isStringOrArrayType(fieldDef.type)) {
-        if (existingColumn.max !== fieldDef.max) {
-            changes.push({
-                type: "length",
-                current: existingColumn.max,
-                expected: fieldDef.max
-            });
-        }
-    }
-
-    // 检查注释变化（MySQL/PG 支持列注释，对比数据库 comment 与字段 name）
-    if (!isSQLite()) {
-        const currentComment = existingColumn.comment || "";
-        if (currentComment !== fieldDef.name) {
-            changes.push({
-                type: "comment",
-                current: currentComment,
-                expected: fieldDef.name
-            });
-        }
-    }
-
-    // 检查数据类型变化（只对比基础类型）
-    const typeMapping = getTypeMapping();
-    const expectedType = typeMapping[fieldDef.type].toLowerCase();
-    const currentType = existingColumn.type.toLowerCase();
-
-    if (currentType !== expectedType) {
-        changes.push({
-            type: "datatype",
-            current: currentType,
-            expected: expectedType
-        });
-    }
-
-    // 检查 nullable 变化
-    const expectedNullable = fieldDef.nullable;
-    if (existingColumn.nullable !== expectedNullable) {
-        changes.push({
-            type: "nullable",
-            current: existingColumn.nullable,
-            expected: expectedNullable
-        });
-    }
-
-    // 使用公共函数处理默认值
-    const expectedDefault = resolveDefaultValue(fieldDef.default, fieldDef.type);
-
-    // 检查默认值变化
-    if (String(existingColumn.defaultValue) !== String(expectedDefault)) {
-        changes.push({
-            type: "default",
-            current: existingColumn.defaultValue,
-            expected: expectedDefault
-        });
-    }
-
-    return changes;
-}
-
-/**
- * 将表结构计划应用到数据库（执行 DDL/索引/注释等）
- *
- * 根据数据库方言和计划内容，执行相应的 DDL 操作：
- * - SQLite: 新增字段直接 ALTER，其他操作需要重建表
- * - MySQL: 尝试在线 DDL（INSTANT/INPLACE）
- * - PostgreSQL: 直接 ALTER
- *
- * @param sql - SQL 客户端实例
- * @param tableName - 表名
- * @param fields - 字段定义对象
- * @param plan - 表结构变更计划
- */
-export async function applyTablePlan(sql: SQL, tableName: string, fields: Record<string, FieldDefinition>, plan: TablePlan): Promise<void> {
-    if (!plan || !plan.changed) return;
-
-    // SQLite: 仅支持部分 ALTER；需要时走重建
-    if (isSQLite()) {
-        if (plan.modifyClauses.length > 0 || plan.defaultClauses.length > 0) {
-            if (IS_PLAN) Logger.debug(`[计划] 重建表 ${tableName} 以应用列修改/默认值变化`);
-            else await rebuildSqliteTable(sql, tableName, fields);
-        } else {
-            for (const c of plan.addClauses) {
-                const stmt = `ALTER TABLE "${tableName}" ${c}`;
-                if (IS_PLAN) Logger.debug(`[计划] ${stmt}`);
-                else await sql.unsafe(stmt);
-            }
-        }
-    } else {
-        const clauses = [...plan.addClauses, ...plan.modifyClauses];
-        if (clauses.length > 0) {
-            const stmt = buildAlterTableSQL(tableName, clauses);
-            if (IS_PLAN) Logger.debug(`[计划] ${stmt}`);
-            else if (isMySQL()) await executeDDLSafely(sql, stmt);
-            else await sql.unsafe(stmt);
-        }
-    }
-
-    // 默认值专用 ALTER（SQLite 不支持）
-    if (plan.defaultClauses.length > 0) {
-        if (isSQLite()) {
-            Logger.warn(`SQLite 不支持修改默认值，表 ${tableName} 的默认值变更已跳过`);
-        } else {
-            const stmt = buildAlterTableSQL(tableName, plan.defaultClauses);
-            if (IS_PLAN) Logger.debug(`[计划] ${stmt}`);
-            else if (isMySQL()) await executeDDLSafely(sql, stmt);
-            else await sql.unsafe(stmt);
-        }
-    }
-
-    // 索引操作
-    for (const act of plan.indexActions) {
-        const stmt = buildIndexSQL(tableName, act.indexName, act.fieldName, act.action);
-        if (IS_PLAN) {
-            Logger.debug(`[计划] ${stmt}`);
-        } else {
-            try {
-                await sql.unsafe(stmt);
-                if (act.action === "create") {
-                    Logger.debug(`[索引变化] 新建索引 ${tableName}.${act.indexName} (${act.fieldName})`);
-                } else {
-                    Logger.debug(`[索引变化] 删除索引 ${tableName}.${act.indexName} (${act.fieldName})`);
-                }
-            } catch (error: any) {
-                Logger.error({ err: error, table: tableName, index: act.indexName, field: act.fieldName }, `${act.action === "create" ? "创建" : "删除"}索引失败`);
-                throw error;
-            }
-        }
-    }
-
-    // PG 列注释
-    if (isPG() && plan.commentActions && plan.commentActions.length > 0) {
-        for (const stmt of plan.commentActions) {
-            if (IS_PLAN) Logger.info(`[计划] ${stmt}`);
-            else await sql.unsafe(stmt);
-        }
-    }
-}