@mikro-orm/knex 6.3.5-dev.2 → 6.3.5-dev.20

package/AbstractSqlDriver.js

@@ -135,11 +135,19 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             .indexHint(options.indexHint)
             .comment(options.comments)
             .hintComment(options.hintComments);
+        const { first, last, before, after } = options;
+        const isCursorPagination = [first, last, before, after].some(v => v != null);
         if (type !== query_1.QueryType.COUNT) {
-            qb.limit(options?.limit, options?.offset);
             if (options.orderBy) {
-                qb.orderBy(options.orderBy);
+                if (isCursorPagination) {
+                    const { orderBy: newOrderBy, where } = this.processCursorOptions(meta, options, options.orderBy);
+                    qb.andWhere(where).orderBy(newOrderBy);
+                }
+                else {
+                    qb.orderBy(options.orderBy);
+                }
             }
+            qb.limit(options?.limit, options?.offset);
         }
         qb.where(where);
         const kqb = qb.getKnexQuery(false).clear('select');
@@ -154,6 +162,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (type === query_1.QueryType.COUNT) {
             return res[0].count;
         }
+        if (isCursorPagination && !first && !!last) {
+            res.reverse();
+        }
         return res.map(row => this.mapResult(row, meta));
     }
     mapResult(result, meta, populate = [], qb, map = {}) {

package/README.md

@@ -143,7 +143,7 @@ There is also auto-generated [CHANGELOG.md](CHANGELOG.md) file based on commit m
 - [Using `QueryBuilder`](https://mikro-orm.io/docs/query-builder)
 - [Preloading Deeply Nested Structures via populate](https://mikro-orm.io/docs/nested-populate)
 - [Property Validation](https://mikro-orm.io/docs/property-validation)
-- [Lifecycle Hooks](https://mikro-orm.io/docs/lifecycle-hooks)
+- [Lifecycle Hooks](https://mikro-orm.io/docs/events#hooks)
 - [Vanilla JS Support](https://mikro-orm.io/docs/usage-with-js)
 - [Schema Generator](https://mikro-orm.io/docs/schema-generator)
 - [Entity Generator](https://mikro-orm.io/docs/entity-generator)
@@ -163,6 +163,7 @@ You can find example integrations for some popular frameworks in the [`mikro-orm
 - [NextJS + MySQL](https://github.com/jonahallibone/mikro-orm-nextjs)
 - [Accounts.js REST and GraphQL authentication + SQLite](https://github.com/darkbasic/mikro-orm-accounts-example)
 - [Nest + Shopify + PostgreSQL + GraphQL](https://github.com/Cloudshelf/Shopify_CSConnector)
+- [Elysia.js + libSQL + Bun](https://github.com/mikro-orm/elysia-bun-example-app)
 
 ### JavaScript Examples 
 

package/dialects/mysql/MySqlPlatform.d.ts

@@ -16,6 +16,11 @@ export declare class MySqlPlatform extends AbstractSqlPlatform {
     convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
     getJsonIndexDefinition(index: IndexDef): string[];
     getBooleanTypeDeclarationSQL(): string;
+    normalizeColumnType(type: string, options?: {
+        length?: number;
+        precision?: number;
+        scale?: number;
+    }): string;
     getDefaultMappedType(type: string): Type<unknown>;
     supportsUnsigned(): boolean;
     /**

package/dialects/mysql/MySqlPlatform.js

@@ -36,6 +36,13 @@ class MySqlPlatform extends AbstractSqlPlatform_1.AbstractSqlPlatform {
     getBooleanTypeDeclarationSQL() {
         return 'tinyint(1)';
     }
+    normalizeColumnType(type, options = {}) {
+        const simpleType = this.extractSimpleType(type);
+        if (['decimal', 'numeric'].includes(simpleType)) {
+            return this.getDecimalTypeDeclarationSQL(options);
+        }
+        return type;
+    }
     getDefaultMappedType(type) {
         if (type === 'tinyint(1)') {
             return super.getDefaultMappedType('boolean');

package/dialects/mysql/MySqlSchemaHelper.js

@@ -92,7 +92,7 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
       order by ordinal_position`;
         const allColumns = await connection.execute(sql);
         const str = (val) => val != null ? '' + val : val;
-        const extra = (val) => val.replace(/auto_increment|default_generated|(stored|virtual) generated/i, '').trim();
+        const extra = (val) => val.replace(/auto_increment|default_generated|(stored|virtual) generated/i, '').trim() || undefined;
         const ret = {};
         for (const col of allColumns) {
             const mappedType = this.platform.getMappedType(col.column_type);

package/dialects/sqlite/BaseSqlitePlatform.d.ts

@@ -36,6 +36,11 @@ export declare abstract class BaseSqlitePlatform extends AbstractSqlPlatform {
     getVarcharTypeDeclarationSQL(column: {
         length?: number;
     }): string;
+    normalizeColumnType(type: string, options?: {
+        length?: number;
+        precision?: number;
+        scale?: number;
+    }): string;
     convertsJsonAutomatically(): boolean;
     /**
      * This is used to narrow the value of Date properties as they will be stored as timestamps in sqlite.

package/dialects/sqlite/BaseSqlitePlatform.js

@@ -44,6 +44,13 @@ class BaseSqlitePlatform extends AbstractSqlPlatform_1.AbstractSqlPlatform {
     getVarcharTypeDeclarationSQL(column) {
         return 'text';
     }
+    normalizeColumnType(type, options = {}) {
+        const simpleType = this.extractSimpleType(type);
+        if (['varchar', 'text'].includes(simpleType)) {
+            return this.getVarcharTypeDeclarationSQL(options);
+        }
+        return simpleType;
+    }
     convertsJsonAutomatically() {
         return false;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.3.5-dev.2",
+  "version": "6.3.5-dev.20",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -66,7 +66,7 @@
     "@mikro-orm/core": "^6.3.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.3.5-dev.2",
+    "@mikro-orm/core": "6.3.5-dev.20",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/schema/DatabaseTable.js

@@ -170,36 +170,46 @@ class DatabaseTable {
         const compositeFkUniques = {};
         const potentiallyUnmappedIndexes = this.indexes.filter(index => !index.primary // Skip primary index. Whether it's in use by scalar column or FK, it's already mapped.
             && (index.columnNames.length > 1 // All composite indexes are to be mapped to entity decorators or FK props.
-                || !(index.columnNames[0] in columnFks) // Non-composite indexes for scalar props are to be mapped to the column.
                 || skippedColumnNames.includes(index.columnNames[0]) // Non-composite indexes for skipped columns are to be mapped as entity decorators.
+                || index.deferMode || index.expression // Non-trivial non-composite indexes will be declared at the entity's metadata, though later outputted in the property
+                || !(index.columnNames[0] in columnFks) // Trivial non-composite indexes for scalar props are to be mapped to the column.
             )
             // ignore indexes that don't have all column names (this can happen in sqlite where there is no way to infer this for expressions)
             && !(index.columnNames.some(col => !col) && !index.expression));
         for (const index of potentiallyUnmappedIndexes) {
-            const ret = { name: index.keyName };
-            // Index is for FK. Map to the FK prop and move on.
-            const fkForIndex = fkIndexes.get(index);
-            if (fkForIndex && !fkForIndex.fk.columnNames.some(col => !index.columnNames.includes(col))) {
-                ret.properties = [this.getPropertyName(namingStrategy, fkForIndex.baseName, fkForIndex.fk)];
-                const map = index.unique ? compositeFkUniques : compositeFkIndexes;
-                map[ret.properties[0]] = { keyName: index.keyName };
-                continue;
+            const ret = {
+                name: index.keyName,
+                deferMode: index.deferMode,
+                expression: index.expression,
+            };
+            const isTrivial = !index.deferMode && !index.expression;
+            if (isTrivial) {
+                // Index is for FK. Map to the FK prop and move on.
+                const fkForIndex = fkIndexes.get(index);
+                if (fkForIndex && !fkForIndex.fk.columnNames.some(col => !index.columnNames.includes(col))) {
+                    ret.properties = [this.getPropertyName(namingStrategy, fkForIndex.baseName, fkForIndex.fk)];
+                    const map = index.unique ? compositeFkUniques : compositeFkIndexes;
+                    if (typeof map[ret.properties[0]] === 'undefined') {
+                        map[ret.properties[0]] = index;
+                        continue;
+                    }
+                }
             }
-            const properties = this.getIndexProperties(index, columnFks, fksOnColumnProps, fksOnStandaloneProps, namingStrategy);
+            const properties = ret.properties ?? this.getIndexProperties(index, columnFks, fksOnColumnProps, fksOnStandaloneProps, namingStrategy);
             // If there is a column that cannot be unambiguously mapped to a prop, render an expression.
-            if (index.expression) {
-                ret.expression = index.expression;
-            }
-            else if (typeof properties === 'undefined') {
-                ret.expression = schemaHelper.getCreateIndexSQL(this.name, index);
+            if (typeof properties === 'undefined') {
+                ret.expression ??= schemaHelper.getCreateIndexSQL(this.name, index);
             }
             else {
-                ret.properties = properties;
+                ret.properties ??= properties;
                 // If the index is for one property that is not a FK prop, map to the column prop and move on.
-                if (properties.length === 1 && !fksOnStandaloneProps.has(properties[0])) {
+                if (properties.length === 1 && isTrivial && !fksOnStandaloneProps.has(properties[0])) {
                     const map = index.unique ? compositeFkUniques : compositeFkIndexes;
-                    map[properties[0]] = { keyName: index.keyName };
-                    continue;
+                    // Only map one trivial index. If the same column is indexed many times over, output
+                    if (typeof map[properties[0]] === 'undefined') {
+                        map[properties[0]] = index;
+                        continue;
+                    }
                 }
             }
             // Composite indexes that aren't exclusively mapped to FK props get an entity decorator.
@@ -216,18 +226,18 @@ class DatabaseTable {
             const standaloneFkPropBasedOnColumn = fksOnStandaloneProps.get(columnName);
             if (standaloneFkPropBasedOnColumn && !fksOnColumnProps.get(columnName)) {
                 addedStandaloneFkPropsBasedOnColumn.add(columnName);
-                const [fkIndex, currentFk] = standaloneFkPropBasedOnColumn;
-                const prop = this.getForeignKeyDeclaration(currentFk, namingStrategy, schemaHelper, fkIndex, nullableForeignKeys.has(currentFk), columnName);
+                const { fkIndex, currentFk } = standaloneFkPropBasedOnColumn;
+                const prop = this.getForeignKeyDeclaration(currentFk, namingStrategy, schemaHelper, fkIndex, nullableForeignKeys.has(currentFk), columnName, fksOnColumnProps);
                 schema.addProperty(prop.name, prop.type, prop);
             }
             const prop = this.getPropertyDeclaration(column, namingStrategy, schemaHelper, compositeFkIndexes, compositeFkUniques, columnFks, fksOnColumnProps.get(columnName));
             schema.addProperty(prop.name, prop.type, prop);
         }
-        for (const [propBaseName, [fkIndex, currentFk]] of fksOnStandaloneProps.entries()) {
+        for (const [propBaseName, { fkIndex, currentFk }] of fksOnStandaloneProps.entries()) {
             if (addedStandaloneFkPropsBasedOnColumn.has(propBaseName)) {
                 continue;
             }
-            const prop = this.getForeignKeyDeclaration(currentFk, namingStrategy, schemaHelper, fkIndex, nullableForeignKeys.has(currentFk), propBaseName);
+            const prop = this.getForeignKeyDeclaration(currentFk, namingStrategy, schemaHelper, fkIndex, nullableForeignKeys.has(currentFk), propBaseName, fksOnColumnProps);
             schema.addProperty(prop.name, prop.type, prop);
         }
         const meta = schema.init().meta;
@@ -246,6 +256,7 @@ class DatabaseTable {
         const columnFks = {};
         const fkIndexes = new Map();
         const nullableForeignKeys = new Set();
+        const standaloneFksBasedOnColumnNames = new Map();
         for (const currentFk of fks) {
             const fkIndex = this.findFkIndex(currentFk);
             if (currentFk.columnNames.length === 1 && !fks.some(fk => fk !== currentFk && fk.columnNames.length === 1 && currentFk.columnNames[0] === fk.columnNames[0])) {
@@ -258,12 +269,17 @@ class DatabaseTable {
                 }
                 if (scalarPropertiesForRelations === 'always') {
                     const baseName = this.getSafeBaseNameForFkProp(namingStrategy, currentFk, fks, columnName);
-                    fksOnStandaloneProps.set(baseName, [fkIndex, currentFk]);
-                    fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+                    standaloneFksBasedOnColumnNames.set(baseName, currentFk);
+                    fksOnStandaloneProps.set(baseName, { fkIndex, currentFk });
+                    if (fkIndex) {
+                        fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+                    }
                 }
                 else {
                     fksOnColumnProps.set(columnName, currentFk);
-                    fkIndexes.set(fkIndex, { fk: currentFk, baseName: columnName });
+                    if (fkIndex) {
+                        fkIndexes.set(fkIndex, { fk: currentFk, baseName: columnName });
+                    }
                 }
                 continue;
             }
@@ -290,12 +306,17 @@ class DatabaseTable {
                 const columnName = specificColumnNames[0];
                 if (scalarPropertiesForRelations === 'always') {
                     const baseName = this.getSafeBaseNameForFkProp(namingStrategy, currentFk, fks, columnName);
-                    fksOnStandaloneProps.set(baseName, [fkIndex, currentFk]);
-                    fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+                    standaloneFksBasedOnColumnNames.set(baseName, currentFk);
+                    fksOnStandaloneProps.set(baseName, { fkIndex, currentFk });
+                    if (fkIndex) {
+                        fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+                    }
                 }
                 else {
                     fksOnColumnProps.set(columnName, currentFk);
-                    fkIndexes.set(fkIndex, { fk: currentFk, baseName: columnName });
+                    if (fkIndex) {
+                        fkIndexes.set(fkIndex, { fk: currentFk, baseName: columnName });
+                    }
                 }
                 continue;
             }
@@ -307,12 +328,17 @@ class DatabaseTable {
                     const columnName = nullableColumnsInFk.at(0) ?? currentFk.columnNames[0];
                     if (scalarPropertiesForRelations === 'always') {
                         const baseName = this.getSafeBaseNameForFkProp(namingStrategy, currentFk, fks, columnName);
-                        fksOnStandaloneProps.set(baseName, [fkIndex, currentFk]);
-                        fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+                        standaloneFksBasedOnColumnNames.set(baseName, currentFk);
+                        fksOnStandaloneProps.set(baseName, { fkIndex, currentFk });
+                        if (fkIndex) {
+                            fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+                        }
                     }
                     else {
                         fksOnColumnProps.set(columnName, currentFk);
-                        fkIndexes.set(fkIndex, { fk: currentFk, baseName: columnName });
+                        if (fkIndex) {
+                            fkIndexes.set(fkIndex, { fk: currentFk, baseName: columnName });
+                        }
                     }
                     continue;
                 }
@@ -320,14 +346,19 @@ class DatabaseTable {
                 // name a standalone prop after the column, but treat the column prop itself as not having FK.
                 const columnName = nullableColumnsInFk[0];
                 const baseName = this.getSafeBaseNameForFkProp(namingStrategy, currentFk, fks, columnName);
-                fksOnStandaloneProps.set(baseName, [fkIndex, currentFk]);
-                fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+                standaloneFksBasedOnColumnNames.set(baseName, currentFk);
+                fksOnStandaloneProps.set(baseName, { fkIndex, currentFk });
+                if (fkIndex) {
+                    fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+                }
                 continue;
             }
             // FK is not unambiguously mappable to a column. Pick another name for a standalone FK prop.
             const baseName = this.getSafeBaseNameForFkProp(namingStrategy, currentFk, fks);
-            fksOnStandaloneProps.set(baseName, [fkIndex, currentFk]);
-            fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+            fksOnStandaloneProps.set(baseName, { fkIndex, currentFk });
+            if (fkIndex) {
+                fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+            }
         }
         const columnsInFks = Object.keys(columnFks);
         const skippingHandlers = {
@@ -350,17 +381,49 @@ class DatabaseTable {
             },
         };
         const skippedColumnNames = this.getColumns().filter(skippingHandlers[scalarPropertiesForRelations]).map(column => column.name);
+        // Check standalone FKs named after columns for potential conflicts among themselves.
+        // This typically happens when two standalone FKs named after a column resolve to the same prop name
+        // because the respective columns include the referenced table in the name.
+        // Depending on naming strategy and actual names, it may also originate from other scenarios.
+        // We do our best to de-duplicate them here.
+        const safePropNames = new Set();
+        const unsafePropNames = new Map();
+        for (const [unsafeBaseName, currentFk] of standaloneFksBasedOnColumnNames) {
+            const propName = this.getPropertyName(namingStrategy, unsafeBaseName, currentFk);
+            if (safePropNames.has(propName)) {
+                if (!unsafePropNames.has(propName)) {
+                    unsafePropNames.set(propName, []);
+                }
+                unsafePropNames.get(propName).push({ unsafeBaseName, currentFk });
+                continue;
+            }
+            safePropNames.add(propName);
+        }
+        for (const [unsafePropName, affectedBaseNames] of unsafePropNames) {
+            safePropNames.delete(unsafePropName);
+            for (const { unsafeBaseName, currentFk } of affectedBaseNames) {
+                const newBaseName = this.getSafeBaseNameForFkProp(namingStrategy, currentFk, fks);
+                fksOnStandaloneProps.delete(unsafeBaseName);
+                let fkIndex;
+                for (const [indexDef, fkIndexDesc] of fkIndexes) {
+                    if (fkIndexDesc.fk !== currentFk) {
+                        continue;
+                    }
+                    fkIndexDesc.baseName = newBaseName;
+                    fkIndex = indexDef;
+                    break;
+                }
+                fksOnStandaloneProps.set(newBaseName, { fkIndex, currentFk });
+            }
+        }
         return { fksOnColumnProps, fksOnStandaloneProps, columnFks, fkIndexes, nullableForeignKeys, skippedColumnNames };
     }
     findFkIndex(currentFk) {
         const fkColumnsLength = currentFk.columnNames.length;
         const possibleIndexes = this.indexes.filter(index => {
-            return index.columnNames.length >= fkColumnsLength && !currentFk.columnNames.some((columnName, i) => index.columnNames[i] !== columnName);
+            return index.columnNames.length === fkColumnsLength && !currentFk.columnNames.some((columnName, i) => index.columnNames[i] !== columnName);
         });
         possibleIndexes.sort((a, b) => {
-            if (a.columnNames.length !== b.columnNames.length) {
-                return a.columnNames.length < b.columnNames.length ? -1 : 1;
-            }
             if (a.primary !== b.primary) {
                 return a.primary ? -1 : 1;
             }
@@ -369,7 +432,7 @@ class DatabaseTable {
             }
             return a.keyName.localeCompare(b.keyName);
         });
-        return possibleIndexes[0];
+        return possibleIndexes.at(0);
     }
     getIndexProperties(index, columnFks, fksOnColumnProps, fksOnStandaloneProps, namingStrategy) {
         const propBaseNames = new Set();
@@ -381,9 +444,13 @@ class DatabaseTable {
         for (let i = 0; i < l; ++i) {
             const columnName = columnNames[i];
             // The column is not involved with FKs.
-            // It has a prop named after it.
-            // Add it and move on.
             if (!(columnName in columnFks)) {
+                // If there is no such column, the "name" is actually an expression.
+                if (!this.hasColumn(columnName)) {
+                    return;
+                }
+                // It has a prop named after it.
+                // Add it and move on.
                 propBaseNames.add(columnName);
                 continue;
             }
@@ -398,7 +465,7 @@ class DatabaseTable {
             // and all of its columns are a subset of this index,
             // include that FK, and consider mapping of this column to a prop a success.
             let propAdded = false;
-            for (const [propName, [, fk]] of fksOnStandaloneProps) {
+            for (const [propName, { currentFk: fk }] of fksOnStandaloneProps) {
                 if (!columnFks[columnName].includes(fk)) {
                     continue;
                 }
@@ -473,7 +540,7 @@ class DatabaseTable {
     hasPrimaryKey() {
         return !!this.getPrimaryKey();
     }
-    getForeignKeyDeclaration(fk, namingStrategy, schemaHelper, fkIndex, nullable, propNameBase) {
+    getForeignKeyDeclaration(fk, namingStrategy, schemaHelper, fkIndex, nullable, propNameBase, fksOnColumnProps) {
         const prop = this.getPropertyName(namingStrategy, propNameBase, fk);
         const kind = (fkIndex?.unique && !fkIndex.primary) ? this.getReferenceKind(fk, fkIndex) : this.getReferenceKind(fk);
         const runtimeType = this.getPropertyTypeForForeignKey(namingStrategy, fk);
@@ -499,6 +566,7 @@ class DatabaseTable {
             columnOptions.length = column.length;
             columnOptions.precision = column.precision;
             columnOptions.scale = column.scale;
+            columnOptions.extra = column.extra;
             columnOptions.comment = column.comment;
             columnOptions.enum = !!column.enumItems?.length;
             columnOptions.items = column.enumItems;
@@ -523,6 +591,11 @@ class DatabaseTable {
         const unique = compositeFkUniques[prop] || this.indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && idx.unique && !idx.primary);
         const kind = this.getReferenceKind(fk, unique);
         const runtimeType = this.getPropertyTypeForColumn(namingStrategy, column, fk);
+        const type = fk ? runtimeType : (core_1.Utils.keys(core_1.t).find(k => {
+            const typeInCoreMap = this.platform.getMappedType(k);
+            return (typeInCoreMap !== core_1.Type.getType(core_1.UnknownType) || k === 'unknown') && typeInCoreMap === column.mappedType;
+        }) ?? runtimeType);
+        const ignoreSchemaChanges = (type === 'unknown' && column.length) ? (column.extra ? ['type', 'extra'] : ['type']) : undefined;
         const defaultRaw = this.getPropertyDefaultValue(schemaHelper, column, runtimeType, true);
         const defaultParsed = this.getPropertyDefaultValue(schemaHelper, column, runtimeType);
         const defaultTs = defaultRaw !== defaultParsed ? defaultParsed : undefined;
@@ -537,12 +610,10 @@ class DatabaseTable {
         }
         return {
             name: prop,
-            type: fk ? runtimeType : (core_1.Utils.keys(core_1.t).find(k => {
-                const typeInCoreMap = this.platform.getMappedType(k);
-                return (typeInCoreMap !== core_1.Type.getType(core_1.UnknownType) || k === 'unknown') && typeInCoreMap === column.mappedType;
-            }) ?? runtimeType),
+            type,
             runtimeType,
             kind,
+            ignoreSchemaChanges,
             generated: column.generated,
             optional: defaultRaw !== 'null' || defaultTs != null || typeof column.generated !== 'undefined',
             columnType: column.type,
@@ -556,6 +627,7 @@ class DatabaseTable {
             length: column.length,
             precision: column.precision,
             scale: column.scale,
+            extra: column.extra,
             comment: column.comment,
             index: index ? index.keyName : undefined,
             unique: unique ? unique.keyName : undefined,

package/schema/SchemaComparator.js

@@ -385,9 +385,9 @@ class SchemaComparator {
         const changedProperties = new Set();
         const fromProp = this.mapColumnToProperty({ ...fromColumn, autoincrement: false });
         const toProp = this.mapColumnToProperty({ ...toColumn, autoincrement: false });
-        const fromColumnType = fromColumn.mappedType.getColumnType(fromProp, this.platform).toLowerCase();
+        const fromColumnType = this.platform.normalizeColumnType(fromColumn.mappedType.getColumnType(fromProp, this.platform).toLowerCase(), fromProp);
         const fromNativeEnum = fromTable.nativeEnums[fromColumnType] ?? Object.values(fromTable.nativeEnums).find(e => e.name === fromColumnType && e.schema !== '*');
-        const toColumnType = toColumn.mappedType.getColumnType(toProp, this.platform).toLowerCase();
+        const toColumnType = this.platform.normalizeColumnType(toColumn.mappedType.getColumnType(toProp, this.platform).toLowerCase(), toProp);
         const log = (msg, params) => {
             if (tableName) {
                 const copy = core_1.Utils.copy(params);