befly 3.10.17 → 3.10.19

package/{sync/syncMenu.ts → dist/sync/syncMenu.js}

@@ -1,62 +1,42 @@
-import type { BeflyContext } from "../types/befly.js";
-import type { MenuConfig } from "../types/sync.js";
-
 import { Logger } from "../lib/logger.js";
 import { compileDisableMenuGlobRules, isMenuPathDisabledByGlobRules } from "../utils/disableMenusGlob.js";
 import { getParentPath } from "../utils/loadMenuConfigs.js";
-
-type MenuDef = {
-    path: string;
-    name: string;
-    sort: number;
-    parentPath: string;
-};
-
-function flattenMenusToDefMap(mergedMenus: MenuConfig[]): Map<string, MenuDef> {
+function flattenMenusToDefMap(mergedMenus) {
     // 读取配置菜单：扁平化为 path => { name, sort, parentPath }
     // - 以 path 为唯一键：后出现的覆盖先出现的（与旧逻辑“同 path 多次同步同一条记录”一致）
     // parentPath 规则：
     // 1) 若 menu 显式携带 parentPath（包括空字符串），以其为准
     // 2) 否则使用“树结构”推导的父级（由 children 嵌套关系决定；根级为 ""）
     // 3) 保底：若无法推导（极端情况），回退到 getParentPath(path)
-    const menuDefMap = new Map<string, MenuDef>();
-
-    const stack: Array<{ menu: MenuConfig; parentPathFromTree: string }> = [];
+    const menuDefMap = new Map();
+    const stack = [];
     for (const m of mergedMenus) {
         stack.push({ menu: m, parentPathFromTree: "" });
     }
-
     while (stack.length > 0) {
         const item = stack.pop();
         const menu = item ? item.menu : null;
         if (!menu) {
             continue;
         }
-
-        const path = typeof (menu as any).path === "string" ? (menu as any).path : "";
-
-        const rawChildren = (menu as any).children;
+        const path = typeof menu.path === "string" ? menu.path : "";
+        const rawChildren = menu.children;
         if (rawChildren && Array.isArray(rawChildren) && rawChildren.length > 0) {
             const nextParentPathFromTree = typeof path === "string" ? path : "";
             for (const child of rawChildren) {
                 stack.push({ menu: child, parentPathFromTree: nextParentPathFromTree });
             }
         }
-
         if (!path) {
             continue;
         }
-
-        const name = typeof (menu as any).name === "string" ? (menu as any).name : "";
+        const name = typeof menu.name === "string" ? menu.name : "";
         if (!name) {
             continue;
         }
-
-        const sort = typeof (menu as any).sort === "number" ? (menu as any).sort : 999999;
-
-        const hasExplicitParentPath = typeof (menu as any).parentPath === "string";
-        const parentPath = hasExplicitParentPath ? ((menu as any).parentPath as string) : typeof item?.parentPathFromTree === "string" ? item.parentPathFromTree : getParentPath(path);
-
+        const sort = typeof menu.sort === "number" ? menu.sort : 999999;
+        const hasExplicitParentPath = typeof menu.parentPath === "string";
+        const parentPath = hasExplicitParentPath ? menu.parentPath : typeof item?.parentPathFromTree === "string" ? item.parentPathFromTree : getParentPath(path);
         menuDefMap.set(path, {
             path: path,
             name: name,
@@ -64,86 +44,68 @@ function flattenMenusToDefMap(mergedMenus: MenuConfig[]): Map<string, MenuDef> {
             parentPath: parentPath
         });
     }
-
     return menuDefMap;
 }
-
-export async function syncMenu(ctx: BeflyContext, mergedMenus: MenuConfig[]): Promise<void> {
+export async function syncMenu(ctx, mergedMenus) {
     if (!ctx.db) {
         throw new Error("syncMenu: ctx.db 未初始化（Db 插件未加载或注入失败）");
     }
-
     if (!ctx.cache) {
         throw new Error("syncMenu: ctx.cache 未初始化（cache 插件未加载或注入失败）");
     }
-
     if (!ctx.config) {
         throw new Error("syncMenu: ctx.config 未初始化（config 插件未加载或注入失败）");
     }
-
     if (!(await ctx.db.tableExists("addon_admin_menu")).data) {
         Logger.debug(`addon_admin_menu 表不存在`);
         return;
     }
-
     // 防御性过滤：保证禁用菜单不会进入 DB（即使上游遗漏了 checkMenu 的过滤）
     const disableRules = compileDisableMenuGlobRules(ctx.config?.disableMenus);
-    const filteredMergedMenus: MenuConfig[] =
-        disableRules.length === 0
-            ? mergedMenus
-            : (() => {
-                  const filterMenusByDisableRules = (menus: MenuConfig[]): MenuConfig[] => {
-                      const filtered: MenuConfig[] = [];
-
-                      for (const menu of menus) {
-                          const menuPath = typeof (menu as any)?.path === "string" ? String((menu as any).path).trim() : "";
-                          if (menuPath && isMenuPathDisabledByGlobRules(menuPath, disableRules)) {
-                              continue;
-                          }
-
-                          const children = Array.isArray((menu as any)?.children) ? ((menu as any).children as MenuConfig[]) : null;
-                          if (children && children.length > 0) {
-                              const nextChildren = filterMenusByDisableRules(children);
-                              if (nextChildren.length > 0) {
-                                  (menu as any).children = nextChildren;
-                              } else {
-                                  delete (menu as any).children;
-                              }
-                          }
-
-                          filtered.push(menu);
-                      }
-
-                      return filtered;
-                  };
-
-                  return filterMenusByDisableRules(mergedMenus);
-              })();
-
+    const filteredMergedMenus = disableRules.length === 0
+        ? mergedMenus
+        : (() => {
+            const filterMenusByDisableRules = (menus) => {
+                const filtered = [];
+                for (const menu of menus) {
+                    const menuPath = typeof menu?.path === "string" ? String(menu.path).trim() : "";
+                    if (menuPath && isMenuPathDisabledByGlobRules(menuPath, disableRules)) {
+                        continue;
+                    }
+                    const children = Array.isArray(menu?.children) ? menu.children : null;
+                    if (children && children.length > 0) {
+                        const nextChildren = filterMenusByDisableRules(children);
+                        if (nextChildren.length > 0) {
+                            menu.children = nextChildren;
+                        }
+                        else {
+                            delete menu.children;
+                        }
+                    }
+                    filtered.push(menu);
+                }
+                return filtered;
+            };
+            return filterMenusByDisableRules(mergedMenus);
+        })();
     const menuDefMap = flattenMenusToDefMap(filteredMergedMenus);
-
-    const configPaths = new Set<string>();
+    const configPaths = new Set();
     for (const p of menuDefMap.keys()) {
         configPaths.add(p);
     }
-
     const tableName = "addon_admin_menu";
-
     // 2) 批量同步（事务内）：按 path diff 执行批量 insert/update/delete
-    await ctx.db.trans(async (trans: any) => {
+    await ctx.db.trans(async (trans) => {
         // 读取全部菜单（用于清理禁用菜单：不分 state）
         const allExistingMenusAllState = await trans.getAll({
             table: tableName,
             fields: ["id", "name", "path", "parentPath", "sort", "state"]
-        } as any);
-
+        });
         const existingListAllState = allExistingMenusAllState.data.lists || [];
-        const existingList = existingListAllState.filter((m: any) => typeof m?.state === "number" && m.state >= 0);
-
-        const existingMenuMap = new Map<string, any>();
-        const duplicateIdSet = new Set<number>();
-        const duplicatePathInfoMap = new Map<string, { keptId: number; removedIds: number[] }>();
-
+        const existingList = existingListAllState.filter((m) => typeof m?.state === "number" && m.state >= 0);
+        const existingMenuMap = new Map();
+        const duplicateIdSet = new Set();
+        const duplicatePathInfoMap = new Map();
         for (const record of existingList) {
             if (typeof record?.path !== "string" || !record.path) {
                 continue;
@@ -151,36 +113,31 @@ export async function syncMenu(ctx: BeflyContext, mergedMenus: MenuConfig[]): Pr
             if (typeof record?.id !== "number") {
                 continue;
             }
-
             const existing = existingMenuMap.get(record.path);
             if (!existing) {
                 existingMenuMap.set(record.path, record);
                 continue;
             }
-
             const existingId = typeof existing?.id === "number" ? existing.id : 0;
             const recordId = record.id;
-
             // 保留 id 最大的一条（genTimeID 越大通常越新），其余标记为重复并清理
             if (recordId > existingId) {
                 existingMenuMap.set(record.path, record);
-
                 if (existingId > 0) {
                     duplicateIdSet.add(existingId);
                 }
-
-                const info = duplicatePathInfoMap.get(record.path) || { keptId: recordId, removedIds: [] as number[] };
+                const info = duplicatePathInfoMap.get(record.path) || { keptId: recordId, removedIds: [] };
                 info.keptId = recordId;
                 if (existingId > 0) {
                     info.removedIds.push(existingId);
                 }
                 duplicatePathInfoMap.set(record.path, info);
-            } else {
+            }
+            else {
                 if (recordId > 0) {
                     duplicateIdSet.add(recordId);
                 }
-
-                const info = duplicatePathInfoMap.get(record.path) || { keptId: existingId, removedIds: [] as number[] };
+                const info = duplicatePathInfoMap.get(record.path) || { keptId: existingId, removedIds: [] };
                 info.keptId = existingId;
                 if (recordId > 0) {
                     info.removedIds.push(recordId);
@@ -188,9 +145,8 @@ export async function syncMenu(ctx: BeflyContext, mergedMenus: MenuConfig[]): Pr
                 duplicatePathInfoMap.set(record.path, info);
             }
         }
-
         if (duplicatePathInfoMap.size > 0) {
-            const examples: Array<{ path: string; keptId: number; removedIds: number[] }> = [];
+            const examples = [];
             for (const entry of duplicatePathInfoMap.entries()) {
                 const path = entry[0];
                 const info = entry[1];
@@ -199,22 +155,16 @@ export async function syncMenu(ctx: BeflyContext, mergedMenus: MenuConfig[]): Pr
                     break;
                 }
             }
-
-            Logger.warn(
-                {
-                    table: tableName,
-                    duplicatePaths: duplicatePathInfoMap.size,
-                    duplicateIds: duplicateIdSet.size,
-                    examples: examples
-                },
-                "addon_admin_menu 检测到重复 path 记录：已保留 id 最大的一条并删除其余记录"
-            );
+            Logger.warn({
+                table: tableName,
+                duplicatePaths: duplicatePathInfoMap.size,
+                duplicateIds: duplicateIdSet.size,
+                examples: examples
+            }, "addon_admin_menu 检测到重复 path 记录：已保留 id 最大的一条并删除其余记录");
         }
-
         // 2) 一次性算出 insert/update（仅依赖 path diff，不使用 pid，不预生成 id）
-        const updList: Array<{ id: number; data: Record<string, any> }> = [];
-        const insList: Array<Record<string, any>> = [];
-
+        const updList = [];
+        const insList = [];
         for (const def of menuDefMap.values()) {
             const existing = existingMenuMap.get(def.path);
             if (existing) {
@@ -231,7 +181,8 @@ export async function syncMenu(ctx: BeflyContext, mergedMenus: MenuConfig[]): Pr
                         }
                     });
                 }
-            } else {
+            }
+            else {
                 insList.push({
                     name: def.name,
                     path: def.path,
@@ -240,18 +191,14 @@ export async function syncMenu(ctx: BeflyContext, mergedMenus: MenuConfig[]): Pr
                 });
             }
         }
-
         if (updList.length > 0) {
             await trans.updBatch(tableName, updList);
         }
-
         if (insList.length > 0) {
             await trans.insBatch(tableName, insList);
         }
-
         // 3) 删除差集（DB - 配置，仅 state>=0） + 删除重复 path 的多余记录 + 删除禁用菜单（不分 state）
-        const delIdSet = new Set<number>();
-
+        const delIdSet = new Set();
         // 3.1) 清理禁用菜单：只要命中 disableMenus，就强制删除（避免 menu/list 之类接口还能查到）
         if (disableRules.length > 0) {
             for (const record of existingListAllState) {
@@ -259,7 +206,6 @@ export async function syncMenu(ctx: BeflyContext, mergedMenus: MenuConfig[]): Pr
                 if (!recordPath) {
                     continue;
                 }
-
                 if (isMenuPathDisabledByGlobRules(recordPath, disableRules)) {
                     if (typeof record?.id === "number" && record.id > 0) {
                         delIdSet.add(record.id);
@@ -267,7 +213,6 @@ export async function syncMenu(ctx: BeflyContext, mergedMenus: MenuConfig[]): Pr
                 }
             }
         }
-
         for (const record of existingList) {
             if (typeof record?.path !== "string" || !record.path) {
                 continue;
@@ -278,30 +223,25 @@ export async function syncMenu(ctx: BeflyContext, mergedMenus: MenuConfig[]): Pr
                 }
             }
         }
-
         for (const id of duplicateIdSet) {
             if (typeof id === "number" && id > 0) {
                 delIdSet.add(id);
             }
         }
-
         const delIds = Array.from(delIdSet);
-
         if (delIds.length > 0) {
             await trans.delForceBatch(tableName, delIds);
         }
     });
-
     // 缓存同步职责已收敛到 syncCache（启动流程单点调用），此处只负责 DB 同步。
 }
