@mikro-orm/knex 6.1.13-dev.2 → 6.1.13-dev.21

package/AbstractSqlConnection.js

@@ -125,7 +125,13 @@ class AbstractSqlConnection extends core_1.Connection {
      */
     async loadFile(path) {
         const buf = await (0, fs_extra_1.readFile)(path);
-        await this.getKnex().raw(buf.toString());
+        try {
+            await this.getKnex().raw(buf.toString());
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            throw this.platform.getExceptionConverter().convertException(e);
+        }
     }
     createKnexClient(type) {
         const driverOptions = this.config.get('driverOptions');

package/AbstractSqlDriver.js

@@ -943,9 +943,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         if (tableAlias) {
             return prop.fieldNames.map(fieldName => {
-                const name = this.platform.quoteIdentifier(`${tableAlias}.${fieldName}`);
-                const alias = this.platform.quoteIdentifier(`${tableAlias}__${fieldName}`);
-                return (0, core_1.raw)(`${name} as ${alias}`);
+                return `${tableAlias}.${fieldName} as ${tableAlias}__${fieldName}`;
             });
         }
         return prop.fieldNames;
@@ -963,10 +961,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (args.ctx) {
             return 'write';
         }
-        else if (args.connectionType) {
+        if (args.connectionType) {
             return args.connectionType;
         }
-        else if (this.config.get('preferReadReplicas') === true) {
+        if (this.config.get('preferReadReplicas')) {
             return 'read';
         }
         return 'write';

package/index.mjs

@@ -56,6 +56,7 @@ export const DateType = mod.DateType;
 export const DeadlockException = mod.DeadlockException;
 export const DecimalType = mod.DecimalType;
 export const DefaultLogger = mod.DefaultLogger;
+export const DeferMode = mod.DeferMode;
 export const DoubleType = mod.DoubleType;
 export const DriverException = mod.DriverException;
 export const EagerProps = mod.EagerProps;

package/package.json

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

package/query/QueryBuilder.js

@@ -598,14 +598,14 @@ class QueryBuilder {
         if (!this.connectionType && method !== 'run' && [enums_1.QueryType.INSERT, enums_1.QueryType.UPDATE, enums_1.QueryType.DELETE, enums_1.QueryType.TRUNCATE].includes(this.type ?? enums_1.QueryType.SELECT)) {
             this.connectionType = 'write';
         }
+        if (!this.finalized && method === 'get' && this.type === enums_1.QueryType.SELECT) {
+            this.limit(1);
+        }
         const query = this.toQuery()._sql;
         const cached = await this.em?.tryCache(this.mainAlias.entityName, this._cache, ['qb.execute', query.sql, query.bindings, method]);
         if (cached?.data) {
             return cached.data;
         }
-        if (!this.finalized && method === 'get') {
-            this.limit(1);
-        }
         const write = method === 'run' || !this.platform.getConfig().get('preferReadReplicas');
         const type = this.connectionType || (write ? 'write' : 'read');
         const res = await this.driver.getConnection(type).execute(query.sql, query.bindings, method, this.context, this.loggerContext);
@@ -652,8 +652,8 @@ class QueryBuilder {
             (0, core_1.helper)(entity).__serializationContext.populate ??= hint;
             hint.forEach(hint => {
                 const [propName] = hint.field.split(':', 2);
-                const value = entity[propName];
-                if (core_1.Utils.isEntity(value, true)) {
+                const value = core_1.Reference.unwrapReference(entity[propName]);
+                if (core_1.Utils.isEntity(value)) {
                     (0, core_1.helper)(value).populated();
                     propagatePopulateHint(value, hint.children ?? []);
                 }
@@ -954,15 +954,19 @@ class QueryBuilder {
         /* istanbul ignore next */
         const requiresSQLConversion = meta?.props.filter(p => p.hasConvertToJSValueSQL && p.persist !== false) ?? [];
         if (this.flags.has(core_1.QueryFlag.CONVERT_CUSTOM_TYPES) && (fields.includes('*') || fields.includes(`${this.mainAlias.aliasName}.*`)) && requiresSQLConversion.length > 0) {
-            requiresSQLConversion.forEach(p => ret.push(this.helper.mapper(p.name, this.type)));
+            for (const p of requiresSQLConversion) {
+                ret.push(this.helper.mapper(p.name, this.type));
+            }
         }
-        Object.keys(this._populateMap).forEach(f => {
-            if (!fields.includes(f.replace(/#\w+$/, '')) && type === 'where') {
+        for (const f of Object.keys(this._populateMap)) {
+            if (type === 'where') {
                 const cols = this.helper.mapJoinColumns(this.type ?? enums_1.QueryType.SELECT, this._joins[f]);
-                ret.push(...cols);
+                for (const col of cols) {
+                    ret.push(col);
+                }
             }
-        });
-        return ret;
+        }
+        return core_1.Utils.unique(ret);
     }
     init(type, data, cond) {
         this.ensureNotFinalized();
@@ -1204,8 +1208,7 @@ class QueryBuilder {
                         // not perfect, but should work most of the time, ideally we should check only the alias (`... as alias`)
                         return field.sql.includes(prop);
                     }
-                    // not perfect, but should work most of the time, ideally we should check only the alias (`... as alias`)
-                    return field.toString().includes(prop);
+                    return false;
                 });
                 if (field instanceof core_1.RawQueryFragment) {
                     knexQuery.select(this.platform.formatQuery(field.sql, field.params));

package/schema/DatabaseTable.js

@@ -123,6 +123,9 @@ class DatabaseTable {
             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.deferMode) {
+                this.foreignKeys[constraintName].deferMode = prop.deferMode;
+            }
         }
         if (prop.index) {
             this.indexes.push({
@@ -473,6 +476,7 @@ class DatabaseTable {
         fkOptions.referencedColumnNames = fk.referencedColumnNames;
         fkOptions.updateRule = fk.updateRule?.toLowerCase();
         fkOptions.deleteRule = fk.deleteRule?.toLowerCase();
+        fkOptions.deferMode = fk.deferMode;
         fkOptions.columnTypes = fk.columnNames.map(c => this.getColumn(c).type);
         const columnOptions = {};
         if (fk.columnNames.length === 1) {
@@ -520,6 +524,7 @@ class DatabaseTable {
             fkOptions.referencedColumnNames = fk.referencedColumnNames;
             fkOptions.updateRule = fk.updateRule?.toLowerCase();
             fkOptions.deleteRule = fk.deleteRule?.toLowerCase();
+            fkOptions.deferMode = fk.deferMode;
         }
         return {
             name: prop,

package/schema/SchemaComparator.js

@@ -273,12 +273,19 @@ class SchemaComparator {
      */
     detectColumnRenamings(tableDifferences, inverseTableDiff) {
         const renameCandidates = {};
+        const oldFKs = Object.values(tableDifferences.fromTable.getForeignKeys());
+        const newFKs = Object.values(tableDifferences.toTable.getForeignKeys());
         for (const addedColumn of Object.values(tableDifferences.addedColumns)) {
             for (const removedColumn of Object.values(tableDifferences.removedColumns)) {
                 const diff = this.diffColumn(addedColumn, removedColumn);
                 if (diff.size !== 0) {
                     continue;
                 }
+                const wasFK = oldFKs.some(fk => fk.columnNames.includes(removedColumn.name));
+                const isFK = newFKs.some(fk => fk.columnNames.includes(addedColumn.name));
+                if (wasFK !== isFK) {
+                    continue;
+                }
                 const renamedColumn = inverseTableDiff?.renamedColumns[addedColumn.name];
                 if (renamedColumn && renamedColumn?.name !== removedColumn.name) {
                     continue;
@@ -348,6 +355,9 @@ class SchemaComparator {
         if (key1.referencedTableName !== key2.referencedTableName) {
             return true;
         }
+        if (key1.deferMode !== key2.deferMode) {
+            return true;
+        }
         const defaultRule = ['restrict', 'no action'];
         const rule = (key, method) => {
             return (key[method] ?? defaultRule[0]).toLowerCase().replace(defaultRule[1], defaultRule[0]);

package/schema/SchemaHelper.d.ts

@@ -27,8 +27,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;

package/schema/SchemaHelper.js

@@ -99,6 +99,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 +204,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 +226,11 @@ 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)}`;
     }
     getDatabaseExistsSQL(name) {
         return `select 1 from information_schema.schemata where schema_name = '${name}'`;

package/schema/SqlSchemaGenerator.d.ts

@@ -1,4 +1,4 @@
-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';
@@ -43,10 +43,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

@@ -118,7 +118,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);
@@ -272,6 +272,9 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         if (foreignKey.deleteRule) {
             builder.onDelete(foreignKey.deleteRule);
         }
+        if (foreignKey.deferMode) {
+            builder.deferrable(foreignKey.deferMode);
+        }
     }
     /**
      * We need to drop foreign keys first for all tables to allow dropping PK constraints.
@@ -338,10 +341,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 +366,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 +421,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 +433,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[];