befly 3.9.40 → 3.10.1

package/tests/syncDb-constants.test.ts

@@ -1,130 +0,0 @@
-/**
- * syncDb 常量模块测试
- *
- * 测试 constants.ts 中的常量：
- * - DB_VERSION_REQUIREMENTS
- * - SYSTEM_INDEX_FIELDS
- * - SYSTEM_INDEX_FIELDS
- * - CHANGE_TYPE_LABELS
- * - MYSQL_TABLE_CONFIG
- * - typeMapping
- */
-
-import { describe, test, expect, beforeAll } from "bun:test";
-
-import { setDbType } from "../sync/syncDb/constants.js";
-
-// 设置数据库类型为 MySQL
-setDbType("mysql");
-
-let constants: any;
-
-beforeAll(async () => {
-    constants = await import("../sync/syncDb/constants.js");
-});
-
-describe("DB_VERSION_REQUIREMENTS", () => {
-    test("MySQL 最低版本为 8", () => {
-        expect(constants.DB_VERSION_REQUIREMENTS.MYSQL_MIN_MAJOR).toBe(8);
-    });
-
-    test("PostgreSQL 最低版本为 17", () => {
-        expect(constants.DB_VERSION_REQUIREMENTS.POSTGRES_MIN_MAJOR).toBe(17);
-    });
-
-    test("SQLite 最低版本为 3.50.0", () => {
-        expect(constants.DB_VERSION_REQUIREMENTS.SQLITE_MIN_VERSION).toBe("3.50.0");
-    });
-});
-
-describe("SYSTEM_INDEX_FIELDS", () => {
-    test("包含 created_at", () => {
-        expect(constants.SYSTEM_INDEX_FIELDS).toContain("created_at");
-    });
-
-    test("包含 updated_at", () => {
-        expect(constants.SYSTEM_INDEX_FIELDS).toContain("updated_at");
-    });
-
-    test("包含 state", () => {
-        expect(constants.SYSTEM_INDEX_FIELDS).toContain("state");
-    });
-
-    test("共 3 个系统索引字段", () => {
-        expect(constants.SYSTEM_INDEX_FIELDS.length).toBe(3);
-    });
-});
-
-describe("CHANGE_TYPE_LABELS", () => {
-    test('length 对应 "长度"', () => {
-        expect(constants.CHANGE_TYPE_LABELS.length).toBe("长度");
-    });
-
-    test('datatype 对应 "类型"', () => {
-        expect(constants.CHANGE_TYPE_LABELS.datatype).toBe("类型");
-    });
-
-    test('comment 对应 "注释"', () => {
-        expect(constants.CHANGE_TYPE_LABELS.comment).toBe("注释");
-    });
-
-    test('default 对应 "默认值"', () => {
-        expect(constants.CHANGE_TYPE_LABELS.default).toBe("默认值");
-    });
-});
-
-describe("MYSQL_TABLE_CONFIG", () => {
-    test("ENGINE 为 InnoDB", () => {
-        expect(constants.MYSQL_TABLE_CONFIG.ENGINE).toBe("InnoDB");
-    });
-
-    test("CHARSET 为 utf8mb4", () => {
-        expect(constants.MYSQL_TABLE_CONFIG.CHARSET).toBe("utf8mb4");
-    });
-
-    test("COLLATE 为 utf8mb4_0900_ai_ci", () => {
-        expect(constants.MYSQL_TABLE_CONFIG.COLLATE).toBe("utf8mb4_0900_ai_ci");
-    });
-});
-
-describe("getTypeMapping (MySQL)", () => {
-    test("number 映射为 BIGINT", () => {
-        expect(constants.getTypeMapping().number).toBe("BIGINT");
-    });
-
-    test("string 映射为 VARCHAR", () => {
-        expect(constants.getTypeMapping().string).toBe("VARCHAR");
-    });
-
-    test("text 映射为 MEDIUMTEXT", () => {
-        expect(constants.getTypeMapping().text).toBe("MEDIUMTEXT");
-    });
-
-    test("array_string 映射为 VARCHAR", () => {
-        expect(constants.getTypeMapping().array_string).toBe("VARCHAR");
-    });
-
-    test("array_text 映射为 MEDIUMTEXT", () => {
-        expect(constants.getTypeMapping().array_text).toBe("MEDIUMTEXT");
-    });
-});
-
-describe("IS_PLAN", () => {
-    test("IS_PLAN 为 boolean 类型", () => {
-        expect(typeof constants.IS_PLAN).toBe("boolean");
-    });
-});
-
-describe("数据库类型判断 (MySQL)", () => {
-    test("isMySQL 为 true", () => {
-        expect(constants.isMySQL()).toBe(true);
-    });
-
-    test("isPG 为 false", () => {
-        expect(constants.isPG()).toBe(false);
-    });
-
-    test("isSQLite 为 false", () => {
-        expect(constants.isSQLite()).toBe(false);
-    });
-});

