@mikro-orm/knex 6.1.13-dev.17 → 6.1.13-dev.19

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.1.13-dev.17",
+  "version": "6.1.13-dev.19",
   "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.17"
+    "@mikro-orm/core": "6.1.13-dev.19"
   }
 }

package/query/QueryBuilder.js

@@ -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/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;

package/schema/SchemaHelper.d.ts

@@ -27,6 +27,7 @@ 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;
     configureColumn(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;

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()) {
@@ -221,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);
@@ -341,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 => {
@@ -421,9 +419,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();
@@ -432,20 +431,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;