befly 3.9.1 → 3.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.9.1",
+    "version": "3.9.3",
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "type": "module",
     "private": false,
@@ -73,7 +73,7 @@
         "pino": "^10.1.0",
         "pino-roll": "^4.0.0"
     },
-    "gitHead": "506400b7cc501bc1d4be3c2af76f2275172dacd8",
+    "gitHead": "4baa6420da1d505fb6a7cd82169d597456d9a99f",
     "devDependencies": {
         "typescript": "^5.9.3"
     }

package/sync/syncDb/ddl.ts

@@ -60,16 +60,39 @@ export function buildIndexSQL(tableName: string, indexName: string, fieldName: s
     return `DROP INDEX IF EXISTS ${indexQuoted}`;
 }
 
+/**
+ * 获取单个系统字段的列定义（用于 ADD COLUMN 或 CREATE TABLE）
+ *
+ * @param fieldName - 系统字段名（id, created_at, updated_at, deleted_at, state）
+ * @returns 列定义字符串，如果不是系统字段则返回 null
+ */
+export function getSystemColumnDef(fieldName: string): string | null {
+    const mysqlDefs: Record<string, string> = {
+        id: '`id` BIGINT UNSIGNED PRIMARY KEY AUTO_INCREMENT COMMENT "主键ID"',
+        created_at: '`created_at` BIGINT UNSIGNED NOT NULL DEFAULT 0 COMMENT "创建时间"',
+        updated_at: '`updated_at` BIGINT UNSIGNED NOT NULL DEFAULT 0 COMMENT "更新时间"',
+        deleted_at: '`deleted_at` BIGINT UNSIGNED NOT NULL DEFAULT 0 COMMENT "删除时间"',
+        state: '`state` BIGINT UNSIGNED NOT NULL DEFAULT 0 COMMENT "状态字段"'
+    };
+    const pgDefs: Record<string, string> = {
+        id: '"id" INTEGER PRIMARY KEY',
+        created_at: '"created_at" INTEGER NOT NULL DEFAULT 0',
+        updated_at: '"updated_at" INTEGER NOT NULL DEFAULT 0',
+        deleted_at: '"deleted_at" INTEGER NOT NULL DEFAULT 0',
+        state: '"state" INTEGER NOT NULL DEFAULT 0'
+    };
+
+    const defs = isMySQL() ? mysqlDefs : pgDefs;
+    return defs[fieldName] || null;
+}
+
 /**
  * 构建系统字段列定义
  *
  * @returns 系统字段的列定义数组
  */
 export function buildSystemColumnDefs(): string[] {
-    if (isMySQL()) {
-        return ['`id` BIGINT UNSIGNED PRIMARY KEY AUTO_INCREMENT COMMENT "主键ID"', '`created_at` BIGINT UNSIGNED NOT NULL DEFAULT 0 COMMENT "创建时间"', '`updated_at` BIGINT UNSIGNED NOT NULL DEFAULT 0 COMMENT "更新时间"', '`deleted_at` BIGINT UNSIGNED NOT NULL DEFAULT 0 COMMENT "删除时间"', '`state` BIGINT UNSIGNED NOT NULL DEFAULT 0 COMMENT "状态字段"'];
-    }
-    return ['"id" INTEGER PRIMARY KEY', '"created_at" INTEGER NOT NULL DEFAULT 0', '"updated_at" INTEGER NOT NULL DEFAULT 0', '"deleted_at" INTEGER NOT NULL DEFAULT 0', '"state" INTEGER NOT NULL DEFAULT 0'];
+    return [getSystemColumnDef('id')!, getSystemColumnDef('created_at')!, getSystemColumnDef('updated_at')!, getSystemColumnDef('deleted_at')!, getSystemColumnDef('state')!];
 }
 
 /**
@@ -180,17 +203,50 @@ export async function executeDDLSafely(sql: SQL, stmt: string): Promise<boolean>
 }
 
 /**
- * PG 兼容类型变更识别：无需数据重写的宽化型变更
+ * 判断是否为兼容的类型变更（宽化型变更，无数据丢失风险）
  *
- * @param currentType - 当前类型
- * @param newType - 新类型
+ * 允许的变更：
+ * - MySQL: INT -> BIGINT, TINYINT -> INT/BIGINT, etc.
+ * - MySQL: VARCHAR -> TEXT/MEDIUMTEXT
+ * - PG: INTEGER -> BIGINT
+ * - PG: VARCHAR -> TEXT
+ *
+ * @param currentType - 当前数据库中的类型
+ * @param newType - 目标类型
  * @returns 是否为兼容变更
  */