package/tests/syncDb-schema.test.ts

@@ -1,179 +0,0 @@
-/**
- * syncDb 表结构查询模块测试
- *
- * 测试 schema.ts 中的函数（纯逻辑测试，不需要数据库连接）：
- * - tableExists
- * - getTableColumns
- * - getTableIndexes
- *
- * 注意：这些是模拟测试，实际数据库操作需要集成测试
- */
-
-import { describe, test, expect, beforeAll } from "bun:test";
-
-import { setDbType } from "../sync/syncDb/constants.js";
-
-// 设置数据库类型为 MySQL
-setDbType("mysql");
-
-let tableExists: any;
-let getTableColumns: any;
-let getTableIndexes: any;
-
-beforeAll(async () => {
-    const schema = await import("../sync/syncDb/schema.js");
-    tableExists = schema.tableExists;
-    getTableColumns = schema.getTableColumns;
-    getTableIndexes = schema.getTableIndexes;
-});
-
-describe("tableExists", () => {
-    test("sql 客户端未初始化时抛出错误", async () => {
-        try {
-            await tableExists(null, "user");
-            expect(true).toBe(false); // 不应该到这里
-        } catch (error: any) {
-            expect(error.message).toBe("SQL 客户端未初始化");
-        }
-    });
-
-    test("传入有效 sql 客户端时正常执行", async () => {
-        // 创建模拟 SQL 客户端
-        const mockSql = Object.assign(
-            async function (_strings: TemplateStringsArray, ..._values: any[]) {
-                // 模拟 MySQL 查询返回
-                return [{ count: 1 }];
-            },
-            {
-                unsafe: async (_query: string) => []
-            }
-        );
-
-        const result = await tableExists(mockSql, "user", "test_db");
-        expect(result).toBe(true);
-    });
-
-    test("表不存在时返回 false", async () => {
-        const mockSql = Object.assign(
-            async function (_strings: TemplateStringsArray, ..._values: any[]) {
-                return [{ count: 0 }];
-            },
-            {
-                unsafe: async (_query: string) => []
-            }
-        );
-
-        const result = await tableExists(mockSql, "nonexistent", "test_db");
-        expect(result).toBe(false);
-    });
-});
-
-describe("getTableColumns", () => {
-    test("返回正确的列信息结构", async () => {
-        const mockSql = Object.assign(
-            async function (_strings: TemplateStringsArray, ..._values: any[]) {
-                // 模拟 MySQL information_schema 返回
-                return [
-                    {
-                        COLUMN_NAME: "id",
-                        DATA_TYPE: "bigint",
-                        CHARACTER_MAXIMUM_LENGTH: null,
-                        IS_NULLABLE: "NO",
-                        COLUMN_DEFAULT: null,
-                        COLUMN_COMMENT: "主键ID",
-                        COLUMN_TYPE: "bigint unsigned"
-                    },
-                    {
-                        COLUMN_NAME: "user_name",
-                        DATA_TYPE: "varchar",
-                        CHARACTER_MAXIMUM_LENGTH: 50,
-                        IS_NULLABLE: "NO",
-                        COLUMN_DEFAULT: "",
-                        COLUMN_COMMENT: "用户名",
-                        COLUMN_TYPE: "varchar(50)"
-                    },
-                    {
-                        COLUMN_NAME: "age",
-                        DATA_TYPE: "bigint",
-                        CHARACTER_MAXIMUM_LENGTH: null,
-                        IS_NULLABLE: "YES",
-                        COLUMN_DEFAULT: "0",
-                        COLUMN_COMMENT: "年龄",
-                        COLUMN_TYPE: "bigint"
-                    }
-                ];
-            },
-            {
-                unsafe: async (_query: string) => []
-            }
-        );
-
-        const columns = await getTableColumns(mockSql, "user", "test_db");
-
-        expect(columns.id).toBeDefined();
-        expect(columns.id.type).toBe("bigint");
-        expect(columns.id.nullable).toBe(false);
-        expect(columns.id.comment).toBe("主键ID");
-
-        expect(columns.user_name).toBeDefined();
-        expect(columns.user_name.type).toBe("varchar");
-        expect(columns.user_name.max).toBe(50);
-        expect(columns.user_name.nullable).toBe(false);
-        expect(columns.user_name.defaultValue).toBe("");
-
-        expect(columns.age).toBeDefined();
-        expect(columns.age.nullable).toBe(true);
-        expect(columns.age.defaultValue).toBe("0");
-    });
-});
-
-describe("getTableIndexes", () => {
-    test("返回正确的索引信息结构", async () => {
-        const mockSql = Object.assign(
-            async function (_strings: TemplateStringsArray, ..._values: any[]) {
-                // 模拟 MySQL information_schema.STATISTICS 返回
-                // 注意：PRIMARY 索引被排除
-                return [
-                    { INDEX_NAME: "idx_created_at", COLUMN_NAME: "created_at" },
-                    { INDEX_NAME: "idx_user_name", COLUMN_NAME: "user_name" }
-                ];
-            },
-            {
-                unsafe: async (_query: string) => []
-            }
-        );
-
-        const indexes = await getTableIndexes(mockSql, "user", "test_db");
-
-        // PRIMARY 索引被排除，不应存在
-        expect(indexes.PRIMARY).toBeUndefined();
-
-        expect(indexes.idx_created_at).toBeDefined();
-        expect(indexes.idx_created_at).toContain("created_at");
-
-        expect(indexes.idx_user_name).toBeDefined();
-        expect(indexes.idx_user_name).toContain("user_name");
-    });
-
-    test("复合索引包含多个列", async () => {
-        const mockSql = Object.assign(
-            async function (_strings: TemplateStringsArray, ..._values: any[]) {
-                // 模拟复合索引，同一索引名包含多个列
-                return [
-                    { INDEX_NAME: "idx_composite", COLUMN_NAME: "user_id" },
-                    { INDEX_NAME: "idx_composite", COLUMN_NAME: "created_at" }
-                ];
-            },
-            {
-                unsafe: async (_query: string) => []
-            }
-        );
-
-        const indexes = await getTableIndexes(mockSql, "user", "test_db");
-
-        expect(indexes.idx_composite).toBeDefined();
-        expect(indexes.idx_composite.length).toBe(2);
-        expect(indexes.idx_composite).toContain("user_id");
-        expect(indexes.idx_composite).toContain("created_at");
-    });
-});

