befly 3.9.40 → 3.10.1

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);
-        }
-    }
-}

package/sync/syncDb/constants.ts

@@ -1,119 +0,0 @@
-/**
- * syncDb 常量定义模块
- *
- * 包含：
- * - 数据库类型判断
- * - 版本要求
- * - 数据类型映射
- * - 系统字段定义
- */
-
-/**
- * 数据库版本要求
- */
-export const DB_VERSION_REQUIREMENTS = {
-    MYSQL_MIN_MAJOR: 8,
-    POSTGRES_MIN_MAJOR: 17,
-    SQLITE_MIN_VERSION: "3.50.0",
-    SQLITE_MIN_VERSION_NUM: 35000 // 3 * 10000 + 50 * 100
-} as const;
-
-/**
- * 需要创建索引的系统字段
- */
-export const SYSTEM_INDEX_FIELDS = ["created_at", "updated_at", "state"] as const;
-
-/**
- * 字段变更类型的中文标签映射
- */
-export const CHANGE_TYPE_LABELS = {
-    length: "长度",
-    datatype: "类型",
-    comment: "注释",
-    default: "默认值",
-    nullable: "可空约束",
-    unique: "唯一约束"
-} as const;
-
-/**
- * MySQL 表配置
- *
- * 固定配置说明：
- * - ENGINE: InnoDB（支持事务、外键）
- * - CHARSET: utf8mb4（完整 Unicode 支持，包括 Emoji）
- * - COLLATE: utf8mb4_0900_ai_ci（MySQL 8.0 推荐，不区分重音和大小写）
- */
-export const MYSQL_TABLE_CONFIG = {
-    ENGINE: "InnoDB",
-    CHARSET: "utf8mb4",
-    COLLATE: "utf8mb4_0900_ai_ci"
-} as const;
-
-// 是否为计划模式（仅输出 SQL 不执行）
-export const IS_PLAN = process.argv.includes("--plan");
-
-// 数据库类型（运行时设置，默认 mysql）
-let _dbType: string = "mysql";
-
-/**
- * 设置数据库类型（由 syncDbCommand 调用）
- * @param dbType - 数据库类型（mysql/postgresql/postgres/sqlite）
- */
-export function setDbType(dbType: string): void {
-    _dbType = (dbType || "mysql").toLowerCase();
-}
-
-/**
- * 获取当前数据库类型
- */
-export function getDbType(): string {
-    return _dbType;
-}
-
-// 数据库类型判断（getter 函数，运行时动态计算）
-export function isMySQL(): boolean {
-    return _dbType === "mysql";
-}
-
-export function isPG(): boolean {
-    return _dbType === "postgresql" || _dbType === "postgres";
-}
-
-export function isSQLite(): boolean {
-    return _dbType === "sqlite";
-}
-
-// 兼容旧代码的静态别名（通过 getter 实现动态获取）
-export const DB_TYPE = {
-    get current(): string {
-        return _dbType;
-    },
-    get IS_MYSQL(): boolean {
-        return isMySQL();
-    },
-    get IS_PG(): boolean {
-        return isPG();
-    },
-    get IS_SQLITE(): boolean {
-        return isSQLite();
-    }
-};
-
-/**
- * 获取字段类型映射（根据当前数据库类型）
- */
-export function getTypeMapping(): Record<string, string> {
-    const isSqlite = isSQLite();
-    const isPg = isPG();
-    const isMysql = isMySQL();
-
-    return {
-        number: isSqlite ? "INTEGER" : isPg ? "BIGINT" : "BIGINT",
-        string: isSqlite ? "TEXT" : isPg ? "character varying" : "VARCHAR",
-        text: isMysql ? "MEDIUMTEXT" : "TEXT",
-        array_string: isSqlite ? "TEXT" : isPg ? "character varying" : "VARCHAR",
-        array_text: isMysql ? "MEDIUMTEXT" : "TEXT",
-        array_number_string: isSqlite ? "TEXT" : isPg ? "character varying" : "VARCHAR",
-        array_number_text: isMysql ? "MEDIUMTEXT" : "TEXT"
-    };
-}