@mikro-orm/knex 6.0.0-dev.4 → 6.0.0-dev.41

package/{dist/query → query}/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/{dist/schema → schema}/DatabaseSchema.d.ts

@@ -11,7 +11,7 @@ export declare class DatabaseSchema {
     private tables;
     private namespaces;
     constructor(platform: AbstractSqlPlatform, name: string);
-    addTable(name: string, schema: string | undefined | null): DatabaseTable;
+    addTable(name: string, schema: string | undefined | null, comment?: string): DatabaseTable;
     getTables(): DatabaseTable[];
     getTable(name: string): DatabaseTable | undefined;
     hasTable(name: string): boolean;

package/{dist/schema → schema}/DatabaseSchema.js

@@ -13,9 +13,10 @@ class DatabaseSchema {
         this.tables = [];
         this.namespaces = new Set();
     }
-    addTable(name, schema) {
+    addTable(name, schema, comment) {
         const namespaceName = schema ?? this.name;
         const table = new DatabaseTable_1.DatabaseTable(this.platform, name, namespaceName);
+        table.comment = comment;
         this.tables.push(table);
         if (namespaceName != null) {
             this.namespaces.add(namespaceName);
@@ -39,21 +40,12 @@ class DatabaseSchema {
     }
     static async create(connection, platform, config, schemaName) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema'));
-        const tables = await connection.execute(platform.getSchemaHelper().getListTablesSQL());
-        for (const t of tables) {
-            if (t.table_name === config.get('migrations').tableName) {
-                continue;
-            }
-            const table = schema.addTable(t.table_name, t.schema_name);
-            table.comment = t.table_comment;
-            const cols = await platform.getSchemaHelper().getColumns(connection, table.name, table.schema);
-            const indexes = await platform.getSchemaHelper().getIndexes(connection, table.name, table.schema);
-            const checks = await platform.getSchemaHelper().getChecks(connection, table.name, table.schema);
-            const pks = await platform.getSchemaHelper().getPrimaryKeys(connection, indexes, table.name, table.schema);
-            const fks = await platform.getSchemaHelper().getForeignKeys(connection, table.name, table.schema);
-            const enums = await platform.getSchemaHelper().getEnumDefinitions(connection, checks, table.name, table.schema);
-            table.init(cols, indexes, checks, pks, fks, enums);
-        }
+        const allTables = await connection.execute(platform.getSchemaHelper().getListTablesSQL());
+        const parts = config.get('migrations').tableName.split('.');
+        const migrationsTableName = parts[1] ?? parts[0];
+        const migrationsSchemaName = parts.length > 1 ? parts[0] : config.get('schema', platform.getDefaultSchemaName());
+        const tables = allTables.filter(t => t.table_name !== migrationsTableName || (t.schema_name && t.schema_name !== migrationsSchemaName));
+        await platform.getSchemaHelper().loadInformationSchema(schema, connection, tables);
         return schema;
     }
     static fromMetadata(metadata, platform, config, schemaName) {
@@ -86,15 +78,15 @@ class DatabaseSchema {
         if (prop.persist === false || !prop.fieldNames) {
             return false;
         }
-        if (meta.pivotTable || (core_1.ReferenceType.EMBEDDED && prop.object)) {
+        if (meta.pivotTable || (core_1.ReferenceKind.EMBEDDED && prop.object)) {
             return true;
         }
         const getRootProperty = (prop) => prop.embedded ? getRootProperty(meta.properties[prop.embedded[0]]) : prop;
         const rootProp = getRootProperty(prop);
-        if (rootProp.reference === core_1.ReferenceType.EMBEDDED) {
+        if (rootProp.kind === core_1.ReferenceKind.EMBEDDED) {
             return prop === rootProp || !rootProp.object;
         }
-        return [core_1.ReferenceType.SCALAR, core_1.ReferenceType.MANY_TO_ONE].includes(prop.reference) || (prop.reference === core_1.ReferenceType.ONE_TO_ONE && prop.owner);
+        return [core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind) || (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && prop.owner);
     }
     toJSON() {
         const { platform, namespaces, ...rest } = this;

package/{dist/schema → schema}/DatabaseTable.d.ts

@@ -1,6 +1,6 @@
 import type { Dictionary, EntityMetadata, EntityProperty, NamingStrategy } from '@mikro-orm/core';
 import type { SchemaHelper } from './SchemaHelper';
-import type { Check, Column, ForeignKey, Index } from '../typings';
+import type { CheckDef, Column, ForeignKey, IndexDef } from '../typings';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
 /**
  * @internal
@@ -17,9 +17,9 @@ export declare class DatabaseTable {
     constructor(platform: AbstractSqlPlatform, name: string, schema?: string | undefined);
     getColumns(): Column[];
     getColumn(name: string): Column | undefined;
-    getIndexes(): Index[];
-    getChecks(): Check[];
-    init(cols: Column[], indexes: Index[], checks: Check[], pks: string[], fks: Dictionary<ForeignKey>, enums: Dictionary<string[]>): void;
+    getIndexes(): IndexDef[];
+    getChecks(): CheckDef[];
+    init(cols: Column[], indexes: IndexDef[] | undefined, checks: CheckDef<unknown>[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;
     addColumn(column: Column): void;
     addColumnFromProperty(prop: EntityProperty, meta: EntityMetadata): void;
     private getIndexName;
@@ -30,14 +30,14 @@ export declare class DatabaseTable {
     getShortestName(): string;
     getForeignKeys(): Dictionary<ForeignKey>;
     hasColumn(columnName: string): boolean;
-    getIndex(indexName: string): Index | undefined;
+    getIndex(indexName: string): IndexDef | undefined;
     hasIndex(indexName: string): boolean;
-    getCheck(checkName: string): Check<unknown> | undefined;
+    getCheck(checkName: string): CheckDef<unknown> | undefined;
     hasCheck(checkName: string): boolean;
-    getPrimaryKey(): Index | undefined;
+    getPrimaryKey(): IndexDef | undefined;
     hasPrimaryKey(): boolean;
     private getPropertyDeclaration;
-    private getReferenceType;
+    private getReferenceKind;
     private getPropertyName;
     private getPropertyType;
     private getPropertyDefaultValue;
@@ -48,6 +48,6 @@ export declare class DatabaseTable {
         expression?: string;
         options?: Dictionary;
     }, type: 'index' | 'unique' | 'primary'): void;
-    addCheck(check: Check): void;
+    addCheck(check: CheckDef): void;
     toJSON(): Dictionary;
 }

package/{dist/schema → schema}/DatabaseTable.js

@@ -30,7 +30,7 @@ class DatabaseTable {
     getChecks() {
         return this.checks;
     }
-    init(cols, indexes, checks, pks, fks, enums) {
+    init(cols, indexes = [], checks = [], pks, fks = {}, enums = {}) {
         this.indexes = indexes;
         this.checks = checks;
         this.foreignKeys = fks;
@@ -51,7 +51,6 @@ class DatabaseTable {
     }
     addColumnFromProperty(prop, meta) {
         prop.fieldNames.forEach((field, idx) => {
-            var _a;
             const type = prop.enum ? 'enum' : prop.columnTypes[idx];
             const mappedType = this.platform.getMappedType(type);
             if (mappedType instanceof core_1.DecimalType) {
@@ -64,9 +63,9 @@ class DatabaseTable {
                 }
             }
             if (mappedType instanceof core_1.DateTimeType) {
-                prop.length ?? (prop.length = this.platform.getDefaultDateTimeLength());
+                prop.length ??= this.platform.getDefaultDateTimeLength();
             }
-            const primary = !meta.compositePK && !!prop.primary && prop.reference === core_1.ReferenceType.SCALAR && this.platform.isNumericColumn(mappedType);
+            const primary = !meta.compositePK && !!prop.primary && prop.kind === core_1.ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType);
             this.columns[field] = {
                 name: prop.fieldNames[idx],
                 type: prop.columnTypes[idx],
@@ -82,12 +81,13 @@ class DatabaseTable {
                 enumItems: prop.items?.every(core_1.Utils.isString) ? prop.items : undefined,
                 comment: prop.comment,
                 extra: prop.extra,
+                ignoreSchemaChanges: prop.ignoreSchemaChanges,
             };
-            (_a = this.columns[field]).unsigned || (_a.unsigned = this.columns[field].autoincrement);
+            this.columns[field].unsigned ||= this.columns[field].autoincrement;
             const defaultValue = this.platform.getSchemaHelper().normalizeDefaultValue(prop.defaultRaw, prop.length);
             this.columns[field].default = defaultValue;
         });
-        if ([core_1.ReferenceType.MANY_TO_ONE, core_1.ReferenceType.ONE_TO_ONE].includes(prop.reference)) {
+        if ([core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
             const constraintName = this.getIndexName(true, prop.fieldNames, 'foreign');
             let schema = prop.targetMeta.schema === '*' ? this.schema : prop.targetMeta.schema ?? this.schema;
             if (prop.referencedTableName.includes('.')) {
@@ -101,11 +101,11 @@ class DatabaseTable {
                 referencedTableName: schema ? `${schema}.${prop.referencedTableName}` : prop.referencedTableName,
             };
             const cascade = prop.cascade.includes(core_1.Cascade.REMOVE) || prop.cascade.includes(core_1.Cascade.ALL);
-            if (prop.onDelete || cascade || prop.nullable) {
-                this.foreignKeys[constraintName].deleteRule = prop.onDelete || (cascade ? 'cascade' : 'set null');
+            if (prop.deleteRule || cascade || prop.nullable) {
+                this.foreignKeys[constraintName].deleteRule = prop.deleteRule || (cascade ? 'cascade' : 'set null');
             }
-            if (prop.onUpdateIntegrity || prop.cascade.includes(core_1.Cascade.PERSIST) || prop.cascade.includes(core_1.Cascade.ALL)) {
-                this.foreignKeys[constraintName].updateRule = prop.onUpdateIntegrity || 'cascade';
+            if (prop.updateRule || prop.cascade.includes(core_1.Cascade.PERSIST) || prop.cascade.includes(core_1.Cascade.ALL)) {
+                this.foreignKeys[constraintName].updateRule = prop.updateRule || 'cascade';
             }
         }
         if (prop.index) {
@@ -163,8 +163,8 @@ class DatabaseTable {
         }
         const meta = schema.init().meta;
         meta.relations
-            .filter(prop => prop.primary && prop.reference === core_1.ReferenceType.MANY_TO_ONE && !meta.compositePK)
-            .forEach(prop => prop.reference = core_1.ReferenceType.ONE_TO_ONE);
+            .filter(prop => prop.primary && prop.kind === core_1.ReferenceKind.MANY_TO_ONE && !meta.compositePK)
+            .forEach(prop => prop.kind = core_1.ReferenceKind.ONE_TO_ONE);
         return meta;
     }
     /**
@@ -205,20 +205,20 @@ class DatabaseTable {
         const prop = this.getPropertyName(namingStrategy, column);
         const index = compositeFkIndexes[prop] || this.indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && !idx.unique && !idx.primary);
         const unique = compositeFkUniques[prop] || this.indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && idx.unique && !idx.primary);
-        const reference = this.getReferenceType(fk, unique);
+        const kind = this.getReferenceKind(fk, unique);
         const type = this.getPropertyType(namingStrategy, column, fk);
         const fkOptions = {};
         if (fk) {
             fkOptions.fieldNames = fk.columnNames;
             fkOptions.referencedTableName = fk.referencedTableName;
             fkOptions.referencedColumnNames = fk.referencedColumnNames;
-            fkOptions.onUpdateIntegrity = fk.updateRule?.toLowerCase();
-            fkOptions.onDelete = fk.deleteRule?.toLowerCase();
+            fkOptions.updateRule = fk.updateRule?.toLowerCase();
+            fkOptions.deleteRule = fk.deleteRule?.toLowerCase();
         }
         return {
             name: prop,
             type,
-            reference,
+            kind,
             columnType: column.type,
             default: this.getPropertyDefaultValue(schemaHelper, column, type),
             defaultRaw: this.getPropertyDefaultValue(schemaHelper, column, type, true),
@@ -233,14 +233,14 @@ class DatabaseTable {
             ...fkOptions,
         };
     }
-    getReferenceType(fk, unique) {
+    getReferenceKind(fk, unique) {
         if (fk && unique) {
-            return core_1.ReferenceType.ONE_TO_ONE;
+            return core_1.ReferenceKind.ONE_TO_ONE;
         }
         if (fk) {
-            return core_1.ReferenceType.MANY_TO_ONE;
+            return core_1.ReferenceKind.MANY_TO_ONE;
         }
-        return core_1.ReferenceType.SCALAR;
+        return core_1.ReferenceKind.SCALAR;
     }
     getPropertyName(namingStrategy, column) {
         const fk = Object.values(this.foreignKeys).find(fk => fk.columnNames.includes(column.name));
@@ -307,10 +307,10 @@ class DatabaseTable {
     }
     toJSON() {
         const { platform, columns, ...rest } = this;
-        const columnsMapped = Object.keys(columns).reduce((o, col) => {
+        const columnsMapped = core_1.Utils.keys(columns).reduce((o, col) => {
             const { mappedType, ...restCol } = columns[col];
             o[col] = restCol;
-            o[col].mappedType = Object.keys(core_1.t).find(k => core_1.t[k] === mappedType.constructor);
+            o[col].mappedType = core_1.Utils.keys(core_1.t).find(k => core_1.t[k] === mappedType.constructor);
             return o;
         }, {});
         return { columns: columnsMapped, ...rest };

package/{dist/schema → schema}/SchemaComparator.d.ts

@@ -1,4 +1,4 @@
-import type { Check, Column, ForeignKey, Index, SchemaDifference, TableDifference } from '../typings';
+import type { CheckDef, Column, ForeignKey, IndexDef, SchemaDifference, TableDifference } from '../typings';
 import type { DatabaseSchema } from './DatabaseSchema';
 import type { DatabaseTable } from './DatabaseTable';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -8,6 +8,7 @@ import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
 export declare class SchemaComparator {
     private readonly platform;
     private readonly helper;
+    private readonly logger;
     constructor(platform: AbstractSqlPlatform);
     /**
      * Returns a SchemaDifference object containing the differences between the schemas fromSchema and toSchema.
@@ -37,19 +38,20 @@ export declare class SchemaComparator {
      * Returns the difference between the columns
      * If there are differences this method returns field2, otherwise the boolean false.
      */
-    diffColumn(column1: Column, column2: Column): Set<string>;
+    diffColumn(column1: Column, column2: Column, tableName?: string): Set<string>;
     diffEnumItems(items1?: string[], items2?: string[]): boolean;
     diffComment(comment1?: string, comment2?: string): boolean;
     /**
      * Finds the difference between the indexes index1 and index2.
      * Compares index1 with index2 and returns index2 if there are any differences or false in case there are no differences.
      */
-    diffIndex(index1: Index, index2: Index): boolean;
+    diffIndex(index1: IndexDef, index2: IndexDef): boolean;
     /**
      * Checks if the other index already fulfills all the indexing and constraint needs of the current one.
      */
-    isIndexFulfilledBy(index1: Index, index2: Index): boolean;
-    diffCheck(check1: Check, check2: Check): boolean;
+    isIndexFulfilledBy(index1: IndexDef, index2: IndexDef): boolean;
+    diffCheck(check1: CheckDef, check2: CheckDef): boolean;
     hasSameDefaultValue(from: Column, to: Column): boolean;
     private mapColumnToProperty;
+    private log;
 }

package/{dist/schema → schema}/SchemaComparator.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaComparator = void 0;
+const util_1 = require("util");
 const core_1 = require("@mikro-orm/core");
 /**
  * Compares two Schemas and return an instance of SchemaDifference.
@@ -9,6 +10,7 @@ class SchemaComparator {
     constructor(platform) {
         this.platform = platform;
         this.helper = this.platform.getSchemaHelper();
+        this.logger = this.platform.getConfig().getLogger();
     }
     /**
      * Returns a SchemaDifference object containing the differences between the schemas fromSchema and toSchema.
@@ -105,18 +107,22 @@ class SchemaComparator {
             renamedColumns: {},
             renamedIndexes: {},
             fromTable,
+            toTable,
         };
         if (this.diffComment(fromTable.comment, toTable.comment)) {
             tableDifferences.changedComment = toTable.comment;
+            this.log(`table comment changed for ${tableDifferences.name}`, { fromTableComment: fromTable.comment, toTableComment: toTable.comment });
         }
         const fromTableColumns = fromTable.getColumns();
         const toTableColumns = toTable.getColumns();
+        const tableName = (toTable.schema ? toTable.schema + '.' : '') + toTable.name;
         // See if all the columns in "from" table exist in "to" table
         for (const column of toTableColumns) {
             if (fromTable.hasColumn(column.name)) {
                 continue;
             }
             tableDifferences.addedColumns[column.name] = column;
+            this.log(`column ${tableDifferences.name}.${column.name} of type ${column.type} added`);
             changes++;
         }
         /* See if there are any removed columns in "to" table */
@@ -124,11 +130,12 @@ class SchemaComparator {
             // See if column is removed in "to" table.
             if (!toTable.hasColumn(column.name)) {
                 tableDifferences.removedColumns[column.name] = column;
+                this.log(`column ${tableDifferences.name}.${column.name} removed`);
                 changes++;
                 continue;
             }
             // See if column has changed properties in "to" table.
-            const changedProperties = this.diffColumn(column, toTable.getColumn(column.name));
+            const changedProperties = this.diffColumn(column, toTable.getColumn(column.name), tableName);
             if (changedProperties.size === 0) {
                 continue;
             }
@@ -138,6 +145,7 @@ class SchemaComparator {
                 column: toTable.getColumn(column.name),
                 changedProperties,
             };
+            this.log(`column ${tableDifferences.name}.${column.name} changed`, { changedProperties });
             changes++;
         }
         this.detectColumnRenamings(tableDifferences);
@@ -149,6 +157,7 @@ class SchemaComparator {
                 continue;
             }
             tableDifferences.addedIndexes[index.keyName] = index;
+            this.log(`index ${index.keyName} added to table ${tableDifferences.name}`, { index });
             changes++;
         }
         // See if there are any removed indexes in "to" table
@@ -156,6 +165,7 @@ class SchemaComparator {
             // See if index is removed in "to" table.
             if ((index.primary && !toTable.hasPrimaryKey()) || !index.primary && !toTable.hasIndex(index.keyName)) {
                 tableDifferences.removedIndexes[index.keyName] = index;
+                this.log(`index ${index.keyName} removed from table ${tableDifferences.name}`);
                 changes++;
                 continue;
             }
@@ -165,6 +175,7 @@ class SchemaComparator {
                 continue;
             }
             tableDifferences.changedIndexes[index.keyName] = toTableIndex;
+            this.log(`index ${index.keyName} changed in table ${tableDifferences.name}`, { fromTableIndex: index, toTableIndex });
             changes++;
         }
         this.detectIndexRenamings(tableDifferences);
@@ -176,12 +187,14 @@ class SchemaComparator {
                 continue;
             }
             tableDifferences.addedChecks[check.name] = check;
+            this.log(`check constraint ${check.name} added to table ${tableDifferences.name}`, { check });
             changes++;
         }
         // See if there are any removed checks in "to" table
         for (const check of fromTableChecks) {
             if (!toTable.hasCheck(check.name)) {
                 tableDifferences.removedChecks[check.name] = check;
+                this.log(`check constraint ${check.name} removed from table ${tableDifferences.name}`);
                 changes++;
                 continue;
             }
@@ -190,6 +203,7 @@ class SchemaComparator {
             if (!this.diffCheck(check, toTableCheck)) {
                 continue;
             }
+            this.log(`check constraint ${check.name} changed in table ${tableDifferences.name}`, { fromTableCheck: check, toTableCheck });
             tableDifferences.changedChecks[check.name] = toTableCheck;
             changes++;
         }
@@ -202,6 +216,7 @@ class SchemaComparator {
                     delete toForeignKeys[toConstraint.constraintName];
                 }
                 else if (fromConstraint.constraintName.toLowerCase() === toConstraint.constraintName.toLowerCase()) {
+                    this.log(`FK constraint ${fromConstraint.constraintName} changed in table ${tableDifferences.name}`, { fromConstraint, toConstraint });
                     tableDifferences.changedForeignKeys[toConstraint.constraintName] = toConstraint;
                     changes++;
                     delete fromForeignKeys[fromConstraint.constraintName];
@@ -211,10 +226,12 @@ class SchemaComparator {
         }
         for (const fromConstraint of Object.values(fromForeignKeys)) {
             tableDifferences.removedForeignKeys[fromConstraint.constraintName] = fromConstraint;
+            this.log(`FK constraint ${fromConstraint.constraintName} removed from table ${tableDifferences.name}`);
             changes++;
         }
         for (const toConstraint of Object.values(toForeignKeys)) {
             tableDifferences.addedForeignKeys[toConstraint.constraintName] = toConstraint;
+            this.log(`FK constraint ${toConstraint.constraintName} added from table ${tableDifferences.name}`, { constraint: toConstraint });
             changes++;
         }
         return changes ? tableDifferences : false;
@@ -249,6 +266,7 @@ class SchemaComparator {
             tableDifferences.renamedColumns[removedColumnName] = addedColumn;
             delete tableDifferences.addedColumns[addedColumnName];
             delete tableDifferences.removedColumns[removedColumnName];
+            this.log(`renamed column detected in table ${tableDifferences.name}`, { old: removedColumnName, new: addedColumnName });
         }
     }
     /**
@@ -282,6 +300,7 @@ class SchemaComparator {
             tableDifferences.renamedIndexes[removedIndexName] = addedIndex;
             delete tableDifferences.addedIndexes[addedIndexName];
             delete tableDifferences.removedIndexes[removedIndexName];
+            this.log(`renamed index detected in table ${tableDifferences.name}`, { old: removedIndexName, new: addedIndexName });
         }
     }
     diffForeignKey(key1, key2) {
@@ -294,7 +313,10 @@ class SchemaComparator {
         if (key1.referencedTableName !== key2.referencedTableName) {
             return true;
         }
-        const rule = (key, method) => (key[method] ?? this.platform.getDefaultIntegrityRule()).toLowerCase();
+        const defaultRule = ['restrict', 'no action'];
+        const rule = (key, method) => {
+            return (key[method] ?? defaultRule[0]).toLowerCase().replace(defaultRule[1], defaultRule[0]);
+        };
         const compare = (method) => rule(key1, method) === rule(key2, method);
         return !compare('updateRule') || !compare('deleteRule');
     }
@@ -302,34 +324,53 @@ class SchemaComparator {
      * Returns the difference between the columns
      * If there are differences this method returns field2, otherwise the boolean false.
      */
-    diffColumn(column1, column2) {
+    diffColumn(column1, column2, tableName) {
         const changedProperties = new Set();
         const prop1 = this.mapColumnToProperty({ ...column1, autoincrement: false });
         const prop2 = this.mapColumnToProperty({ ...column2, autoincrement: false });
-        const columnType1 = column1.mappedType.getColumnType(prop1, this.platform);
-        const columnType2 = column2.mappedType.getColumnType(prop2, this.platform);
-        if (columnType1 !== columnType2) {
+        const columnType1 = column1.mappedType.getColumnType(prop1, this.platform).toLowerCase();
+        const columnType2 = column2.mappedType.getColumnType(prop2, this.platform).toLowerCase();
+        const log = (msg, params) => {
+            if (tableName) {
+                const copy = core_1.Utils.copy(params);
+                core_1.Utils.dropUndefinedProperties(copy);
+                this.log(msg, copy);
+            }
+        };
+        if (columnType1 !== columnType2 &&
+            !(column1.ignoreSchemaChanges?.includes('type') ||
+                column2.ignoreSchemaChanges?.includes('type'))) {
+            log(`'type' changed for column ${tableName}.${column1.name}`, { columnType1, columnType2 });
             changedProperties.add('type');
         }
         if (column1.nullable !== column2.nullable) {
+            log(`'nullable' changed for column ${tableName}.${column1.name}`, { column1, column2 });
             changedProperties.add('nullable');
         }
         if (!!column1.autoincrement !== !!column2.autoincrement) {
+            log(`'autoincrement' changed for column ${tableName}.${column1.name}`, { column1, column2 });
             changedProperties.add('autoincrement');
         }
         if (column1.unsigned !== column2.unsigned && this.platform.supportsUnsigned()) {
+            log(`'unsigned' changed for column ${tableName}.${column1.name}`, { column1, column2 });
             changedProperties.add('unsigned');
         }
         if (!this.hasSameDefaultValue(column1, column2)) {
+            log(`'default' changed for column ${tableName}.${column1.name}`, { column1, column2 });
             changedProperties.add('default');
         }
         if (this.diffComment(column1.comment, column2.comment)) {
+            log(`'comment' changed for column ${tableName}.${column1.name}`, { column1, column2 });
             changedProperties.add('comment');
         }
         if (this.diffEnumItems(column1.enumItems, column2.enumItems)) {
+            log(`'enumItems' changed for column ${tableName}.${column1.name}`, { column1, column2 });
             changedProperties.add('enumItems');
         }
-        if ((column1.extra || '').toLowerCase() !== (column2.extra || '').toLowerCase()) {
+        if ((column1.extra || '').toLowerCase() !== (column2.extra || '').toLowerCase() &&
+            !(column1.ignoreSchemaChanges?.includes('extra') ||
+                column2.ignoreSchemaChanges?.includes('extra'))) {
+            log(`'extra' changed for column ${tableName}.${column1.name}`, { column1, column2 });
             changedProperties.add('extra');
         }
         return changedProperties;
@@ -347,8 +388,8 @@ class SchemaComparator {
      * Compares index1 with index2 and returns index2 if there are any differences or false in case there are no differences.
      */
     diffIndex(index1, index2) {
-        // if one of them is a custom expression, compare only by name
-        if (index1.expression || index2.expression) {
+        // if one of them is a custom expression or full text index, compare only by name
+        if (index1.expression || index2.expression || index1.type === 'fulltext' || index2.type === 'fulltext') {
             return index1.keyName !== index2.keyName;
         }
         return !this.isIndexFulfilledBy(index1, index2) || !this.isIndexFulfilledBy(index2, index1);
@@ -384,7 +425,10 @@ class SchemaComparator {
         return index1.primary === index2.primary && index1.unique === index2.unique;
     }
     diffCheck(check1, check2) {
-        return check1.expression !== check2.expression;
+        // check constraint definition might be normalized by the driver,
+        // e.g. quotes might be added (https://github.com/mikro-orm/mikro-orm/issues/3827)
+        const simplify = (str) => str?.replace(/['"`()]/g, '').toLowerCase();
+        return simplify(check1.expression) !== simplify(check2.expression);
     }
     hasSameDefaultValue(from, to) {
         if (from.default == null || from.default.toString().toLowerCase() === 'null' || from.default.toString().startsWith('nextval(')) {
@@ -423,5 +467,11 @@ class SchemaComparator {
             scale: match ? +match[2] : column.scale,
         };
     }
+    log(message, params) {
+        if (params) {
+            message += ' ' + (0, util_1.inspect)(params);
+        }
+        this.logger.log('schema', message);
+    }
 }
 exports.SchemaComparator = SchemaComparator;

package/{dist/schema → schema}/SchemaHelper.d.ts

@@ -2,8 +2,9 @@ import type { Knex } from 'knex';
 import type { Connection, Dictionary } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
-import type { Check, Column, Index, TableDifference } from '../typings';
+import type { CheckDef, Column, IndexDef, Table, TableDifference } from '../typings';
 import type { DatabaseTable } from './DatabaseTable';
+import type { DatabaseSchema } from './DatabaseSchema';
 export declare abstract class SchemaHelper {
     protected readonly platform: AbstractSqlPlatform;
     constructor(platform: AbstractSqlPlatform);
@@ -13,24 +14,28 @@ export declare abstract class SchemaHelper {
     getSchemaEnd(): string;
     finalizeTable(table: Knex.TableBuilder, charset: string, collate?: string): void;
     supportsSchemaConstraints(): boolean;
-    getPrimaryKeys(connection: AbstractSqlConnection, indexes: Index[], tableName: string, schemaName?: string): Promise<string[]>;
+    getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[] | undefined, tableName: string, schemaName?: string): Promise<string[]>;
     getForeignKeys(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Dictionary>;
-    getEnumDefinitions(connection: AbstractSqlConnection, checks: Check[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
+    protected getTableKey(t: Table): string;
+    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[]): Promise<void>;
     getListTablesSQL(schemaName?: string): string;
-    getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column): string;
-    getCreateIndexSQL(tableName: string, index: Index): string;
-    getDropIndexSQL(tableName: string, index: Index): string;
-    getRenameIndexSQL(tableName: string, index: Index, oldIndexName: string): string;
+    getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
+    getCreateIndexSQL(tableName: string, index: IndexDef): string;
+    getDropIndexSQL(tableName: string, index: IndexDef): string;
+    getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string;
+    hasNonDefaultPrimaryKeyName(table: DatabaseTable): boolean;
     createTableColumn(table: Knex.TableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>): Knex.ColumnBuilder;
     configureColumn(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
     configureColumnDefault(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string;
     getAlterColumnAutoincrement(tableName: string, column: Column): string;
     getChangeColumnCommentSQL(tableName: string, to: Column): string;
+    getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
     getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Column[]>;
-    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Index[]>;
-    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Check[]>;
-    protected mapIndexes(indexes: Index[]): Promise<Index[]>;
+    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<IndexDef[]>;
+    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName?: string, columns?: Column[]): Promise<CheckDef[]>;
+    protected mapIndexes(indexes: IndexDef[]): Promise<IndexDef[]>;
     getForeignKeysSQL(tableName: string, schemaName?: string): string;
     mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;
     normalizeDefaultValue(defaultValue: string, length?: number, defaultValues?: Dictionary<string[]>): string | number;