package/tests/syncDb-types.test.ts

@@ -1,139 +0,0 @@
-/**
- * syncDb 类型处理模块测试
- *
- * 测试 types.ts 中的函数：
- * - isStringOrArrayType
- * - getSqlType
- * - resolveDefaultValue
- * - generateDefaultSql
- */
-
-import { describe, test, expect, beforeAll } from "bun:test";
-
-import { setDbType } from "../sync/syncDb/constants.js";
-
-// 设置数据库类型为 MySQL
-setDbType("mysql");
-
-// 动态导入以确保环境变量生效
-let isStringOrArrayType: any;
-let getSqlType: any;
-let resolveDefaultValue: any;
-let generateDefaultSql: any;
-
-beforeAll(async () => {
-    const types = await import("../sync/syncDb/types.js");
-    isStringOrArrayType = types.isStringOrArrayType;
-    getSqlType = types.getSqlType;
-    resolveDefaultValue = types.resolveDefaultValue;
-    generateDefaultSql = types.generateDefaultSql;
-});
-
-describe("isStringOrArrayType", () => {
-    test("string 类型返回 true", () => {
-        expect(isStringOrArrayType("string")).toBe(true);
-    });
-
-    test("array_string 类型返回 true", () => {
-        expect(isStringOrArrayType("array_string")).toBe(true);
-    });
-
-    test("number 类型返回 false", () => {
-        expect(isStringOrArrayType("number")).toBe(false);
-    });
-
-    test("text 类型返回 false", () => {
-        expect(isStringOrArrayType("text")).toBe(false);
-    });
-
-    test("array_text 类型返回 false", () => {
-        expect(isStringOrArrayType("array_text")).toBe(false);
-    });
-});
-
-describe("resolveDefaultValue", () => {
-    test("null 值 + string 类型 => 空字符串", () => {
-        expect(resolveDefaultValue(null, "string")).toBe("");
-    });
-
-    test("null 值 + number 类型 => 0", () => {
-        expect(resolveDefaultValue(null, "number")).toBe(0);
-    });
-
-    test('"null" 字符串 + number 类型 => 0', () => {
-        expect(resolveDefaultValue("null", "number")).toBe(0);
-    });
-
-    test('null 值 + array_string 类型 => "[]"', () => {
-        expect(resolveDefaultValue(null, "array_string")).toBe("[]");
-    });
-
-    test('null 值 + text 类型 => "null"', () => {
-        expect(resolveDefaultValue(null, "text")).toBe("null");
-    });
-
-    test('null 值 + array_text 类型 => "null"（TEXT 不支持默认值）', () => {
-        expect(resolveDefaultValue(null, "array_text")).toBe("null");
-    });
-
-    test("有实际值时直接返回", () => {
-        expect(resolveDefaultValue("admin", "string")).toBe("admin");
-        expect(resolveDefaultValue(100, "number")).toBe(100);
-        expect(resolveDefaultValue(0, "number")).toBe(0);
-    });
-});
-
-describe("generateDefaultSql", () => {
-    test("number 类型生成数字默认值", () => {
-        expect(generateDefaultSql(0, "number")).toBe(" DEFAULT 0");
-        expect(generateDefaultSql(100, "number")).toBe(" DEFAULT 100");
-    });
-
-    test("string 类型生成带引号默认值", () => {
-        expect(generateDefaultSql("admin", "string")).toBe(" DEFAULT 'admin'");
-        expect(generateDefaultSql("", "string")).toBe(" DEFAULT ''");
-    });
-
-    test("text 类型不生成默认值", () => {
-        expect(generateDefaultSql("null", "text")).toBe("");
-    });
-
-    test("array_string 类型生成 JSON 数组默认值", () => {
-        expect(generateDefaultSql("[]", "array_string")).toBe(" DEFAULT '[]'");
-    });
-
-    test("array_text 类型不生成默认值（MySQL TEXT 不支持）", () => {
-        expect(generateDefaultSql("[]", "array_text")).toBe("");
-    });
-
-    test("单引号被正确转义", () => {
-        expect(generateDefaultSql("it's", "string")).toBe(" DEFAULT 'it''s'");
-    });
-});
-
-describe("getSqlType", () => {
-    test("string 类型带长度", () => {
-        const result = getSqlType("string", 100);
-        expect(result).toBe("VARCHAR(100)");
-    });
-
-    test("array_string 类型带长度", () => {
-        const result = getSqlType("array_string", 500);
-        expect(result).toBe("VARCHAR(500)");
-    });
-
-    test("number 类型无符号", () => {
-        const result = getSqlType("number", null, true);
-        expect(result).toBe("BIGINT UNSIGNED");
-    });
-
-    test("number 类型有符号", () => {
-        const result = getSqlType("number", null, false);
-        expect(result).toBe("BIGINT");
-    });
-
-    test("text 类型", () => {
-        const result = getSqlType("text", null);
-        expect(result).toBe("MEDIUMTEXT");
-    });
-});

