@mikro-orm/knex 6.1.13-dev.4 → 6.1.13-dev.40

package/schema/SchemaHelper.d.ts

@@ -15,6 +15,7 @@ export declare abstract class SchemaHelper {
     finalizeTable(table: Knex.TableBuilder, charset: string, collate?: string): void;
     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[]>>;
@@ -27,8 +28,9 @@ export declare abstract class SchemaHelper {
     getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
     getDropIndexSQL(tableName: string, index: IndexDef): string;
     getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): 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;
+    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;
@@ -45,6 +47,8 @@ export declare abstract class SchemaHelper {
     normalizeDefaultValue(defaultValue: string, length?: number, defaultValues?: Dictionary<string[]>): string | number;
     getCreateDatabaseSQL(name: string): string;
     getDropDatabaseSQL(name: string): string;
+    getCreateNamespaceSQL(name: string): string;
+    getDropNamespaceSQL(name: string): string;
     getDatabaseExistsSQL(name: string): string;
     getDatabaseNotExistsError(dbName: string): string;
     getManagementDbName(): string;

package/schema/SchemaHelper.js

@@ -29,6 +29,9 @@ class SchemaHelper {
         const pks = indexes.filter(i => i.primary).map(pk => pk.columnNames);
         return core_1.Utils.flatten(pks);
     }
+    inferLengthFromColumnType(type) {
+        return undefined;
+    }
     async getForeignKeys(connection, tableName, schemaName) {
         const fks = await connection.execute(this.getForeignKeysSQL(tableName, schemaName));
         return this.mapForeignKeys(fks, tableName, schemaName);
@@ -99,6 +102,11 @@ class SchemaHelper {
     getRenameIndexSQL(tableName, index, oldIndexName) {
         return [this.getDropIndexSQL(tableName, { ...index, keyName: oldIndexName }), this.getCreateIndexSQL(tableName, index)].join(';\n');
     }
+    getDropColumnsSQL(tableName, columns, schemaName) {
+        const name = this.platform.quoteIdentifier((schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName);
+        const drops = columns.map(column => `drop column ${this.platform.quoteIdentifier(column.name)}`).join(', ');
+        return `alter table ${name} ${drops}`;
+    }
     hasNonDefaultPrimaryKeyName(table) {
         const pkIndex = table.getPrimaryKey();
         if (!pkIndex || !this.platform.supportsCustomPrimaryKeyNames()) {
@@ -199,6 +207,7 @@ class SchemaHelper {
                     referencedColumnNames: [fk.referenced_column_name],
                     updateRule: fk.update_rule.toLowerCase(),
                     deleteRule: fk.delete_rule.toLowerCase(),
+                    deferMode: fk.defer_mode,
                 };
             }
             return ret;
@@ -220,10 +229,19 @@ class SchemaHelper {
         return norm[0].replace('(?)', length != null ? `(${length})` : '');
     }
     getCreateDatabaseSQL(name) {
-        return `create database ${name}`;
+        // two line breaks to force separate execution
+        return `create database ${name};\n\nuse ${name}`;
     }
     getDropDatabaseSQL(name) {
-        return `drop database if exists ${name}`;
+        return `drop database if exists ${this.platform.quoteIdentifier(name)}`;
+    }
+    /* istanbul ignore next */
+    getCreateNamespaceSQL(name) {
+        return `create schema if not exists ${this.platform.quoteIdentifier(name)}`;
+    }
+    /* istanbul ignore next */
+    getDropNamespaceSQL(name) {
+        return `drop schema if exists ${this.platform.quoteIdentifier(name)}`;
     }
     getDatabaseExistsSQL(name) {
         return `select 1 from information_schema.schemata where schema_name = '${name}'`;

package/schema/SqlSchemaGenerator.d.ts

@@ -1,10 +1,15 @@
-import { AbstractSchemaGenerator, type MikroORM, type ISchemaGenerator, type ClearDatabaseOptions, type CreateSchemaOptions, type EnsureDatabaseOptions, type DropSchemaOptions, type UpdateSchemaOptions } from '@mikro-orm/core';
+import { AbstractSchemaGenerator, type ClearDatabaseOptions, type CreateSchemaOptions, type DropSchemaOptions, type EnsureDatabaseOptions, type ISchemaGenerator, type MikroORM, type Transaction, type UpdateSchemaOptions } from '@mikro-orm/core';
 import type { SchemaDifference } from '../typings';
 import { DatabaseSchema } from './DatabaseSchema';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
 export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<AbstractSqlDriver> implements ISchemaGenerator {
-    private readonly helper;
-    private readonly options;
+    protected readonly helper: import("./SchemaHelper").SchemaHelper;
+    protected readonly options: {
+        disableForeignKeys?: boolean | undefined;
+        createForeignKeyConstraints?: boolean | undefined;
+        ignoreSchema?: string[] | undefined;
+        managementDbName?: string | undefined;
+    };
     protected lastEnsuredDatabase?: string;
     static register(orm: MikroORM): void;
     createSchema(options?: CreateSchemaOptions): Promise<void>;
@@ -15,6 +20,8 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     getTargetSchema(schema?: string): DatabaseSchema;
     getCreateSchemaSQL(options?: CreateSchemaOptions): Promise<string>;
     dropSchema(options?: DropSchemaOptions): Promise<void>;
+    createNamespace(name: string): Promise<void>;
+    dropNamespace(name: string): Promise<void>;
     clearDatabase(options?: ClearDatabaseOptions): Promise<void>;
     getDropSchemaSQL(options?: Omit<DropSchemaOptions, 'dropDb'>): Promise<string>;
     private getSchemaName;
@@ -43,10 +50,11 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     /**
      * creates new database and connects to it
      */
-    createDatabase(name: string): Promise<void>;
+    createDatabase(name?: string): Promise<void>;
     dropDatabase(name?: string): Promise<void>;
     execute(sql: string, options?: {
         wrap?: boolean;
+        ctx?: Transaction;
     }): Promise<void>;
     private wrapSchema;
     private createSchemaBuilder;

package/schema/SqlSchemaGenerator.js

@@ -58,7 +58,8 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
             if (namespace === this.platform.getDefaultSchemaName()) {
                 continue;
             }
-            ret += await this.dump(this.knex.schema.createSchemaIfNotExists(namespace));
+            const sql = this.helper.getCreateNamespaceSQL(namespace);
+            ret += await this.dump(this.knex.schema.raw(sql), '\n');
         }
         if (this.platform.supportsNativeEnums()) {
             const created = [];
@@ -88,6 +89,14 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         const sql = await this.getDropSchemaSQL(options);
         await this.execute(sql);
     }
+    async createNamespace(name) {
+        const sql = await this.helper.getCreateNamespaceSQL(name);
+        await this.execute(sql);
+    }
+    async dropNamespace(name) {
+        const sql = await this.helper.getDropNamespaceSQL(name);
+        await this.execute(sql);
+    }
     async clearDatabase(options) {
         // truncate by default, so no value is considered as true
         /* istanbul ignore if */
@@ -101,12 +110,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 .truncate();
         }
         await this.execute(this.helper.enableForeignKeysSQL());
-        if (this.em) {
-            const allowGlobalContext = this.config.get('allowGlobalContext');
-            this.config.set('allowGlobalContext', true);
-            this.em.clear();
-            this.config.set('allowGlobalContext', allowGlobalContext);
-        }
+        this.clearIdentityMap();
     }
     async getDropSchemaSQL(options = {}) {
         await this.ensureDatabase();
@@ -118,7 +122,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         // remove FKs explicitly if we can't use cascading statement and we don't disable FK checks (we need this for circular relations)
         for (const meta of metadata) {
             const table = schema.getTable(meta.tableName);
-            if (!this.platform.usesCascadeStatement() && table && !wrap) {
+            if (!this.platform.usesCascadeStatement() && table && (!wrap || options.dropForeignKeys)) {
                 for (const fk of Object.values(table.getForeignKeys())) {
                     const builder = this.createSchemaBuilder(table.schema).alterTable(table.name, tbl => {
                         tbl.dropForeign(fk.columnNames, fk.constraintName);
@@ -186,8 +190,8 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         let ret = '';
         if (this.platform.supportsSchemas()) {
             for (const newNamespace of schemaDiff.newNamespaces) {
-                // schema might already exist, e.g. explicit usage of `public` in postgres
-                ret += await this.dump(this.knex.schema.createSchemaIfNotExists(newNamespace));
+                const sql = this.helper.getCreateNamespaceSQL(newNamespace);
+                ret += await this.dump(this.knex.schema.raw(sql), '\n');
             }
         }
         if (this.platform.supportsNativeEnums()) {
@@ -240,7 +244,8 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         }
         if (options.dropTables && !options.safe) {
             for (const removedNamespace of schemaDiff.removedNamespaces) {
-                ret += await this.dump(this.knex.schema.dropSchema(removedNamespace));
+                const sql = this.helper.getDropNamespaceSQL(removedNamespace);
+                ret += await this.dump(this.knex.schema.raw(sql), '\n');
             }
         }
         return this.wrapSchema(ret, options);
@@ -266,11 +271,16 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
             .references(foreignKey.referencedColumnNames)
             .inTable(this.getReferencedTableName(foreignKey.referencedTableName, schema))
             .withKeyName(foreignKey.constraintName);
-        if (foreignKey.updateRule) {
-            builder.onUpdate(foreignKey.updateRule);
+        if (foreignKey.localTableName !== foreignKey.referencedTableName || this.platform.supportsMultipleCascadePaths()) {
+            if (foreignKey.updateRule) {
+                builder.onUpdate(foreignKey.updateRule);
+            }
+            if (foreignKey.deleteRule) {
+                builder.onDelete(foreignKey.deleteRule);
+            }
         }
-        if (foreignKey.deleteRule) {
-            builder.onDelete(foreignKey.deleteRule);
+        if (foreignKey.deferMode) {
+            builder.deferrable(foreignKey.deferMode);
         }
     }
     /**
@@ -338,10 +348,8 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 this.dropCheck(table, check);
             }
             /* istanbul ignore else */
-            if (!safe) {
-                for (const column of Object.values(diff.removedColumns)) {
-                    this.helper.pushTableQuery(table, `alter table ${this.platform.quoteIdentifier(tableName)} drop column ${this.platform.quoteIdentifier(column.name)}`);
-                }
+            if (!safe && Object.values(diff.removedColumns).length > 0) {
+                this.helper.pushTableQuery(table, this.helper.getDropColumnsSQL(tableName, Object.values(diff.removedColumns), schemaName));
             }
         }));
         ret.push(this.createSchemaBuilder(schemaName).alterTable(tableName, table => {
@@ -365,8 +373,10 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 if (changedProperties.size === 1 && changedProperties.has('enumItems') && column.nativeEnumName) {
                     continue;
                 }
-                const col = this.helper.createTableColumn(table, column, diff.fromTable, changedProperties, true).alter();
-                this.helper.configureColumn(column, col, this.knex, changedProperties);
+                const col = this.helper.createTableColumn(table, column, diff.fromTable, changedProperties, true)?.alter();
+                if (col) {
+                    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, schemaName));
@@ -418,9 +428,10 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
      * creates new database and connects to it
      */
     async createDatabase(name) {
+        name ??= this.config.get('dbName');
         const sql = this.helper.getCreateDatabaseSQL('' + this.knex.ref(name));
         if (sql) {
-            await this.driver.execute(sql);
+            await this.execute(sql);
         }
         this.config.set('dbName', name);
         await this.driver.reconnect();
@@ -429,20 +440,34 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         name ??= this.config.get('dbName');
         this.config.set('dbName', this.helper.getManagementDbName());
         await this.driver.reconnect();
-        await this.driver.execute(this.helper.getDropDatabaseSQL('' + this.knex.ref(name)));
+        await this.execute(this.helper.getDropDatabaseSQL(name));
     }
     async execute(sql, options = {}) {
         options.wrap ??= false;
-        const lines = this.wrapSchema(sql, options).split('\n').filter(i => i.trim());
-        if (lines.length === 0) {
+        const lines = this.wrapSchema(sql, options).split('\n');
+        const groups = [];
+        let i = 0;
+        for (const line of lines) {
+            if (line.trim() === '') {
+                if (groups[i]?.length > 0) {
+                    i++;
+                }
+                continue;
+            }
+            groups[i] ??= [];
+            groups[i].push(line.trim());
+        }
+        if (groups.length === 0) {
             return;
         }
         if (this.platform.supportsMultipleStatements()) {
-            const query = lines.join('\n');
-            await this.driver.execute(query);
+            for (const group of groups) {
+                const query = group.join('\n');
+                await this.driver.execute(query);
+            }
             return;
         }
-        await core_1.Utils.runSerial(lines, line => this.driver.execute(line));
+        await core_1.Utils.runSerial(groups.flat(), line => this.driver.execute(line));
     }
     wrapSchema(sql, options) {
         options.wrap ??= this.options.disableForeignKeys;

package/typings.d.ts

@@ -1,5 +1,5 @@
+import type { DeferMode, CheckCallback, Dictionary, EntityProperty, GroupOperator, RawQueryFragment, QBFilterQuery, QueryOrderMap, Type, QueryFlag, AnyEntity, EntityName } from '@mikro-orm/core';
 import type { Knex } from 'knex';
-import type { CheckCallback, Dictionary, EntityProperty, GroupOperator, RawQueryFragment, QBFilterQuery, QueryOrderMap, Type, QueryFlag, AnyEntity, EntityName } from '@mikro-orm/core';
 import type { JoinType, QueryType } from './query/enums';
 import type { DatabaseSchema, DatabaseTable } from './schema';
 export interface Table {
@@ -57,6 +57,7 @@ export interface ForeignKey {
     referencedColumnNames: string[];
     updateRule?: string;
     deleteRule?: string;
+    deferMode?: DeferMode;
 }
 export interface IndexDef {
     columnNames: string[];