@mikro-orm/knex 6.4.6-dev.9 → 7.0.0-dev.0

package/schema/DatabaseTable.d.ts

@@ -20,6 +20,7 @@ export declare class DatabaseTable {
     }>;
     comment?: string;
     constructor(platform: AbstractSqlPlatform, name: string, schema?: string | undefined);
+    getQuotedName(): string;
     getColumns(): Column[];
     getColumn(name: string): Column | undefined;
     removeColumn(name: string): void;
@@ -37,7 +38,7 @@ export declare class DatabaseTable {
     /**
      * The shortest name is stripped of the default namespace. All other namespaced elements are returned as full-qualified names.
      */
-    getShortestName(): string;
+    getShortestName(skipDefaultSchema?: boolean): string;
     getForeignKeys(): Dictionary<ForeignKey>;
     hasColumn(columnName: string): boolean;
     getIndex(indexName: string): IndexDef | undefined;

package/schema/DatabaseTable.js

@@ -23,6 +23,9 @@ class DatabaseTable {
             platform: { enumerable: false, writable: true },
         });
     }
+    getQuotedName() {
+        return this.platform.quoteIdentifier(this.getShortestName());
+    }
     getColumns() {
         return Object.values(this.columns);
     }
@@ -76,14 +79,14 @@ class DatabaseTable {
                     prop.length ??= mappedType.getDefaultLength(this.platform);
                 }
             }
-            const primary = !meta.compositePK && !!prop.primary && prop.kind === core_1.ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType);
+            const primary = !meta.compositePK && prop.fieldNames.length === 1 && !!prop.primary;
             this.columns[field] = {
                 name: prop.fieldNames[idx],
                 type: prop.columnTypes[idx],
                 generated: prop.generated,
                 mappedType,
                 unsigned: prop.unsigned && this.platform.isNumericColumn(mappedType),
-                autoincrement: prop.autoincrement ?? primary,
+                autoincrement: prop.autoincrement ?? (primary && prop.kind === core_1.ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType)),
                 primary,
                 nullable: this.columns[field]?.nullable ?? !!prop.nullable,
                 nativeEnumName: prop.nativeEnumName,