-export function isPgCompatibleTypeChange(currentType: string, newType: string): boolean {
+export function isCompatibleTypeChange(currentType: string, newType: string): boolean {
     const c = String(currentType || '').toLowerCase();
     const n = String(newType || '').toLowerCase();
-    // varchar -> text 视为宽化
-    if (c === 'character varying' && n === 'text') return true;
-    // text -> character varying 非宽化（可能截断），不兼容
+
+    // 相同类型不算变更
+    if (c === n) return false;
+
+    // 提取基础类型（去掉 unsigned、长度等修饰）
+    const extractBaseType = (t: string): string => {
+        // 移除 unsigned 和括号内容
+        return t
+            .replace(/\s*unsigned/gi, '')
+            .replace(/\([^)]*\)/g, '')
+            .trim();
+    };
+
+    const cBase = extractBaseType(c);
+    const nBase = extractBaseType(n);
+
+    // MySQL/通用 整数类型宽化（小 -> 大）
+    const intTypes = ['tinyint', 'smallint', 'mediumint', 'int', 'integer', 'bigint'];
+    const cIntIdx = intTypes.indexOf(cBase);
+    const nIntIdx = intTypes.indexOf(nBase);
+    if (cIntIdx !== -1 && nIntIdx !== -1 && nIntIdx > cIntIdx) {
+        return true;
+    }
+
+    // 字符串类型宽化
+    // MySQL: varchar -> text/mediumtext/longtext
+    if (cBase === 'varchar' && (nBase === 'text' || nBase === 'mediumtext' || nBase === 'longtext')) return true;
+    // PG: character varying -> text
+    if (cBase === 'character varying' && nBase === 'text') return true;
+
     return false;
 }

package/sync/syncDb/table.ts

@@ -9,9 +9,9 @@
 
 import { snakeCase } from 'es-toolkit/string';
 import { Logger } from '../../lib/logger.js';
-import { isMySQL, isPG, CHANGE_TYPE_LABELS, getTypeMapping } from './constants.js';
+import { isMySQL, isPG, CHANGE_TYPE_LABELS, getTypeMapping, SYSTEM_INDEX_FIELDS } from './constants.js';
 import { logFieldChange, resolveDefaultValue, generateDefaultSql, isStringOrArrayType } from './helpers.js';
-import { generateDDLClause, isPgCompatibleTypeChange } from './ddl.js';
+import { generateDDLClause, getSystemColumnDef, isCompatibleTypeChange } from './ddl.js';
 import { getTableColumns, getTableIndexes } from './schema.js';
 import { compareFieldDefinition, applyTablePlan } from './apply.js';
 import type { TablePlan } from '../../types/sync.js';
@@ -71,11 +71,18 @@ export async function modifyTable(sql: SQL, tableName: string, fields: Record<st
                 const onlyDefaultChanged = comparison.every((c) => c.type === 'default');
                 const defaultChanged = comparison.some((c) => c.type === 'default');
 
-                // 严格限制：除 string/array 互转外，禁止任何字段类型变更
+                // 类型变更检查：只允许兼容的宽化型变更（如 INT -> BIGINT）
                 if (hasTypeChange) {
                     const typeChange = comparison.find((c) => c.type === 'datatype');
-                    const errorMsg = [`禁止字段类型变更: ${tableName}.${dbFieldName}`, `当前类型: ${typeChange?.current}`, `目标类型: ${typeChange?.expected}`, `说明: 仅允许 string<->array 互相切换，其他类型变更需要手动处理`].join('\n');
-                    throw new Error(errorMsg);
+                    const currentType = String(typeChange?.current || '').toLowerCase();
+                    const typeMapping = getTypeMapping();
+                    const expectedType = typeMapping[fieldDef.type]?.toLowerCase() || '';
+
+                    if (!isCompatibleTypeChange(currentType, expectedType)) {
+                        const errorMsg = [`禁止字段类型变更: ${tableName}.${dbFieldName}`, `当前类型: ${typeChange?.current}`, `目标类型: ${typeChange?.expected}`, `说明: 仅允许宽化型变更（如 INT->BIGINT, VARCHAR->TEXT），其他类型变更需要手动处理`].join('\n');
+                        throw new Error(errorMsg);
+                    }
+                    Logger.debug(`[兼容类型变更] ${tableName}.${dbFieldName} ${currentType} -> ${expectedType}`);
                 }
 
                 // 默认值变化处理
@@ -111,13 +118,6 @@ export async function modifyTable(sql: SQL, tableName: string, fields: Record<st
                         if (isShrink && !force) skipModify = true;
                     }
 
-                    if (hasTypeChange) {
-                        const typeMapping = getTypeMapping();
-                        if (isPG() && isPgCompatibleTypeChange(existingColumns[dbFieldName].type, typeMapping[fieldDef.type].toLowerCase())) {
-                            Logger.debug(`[PG兼容类型变更] ${tableName}.${dbFieldName} ${existingColumns[dbFieldName].type} -> ${typeMapping[fieldDef.type].toLowerCase()} 允许执行`);
-                        }
-                    }
-
                     if (!skipModify) modifyClauses.push(generateDDLClause(fieldKey, fieldDef, false));
                 }
                 changed = true;
@@ -130,10 +130,26 @@ export async function modifyTable(sql: SQL, tableName: string, fields: Record<st
         }
     }
 