package/utils/addonHelper.ts

@@ -1,90 +0,0 @@
-import fs from "node:fs";
-import { existsSync, statSync } from "node:fs";
-
-import { join } from "pathe";
-
-import { projectAddonsDir } from "../paths.js";
-
-/**
- * 扫描所有可用的 addon
- * 优先从本地 addons/ 目录加载，其次从 node_modules/@befly-addon/ 加载
- * @param cwd - 项目根目录，默认为 process.cwd()
- * @returns addon 名称数组
- */
-export const scanAddons = (cwd: string = process.cwd()): string[] => {
-    const addons = new Set<string>();
-
-    // 1. 扫描本地 addons 目录（优先级高）
-    if (existsSync(projectAddonsDir)) {
-        try {
-            const localAddons = fs.readdirSync(projectAddonsDir).filter((name) => {
-                const fullPath = join(projectAddonsDir, name);
-                try {
-                    const stat = statSync(fullPath);
-                    return stat.isDirectory() && !name.startsWith("_");
-                } catch {
-                    return false;
-                }
-            });
-            localAddons.forEach((name) => addons.add(name));
-        } catch {
-            // 忽略本地目录读取错误
-        }
-    }
-
-    // 2. 扫描 node_modules/@befly-addon 目录
-    const beflyDir = join(cwd, "node_modules", "@befly-addon");
-    if (existsSync(beflyDir)) {
-        try {
-            const npmAddons = fs.readdirSync(beflyDir).filter((name) => {
-                // 如果本地已存在，跳过 npm 包版本
-                if (addons.has(name)) return false;
-
-                const fullPath = join(beflyDir, name);
-                try {
-                    const stat = statSync(fullPath);
-                    return stat.isDirectory();
-                } catch {
-                    return false;
-                }
-            });
-            npmAddons.forEach((name) => addons.add(name));
-        } catch {
-            // 忽略 npm 目录读取错误
-        }
-    }
-
-    return Array.from(addons).sort();
-};
-
-/**
- * 获取 addon 的指定子目录路径
- * 优先返回本地 addons 目录，其次返回 node_modules 目录
- * @param name - addon 名称
- * @param subDir - 子目录名称
- * @param cwd - 项目根目录，默认为 process.cwd()
- * @returns 完整路径
- */
-export const getAddonDir = (name: string, subDir: string, cwd: string = process.cwd()): string => {
-    // 优先使用本地 addons 目录
-    // const projectAddonsDir = join(cwd, 'addons');
-    // const localPath = join(projectAddonsDir, name, subDir);
-    // if (existsSync(localPath)) {
-    //     return localPath;
-    // }
-
-    // 降级使用 node_modules 目录
-    return join(cwd, "node_modules", "@befly-addon", name, subDir);
-};
-
-/**
- * 检查 addon 子目录是否存在
- * @param name - addon 名称
- * @param subDir - 子目录名称
- * @param cwd - 项目根目录，默认为 process.cwd()
- * @returns 是否存在
- */
-export const addonDirExists = (name: string, subDir: string, cwd: string = process.cwd()): boolean => {
-    const dir = getAddonDir(name, subDir, cwd);
-    return existsSync(dir) && statSync(dir).isDirectory();
-};