-
 // 仅测试用（避免将内部扫描逻辑变成稳定 API）
 export const __test__ = {
-    scanViewsDir: async (viewsDir: string, prefix: string, parentPath: string = "") => {
+    scanViewsDir: async (viewsDir, prefix, parentPath = "") => {
         const mod = await import("../utils/loadMenuConfigs.js");
         return await mod.scanViewsDirToMenuConfigs(viewsDir, prefix, parentPath);
     },
-    flattenMenusToDefMap: (mergedMenus: MenuConfig[]) => {
+    flattenMenusToDefMap: (mergedMenus) => {
         return flattenMenusToDefMap(mergedMenus);
     }
 };

package/dist/sync/syncTable.d.ts

@@ -0,0 +1,151 @@
+/**
+ * syncTable 命令 - 同步数据库表结构（单文件版）
+ *
+ * 说明：
+ * - 历史上该能力拆分在 packages/core/sync/syncTable/* 多个模块中
+ * - 现在按项目要求，将所有实现合并到本文件（目录 packages/core/sync/syncTable/ 已删除）
+ */
+import type { DbDialectName } from "../lib/dbDialect.ts";
+import type { BeflyContext } from "../types/befly.ts";
+import type { DbResult, SqlInfo } from "../types/database.ts";
+import type { ColumnInfo, FieldChange, IndexInfo } from "../types/sync.ts";
+import type { FieldDefinition } from "../types/validate.ts";
+import type { ScanFileResult } from "../utils/scanFiles.ts";
+type SqlExecutor = {
+    unsafe<T = any>(sqlStr: string, params?: unknown[]): Promise<DbResult<T, SqlInfo>>;
+};
+type DbDialect = DbDialectName;
+/**
+ * 文件导航（推荐阅读顺序）
+ * 1) syncTable(ctx, items) 入口（本段下方）
+ * 2) 版本/常量/方言判断（DB_VERSION_REQUIREMENTS 等）
+ * 3) 通用 DDL 工具（quote/type/default/ddl/index SQL）
+ * 4) Runtime I/O（只读元信息：表/列/索引/版本）
+ * 5) plan/apply（写变更：建表/改表/SQLite 重建）
+ */
+type SyncTableFn = ((ctx: BeflyContext, items: ScanFileResult[]) => Promise<void>) & {
+    TestKit: typeof SYNC_TABLE_TEST_KIT;
+};
+/**
+ * 数据库同步命令入口（函数模式）
+ */
+export declare const syncTable: SyncTableFn;
+declare const SYNC_TABLE_TEST_KIT: {
+    DB_VERSION_REQUIREMENTS: {
+        readonly MYSQL_MIN_MAJOR: 8;
+        readonly POSTGRES_MIN_MAJOR: 17;
+        readonly SQLITE_MIN_VERSION: "3.50.0";
+        readonly SQLITE_MIN_VERSION_NUM: 35000;
+    };
+    CHANGE_TYPE_LABELS: {
+        readonly length: "长度";
+        readonly datatype: "类型";
+        readonly comment: "注释";
+        readonly default: "默认值";
+        readonly nullable: "可空约束";
+        readonly unique: "唯一约束";
+    };
+    MYSQL_TABLE_CONFIG: {
+        readonly ENGINE: "InnoDB";
+        readonly CHARSET: "utf8mb4";
+        readonly COLLATE: "utf8mb4_0900_ai_ci";
+    };
+    SYSTEM_INDEX_FIELDS: readonly string[];
+    getTypeMapping: typeof getTypeMapping;
+    quoteIdentifier: typeof quoteIdentifier;
+    escapeComment: typeof escapeComment;
+    applyFieldDefaults: typeof applyFieldDefaults;
+    isStringOrArrayType: typeof isStringOrArrayType;
+    getSqlType: typeof getSqlType;
+    resolveDefaultValue: typeof resolveDefaultValue;
+    generateDefaultSql: typeof generateDefaultSql;
+    buildIndexSQL: typeof buildIndexSQL;
+    buildSystemColumnDefs: typeof buildSystemColumnDefs;
+    buildBusinessColumnDefs: typeof buildBusinessColumnDefs;
+    generateDDLClause: typeof generateDDLClause;
+    isCompatibleTypeChange: typeof isCompatibleTypeChange;
+    compareFieldDefinition: typeof compareFieldDefinition;
+    tableExistsRuntime: typeof tableExistsRuntime;
+    getTableColumnsRuntime: typeof getTableColumnsRuntime;
+    getTableIndexesRuntime: typeof getTableIndexesRuntime;
+    createRuntime: (dbDialect: DbDialectName, db: SqlExecutor, dbName?: string) => SyncRuntime;
+};
+/**
+ * 获取字段类型映射（根据当前数据库类型）
+ */
+declare function getTypeMapping(dbDialect: DbDialect): Record<string, string>;
+/**
+ * 根据数据库类型引用标识符
+ */
+declare function quoteIdentifier(dbDialect: DbDialect, identifier: string): string;
+/**
+ * 转义 SQL 注释中的双引号
+ */
+declare function escapeComment(str: string): string;
+/**
+ * 为字段定义应用默认值
+ */
+declare function applyFieldDefaults(fieldDef: any): void;
+/**
+ * 判断是否为字符串或数组类型（需要长度参数）
+ */
+declare function isStringOrArrayType(fieldType: string): boolean;
+/**
+ * 获取 SQL 数据类型
+ */
+declare function getSqlType(dbDialect: DbDialect, fieldType: string, fieldMax: number | null, unsigned?: boolean): string;
+/**
+ * 处理默认值：将 null 或 'null' 字符串转换为对应类型的默认值
+ */
+declare function resolveDefaultValue(fieldDefault: any, fieldType: string): any;
+/**
+ * 生成 SQL DEFAULT 子句
+ */
+declare function generateDefaultSql(actualDefault: any, fieldType: string): string;
+/**
+ * 构建索引操作 SQL（统一使用在线策略）
+ */
+declare function buildIndexSQL(dbDialect: DbDialect, tableName: string, indexName: string, fieldName: string, action: "create" | "drop"): string;
+/**
+ * 构建系统字段列定义
+ */
+declare function buildSystemColumnDefs(dbDialect: DbDialect): string[];
+/**
+ * 构建业务字段列定义
+ */
+declare function buildBusinessColumnDefs(dbDialect: DbDialect, fields: Record<string, FieldDefinition>): string[];
+/**
+ * 生成字段 DDL 子句（不含 ALTER TABLE 前缀）
+ */
+declare function generateDDLClause(dbDialect: DbDialect, fieldKey: string, fieldDef: FieldDefinition, isAdd?: boolean): string;
+/**
+ * 判断是否为兼容的类型变更（宽化型变更，无数据丢失风险）
+ */
+declare function isCompatibleTypeChange(currentType: string, newType: string): boolean;
+type SyncRuntime = {
+    /**
+     * 当前数据库方言（mysql/postgresql/sqlite），决定 SQL 片段与元信息查询方式。
+     * 约束：必须与 ctx.config.db.type 一致（经归一化）。
+     */
+    dbDialect: DbDialect;
+    /**
+     * SQL 执行器：必须复用 ctx.db。
+     * 约束：syncTable 内部禁止新建 DB 连接/事务；runtime 仅保存引用，不拥有生命周期。
+     */
+    db: SqlExecutor;
+    /**
+     * 数据库名：主要用于 MySQL information_schema 查询。
+     * 约束：PG/SQLite 可以传空字符串；不要在非 MySQL 方言依赖该值。
+     */
+    dbName: string;
+};
+declare function tableExistsRuntime(runtime: SyncRuntime, tableName: string): Promise<boolean>;
+declare function getTableColumnsRuntime(runtime: SyncRuntime, tableName: string): Promise<{
+    [key: string]: ColumnInfo;
+}>;
+declare function getTableIndexesRuntime(runtime: SyncRuntime, tableName: string): Promise<IndexInfo>;
+/**
+ * 比较字段定义变化
+ */
+declare function compareFieldDefinition(dbDialect: DbDialect, existingColumn: ColumnInfo, fieldDef: FieldDefinition): FieldChange[];
+export {};