@@ -109,7 +112,7 @@ class DatabaseTable {
             this.foreignKeys[constraintName] = {
                 constraintName,
                 columnNames: prop.fieldNames,
-                localTableName: this.getShortestName(),
+                localTableName: this.getShortestName(false),
                 referencedColumnNames: prop.referencedColumnNames,
                 referencedTableName: schema ? `${schema}.${prop.referencedTableName}` : prop.referencedTableName,
             };
@@ -510,8 +513,9 @@ class DatabaseTable {
     /**
      * The shortest name is stripped of the default namespace. All other namespaced elements are returned as full-qualified names.
      */
-    getShortestName() {
-        if (!this.schema || this.name.startsWith(this.schema + '.')) {
+    getShortestName(skipDefaultSchema = true) {
+        const defaultSchema = this.platform.getDefaultSchemaName();
+        if (!this.schema || this.name.startsWith(defaultSchema + '.') || (this.schema === defaultSchema && skipDefaultSchema)) {
             return this.name;
         }
         return `${this.schema}.${this.name}`;

package/schema/SchemaComparator.d.ts

@@ -37,9 +37,8 @@ export declare class SchemaComparator {
     diffForeignKey(key1: ForeignKey, key2: ForeignKey, tableDifferences: TableDifference): boolean;
     /**
      * Returns the difference between the columns
-     * If there are differences this method returns field2, otherwise the boolean false.
      */
-    diffColumn(fromColumn: Column, toColumn: Column, fromTable: DatabaseTable, tableName?: string): Set<string>;
+    diffColumn(fromColumn: Column, toColumn: Column, fromTable: DatabaseTable, logging?: boolean): Set<string>;
     diffEnumItems(items1?: string[], items2?: string[]): boolean;
     diffComment(comment1?: string, comment2?: string): boolean;
     /**

package/schema/SchemaComparator.js

@@ -66,7 +66,7 @@ class SchemaComparator {
             diff.removedNativeEnums.push(nativeEnum);
         }
         for (const table of toSchema.getTables()) {
-            const tableName = table.getShortestName();
+            const tableName = table.getShortestName(false);
             if (!fromSchema.hasTable(tableName)) {
                 diff.newTables[tableName] = toSchema.getTable(tableName);
             }
@@ -146,7 +146,6 @@ class SchemaComparator {
         }
         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)) {
@@ -166,7 +165,7 @@ class SchemaComparator {
                 continue;
             }
             // See if column has changed properties in "to" table.
-            const changedProperties = this.diffColumn(column, toTable.getColumn(column.name), fromTable, tableName);
+            const changedProperties = this.diffColumn(column, toTable.getColumn(column.name), fromTable, true);
             if (changedProperties.size === 0) {
                 continue;
             }
@@ -235,11 +234,16 @@ class SchemaComparator {
                 changes++;
                 continue;
             }
-            // See if index has changed in "to" table
+            // See if check has changed in "to" table
             const toTableCheck = toTable.getCheck(check.name);
+            const toColumn = toTable.getColumn(check.columnName);
+            const fromColumn = fromTable.getColumn(check.columnName);
             if (!this.diffExpression(check.expression, toTableCheck.expression)) {
                 continue;
             }
+            if (fromColumn?.enumItems && toColumn?.enumItems && !this.diffEnumItems(fromColumn.enumItems, toColumn.enumItems)) {
+                continue;
+            }
             this.log(`check constraint ${check.name} changed in table ${tableDifferences.name}`, { fromTableCheck: check, toTableCheck });
             tableDifferences.changedChecks[check.name] = toTableCheck;
             changes++;
@@ -385,9 +389,8 @@ class SchemaComparator {
     }
     /**
      * Returns the difference between the columns
-     * If there are differences this method returns field2, otherwise the boolean false.
      */
-    diffColumn(fromColumn, toColumn, fromTable, tableName) {
+    diffColumn(fromColumn, toColumn, fromTable, logging) {
         const changedProperties = new Set();
         const fromProp = this.mapColumnToProperty({ ...fromColumn, autoincrement: false });
         const toProp = this.mapColumnToProperty({ ...toColumn, autoincrement: false });
@@ -395,7 +398,7 @@ class SchemaComparator {
         const fromNativeEnum = fromTable.nativeEnums[fromColumnType] ?? Object.values(fromTable.nativeEnums).find(e => e.name === fromColumnType && e.schema !== '*');
         let toColumnType = this.platform.normalizeColumnType(toColumn.mappedType.getColumnType(toProp, this.platform).toLowerCase(), toProp);
         const log = (msg, params) => {
-            if (tableName) {
+            if (logging) {
                 const copy = core_1.Utils.copy(params);
                 core_1.Utils.dropUndefinedProperties(copy);
                 this.log(msg, copy);
@@ -409,45 +412,45 @@ class SchemaComparator {
                 toColumnType = `${fromTable.schema}.${toColumnType}`;
             }
             if (fromColumnType !== toColumnType) {
-                log(`'type' changed for column ${tableName}.${fromColumn.name}`, { fromColumnType, toColumnType });
+                log(`'type' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumnType, toColumnType });
                 changedProperties.add('type');
             }
         }
         if (fromColumn.nullable !== toColumn.nullable && !fromColumn.generated && !toColumn.generated) {
-            log(`'nullable' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
+            log(`'nullable' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('nullable');
         }
         if (this.diffExpression(fromColumn.generated, toColumn.generated)) {
-            log(`'generated' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
+            log(`'generated' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('generated');
         }
         if (!!fromColumn.autoincrement !== !!toColumn.autoincrement) {
-            log(`'autoincrement' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
+            log(`'autoincrement' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('autoincrement');
         }
         if (fromColumn.unsigned !== toColumn.unsigned && this.platform.supportsUnsigned()) {
-            log(`'unsigned' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
+            log(`'unsigned' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('unsigned');
         }
         if (!(fromColumn.ignoreSchemaChanges?.includes('default') ||
             toColumn.ignoreSchemaChanges?.includes('default')) && !this.hasSameDefaultValue(fromColumn, toColumn)) {
-            log(`'default' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
+            log(`'default' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('default');
         }
         if (this.diffComment(fromColumn.comment, toColumn.comment)) {
-            log(`'comment' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
+            log(`'comment' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('comment');
         }
         if (!(fromColumn.mappedType instanceof core_1.ArrayType) &&
             !(toColumn.mappedType instanceof core_1.ArrayType) &&
             this.diffEnumItems(fromColumn.enumItems, toColumn.enumItems)) {
-            log(`'enumItems' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
+            log(`'enumItems' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('enumItems');
         }
         if ((fromColumn.extra || '').toLowerCase() !== (toColumn.extra || '').toLowerCase() &&
             !(fromColumn.ignoreSchemaChanges?.includes('extra') ||
                 toColumn.ignoreSchemaChanges?.includes('extra'))) {
-            log(`'extra' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
+            log(`'extra' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('extra');
         }
         return changedProperties;
@@ -499,12 +502,22 @@ class SchemaComparator {
             // index that has no constraints.
             return true;
         }
-        return index1.primary === index2.primary && index1.unique === index2.unique && index1.deferMode === index2.deferMode;
+        if (this.platform.supportsDeferredUniqueConstraints() && index1.deferMode !== index2.deferMode) {
+            return false;
+        }
+        return index1.primary === index2.primary && index1.unique === index2.unique;
     }
     diffExpression(expr1, expr2) {
         // expressions like check constraints 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(/_\w+'(.*?)'/g, '$1').replace(/['"`()]|::\w+| +/g, '').toLowerCase();
+        const simplify = (str) => {
+            return str
+                ?.replace(/_\w+'(.*?)'/g, '$1')
+                .replace(/in\s*\((.*?)\)/ig, '= any (array[$1])')
+                .replace(/['"`()]|::\w+| +/g, '')
+                .replace(/anyarray\[(.*)]/ig, '$1')
+                .toLowerCase();
+        };
         return simplify(expr1) !== simplify(expr2);
     }
     parseJsonDefault(defaultValue) {

package/schema/SchemaHelper.d.ts

@@ -1,5 +1,4 @@
 import { type Connection, type Dictionary } from '@mikro-orm/core';
-import type { Knex } from 'knex';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
 import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../typings';
@@ -8,41 +7,37 @@ import type { DatabaseTable } from './DatabaseTable';
 export declare abstract class SchemaHelper {
     protected readonly platform: AbstractSqlPlatform;
     constructor(platform: AbstractSqlPlatform);
-    getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
+    getSchemaBeginning(_charset: string, disableForeignKeys?: boolean): string;
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
     getSchemaEnd(disableForeignKeys?: boolean): string;
-    finalizeTable(table: Knex.TableBuilder, charset: string, collate?: string): void;
+    finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;
+    appendComments(table: DatabaseTable): string[];
     supportsSchemaConstraints(): boolean;
     getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[] | undefined, tableName: string, schemaName?: string): Promise<string[]>;
     inferLengthFromColumnType(type: string): number | undefined;
-    getForeignKeys(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Dictionary>;
     protected getTableKey(t: Table): string;
-    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
     getCreateNativeEnumSQL(name: string, values: unknown[], schema?: string): string;
     getDropNativeEnumSQL(name: string, schema?: string): string;
     getAlterNativeEnumSQL(name: string, schema?: string, value?: string, items?: string[], oldItems?: string[]): string;
-    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
+    abstract loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
     getListTablesSQL(schemaName?: string): string;
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
-    getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
+    getCreateIndexSQL(tableName: string, index: IndexDef): string;
     getDropIndexSQL(tableName: string, index: IndexDef): string;
-    getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string;
+    getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string[];
+    alterTable(diff: TableDifference, safe?: boolean): string[];
+    getAddColumnsSQL(table: DatabaseTable, columns: Column[]): string[];
     getDropColumnsSQL(tableName: string, columns: Column[], schemaName?: string): string;
     hasNonDefaultPrimaryKeyName(table: DatabaseTable): boolean;
-    createTableColumn(table: Knex.TableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>, alter?: boolean): Knex.ColumnBuilder | undefined;
-    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;
-    getPostAlterTable(tableDiff: TableDifference, safe: boolean): string;
-    getAlterColumnAutoincrement(tableName: string, column: Column, schemaName?: string): string;
+    castColumn(name: string, type: string): string;
+    alterTableColumn(column: Column, table: DatabaseTable, changedProperties: Set<string>): string[];
+    createTableColumn(column: Column, table: DatabaseTable, changedProperties?: Set<string>): string | undefined;
+    getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
+    getPostAlterTable(tableDiff: TableDifference, safe: boolean): 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<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;
     getCreateDatabaseSQL(name: string): string;
@@ -54,27 +49,26 @@ export declare abstract class SchemaHelper {
     getManagementDbName(): string;
     getDefaultEmptyString(): string;
     databaseExists(connection: Connection, name: string): Promise<boolean>;
-    /**
-     * Uses `raw` method injected in `AbstractSqlConnection` to allow adding custom queries inside alter statements.
-     */
-    pushTableQuery(table: Knex.TableBuilder, expression: string, grouping?: string): void;
-    dump(builder: Knex.SchemaBuilder | string, append: string): Promise<string>;
-    createTable(tableDef: DatabaseTable, alter?: boolean): Knex.SchemaBuilder;
-    createForeignKey(table: Knex.CreateTableBuilder, foreignKey: ForeignKey, schema?: string): void;
-    splitTableName(name: string): [string | undefined, string];
+    append(array: string[], sql: string | string[], pad?: boolean): void;
+    createTable(table: DatabaseTable, alter?: boolean): string[];
+    alterTableComment(table: DatabaseTable, comment?: string): string;
+    createForeignKey(table: DatabaseTable, foreignKey: ForeignKey, alterTable?: boolean, inline?: boolean): string;
+    splitTableName(name: string, skipDefaultSchema?: boolean): [string | undefined, string];
     getReferencedTableName(referencedTableName: string, schema?: string): string;
-    createIndex(table: Knex.CreateTableBuilder, index: IndexDef, tableDef: DatabaseTable, createPrimary?: boolean): void;
-    createCheck(table: Knex.CreateTableBuilder, check: CheckDef): void;
-    createSchemaBuilder(schema?: string): Knex.SchemaBuilder;
+    createIndex(index: IndexDef, table: DatabaseTable, createPrimary?: boolean): string;
+    createCheck(table: DatabaseTable, check: CheckDef): string;
+    protected getTableName(table: string, schema?: string): string;
     getTablesGroupedBySchemas(tables: Table[]): Map<string | undefined, Table[]>;
-    getAlterTable?(changedTable: TableDifference, wrap?: boolean): Promise<string>;
-    get knex(): Knex;
     get options(): {
         disableForeignKeys?: boolean;
         createForeignKeyConstraints?: boolean;
         ignoreSchema?: string[];
         managementDbName?: string;
     };
-    private processComment;
-    protected handleMultilineComment(comment: string): string;
+    protected processComment(comment: string): string;
+    protected quote(...keys: (string | undefined)[]): string;
+    dropForeignKey(tableName: string, constraintName: string): string;
+    dropIndex(table: string, index: IndexDef, oldIndexName?: string): string;
+    dropConstraint(table: string, name: string): string;
+    dropTableIfExists(name: string, schema?: string): string;
 }