package/utils/modules.ts

@@ -1,98 +0,0 @@
-import type { Hook } from "../types/hook.js";
-import type { Plugin } from "../types/plugin.js";
-
-import { existsSync } from "node:fs";
-
-import { camelCase } from "es-toolkit/string";
-
-import { Logger } from "../lib/logger.js";
-import { scanFiles } from "./scanFiles.js";
-
-/**
- * 扫描模块（插件或钩子）
- * @param dir - 目录路径
- * @param type - 模块类型（core/addon/app）
- * @param moduleLabel - 模块标签（如"插件"、"钩子"）
- * @param addonName - 组件名称（仅 type='addon' 时需要）
- * @returns 模块列表
- */
-export async function scanModules<T extends Plugin | Hook>(dir: string, type: "core" | "addon" | "app", moduleLabel: string, addonName?: string): Promise<T[]> {
-    if (!existsSync(dir)) return [];
-
-    const items: T[] = [];
-    const files = await scanFiles(dir, "*.ts");
-
-    for (const { filePath, fileName } of files) {
-        // 生成模块名称
-        const name = camelCase(fileName);
-        const moduleName = type === "core" ? name : type === "addon" ? `addon_${camelCase(addonName!)}_${name}` : `app_${name}`;
-
-        try {
-            const normalizedFilePath = filePath.replace(/\\/g, "/");
-            const moduleImport = await import(normalizedFilePath);
-            const item = moduleImport.default;
-
-            item.name = moduleName;
-            // 为 addon 模块记录 addon 名称
-            if (type === "addon" && addonName) {
-                item.addonName = addonName;
-            }
-            items.push(item);
-        } catch (err: any) {
-            const typeLabel = type === "core" ? "核心" : type === "addon" ? `组件${addonName}` : "项目";
-            Logger.error({ err: err, module: fileName }, `${typeLabel}${moduleLabel} 导入失败`);
-            process.exit(1);
-        }
-    }
-
-    return items;
-}
-
-/**
- * 排序模块（根据依赖关系）
- * @param modules - 待排序的模块列表
- * @returns 排序后的模块列表，如果存在循环依赖或依赖不存在则返回 false
- */
-export function sortModules<T extends { name?: string; after?: string[] }>(modules: T[]): T[] | false {
-    const result: T[] = [];
-    const visited = new Set<string>();
-    const visiting = new Set<string>();
-    const moduleMap: Record<string, T> = Object.fromEntries(modules.map((m) => [m.name!, m]));
-    let isPass = true;
-
-    // 检查依赖是否存在
-    for (const module of modules) {
-        if (module.after) {
-            for (const dep of module.after) {
-                if (!moduleMap[dep]) {
-                    Logger.error({ module: module.name, dependency: dep }, "依赖的模块未找到");
-                    isPass = false;
-                }
-            }
-        }
-    }
-
-    if (!isPass) return false;
-
-    const visit = (name: string): void => {
-        if (visited.has(name)) return;
-        if (visiting.has(name)) {
-            Logger.error({ module: name }, "模块循环依赖");
-            isPass = false;
-            return;
-        }
-
-        const module = moduleMap[name];
-        if (!module) return;
-
-        visiting.add(name);
-        (module.after || []).forEach(visit);
-        visiting.delete(name);
-        visited.add(name);
-        result.push(module);
-    };
-
-    modules.forEach((m) => visit(m.name!));
-
-    return isPass ? result : false;
-}

package/utils/route.ts

@@ -1,23 +0,0 @@
-/**
- * 标准化接口权限路径（用于写入/读取权限缓存时保持一致）
- * 规则（简化版）：method 大写；path 为空则为 '/'；确保以 '/' 开头
- * 说明：当前框架内 api.path 来源于目录结构生成、请求侧使用 URL.pathname，默认不包含 query/hash，且不期望出现尾部斜杠等异常输入。
- */
-export function normalizeApiPath(method: string, path: string): string {
-    const normalizedMethod = (method || "").toUpperCase();
-    let normalizedPath = path || "/";
-
-    if (!normalizedPath.startsWith("/")) {
-        normalizedPath = "/" + normalizedPath;
-    }
-
-    return `${normalizedMethod}${normalizedPath}`;
-}
-
-/**
- * 生成路由 Key（用于路由匹配 / 权限缓存 / 日志等场景统一使用）
- * 格式：METHOD/path
- */
-export function makeRouteKey(method: string, pathname: string): string {
-    return normalizeApiPath(method, pathname);
-}