befly 3.15.1 → 3.15.3

package/dist/lib/dbUtils.d.ts

@@ -1,4 +1,14 @@
-import type { WhereConditions } from "../types/common";
+import type { SqlValue, WhereConditions } from "../types/common";
+type BuildInsertRowOptions = {
+    idMode: "timeId";
+    data: Record<string, SqlValue>;
+    id: number;
+    now: number;
+} | {
+    idMode: "autoId";
+    data: Record<string, SqlValue>;
+    now: number;
+};
 export declare class DbUtils {
     static parseTableRef(tableRef: string): {
         schema: string | null;
@@ -51,11 +61,7 @@ export declare class DbUtils {
     static stripSystemFieldsForWrite(data: Record<string, any>, options: {
         allowState: boolean;
     }): Record<string, any>;
-    static buildInsertRow(options: {
-        data: Record<string, any>;
-        id: number;
-        now: number;
-    }): Record<string, any>;
+    static buildInsertRow(options: BuildInsertRowOptions): Record<string, any>;
     static buildUpdateRow(options: {
         data: Record<string, any>;
         now: number;
@@ -66,3 +72,4 @@ export declare class DbUtils {
         allowState: boolean;
     }): Record<string, any>;
 }
+export {};

package/dist/lib/dbUtils.js

@@ -1,5 +1,6 @@
 import { fieldClear } from "../utils/fieldClear";
 import { keysToSnake, snakeCase } from "../utils/util";
+import { SqlCheck } from "./sqlCheck";
 export class DbUtils {
     static parseTableRef(tableRef) {
         if (typeof tableRef !== "string") {
@@ -92,11 +93,7 @@ export class DbUtils {
         // 情况2：指定包含字段
         if (classified.type === "include") {
             return classified.fields.map((field) => {
-                // 保留函数和特殊字段
-                if (field.includes("(") || field.includes(" ")) {
-                    return field;
-                }
-                return snakeCase(field);
+                return DbUtils.processJoinField(field);
             });
         }
         // 情况3：排除字段
@@ -124,6 +121,11 @@ export class DbUtils {
         if (fields.some((f) => !f || typeof f !== "string" || f.trim() === "")) {
             throw new Error("fields 不能包含空字符串或无效值");
         }
+        // 统一禁止函数/表达式：复杂表达式请使用 selectRaw/whereRaw
+        for (const rawField of fields) {
+            const checkField = rawField.startsWith("!") ? rawField.substring(1) : rawField;
+            SqlCheck.assertNoExprField(checkField);
+        }
         // 统计包含字段和排除字段
         const includeFields = fields.filter((f) => !f.startsWith("!"));
         const excludeFields = fields.filter((f) => f.startsWith("!"));
@@ -161,8 +163,10 @@ export class DbUtils {
         });
     }
     static processJoinField(field) {
-        // 跳过函数、星号、已处理的字段
-        if (field.includes("(") || field === "*" || field.startsWith("`")) {
+        // 统一禁止函数/表达式：复杂表达式请使用 SqlBuilder.selectRaw
+        SqlCheck.assertNoExprField(field);
+        // 跳过星号、已引用字段
+        if (field === "*" || field.startsWith("`")) {
             return field;
         }
         // 处理别名 AS
@@ -200,6 +204,8 @@ export class DbUtils {
         if (key === "$or" || key === "$and") {
             return key;
         }
+        // 统一禁止函数/表达式：复杂表达式请使用 whereRaw
+        SqlCheck.assertNoExprField(key);
         // 处理带操作符的字段名（如 user.userId$gt）
         if (key.includes("$")) {
             const lastDollarIndex = key.lastIndexOf("$");
@@ -328,6 +334,8 @@ export class DbUtils {
                 result[key] = Array.isArray(value) ? value.map((item) => DbUtils.whereKeysToSnake(item)) : [];
                 continue;
             }
+            // 统一禁止函数/表达式：复杂表达式请使用 whereRaw
+            SqlCheck.assertNoExprField(key);
             // 处理带操作符的字段名（如 userId$gt）
             if (key.includes("$")) {
                 const lastDollarIndex = key.lastIndexOf("$");
@@ -427,7 +435,13 @@ export class DbUtils {
         for (const [key, value] of Object.entries(userData)) {
             result[key] = value;
         }
-        result["id"] = options.id;
+        if (options.idMode === "timeId") {
+            if (!Number.isFinite(options.id) || options.id <= 0) {
+                throw new Error(`buildInsertRow(timeId) 失败：id 必须为 > 0 的有限 number (id: ${String(options.id)})`);
+            }
+            result["id"] = options.id;
+        }
+        // autoId 模式：不写入 id，交给 MySQL AUTO_INCREMENT 生成
         result["created_at"] = options.now;
         result["updated_at"] = options.now;
         result["state"] = 1;

package/dist/plugins/db.js

@@ -3,7 +3,6 @@
  * 初始化数据库连接和 SQL 管理器
  */
 import { Connect } from "../lib/connect";
-import { getDialectByName } from "../lib/dbDialect";
 import { DbHelper } from "../lib/dbHelper";
 import { Logger } from "../lib/logger";
 /**
@@ -15,16 +14,19 @@ const dbPlugin = {
     deps: ["logger", "redis"],
     async handler(befly) {
         const env = befly.config?.nodeEnv;
+        const dbName = String(befly.config?.db?.database || "");
+        if (!dbName) {
+            throw new Error("数据库初始化失败：befly.config.db.database 缺失");
+        }
         if (!befly.redis) {
             throw new Error("Redis 未初始化");
         }
         try {
             const sql = Connect.getSql();
-            const rawDbDialect = befly.config?.db?.dialect;
-            const dialectName = rawDbDialect === "postgresql" || rawDbDialect === "sqlite" ? rawDbDialect : "mysql";
-            const dialect = getDialectByName(dialectName);
+            const idMode = befly.config?.db?.idMode;
+            const normalizedIdMode = idMode === "autoId" ? "autoId" : "timeId";
             // 创建数据库管理器实例
-            const dbManager = new DbHelper({ redis: befly.redis, sql: sql, dialect: dialect });
+            const dbManager = new DbHelper({ redis: befly.redis, dbName: dbName, sql: sql, idMode: normalizedIdMode });
             return dbManager;
         }
         catch (error) {

package/dist/sync/syncDev.js

@@ -145,6 +145,8 @@ export async function syncDev(ctx, config = {}) {
                     code: roleConfig.code,
                     name: roleConfig.name,
                     description: roleConfig.description,
+                    menus: [],
+                    apis: [],
                     sort: roleConfig.sort
                 }
             });

package/dist/sync/syncTable.d.ts

@@ -1,13 +1,13 @@
 /**
- * syncTable 命令 - 同步数据库表结构（单文件版）
+ * syncTable 命令 - 同步数据库表结构（MySQL 8+ only / 单文件版）
  *
  * 说明：
  * - 历史上该能力拆分在 packages/core/sync/syncTable/* 多个模块中
  * - 现在按项目要求，将所有实现合并到本文件（目录 packages/core/sync/syncTable/ 已删除）
+ * - core 仅支持 MySQL 8.0+
  */
-import type { DbDialectName } from "../lib/dbDialect";
 import type { DbResult, SqlInfo } from "../types/database";
-import type { ColumnInfo, FieldChange, IndexInfo } from "../types/sync";
+import type { ColumnInfo, FieldChange, IndexInfo, TablePlan } from "../types/sync";
 import type { FieldDefinition } from "../types/validate";
 import type { ScanFileResult } from "../utils/scanFiles";
 type SqlExecutor = {
@@ -15,41 +15,32 @@ type SqlExecutor = {
 };
 type SyncTableContext = {
     db: SqlExecutor;
-    redis: {
-        delBatch(keys: string[]): Promise<unknown>;
-    };
     config: {
         db?: {
-            dialect?: DbDialectName;
             database?: string;
         };
     };
 };
-type DbDialect = DbDialectName;
-declare function createRuntimeForIO(dbDialect: DbDialect, db: SqlExecutor, dbName?: string): SyncRuntimeForIO;
-/**
- * 文件导航（推荐阅读顺序）
- * 1) 同步表：入口（本段下方）
- * 2) 版本/常量/方言判断（DB_VERSION_REQUIREMENTS 等）
- * 3) 通用 DDL 工具（quote/type/default/ddl/index SQL）
- * 4) Runtime I/O（只读元信息：表/列/索引/版本）
- * 5) plan/apply（写变更：建表/改表/SQLite 重建）
- */
-type SyncTableFn = ((ctx: SyncTableContext, items: ScanFileResult[]) => Promise<void>) & {
-    TestKit: typeof SYNC_TABLE_TEST_KIT;
+type SystemFieldMeta = {
+    name: "id" | "created_at" | "updated_at" | "deleted_at" | "state";
+    comment: string;
+    needsIndex: boolean;
+    mysqlDdl: string;
 };
 /**
- * 数据库同步命令入口（函数模式）
+ * 数据库同步命令入口（class 模式）
  */
-export declare const syncTable: SyncTableFn;
-declare const SYNC_TABLE_TEST_KIT: {
-    DB_VERSION_REQUIREMENTS: {
+export declare class SyncTable {
+    /**
+     * 数据库版本要求（MySQL only）
+     */
+    static 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: {
+    /**
+     * 字段变更类型的中文标签映射
+     */
+    static CHANGE_TYPE_LABELS: {
         readonly length: "长度";
         readonly datatype: "类型";
         readonly comment: "注释";
@@ -57,95 +48,68 @@ declare const SYNC_TABLE_TEST_KIT: {
         readonly nullable: "可空约束";
         readonly unique: "唯一约束";
     };
-    MYSQL_TABLE_CONFIG: {
+    /**
+     * MySQL 表配置
+     */
+    static 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;
-    normalizeFieldDefinitionInPlace: typeof normalizeFieldDefinitionInPlace;
-    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: typeof createRuntimeForIO;
-};
-/**
- * 获取字段类型映射（根据当前数据库类型）
- */
-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 normalizeFieldDefinitionInPlace(fieldDef: FieldDefinition): 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 | null | undefined, newType: string | null | undefined): boolean;
-type SyncRuntimeForIO = Readonly<{
-    dbDialect: DbDialect;
-    db: SqlExecutor;
-    dbName: string;
-}>;
-declare function tableExistsRuntime(runtime: SyncRuntimeForIO, tableName: string): Promise<boolean>;
-declare function getTableColumnsRuntime(runtime: SyncRuntimeForIO, tableName: string): Promise<{
-    [key: string]: ColumnInfo;
-}>;
-declare function getTableIndexesRuntime(runtime: SyncRuntimeForIO, tableName: string): Promise<IndexInfo>;
-/**
- * 比较字段定义变化
- */
-declare function compareFieldDefinition(dbDialect: DbDialect, existingColumn: Pick<ColumnInfo, "type" | "columnType" | "max" | "nullable" | "defaultValue" | "comment">, fieldDef: FieldDefinition): FieldChange[];
+    static SYSTEM_FIELDS: ReadonlyArray<SystemFieldMeta>;
+    static SYSTEM_INDEX_FIELDS: ReadonlyArray<string>;
+    private db;
+    private dbName;
+    constructor(ctx: SyncTableContext);
+    run(items: ScanFileResult[]): Promise<void>;
+    static buildRuntimeIoError(operation: string, tableName: string, error: unknown): Error & {
+        sqlInfo?: SqlInfo;
+    };
+    static getTypeMapping(): Record<string, string>;
+    static normalizeFieldDefinitionInPlace(fieldDef: FieldDefinition): void;
+    static isStringOrArrayType(fieldType: string): boolean;
+    /**
+     * MySQL 标识符安全包裹：仅允许 [a-zA-Z_][a-zA-Z0-9_]*，并用反引号包裹。
+     *
+     * 说明：
+     * - 这是 syncTable 内部用于拼接 DDL 的安全阀
+     * - 若未来需要支持更复杂的标识符（如关键字/点号/反引号转义），应在此处统一扩展并补测试
+     */
+    static quoteIdentifier(identifier: string): string;
+    static getSqlType(fieldType: string, fieldMax: number | null, unsigned?: boolean): string;
+    static resolveDefaultValue(fieldDefault: any, fieldType: string): any;
+    static generateDefaultSql(actualDefault: any, fieldType: string): string;
+    static buildIndexSQL(tableName: string, indexName: string, fieldName: string, action: "create" | "drop"): string;
+    static getSystemColumnDef(fieldName: string): string | null;
+    static buildSystemColumnDefs(): string[];
+    static buildBusinessColumnDefs(fields: Record<string, FieldDefinition>): string[];
+    static generateDDLClause(fieldKey: string, fieldDef: FieldDefinition, isAdd?: boolean): string;
+    static executeDDLSafely(db: SqlExecutor, stmt: string): Promise<boolean>;
+    static isCompatibleTypeChange(currentType: string | null | undefined, newType: string | null | undefined): boolean;
+    static compareFieldDefinition(existingColumn: Pick<ColumnInfo, "type" | "columnType" | "max" | "nullable" | "defaultValue" | "comment">, fieldDef: FieldDefinition): FieldChange[];
+    /**
+     * 只读查询 information_schema.TABLES，用于判断表是否存在。
+     * - 该方法不会执行 DDL，不会修改数据库结构
+     * - 失败时会包装错误信息（含 tableName / operation）以便排查
+     */
+    static tableExists(db: SqlExecutor, dbName: string, tableName: string): Promise<boolean>;
+    /**
+     * 只读查询 information_schema.COLUMNS，读取列元信息。
+     * - 该方法不会执行 DDL，不会修改数据库结构
+     * - 返回结构用于与字段定义做对比（compareFieldDefinition）
+     */
+    static getTableColumns(db: SqlExecutor, dbName: string, tableName: string): Promise<{
+        [key: string]: ColumnInfo;
+    }>;
+    /**
+     * 只读查询 information_schema.STATISTICS，读取（非主键）索引元信息。
+     * - 该方法不会执行 DDL，不会修改数据库结构
+     * - 仅返回 PRIMARY 之外的索引（PRIMARY 会被同步逻辑视为系统约束）
+     */
+    static getTableIndexes(db: SqlExecutor, dbName: string, tableName: string): Promise<IndexInfo>;
+    static ensureDbVersion(db: SqlExecutor): Promise<void>;
+    static applyTablePlan(db: SqlExecutor, tableName: string, plan: TablePlan): Promise<void>;
+    static createTable(db: SqlExecutor, tableName: string, fields: Record<string, FieldDefinition>, systemIndexFields?: ReadonlyArray<string>): Promise<void>;
+    static modifyTable(db: SqlExecutor, dbName: string, tableName: string, fields: Record<string, FieldDefinition>): Promise<TablePlan>;
+}
 export {};