@mikro-orm/knex 6.0.0-dev.5 → 6.0.0-dev.50

package/query/QueryBuilderHelper.js

@@ -19,6 +19,9 @@ class QueryBuilderHelper {
         this.metadata = this.driver.getMetadata();
     }
     mapper(field, type = enums_1.QueryType.SELECT, value, alias) {
+        if (core_1.Utils.isRawSql(field)) {
+            return this.platform.formatQuery(field.sql, field.params ?? []);
+        }
         if (typeof field !== 'string') {
             return field;
         }
@@ -36,6 +39,17 @@ class QueryBuilderHelper {
                     parts.push(this.mapper(a !== this.alias ? `${a}.${f}` : f, type, value, alias));
                 }
             }
+            // flatten the value if we see we are expanding nested composite key
+            // hackish, but cleaner solution would require quite a lot of refactoring
+            if (fields.length !== parts.length && Array.isArray(value)) {
+                value.forEach(row => {
+                    if (Array.isArray(row)) {
+                        const tmp = core_1.Utils.flatten(row);
+                        row.length = 0;
+                        row.push(...tmp);
+                    }
+                });
+            }
             return this.knex.raw('(' + parts.map(part => this.knex.ref(part)).join(', ') + ')');
         }
         let ret = field;
@@ -72,7 +86,8 @@ class QueryBuilderHelper {
             ret += ' as ' + alias;
         }
         if (customExpression) {
-            return this.knex.raw(ret, value);
+            const bindings = core_1.Utils.asArray(value).slice(0, ret.match(/\?/g)?.length ?? 0);
+            return this.knex.raw(ret, bindings);
         }
         if (!isTableNameAliasRequired || this.isPrefixed(ret) || noPrefix) {
             return ret;
@@ -241,7 +256,7 @@ class QueryBuilderHelper {
         return `(${parts.join(` ${core_1.GroupOperator[operator]} `)})`;
     }
     mapJoinColumns(type, join) {
-        if (join.prop && join.prop.reference === core_1.ReferenceType.ONE_TO_ONE && !join.prop.owner) {
+        if (join.prop && join.prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !join.prop.owner) {
             return join.prop.fieldNames.map((fieldName, idx) => {
                 return this.mapper(`${join.alias}.${join.inverseJoinColumns[idx]}`, type, undefined, fieldName);
             });
@@ -254,7 +269,7 @@ class QueryBuilderHelper {
     isOneToOneInverse(field) {
         const meta = this.metadata.find(this.entityName);
         const prop = meta.properties[field];
-        return prop && prop.reference === core_1.ReferenceType.ONE_TO_ONE && !prop.owner;
+        return prop && prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner;
     }
     getTableName(entityName) {
         const meta = this.metadata.find(entityName);
@@ -299,7 +314,7 @@ class QueryBuilderHelper {
                 let mergeParam = item.merge;
                 if (core_1.Utils.isObject(item.merge)) {
                     mergeParam = {};
-                    Object.keys(item.merge).forEach(key => {
+                    core_1.Utils.keys(item.merge).forEach(key => {
                         const k = this.mapper(key, type);
                         mergeParam[k] = item.merge[key];
                     });
@@ -394,7 +409,8 @@ class QueryBuilderHelper {
             }));
         }
         else {
-            qb[m](this.mapper(key, type, undefined, null), replacement, value[op]);
+            const mappedKey = this.mapper(key, type, value[op], null);
+            qb[m](mappedKey, replacement, value[op]);
         }
     }
     getOperatorReplacement(op, value) {
@@ -429,13 +445,13 @@ class QueryBuilderHelper {
                 ret.push(`${k} ${order.toLowerCase()}`);
                 return;
             }
-            // eslint-disable-next-line prefer-const
-            let [alias, field] = this.splitField(k, true);
-            alias = populate[alias] || alias;
-            core_1.Utils.splitPrimaryKeys(field).forEach(f => {
-                const prop = this.getProperty(f, alias);
+            core_1.Utils.splitPrimaryKeys(k).forEach(f => {
+                // eslint-disable-next-line prefer-const
+                let [alias, field] = this.splitField(f, true);
+                alias = populate[alias] || alias;
+                const prop = this.getProperty(field, alias);
                 const noPrefix = (prop && prop.persist === false && !prop.formula) || QueryBuilderHelper.isCustomExpression(f);
-                const column = this.mapper(noPrefix ? f : `${alias}.${f}`, type, undefined, null);
+                const column = this.mapper(noPrefix ? field : `${alias}.${field}`, type, undefined, null);
                 /* istanbul ignore next */
                 const rawColumn = core_1.Utils.isString(column) ? column.split('.').map(e => this.knex.ref(e)).join('.') : column;
                 const customOrder = prop?.customOrder;
@@ -447,11 +463,23 @@ class QueryBuilderHelper {
         });
         return ret.join(', ');
     }
-    finalize(type, qb, meta) {
-        const useReturningStatement = type === enums_1.QueryType.INSERT && this.platform.usesReturningStatement() && meta && !meta.compositePK;
-        if (useReturningStatement) {
-            const returningProps = meta.hydrateProps.filter(prop => prop.persist !== false && (prop.primary || prop.defaultRaw));
-            qb.returning(core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames)));
+    finalize(type, qb, meta, data) {
+        if (!meta || !data || !this.platform.usesReturningStatement()) {
+            return;
+        }
+        if (type === enums_1.QueryType.INSERT) {
+            const returningProps = meta.hydrateProps
+                .filter(prop => prop.persist !== false && ((prop.primary && prop.autoincrement) || prop.defaultRaw))
+                .filter(prop => !(prop.name in data) || core_1.Utils.isRawSql(data[prop.name]));
+            if (returningProps.length > 0) {
+                qb.returning(core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames)));
+            }
+        }
+        if (type === enums_1.QueryType.UPDATE) {
+            const returningProps = meta.hydrateProps.filter(prop => core_1.Utils.isRawSql(data[prop.name]));
+            if (returningProps.length > 0) {
+                qb.returning(core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames)));
+            }
         }
     }
     splitField(field, greedyAlias = false) {
@@ -564,7 +592,7 @@ class QueryBuilderHelper {
         // check if `alias` is not matching an embedded property name instead of alias, e.g. `address.city`
         if (alias && meta) {
             const prop = meta.properties[alias];
-            if (prop?.reference === core_1.ReferenceType.EMBEDDED) {
+            if (prop?.kind === core_1.ReferenceKind.EMBEDDED) {
                 // we want to select the full object property so hydration works as expected
                 if (prop.object) {
                     return prop;
@@ -596,13 +624,13 @@ class QueryBuilderHelper {
                 return;
             }
             if (prop.joinColumns && Array.isArray(data[k])) {
-                const copy = data[k];
+                const copy = core_1.Utils.flatten(data[k]);
                 delete data[k];
                 prop.joinColumns.forEach((joinColumn, idx) => data[joinColumn] = copy[idx]);
                 return;
             }
             if (prop.customType && convertCustomTypes && !this.platform.isRaw(data[k])) {
-                data[k] = prop.customType.convertToDatabaseValue(data[k], this.platform, { fromQuery: true, key: k, mode: 'query' });
+                data[k] = prop.customType.convertToDatabaseValue(data[k], this.platform, { fromQuery: true, key: k, mode: 'query-data' });
             }
             if (prop.customType && 'convertToDatabaseValueSQL' in prop.customType && !this.platform.isRaw(data[k])) {
                 const quoted = this.platform.quoteValue(data[k]);

package/query/ScalarCriteriaNode.d.ts

@@ -3,7 +3,8 @@ import type { IQueryBuilder } from '../typings';
 /**
  * @internal
  */
-export declare class ScalarCriteriaNode extends CriteriaNode {
-    process<T>(qb: IQueryBuilder<T>, alias?: string): any;
+export declare class ScalarCriteriaNode<T extends object> extends CriteriaNode<T> {
+    process(qb: IQueryBuilder<T>, alias?: string): any;
+    willAutoJoin<T>(qb: IQueryBuilder<T>, alias?: string): boolean;
     shouldJoin(): boolean;
 }

package/query/ScalarCriteriaNode.js

@@ -13,23 +13,26 @@ class ScalarCriteriaNode extends CriteriaNode_1.CriteriaNode {
             const parentPath = this.parent.getPath(); // the parent is always there, otherwise `shouldJoin` would return `false`
             const nestedAlias = qb.getAliasForJoinPath(path) || qb.getNextAlias(this.prop?.pivotTable ?? this.entityName);
             const field = `${alias}.${this.prop.name}`;
-            const type = this.prop.reference === core_1.ReferenceType.MANY_TO_MANY ? 'pivotJoin' : 'leftJoin';
+            const type = this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY ? 'pivotJoin' : 'leftJoin';
             qb.join(field, nestedAlias, undefined, type, path);
             // select the owner as virtual property when joining from 1:1 inverse side, but only if the parent is root entity
-            if (this.prop.reference === core_1.ReferenceType.ONE_TO_ONE && !parentPath.includes('.')) {
+            if (this.prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !parentPath.includes('.')) {
                 qb.addSelect(field);
             }
         }
         return this.payload;
     }
+    willAutoJoin(qb, alias) {
+        return this.shouldJoin();
+    }
     shouldJoin() {
         if (!this.parent || !this.prop) {
             return false;
         }
-        switch (this.prop.reference) {
-            case core_1.ReferenceType.ONE_TO_MANY: return true;
-            case core_1.ReferenceType.MANY_TO_MANY: return true;
-            case core_1.ReferenceType.ONE_TO_ONE: return !this.prop.owner;
+        switch (this.prop.kind) {
+            case core_1.ReferenceKind.ONE_TO_MANY: return true;
+            case core_1.ReferenceKind.MANY_TO_MANY: return true;
+            case core_1.ReferenceKind.ONE_TO_ONE: return !this.prop.owner;
             default: return false; // SCALAR, MANY_TO_ONE
         }
     }

package/schema/DatabaseSchema.js

@@ -78,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/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[] | undefined, checks: Check<unknown>[] | undefined, 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/schema/DatabaseTable.js

@@ -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],
@@ -84,11 +83,11 @@ class DatabaseTable {
                 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('.')) {
@@ -102,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) {
@@ -164,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;
     }
     /**
@@ -206,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),
@@ -234,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));
@@ -288,7 +287,7 @@ class DatabaseTable {
         return '' + val;
     }
     addIndex(meta, index, type) {
-        const properties = core_1.Utils.flatten(core_1.Utils.asArray(index.properties).map(prop => meta.properties[prop].fieldNames));
+        const properties = core_1.Utils.unique(core_1.Utils.flatten(core_1.Utils.asArray(index.properties).map(prop => meta.properties[prop].fieldNames)));
         if (properties.length === 0 && !index.expression) {
             return;
         }
@@ -308,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/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';
@@ -45,12 +45,12 @@ export declare class SchemaComparator {
      * 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/schema/SchemaComparator.js

@@ -425,8 +425,10 @@ class SchemaComparator {
         return index1.primary === index2.primary && index1.unique === index2.unique;
     }
     diffCheck(check1, check2) {
-        const unquote = (str) => str?.replace(/['"`]/g, '');
-        return unquote(check1.expression) !== unquote(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(')) {

package/schema/SchemaHelper.d.ts

@@ -2,7 +2,7 @@ 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, Table, 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 {
@@ -14,28 +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[] | undefined, 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>;
     protected getTableKey(t: Table): string;
-    getEnumDefinitions(connection: AbstractSqlConnection, checks: Check[], tableName: string, schemaName?: string): Promise<Dictionary<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, schemaName?: string): string;
-    getCreateIndexSQL(tableName: string, index: Index): string;
-    getDropIndexSQL(tableName: string, index: Index): string;
-    getRenameIndexSQL(tableName: string, index: Index, oldIndexName: 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;
+    getAlterColumnAutoincrement(tableName: string, column: Column, schemaName?: string): string;
+    getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): 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, columns?: Column[]): 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;

package/schema/SchemaHelper.js

@@ -122,17 +122,17 @@ class SchemaHelper {
             core_1.Utils.runIfNotEmpty(() => col.defaultTo(column.default == null ? null : knex.raw(column.default)), guard('default'));
         }
         else {
-            core_1.Utils.runIfNotEmpty(() => col.defaultTo(column.default == null ? null : knex.raw(column.default)), column.default !== undefined);
+            core_1.Utils.runIfNotEmpty(() => col.defaultTo(knex.raw(column.default)), column.default != null && column.default !== 'null');
         }
         return col;
     }
     getPreAlterTable(tableDiff, safe) {
         return '';
     }
-    getAlterColumnAutoincrement(tableName, column) {
+    getAlterColumnAutoincrement(tableName, column, schemaName) {
         return '';
     }
-    getChangeColumnCommentSQL(tableName, to) {
+    getChangeColumnCommentSQL(tableName, to, schemaName) {
         return '';
     }
     async getNamespaces(connection) {

package/schema/{SchemaGenerator.d.ts → SqlSchemaGenerator.d.ts}

@@ -1,18 +1,13 @@
-import type { MikroORM } from '@mikro-orm/core';
+import type { MikroORM, ISchemaGenerator } from '@mikro-orm/core';
 import { AbstractSchemaGenerator } from '@mikro-orm/core';
 import type { SchemaDifference } from '../typings';
 import { DatabaseSchema } from './DatabaseSchema';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
-/**
- * Should be renamed to `SqlSchemaGenerator` in v6
- */
-export declare class SchemaGenerator extends AbstractSchemaGenerator<AbstractSqlDriver> {
+export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<AbstractSqlDriver> implements ISchemaGenerator {
     private readonly helper;
     private readonly options;
     protected lastEnsuredDatabase?: string;
     static register(orm: MikroORM): void;
-    /** @deprecated use `dropSchema` and `createSchema` commands respectively */
-    generate(): Promise<string>;
     createSchema(options?: {
         wrap?: boolean;
         schema?: string;
@@ -88,7 +83,7 @@ export declare class SchemaGenerator extends AbstractSchemaGenerator<AbstractSql
     dropDatabase(name: string): Promise<void>;
     execute(sql: string, options?: {
         wrap?: boolean;
-    }): Promise<undefined>;
+    }): Promise<void>;
     private wrapSchema;
     private createSchemaBuilder;
     private createTable;
@@ -101,3 +96,4 @@ export declare class SchemaGenerator extends AbstractSchemaGenerator<AbstractSql
     private dump;
     private get knex();
 }
+export { SqlSchemaGenerator as SchemaGenerator };

package/schema/{SchemaGenerator.js → SqlSchemaGenerator.js}

@@ -1,28 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaGenerator = void 0;
+exports.SchemaGenerator = exports.SqlSchemaGenerator = void 0;
 const core_1 = require("@mikro-orm/core");
 const DatabaseSchema_1 = require("./DatabaseSchema");
 const SchemaComparator_1 = require("./SchemaComparator");
-/**
- * Should be renamed to `SqlSchemaGenerator` in v6
- */
-class SchemaGenerator extends core_1.AbstractSchemaGenerator {
+class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
     constructor() {
         super(...arguments);
         this.helper = this.platform.getSchemaHelper();
         this.options = this.config.get('schemaGenerator');
     }
     static register(orm) {
-        orm.config.registerExtension('@mikro-orm/schema-generator', new SchemaGenerator(orm.em));
-    }
-    /** @deprecated use `dropSchema` and `createSchema` commands respectively */
-    async generate() {
-        const [dropSchema, createSchema] = await Promise.all([
-            this.getDropSchemaSQL({ wrap: false }),
-            this.getCreateSchemaSQL({ wrap: false }),
-        ]);
-        return this.wrapSchema(dropSchema + createSchema);
+        orm.config.registerExtension('@mikro-orm/schema-generator', () => new SqlSchemaGenerator(orm.em));
     }
     async createSchema(options) {
         await this.ensureDatabase();
@@ -143,7 +132,9 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         return this.diffToSQL(diffUp, options);
     }
     async getUpdateSchemaMigrationSQL(options = {}) {
-        await this.ensureDatabase();
+        if (!options.fromSchema) {
+            await this.ensureDatabase();
+        }
         const { fromSchema, toSchema } = await this.prepareSchemaForComparison(options);
         const comparator = new SchemaComparator_1.SchemaComparator(this.platform);
         const diffUp = comparator.compare(fromSchema, toSchema);
@@ -154,9 +145,9 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         };
     }
     async prepareSchemaForComparison(options) {
-        options.wrap ?? (options.wrap = this.options.disableForeignKeys);
-        options.safe ?? (options.safe = false);
-        options.dropTables ?? (options.dropTables = true);
+        options.wrap ??= this.options.disableForeignKeys;
+        options.safe ??= false;
+        options.dropTables ??= true;
         const toSchema = this.getTargetSchema(options.schema);
         const fromSchema = options.fromSchema ?? await DatabaseSchema_1.DatabaseSchema.create(this.connection, this.platform, this.config, options.schema);
         const wildcardSchemaTables = Object.values(this.metadata.getAll()).filter(meta => meta.schema === '*').map(meta => meta.tableName);
@@ -305,13 +296,13 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
                 this.helper.configureColumn(column, col, this.knex, changedProperties);
             }
             for (const { column } of Object.values(diff.changedColumns).filter(diff => diff.changedProperties.has('autoincrement'))) {
-                this.helper.pushTableQuery(table, this.helper.getAlterColumnAutoincrement(tableName, column));
+                this.helper.pushTableQuery(table, this.helper.getAlterColumnAutoincrement(tableName, column, schemaName));
             }
             for (const { column, changedProperties } of Object.values(diff.changedColumns).filter(diff => diff.changedProperties.has('comment'))) {
                 if (['type', 'nullable', 'autoincrement', 'unsigned', 'default', 'enumItems'].some(t => changedProperties.has(t))) {
                     continue; // will be handled via knex
                 }
-                this.helper.pushTableQuery(table, this.helper.getChangeColumnCommentSQL(tableName, column));
+                this.helper.pushTableQuery(table, this.helper.getChangeColumnCommentSQL(tableName, column, schemaName));
             }
             for (const [oldColumnName, column] of Object.entries(diff.renamedColumns)) {
                 this.helper.pushTableQuery(table, this.helper.getRenameColumnSQL(tableName, oldColumnName, column, schemaName));
@@ -364,19 +355,20 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         await this.driver.execute(this.helper.getDropDatabaseSQL('' + this.knex.ref(name)));
     }
     async execute(sql, options = {}) {
-        options.wrap ?? (options.wrap = false);
+        options.wrap ??= false;
         const lines = this.wrapSchema(sql, options).split('\n').filter(i => i.trim());
         if (lines.length === 0) {
             return;
         }
         if (this.platform.supportsMultipleStatements()) {
             const query = lines.join('\n');
-            return void await this.driver.execute(query);
+            await this.driver.execute(query);
+            return;
         }
         await core_1.Utils.runSerial(lines, line => this.driver.execute(line));
     }
     wrapSchema(sql, options = {}) {
-        options.wrap ?? (options.wrap = this.options.disableForeignKeys);
+        options.wrap ??= this.options.disableForeignKeys;
         if (!options.wrap || sql.trim() === '') {
             return sql;
         }
@@ -487,4 +479,5 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         return this.connection.getKnex();
     }
 }
-exports.SchemaGenerator = SchemaGenerator;
+exports.SqlSchemaGenerator = SqlSchemaGenerator;
+exports.SchemaGenerator = SqlSchemaGenerator;

package/schema/index.d.ts

@@ -1,5 +1,5 @@
 export * from './DatabaseSchema';
 export * from './DatabaseTable';
-export * from './SchemaGenerator';
+export * from './SqlSchemaGenerator';
 export * from './SchemaHelper';
 export * from './SchemaComparator';