befly 3.9.2 → 3.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.9.2",
+    "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": "a311a415ccf02fb5089040883049a02a54f5ec60",
+    "gitHead": "4baa6420da1d505fb6a7cd82169d597456d9a99f",
     "devDependencies": {
         "typescript": "^5.9.3"
     }

package/sync/syncDb/ddl.ts

@@ -203,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

@@ -11,7 +11,7 @@ import { snakeCase } from 'es-toolkit/string';
 import { Logger } from '../../lib/logger.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, getSystemColumnDef } 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;

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