-    // 检查系统字段索引
-    for (const sysField of ['created_at', 'updated_at', 'state']) {
+    // 检查并添加缺失的系统字段（created_at, updated_at, deleted_at, state）
+    // 注意：id 是主键，不会缺失；这里只处理可能缺失的其他系统字段
+    const systemFieldNames = ['created_at', 'updated_at', 'deleted_at', 'state'];
+    for (const sysFieldName of systemFieldNames) {
+        if (!existingColumns[sysFieldName]) {
+            const colDef = getSystemColumnDef(sysFieldName);
+            if (colDef) {
+                Logger.debug(`  + 新增系统字段 ${sysFieldName}`);
+                addClauses.push(`ADD COLUMN ${colDef}`);
+                changed = true;
+            }
+        }
+    }
+
+    // 检查系统字段索引（字段存在或即将被添加时才创建索引）
+    for (const sysField of SYSTEM_INDEX_FIELDS) {
         const idxName = `idx_${sysField}`;
-        if (!existingIndexes[idxName]) {
+        // 字段已存在或刚添加到 addClauses 中
+        const fieldWillExist = existingColumns[sysField] || systemFieldNames.includes(sysField);
+        if (fieldWillExist && !existingIndexes[idxName]) {
             indexActions.push({ action: 'create', indexName: idxName, fieldName: sysField });
             changed = true;
         }

package/tests/syncDb-ddl.test.ts

@@ -6,7 +6,7 @@
  * - buildSystemColumnDefs
  * - buildBusinessColumnDefs
  * - generateDDLClause
- * - isPgCompatibleTypeChange
+ * - isCompatibleTypeChange
  */
 
 import { describe, test, expect, beforeAll } from 'bun:test';
@@ -19,7 +19,7 @@ let buildIndexSQL: any;
 let buildSystemColumnDefs: any;
 let buildBusinessColumnDefs: any;
 let generateDDLClause: any;
-let isPgCompatibleTypeChange: any;
+let isCompatibleTypeChange: any;
 
 beforeAll(async () => {
     const ddl = await import('../sync/syncDb/ddl.js');
@@ -27,7 +27,7 @@ beforeAll(async () => {
     buildSystemColumnDefs = ddl.buildSystemColumnDefs;
     buildBusinessColumnDefs = ddl.buildBusinessColumnDefs;
     generateDDLClause = ddl.generateDDLClause;
-    isPgCompatibleTypeChange = ddl.isPgCompatibleTypeChange;
+    isCompatibleTypeChange = ddl.isCompatibleTypeChange;
 });
 
 describe('buildIndexSQL (MySQL)', () => {
@@ -186,21 +186,45 @@ describe('generateDDLClause (MySQL)', () => {
     });
 });
 
-describe('isPgCompatibleTypeChange', () => {
+describe('isCompatibleTypeChange', () => {
     test('varchar -> text 是兼容变更', () => {
-        expect(isPgCompatibleTypeChange('character varying', 'text')).toBe(true);
+        expect(isCompatibleTypeChange('character varying', 'text')).toBe(true);
+        expect(isCompatibleTypeChange('varchar(100)', 'text')).toBe(true);
+        expect(isCompatibleTypeChange('varchar(100)', 'mediumtext')).toBe(true);
     });
 
     test('text -> varchar 不是兼容变更', () => {
-        expect(isPgCompatibleTypeChange('text', 'character varying')).toBe(false);
+        expect(isCompatibleTypeChange('text', 'character varying')).toBe(false);
+        expect(isCompatibleTypeChange('text', 'varchar(100)')).toBe(false);
+    });
+
+    test('int -> bigint 是兼容变更', () => {
+        expect(isCompatibleTypeChange('int', 'bigint')).toBe(true);
+        expect(isCompatibleTypeChange('int unsigned', 'bigint unsigned')).toBe(true);
+        expect(isCompatibleTypeChange('tinyint', 'int')).toBe(true);
+        expect(isCompatibleTypeChange('tinyint', 'bigint')).toBe(true);
+        expect(isCompatibleTypeChange('smallint', 'int')).toBe(true);
+        expect(isCompatibleTypeChange('mediumint', 'bigint')).toBe(true);
+    });
+
+    test('bigint -> int 不是兼容变更（收缩）', () => {
+        expect(isCompatibleTypeChange('bigint', 'int')).toBe(false);
+        expect(isCompatibleTypeChange('int', 'tinyint')).toBe(false);
+    });
+
+    test('PG integer -> bigint 是兼容变更', () => {
+        expect(isCompatibleTypeChange('integer', 'bigint')).toBe(true);
+        expect(isCompatibleTypeChange('smallint', 'integer')).toBe(true);
+        expect(isCompatibleTypeChange('smallint', 'bigint')).toBe(true);
     });
 
     test('相同类型不是变更', () => {
-        expect(isPgCompatibleTypeChange('text', 'text')).toBe(false);
+        expect(isCompatibleTypeChange('text', 'text')).toBe(false);
+        expect(isCompatibleTypeChange('bigint', 'bigint')).toBe(false);
     });
 
     test('空值处理', () => {
-        expect(isPgCompatibleTypeChange(null, 'text')).toBe(false);
-        expect(isPgCompatibleTypeChange('text', null)).toBe(false);
+        expect(isCompatibleTypeChange(null, 'text')).toBe(false);
+        expect(isCompatibleTypeChange('text', null)).toBe(false);
     });
 });