@mikro-orm/knex 6.4.17-dev.9 → 6.4.17-dev.91

package/AbstractSqlConnection.d.ts

@@ -1,5 +1,5 @@
 import { type Knex } from 'knex';
-import { Connection, type AnyEntity, type Configuration, type ConnectionOptions, type EntityData, type IsolationLevel, type QueryResult, type Transaction, type TransactionEventBroadcaster, type LoggingOptions } from '@mikro-orm/core';
+import { Connection, type AnyEntity, type Configuration, type ConnectionOptions, type EntityData, type IsolationLevel, type QueryResult, type Transaction, type TransactionEventBroadcaster, type LogContext, type LoggingOptions } from '@mikro-orm/core';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform';
 export declare abstract class AbstractSqlConnection extends Connection {
     private static __patched;
@@ -33,15 +33,17 @@ export declare abstract class AbstractSqlConnection extends Connection {
         readOnly?: boolean;
         ctx?: Knex.Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
+        loggerContext?: LogContext;
     }): Promise<T>;
     begin(options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;
         ctx?: Knex.Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
+        loggerContext?: LogContext;
     }): Promise<Knex.Transaction>;
-    commit(ctx: Knex.Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
-    rollback(ctx: Knex.Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
+    commit(ctx: Knex.Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
+    rollback(ctx: Knex.Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: unknown[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
     /**
      * Execute raw SQL queries from file

package/AbstractSqlConnection.js

@@ -56,11 +56,11 @@ class AbstractSqlConnection extends core_1.Connection {
         const trx = await this.begin(options);
         try {
             const ret = await cb(trx);
-            await this.commit(trx, options.eventBroadcaster);
+            await this.commit(trx, options.eventBroadcaster, options.loggerContext);
             return ret;
         }
         catch (error) {
-            await this.rollback(trx, options.eventBroadcaster);
+            await this.rollback(trx, options.eventBroadcaster, options.loggerContext);
             throw error;
         }
     }
@@ -72,6 +72,19 @@ class AbstractSqlConnection extends core_1.Connection {
             isolationLevel: options.isolationLevel,
             readOnly: options.readOnly,
         });
+        if (options.ctx) {
+            const ctx = options.ctx;
+            ctx.index ??= 0;
+            const savepointName = `trx${ctx.index + 1}`;
+            Reflect.defineProperty(trx, 'index', { value: ctx.index + 1 });
+            Reflect.defineProperty(trx, 'savepointName', { value: savepointName });
+            this.logQuery(this.platform.getSavepointSQL(savepointName), options.loggerContext);
+        }
+        else {
+            for (const query of this.platform.getBeginTransactionSQL(options)) {
+                this.logQuery(query, options.loggerContext);
+            }
+        }
         if (!options.ctx) {
             await options.eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionStart, trx);
         }
@@ -80,23 +93,35 @@ class AbstractSqlConnection extends core_1.Connection {
         }
         return trx;
     }
-    async commit(ctx, eventBroadcaster) {
+    async commit(ctx, eventBroadcaster, loggerContext) {
         const runTrxHooks = isRootTransaction(ctx);
         if (runTrxHooks) {
             await eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionCommit, ctx);
         }
         ctx.commit();
         await ctx.executionPromise; // https://github.com/knex/knex/issues/3847#issuecomment-626330453
+        if ('savepointName' in ctx) {
+            this.logQuery(this.platform.getReleaseSavepointSQL(ctx.savepointName), loggerContext);
+        }
+        else {
+            this.logQuery(this.platform.getCommitTransactionSQL(), loggerContext);
+        }
         if (runTrxHooks) {
             await eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionCommit, ctx);
         }
     }
-    async rollback(ctx, eventBroadcaster) {
+    async rollback(ctx, eventBroadcaster, loggerContext) {
         const runTrxHooks = isRootTransaction(ctx);
         if (runTrxHooks) {
             await eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionRollback, ctx);
         }
         await ctx.rollback();
+        if ('savepointName' in ctx) {
+            this.logQuery(this.platform.getRollbackToSavepointSQL(ctx.savepointName), loggerContext);
+        }
+        else {
+            this.logQuery(this.platform.getRollbackTransactionSQL(), loggerContext);
+        }
         if (runTrxHooks) {
             await eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionRollback, ctx);
         }
@@ -107,7 +132,7 @@ class AbstractSqlConnection extends core_1.Connection {
             ctx ??= (queryOrKnex.client.transacting ? queryOrKnex : null);
             const q = queryOrKnex.toSQL();
             queryOrKnex = q.sql;
-            params = q.bindings;
+            params = q.bindings ?? [];
         }
         queryOrKnex = this.config.get('onQuery')(queryOrKnex, params);
         const formatted = this.platform.formatQuery(queryOrKnex, params);
@@ -141,11 +166,7 @@ class AbstractSqlConnection extends core_1.Connection {
             return driverOptions;
         }
         return (0, knex_1.knex)(this.getKnexOptions(type))
-            .on('query', data => {
-            if (!data.__knexQueryUid) {
-                this.logQuery(data.sql.toLowerCase().replace(/;$/, ''));
-            }
-        });
+            .on('query', data => data);
     }
     getKnexOptions(type) {
         const config = core_1.Utils.mergeConfig({

package/AbstractSqlDriver.js

@@ -333,6 +333,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (meta && !core_1.Utils.isEmpty(populate)) {
             this.buildFields(meta, populate, joinedProps, qb, qb.alias, options, true);
         }
+        if (options.em) {
+            await qb.applyJoinedFilters(options.em, options.filters);
+        }
         return this.rethrow(qb.getCount());
     }
     async nativeInsert(entityName, data, options = {}) {
@@ -340,7 +343,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const meta = this.metadata.find(entityName);
         const collections = this.extractManyToMany(entityName, data);
         const pks = meta?.primaryKeys ?? [this.config.getNamingStrategy().referenceColumnName()];
-        const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
+        const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
         const res = await this.rethrow(qb.insert(data).execute('run', false));
         res.row = res.row || {};
         let pk;
@@ -401,14 +404,14 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     value = this.mapDataToFieldNames(value, false, prop.embeddedProps, options.convertCustomTypes);
                 }
             }
-            if (options.convertCustomTypes && prop.customType) {
-                params.push(prop.customType.convertToDatabaseValue(value, this.platform, { key: prop.name, mode: 'query-data' }));
-                return;
-            }
             if (typeof value === 'undefined' && this.platform.usesDefaultKeyword()) {
                 params.push((0, core_1.raw)('default'));
                 return;
             }
+            if (options.convertCustomTypes && prop.customType) {
+                params.push(prop.customType.convertToDatabaseValue(value, this.platform, { key: prop.name, mode: 'query-data' }));
+                return;
+            }
             params.push(value);
         };
         if (fields.length > 0 || this.platform.usesDefaultKeyword()) {
@@ -467,7 +470,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (transform) {
             sql = transform(sql);
         }
-        const res = await this.execute(sql, params, 'run', options.ctx);
+        const res = await this.execute(sql, params, 'run', options.ctx, options.loggerContext);
         let pk;
         /* istanbul ignore next */
         if (pks.length > 1) { // owner has composite pk
@@ -495,7 +498,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             where = { [meta?.primaryKeys[0] ?? pks[0]]: where };
         }
         if (core_1.Utils.hasObjectKeys(data)) {
-            const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes)
+            const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext)
                 .withSchema(this.getSchemaName(meta, options));
             if (options.upsert) {
                 /* istanbul ignore next */
@@ -534,7 +537,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const meta = this.metadata.get(entityName);
         if (options.upsert) {
             const uniqueFields = options.onConflictFields ?? (core_1.Utils.isPlainObject(where[0]) ? Object.keys(where[0]).flatMap(key => core_1.Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
-            const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
+            const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
             const returning = (0, core_1.getOnConflictReturningFields)(meta, data[0], uniqueFields, options);
             qb.insert(data)
                 .onConflict(uniqueFields)
@@ -647,7 +650,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             /* istanbul ignore next */
             sql += returningFields.length > 0 ? ` returning ${returningFields.map(field => this.platform.quoteIdentifier(field)).join(', ')}` : '';
         }
-        const res = await this.rethrow(this.execute(sql, params, 'run', options.ctx));
+        const res = await this.rethrow(this.execute(sql, params, 'run', options.ctx, options.loggerContext));
         for (let i = 0; i < collections.length; i++) {
             await this.processManyToMany(meta, where[i], collections[i], false, options);
         }
@@ -659,7 +662,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (core_1.Utils.isPrimaryKey(where) && pks.length === 1) {
             where = { [pks[0]]: where };
         }
-        const qb = this.createQueryBuilder(entityName, options.ctx, 'write', false).delete(where).withSchema(this.getSchemaName(meta, options));
+        const qb = this.createQueryBuilder(entityName, options.ctx, 'write', false, options.loggerContext).delete(where).withSchema(this.getSchemaName(meta, options));
         return this.rethrow(qb.execute('run', false));
     }
     /**
@@ -747,7 +750,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 schema = this.config.get('schema');
             }
             const tableName = `${schema ?? '_'}.${pivotMeta.tableName}`;
-            const persister = groups[tableName] ??= new PivotCollectionPersister_1.PivotCollectionPersister(pivotMeta, this, options?.ctx, schema);
+            const persister = groups[tableName] ??= new PivotCollectionPersister_1.PivotCollectionPersister(pivotMeta, this, options?.ctx, schema, options?.loggerContext);
             persister.enqueueUpdate(coll.property, insertDiff, deleteDiff, pks);
         }
         for (const persister of core_1.Utils.values(groups)) {
@@ -755,112 +758,64 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
     }
     async loadFromPivotTable(prop, owners, where = {}, orderBy, ctx, options, pivotJoin) {
+        if (owners.length === 0) {
+            return {};
+        }
         const pivotMeta = this.metadata.find(prop.pivotEntity);
         const pivotProp1 = pivotMeta.relations[prop.owner ? 1 : 0];
         const pivotProp2 = pivotMeta.relations[prop.owner ? 0 : 1];
         const ownerMeta = this.metadata.find(pivotProp2.type);
-        options = { ...options };
-        const qb = this.createQueryBuilder(prop.pivotEntity, ctx, options.connectionType, undefined, options?.logging)
-            .withSchema(this.getSchemaName(pivotMeta, options))
-            .indexHint(options.indexHint)
-            .comment(options.comments)
-            .hintComment(options.hintComments);
-        const pivotAlias = qb.alias;
-        const pivotKey = pivotProp2.joinColumns.map(column => `${pivotAlias}.${column}`).join(core_1.Utils.PK_SEPARATOR);
         const cond = {
-            [pivotKey]: { $in: ownerMeta.compositePK ? owners : owners.map(o => o[0]) },
+            [pivotProp2.name]: { $in: ownerMeta.compositePK ? owners : owners.map(o => o[0]) },
         };
-        /* istanbul ignore if */
-        if (!core_1.Utils.isEmpty(where) && Object.keys(where).every(k => core_1.Utils.isOperator(k, false))) {
-            where = cond;
-        }
-        else {
-            where = { ...where, ...cond };
-        }
-        orderBy = this.getPivotOrderBy(prop, pivotProp1, pivotAlias, orderBy);
-        const populate = this.autoJoinOneToOneOwner(prop.targetMeta, []);
-        const fields = [];
-        const k1 = !prop.owner ? 'joinColumns' : 'inverseJoinColumns';
-        const k2 = prop.owner ? 'joinColumns' : 'inverseJoinColumns';
-        const cols = [
-            ...prop[k1].map(col => `${pivotAlias}.${col} as fk__${col}`),
-            ...prop[k2].map(col => `${pivotAlias}.${col} as fk__${col}`),
-        ];
-        fields.push(...cols);
-        if (!pivotJoin) {
-            const targetAlias = qb.getNextAlias(prop.targetMeta.tableName);
-            const targetSchema = this.getSchemaName(prop.targetMeta, options) ?? this.platform.getDefaultSchemaName();
-            qb.innerJoin(pivotProp1.name, targetAlias, {}, targetSchema);
-            const targetFields = this.buildFields(prop.targetMeta, (options.populate ?? []), [], qb, targetAlias, options);
-            const additionalFields = [];
-            for (const field of targetFields) {
-                const f = field.toString();
-                additionalFields.push(f.includes('.') ? field : `${targetAlias}.${f}`);
-                if (core_1.RawQueryFragment.isKnownFragment(field)) {
-                    qb.rawFragments.add(f);
-                }
-            }
-            fields.unshift(...additionalFields);
-            // we need to handle 1:1 owner auto-joins explicitly, as the QB type is the pivot table, not the target
-            populate.forEach(hint => {
-                const alias = qb.getNextAlias(prop.targetMeta.tableName);
-                qb.leftJoin(`${targetAlias}.${hint.field}`, alias);
-                // eslint-disable-next-line dot-notation
-                for (const join of Object.values(qb['_joins'])) {
-                    const [propName] = hint.field.split(':', 2);
-                    if (join.alias === alias && join.prop.name === propName) {
-                        fields.push(...qb.helper.mapJoinColumns(qb.type, join));
-                    }
-                }
-            });
-        }
-        qb.select(fields)
-            .where({ [pivotProp1.name]: where })
-            .orderBy(orderBy)
-            .setLockMode(options.lockMode, options.lockTableAliases);
-        if (owners.length === 1 && (options.offset != null || options.limit != null)) {
-            qb.limit(options.limit, options.offset);
-        }
-        const res = owners.length ? await this.rethrow(qb.execute('all', { mergeResults: false, mapResults: false })) : [];
-        const tmp = {};
-        const items = res.map((row) => {
-            const root = super.mapResult(row, prop.targetMeta);
-            this.mapJoinedProps(root, prop.targetMeta, populate, qb, root, tmp, pivotMeta.className + '.' + pivotProp1.name);
-            return root;
+        if (!core_1.Utils.isEmpty(where)) {
+            cond[pivotProp1.name] = { ...where };
+        }
+        where = cond;
+        const populateField = pivotJoin ? `${pivotProp1.name}:ref` : pivotProp1.name;
+        const populate = this.autoJoinOneToOneOwner(prop.targetMeta, options?.populate ?? [], options?.fields);
+        const childFields = !core_1.Utils.isEmpty(options?.fields) ? options.fields.map(f => `${pivotProp1.name}.${f}`) : [];
+        const childExclude = !core_1.Utils.isEmpty(options?.exclude) ? options.exclude.map(f => `${pivotProp1.name}.${f}`) : [];
+        const fields = pivotJoin
+            ? [pivotProp1.name, pivotProp2.name]
+            : [pivotProp1.name, pivotProp2.name, ...childFields];
+        const res = await this.find(pivotMeta.className, where, {
+            ctx,
+            ...options,
+            fields,
+            exclude: childExclude,
+            orderBy: this.getPivotOrderBy(prop, pivotProp1, orderBy, options?.orderBy),
+            populate: [{ field: populateField, strategy: core_1.LoadStrategy.JOINED, joinType: query_1.JoinType.innerJoin, children: populate }],
+            populateWhere: undefined,
+            // @ts-ignore
+            _populateWhere: 'infer',
+            populateFilter: !core_1.Utils.isEmpty(options?.populateFilter) ? { [pivotProp2.name]: options?.populateFilter } : undefined,
         });
-        qb.clearRawFragmentsCache();
         const map = {};
-        const pkProps = ownerMeta.getPrimaryProps();
         for (const owner of owners) {
-            const key = core_1.Utils.getPrimaryKeyHash(prop.joinColumns.map((_col, idx) => {
-                const pkProp = pkProps[idx];
-                return pkProp.customType ? pkProp.customType.convertToJSValue(owner[idx], this.platform) : owner[idx];
-            }));
+            const key = core_1.Utils.getPrimaryKeyHash(owner);
             map[key] = [];
         }
-        for (const item of items) {
-            const key = core_1.Utils.getPrimaryKeyHash(prop.joinColumns.map((col, idx) => {
-                const pkProp = pkProps[idx];
-                return pkProp.customType ? pkProp.customType.convertToJSValue(item[`fk__${col}`], this.platform) : item[`fk__${col}`];
-            }));
-            map[key].push(item);
-            prop.joinColumns.forEach(col => delete item[`fk__${col}`]);
-            prop.inverseJoinColumns.forEach((col, idx) => {
-                core_1.Utils.renameKey(item, `fk__${col}`, prop.targetMeta.primaryKeys[idx]);
-            });
+        for (const item of res) {
+            const key = core_1.Utils.getPrimaryKeyHash(core_1.Utils.asArray(item[pivotProp2.name]));
+            map[key].push(item[pivotProp1.name]);
         }
         return map;
     }
-    getPivotOrderBy(prop, pivotProp, pivotAlias, orderBy) {
-        // FIXME this is ignoring the rest of the array items
+    getPivotOrderBy(prop, pivotProp, orderBy, parentOrderBy) {
         if (!core_1.Utils.isEmpty(orderBy)) {
-            return [{ [pivotProp.name]: core_1.Utils.asArray(orderBy)[0] }];
+            return core_1.Utils.asArray(orderBy).map(o => ({ [pivotProp.name]: o }));
+        }
+        if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && core_1.Utils.asArray(parentOrderBy).some(o => o[prop.name])) {
+            return core_1.Utils.asArray(parentOrderBy)
+                .filter(o => o[prop.name])
+                .map(o => ({ [pivotProp.name]: o[prop.name] }));
         }
         if (!core_1.Utils.isEmpty(prop.orderBy)) {
-            return [{ [pivotProp.name]: core_1.Utils.asArray(prop.orderBy)[0] }];
+            return core_1.Utils.asArray(prop.orderBy).map(o => ({ [pivotProp.name]: o }));
         }
         if (prop.fixedOrder) {
-            return [{ [`${pivotAlias}.${prop.fixedOrderColumn}`]: core_1.QueryOrder.ASC }];
+            return [{ [prop.fixedOrderColumn]: core_1.QueryOrder.ASC }];
         }
         return [];
     }
@@ -878,7 +833,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const toPopulate = meta.relations
             .filter(prop => prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner && !prop.lazy && !relationsToPopulate.includes(prop.name))
             .filter(prop => fields.length === 0 || fields.some(f => prop.name === f || prop.name.startsWith(`${String(f)}.`)))
-            .map(prop => ({ field: `${prop.name}:ref`, strategy: prop.strategy }));
+            .map(prop => ({ field: `${prop.name}:ref`, strategy: core_1.LoadStrategy.JOINED }));
         return [...populate, ...toPopulate];
     }
     /**
@@ -886,16 +841,17 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
      */
     joinedProps(meta, populate, options) {
         return populate.filter(hint => {
-            const [propName, ref] = hint.field.split(':', 2);
+            const [propName] = hint.field.split(':', 2);
             const prop = meta.properties[propName] || {};
-            if (hint.filter && hint.strategy === core_1.LoadStrategy.JOINED) {
+            const strategy = (0, core_1.getLoadingStrategy)(hint.strategy || prop.strategy || options?.strategy || this.config.get('loadStrategy'), prop.kind);
+            if (hint.filter && [core_1.ReferenceKind.ONE_TO_ONE, core_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind) && !prop.nullable) {
                 return true;
             }
             // skip redundant joins for 1:1 owner population hints when using `mapToPk`
             if (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && prop.mapToPk && prop.owner) {
                 return false;
             }
-            if ((options?.strategy || hint.strategy || prop.strategy || this.config.get('loadStrategy')) !== core_1.LoadStrategy.JOINED) {
+            if (strategy !== core_1.LoadStrategy.JOINED) {
                 // force joined strategy for explicit 1:1 owner populate hint as it would require a join anyway
                 return prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner;
             }
@@ -906,31 +862,26 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
      * @internal
      */
     mergeJoinedResult(rawResults, meta, joinedProps) {
+        if (rawResults.length <= 1) {
+            return rawResults;
+        }
         const res = [];
         const map = {};
+        const collectionsToMerge = {};
+        const hints = joinedProps.map(hint => {
+            const [propName, ref] = hint.field.split(':', 2);
+            return { propName, ref, children: hint.children };
+        });
         for (const item of rawResults) {
             const pk = core_1.Utils.getCompositeKeyHash(item, meta);
             if (map[pk]) {
-                for (const hint of joinedProps) {
-                    const [propName, ref] = hint.field.split(':', 2);
-                    const prop = meta.properties[propName];
+                for (const { propName } of hints) {
                     if (!item[propName]) {
                         continue;
                     }
-                    if ([core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind) && ref) {
-                        map[pk][propName] = [...map[pk][propName], ...item[propName]];
-                        continue;
-                    }
-                    switch (prop.kind) {
-                        case core_1.ReferenceKind.ONE_TO_MANY:
-                        case core_1.ReferenceKind.MANY_TO_MANY:
-                            map[pk][propName] = this.mergeJoinedResult([...map[pk][propName], ...item[propName]], prop.targetMeta, hint.children ?? []);
-                            break;
-                        case core_1.ReferenceKind.MANY_TO_ONE:
-                        case core_1.ReferenceKind.ONE_TO_ONE:
-                            map[pk][propName] = this.mergeJoinedResult([map[pk][propName], item[propName]], prop.targetMeta, hint.children ?? [])[0];
-                            break;
-                    }
+                    collectionsToMerge[pk] ??= {};
+                    collectionsToMerge[pk][propName] ??= [map[pk][propName]];
+                    collectionsToMerge[pk][propName].push(item[propName]);
                 }
             }
             else {
@@ -938,6 +889,31 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 res.push(item);
             }
         }
+        for (const pk in collectionsToMerge) {
+            const entity = map[pk];
+            const collections = collectionsToMerge[pk];
+            for (const { propName, ref, children } of hints) {
+                if (!collections[propName]) {
+                    continue;
+                }
+                const prop = meta.properties[propName];
+                const items = collections[propName].flat();
+                if ([core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind) && ref) {
+                    entity[propName] = items;
+                    continue;
+                }
+                switch (prop.kind) {
+                    case core_1.ReferenceKind.ONE_TO_MANY:
+                    case core_1.ReferenceKind.MANY_TO_MANY:
+                        entity[propName] = this.mergeJoinedResult(items, prop.targetMeta, children ?? []);
+                        break;
+                    case core_1.ReferenceKind.MANY_TO_ONE:
+                    case core_1.ReferenceKind.ONE_TO_ONE:
+                        entity[propName] = this.mergeJoinedResult(items, prop.targetMeta, children ?? [])[0];
+                        break;
+                }
+            }
+        }
         return res;
     }
     getFieldsForJoinedLoad(qb, meta, explicitFields, exclude, populate = [], options, parentTableAlias, parentJoinPath, count) {
@@ -964,7 +940,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName];
             // ignore ref joins of known FKs unless it's a filter hint
-            if (ref && !hint.filter && (prop.kind === core_1.ReferenceKind.MANY_TO_ONE || (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner))) {
+            if (ref && !hint.filter && (prop.kind === core_1.ReferenceKind.MANY_TO_ONE || (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && prop.owner))) {
                 continue;
             }
             if (count && (!options?.populateFilter || !options.populateFilter[prop.name])) {
@@ -978,11 +954,14 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             if (!parentJoinPath && populateWhereAll && !hint.filter && !path.startsWith('[populate]')) {
                 path = '[populate]' + path;
             }
+            const mandatoryToOneProperty = [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.nullable;
             const joinType = pivotRefJoin
                 ? query_1.JoinType.pivotJoin
-                : hint.filter && !prop.nullable
-                    ? query_1.JoinType.innerJoin
-                    : query_1.JoinType.leftJoin;
+                : hint.joinType
+                    ? hint.joinType
+                    : (hint.filter && !prop.nullable) || mandatoryToOneProperty
+                        ? query_1.JoinType.innerJoin
+                        : query_1.JoinType.leftJoin;
             qb.join(field, tableAlias, {}, joinType, path);
             if (pivotRefJoin) {
                 fields.push(...prop.joinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)), ...prop.inverseJoinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
@@ -1000,7 +979,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             if (!ref && !prop.mapToPk) {
                 fields.push(...this.getFieldsForJoinedLoad(qb, meta2, childExplicitFields.length === 0 ? undefined : childExplicitFields, childExclude, hint.children, options, tableAlias, path, count));
             }
-            else if (hint.filter || prop.mapToPk) {
+            else if (hint.filter || prop.mapToPk || (ref && [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind))) {
                 fields.push(...prop.referencedColumnNames.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
             }
         }
@@ -1078,7 +1057,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         for (const prop of meta.relations) {
             if (collections[prop.name]) {
                 const pivotMeta = this.metadata.find(prop.pivotEntity);
-                const persister = new PivotCollectionPersister_1.PivotCollectionPersister(pivotMeta, this, options?.ctx, options?.schema);
+                const persister = new PivotCollectionPersister_1.PivotCollectionPersister(pivotMeta, this, options?.ctx, options?.schema, options?.loggerContext);
                 persister.enqueueUpdate(prop, collections[prop.name], clear, pks);
                 await this.rethrow(persister.execute());
             }
@@ -1145,7 +1124,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 let path = parentPath;
                 const meta2 = this.metadata.find(prop.type);
                 const childOrder = orderHint[prop.name];
-                if (![core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) || !prop.owner || core_1.Utils.isPlainObject(childOrder)) {
+                if (prop.kind !== core_1.ReferenceKind.SCALAR && (![core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) || !prop.owner || core_1.Utils.isPlainObject(childOrder))) {
                     path += `.${propName}`;
                 }
                 if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && typeof childOrder !== 'object') {
@@ -1153,10 +1132,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 }
                 const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
                 const propAlias = qb.getAliasForJoinPath(join ?? path, { matchPopulateJoins: true }) ?? parentAlias;
-                if (!join && parentAlias === qb.alias) {
+                if (!join) {
                     continue;
                 }
-                if (![core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.EMBEDDED].includes(prop.kind) && typeof childOrder === 'object') {
+                if (join && ![core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.EMBEDDED].includes(prop.kind) && typeof childOrder === 'object') {
                     const children = this.buildPopulateOrderBy(qb, meta2, core_1.Utils.asArray(childOrder), path, explicit, propAlias);
                     orderBy.push(...children);
                     continue;
@@ -1311,16 +1290,19 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             ret.push('*');
         }
         if (ret.length > 0 && !hasExplicitFields && addFormulas) {
-            meta.props
-                .filter(prop => prop.formula && !lazyProps.includes(prop))
-                .forEach(prop => {
-                const a = this.platform.quoteIdentifier(alias);
-                const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
-                ret.push((0, core_1.raw)(`${prop.formula(a)} as ${aliased}`));
-            });
-            meta.props
-                .filter(prop => !prop.object && (prop.hasConvertToDatabaseValueSQL || prop.hasConvertToJSValueSQL))
-                .forEach(prop => ret.push(prop.name));
+            for (const prop of meta.props) {
+                if (lazyProps.includes(prop)) {
+                    continue;
+                }
+                if (prop.formula) {
+                    const a = this.platform.quoteIdentifier(alias);
+                    const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
+                    ret.push((0, core_1.raw)(`${prop.formula(a)} as ${aliased}`));
+                }
+                if (!prop.object && (prop.hasConvertToDatabaseValueSQL || prop.hasConvertToJSValueSQL)) {
+                    ret.push(prop.name);
+                }
+            }
         }
         // add joined relations after the root entity fields
         if (joinedProps.length > 0) {

package/AbstractSqlPlatform.d.ts

@@ -1,4 +1,4 @@
-import { Platform, type Constructor, type EntityManager, type EntityRepository, type IDatabaseDriver, type MikroORM } from '@mikro-orm/core';
+import { Platform, type Constructor, type EntityManager, type EntityRepository, type IDatabaseDriver, type MikroORM, type IsolationLevel } from '@mikro-orm/core';
 import { SqlSchemaGenerator, type SchemaHelper } from './schema';
 import type { IndexDef } from './typings';
 export declare abstract class AbstractSqlPlatform extends Platform {
@@ -10,6 +10,15 @@ export declare abstract class AbstractSqlPlatform extends Platform {
     /** @inheritDoc */
     lookupExtensions(orm: MikroORM): void;
     getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): SqlSchemaGenerator;
+    getBeginTransactionSQL(options?: {
+        isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
+    }): string[];
+    getCommitTransactionSQL(): string;
+    getRollbackTransactionSQL(): string;
+    getSavepointSQL(savepointName: string): string;
+    getRollbackToSavepointSQL(savepointName: string): string;
+    getReleaseSavepointSQL(savepointName: string): string;
     quoteValue(value: any): string;
     escape(value: any): string;
     getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string;

package/AbstractSqlPlatform.js

@@ -27,6 +27,27 @@ class AbstractSqlPlatform extends core_1.Platform {
     getSchemaGenerator(driver, em) {
         return new schema_1.SqlSchemaGenerator(em ?? driver);
     }
+    getBeginTransactionSQL(options) {
+        if (options?.isolationLevel) {
+            return [`set transaction isolation level ${options.isolationLevel}`, 'begin'];
+        }
+        return ['begin'];
+    }
+    getCommitTransactionSQL() {
+        return 'commit';
+    }
+    getRollbackTransactionSQL() {
+        return 'rollback';
+    }
+    getSavepointSQL(savepointName) {
+        return `savepoint ${this.quoteIdentifier(savepointName)}`;
+    }
+    getRollbackToSavepointSQL(savepointName) {
+        return `rollback to savepoint ${this.quoteIdentifier(savepointName)}`;
+    }
+    getReleaseSavepointSQL(savepointName) {
+        return `release savepoint ${this.quoteIdentifier(savepointName)}`;
+    }
     quoteValue(value) {
         if (core_1.Utils.isRawSql(value)) {
             return this.formatQuery(value.sql, value.params ?? []);

package/PivotCollectionPersister.d.ts

@@ -1,16 +1,17 @@
-import { type EntityMetadata, type EntityProperty, type Primary, type Transaction } from '@mikro-orm/core';
+import { type Dictionary, type EntityMetadata, type EntityProperty, type Primary, type Transaction } from '@mikro-orm/core';
 import { type AbstractSqlDriver } from './AbstractSqlDriver';
 export declare class PivotCollectionPersister<Entity extends object> {
     private readonly meta;
     private readonly driver;
     private readonly ctx?;
     private readonly schema?;
+    private readonly loggerContext?;
     private readonly platform;
     private readonly inserts;
     private readonly deletes;
     private readonly batchSize;
     private order;
-    constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: Transaction | undefined, schema?: string | undefined);
+    constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: Transaction | undefined, schema?: string | undefined, loggerContext?: Dictionary | undefined);
     enqueueUpdate(prop: EntityProperty<Entity>, insertDiff: Primary<Entity>[][], deleteDiff: Primary<Entity>[][] | boolean, pks: Primary<Entity>[]): void;
     private enqueueInsert;
     private enqueueDelete;

package/PivotCollectionPersister.js

@@ -41,16 +41,18 @@ class PivotCollectionPersister {
     driver;
     ctx;
     schema;
+    loggerContext;
     platform;
     inserts = new Map();
     deletes = new Map();
     batchSize;
     order = 0;
-    constructor(meta, driver, ctx, schema) {
+    constructor(meta, driver, ctx, schema, loggerContext) {
         this.meta = meta;
         this.driver = driver;
         this.ctx = ctx;
         this.schema = schema;
+        this.loggerContext = loggerContext;
         this.platform = this.driver.getPlatform();
         this.batchSize = this.driver.config.get('batchSize');
     }
@@ -102,6 +104,7 @@ class PivotCollectionPersister {
                 await this.driver.nativeDelete(this.meta.className, cond, {
                     ctx: this.ctx,
                     schema: this.schema,
+                    loggerContext: this.loggerContext,
                 });
             }
         }
@@ -122,12 +125,13 @@ class PivotCollectionPersister {
                     schema: this.schema,
                     convertCustomTypes: false,
                     processCollections: false,
+                    loggerContext: this.loggerContext,
                 });
             }
         }
         else {
             await core_1.Utils.runSerial(items, item => {
-                return this.driver.createQueryBuilder(this.meta.className, this.ctx, 'write')
+                return this.driver.createQueryBuilder(this.meta.className, this.ctx, 'write', false, this.loggerContext)
                     .withSchema(this.schema)
                     .insert(item)
                     .execute('run', false);

package/README.md

@@ -11,7 +11,6 @@ TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-or
 [![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
 [![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
-[![Maintainability](https://api.codeclimate.com/v1/badges/27999651d3adc47cfa40/maintainability)](https://codeclimate.com/github/mikro-orm/mikro-orm/maintainability)
 [![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
 
 ## 🤔 Unit of What?
@@ -141,7 +140,7 @@ There is also auto-generated [CHANGELOG.md](CHANGELOG.md) file based on commit m
 - [Composite and Foreign Keys as Primary Key](https://mikro-orm.io/docs/composite-keys)
 - [Filters](https://mikro-orm.io/docs/filters)
 - [Using `QueryBuilder`](https://mikro-orm.io/docs/query-builder)
-- [Preloading Deeply Nested Structures via populate](https://mikro-orm.io/docs/nested-populate)
+- [Populating relations](https://mikro-orm.io/docs/populating-relations)
 - [Property Validation](https://mikro-orm.io/docs/property-validation)
 - [Lifecycle Hooks](https://mikro-orm.io/docs/events#hooks)
 - [Vanilla JS Support](https://mikro-orm.io/docs/usage-with-js)

package/dialects/mysql/MySqlPlatform.d.ts

@@ -1,4 +1,4 @@
-import { type SimpleColumnMeta, type Type, type TransformContext } from '@mikro-orm/core';
+import { type SimpleColumnMeta, type Type, type TransformContext, type IsolationLevel } from '@mikro-orm/core';
 import { MySqlSchemaHelper } from './MySqlSchemaHelper';
 import { MySqlExceptionConverter } from './MySqlExceptionConverter';
 import { AbstractSqlPlatform } from '../../AbstractSqlPlatform';
@@ -13,6 +13,10 @@ export declare class MySqlPlatform extends AbstractSqlPlatform {
         readonly "desc nulls last": "is null";
     };
     getDefaultCharset(): string;
+    getBeginTransactionSQL(options?: {
+        isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
+    }): string[];
     convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
     getJsonIndexDefinition(index: IndexDef): string[];
     getBooleanTypeDeclarationSQL(): string;

package/dialects/mysql/MySqlPlatform.js

@@ -17,6 +17,20 @@ class MySqlPlatform extends AbstractSqlPlatform_1.AbstractSqlPlatform {
     getDefaultCharset() {
         return 'utf8mb4';
     }
+    getBeginTransactionSQL(options) {
+        if (options?.isolationLevel || options?.readOnly) {
+            const parts = [];
+            if (options.isolationLevel) {
+                parts.push(`isolation level ${options.isolationLevel}`);
+            }
+            if (options.readOnly) {
+                parts.push('read only');
+            }
+            const sql = `set transaction ${parts.join(', ')}`;
+            return [sql, 'begin'];
+        }
+        return ['begin'];
+    }
     convertJsonToDatabaseValue(value, context) {
         if (context?.mode === 'query') {
             return value;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -204,7 +204,14 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
                 col.defaultTo(null);
             }
             else {
-                col.defaultTo(knex.raw(column.default + (column.extra ? ' ' + column.extra : '')));
+                const columnType = column.type.toLowerCase();
+                // https://dev.mysql.com/doc/refman/9.0/en/data-type-defaults.html
+                const needsExpression = ['blob', 'text', 'json', 'point', 'linestring', 'polygon', 'multipoint', 'multilinestring', 'multipolygon', 'geometrycollection'].some(type => columnType.startsWith(type));
+                let defaultSql = needsExpression && !column.default.startsWith('(') ? `(${column.default})` : column.default;
+                if (column.extra) {
+                    defaultSql += ' ' + column.extra;
+                }
+                col.defaultTo(knex.raw(defaultSql));
             }
         }
         return col;

package/dialects/sqlite/BaseSqlitePlatform.d.ts

@@ -1,4 +1,4 @@
-import { type EntityProperty } from '@mikro-orm/core';
+import { type EntityProperty, type IsolationLevel } from '@mikro-orm/core';
 import { AbstractSqlPlatform } from '../../AbstractSqlPlatform';
 export declare abstract class BaseSqlitePlatform extends AbstractSqlPlatform {
     usesDefaultKeyword(): boolean;
@@ -7,6 +7,10 @@ export declare abstract class BaseSqlitePlatform extends AbstractSqlPlatform {
     getDateTimeTypeDeclarationSQL(column: {
         length: number;
     }): string;
+    getBeginTransactionSQL(options?: {
+        isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
+    }): string[];
     getEnumTypeDeclarationSQL(column: {
         items?: unknown[];
         fieldNames: string[];

package/dialects/sqlite/BaseSqlitePlatform.js

@@ -16,6 +16,9 @@ class BaseSqlitePlatform extends AbstractSqlPlatform_1.AbstractSqlPlatform {
     getDateTimeTypeDeclarationSQL(column) {
         return 'datetime';
     }
+    getBeginTransactionSQL(options) {
+        return ['begin'];
+    }
     getEnumTypeDeclarationSQL(column) {
         if (column.items?.every(item => core_1.Utils.isString(item))) {
             return 'text';

package/index.mjs

@@ -219,12 +219,16 @@ export const compareBuffers = mod.compareBuffers;
 export const compareObjects = mod.compareObjects;
 export const createSqlFunction = mod.createSqlFunction;
 export const defineConfig = mod.defineConfig;
+export const defineEntity = mod.defineEntity;
 export const equals = mod.equals;
+export const expandDotPaths = mod.expandDotPaths;
+export const getLoadingStrategy = mod.getLoadingStrategy;
 export const getOnConflictFields = mod.getOnConflictFields;
 export const getOnConflictReturningFields = mod.getOnConflictReturningFields;
 export const helper = mod.helper;
 export const knex = mod.knex;
 export const parseJsonSafe = mod.parseJsonSafe;
+export const quote = mod.quote;
 export const raw = mod.raw;
 export const ref = mod.ref;
 export const rel = mod.rel;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.4.17-dev.9",
+  "version": "6.4.17-dev.91",
   "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",
@@ -58,7 +58,7 @@
     "access": "public"
   },
   "dependencies": {
-    "fs-extra": "11.3.0",
+    "fs-extra": "11.3.1",
     "knex": "3.1.0",
     "sqlstring": "2.3.3"
   },
@@ -66,7 +66,7 @@
     "@mikro-orm/core": "^6.4.16"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.4.17-dev.9",
+    "@mikro-orm/core": "6.4.17-dev.91",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/query/CriteriaNode.js

@@ -69,7 +69,7 @@ class CriteriaNode {
         }
     }
     renameFieldToPK(qb) {
-        let joinAlias = qb.getAliasForJoinPath(this.getPath());
+        let joinAlias = qb.getAliasForJoinPath(this.getPath(), { matchPopulateJoins: true });
         if (!joinAlias && this.parent && [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(this.prop.kind) && this.prop.owner) {
             joinAlias = qb.getAliasForJoinPath(this.parent.getPath());
             return core_1.Utils.getPrimaryKeyHash(this.prop.joinColumns.map(col => `${joinAlias ?? qb.alias}.${col}`));

package/query/CriteriaNodeFactory.js

@@ -49,13 +49,14 @@ class CriteriaNodeFactory {
     static createObjectItemNode(metadata, entityName, node, payload, key, meta) {
         const prop = meta?.properties[key];
         const childEntity = prop && prop.kind !== core_1.ReferenceKind.SCALAR ? prop.type : entityName;
-        if (prop?.customType instanceof core_1.JsonType) {
+        const isNotEmbedded = prop?.kind !== core_1.ReferenceKind.EMBEDDED;
+        if (isNotEmbedded && prop?.customType instanceof core_1.JsonType) {
             return this.createScalarNode(metadata, childEntity, payload[key], node, key);
         }
         if (prop?.kind === core_1.ReferenceKind.SCALAR && payload[key] != null && Object.keys(payload[key]).some(f => core_1.Utils.isGroupOperator(f))) {
             throw core_1.ValidationError.cannotUseGroupOperatorsInsideScalars(entityName, prop.name, payload);
         }
-        if (prop?.kind !== core_1.ReferenceKind.EMBEDDED) {
+        if (isNotEmbedded) {
             return this.createNode(metadata, childEntity, payload[key], node, key);
         }
         if (payload[key] == null) {
@@ -72,11 +73,12 @@ class CriteriaNodeFactory {
             throw core_1.ValidationError.cannotUseOperatorsInsideEmbeddables(entityName, prop.name, payload);
         }
         const map = Object.keys(payload[key]).reduce((oo, k) => {
-            if (!prop.embeddedProps[k] && !allowedOperators.includes(k)) {
+            const embeddedProp = prop.embeddedProps[k] ?? Object.values(prop.embeddedProps).find(p => p.name === k);
+            if (!embeddedProp && !allowedOperators.includes(k)) {
                 throw core_1.ValidationError.invalidEmbeddableQuery(entityName, k, prop.type);
             }
-            if (prop.embeddedProps[k]) {
-                oo[prop.embeddedProps[k].name] = payload[key][k];
+            if (embeddedProp) {
+                oo[embeddedProp.name] = payload[key][k];
             }
             else if (typeof payload[key][k] === 'object') {
                 oo[k] = JSON.stringify(payload[key][k]);

package/query/ObjectCriteriaNode.js

@@ -9,7 +9,8 @@ const enums_1 = require("./enums");
  */
 class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
     process(qb, options) {
-        const nestedAlias = qb.getAliasForJoinPath(this.getPath(), options);
+        const matchPopulateJoins = options?.matchPopulateJoins || (this.prop && [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
+        const nestedAlias = qb.getAliasForJoinPath(this.getPath(), { ...options, matchPopulateJoins });
         const ownerAlias = options?.alias || qb.alias;
         const keys = Object.keys(this.payload);
         let alias = options?.alias;
@@ -209,7 +210,23 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
         }
         else {
             const prev = qb._fields?.slice();
-            qb[method](field, nestedAlias, undefined, enums_1.JoinType.leftJoin, path);
+            const toOneProperty = [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(this.prop.kind);
+            const joinType = toOneProperty && !this.prop.nullable
+                ? enums_1.JoinType.innerJoin
+                : enums_1.JoinType.leftJoin;
+            qb[method](field, nestedAlias, undefined, joinType, path);
+            // if the property is nullable, we need to use left join, so we mimic the inner join behaviour
+            // with an exclusive condition on the join columns:
+            // - if the owning column is null, the row is missing, we don't apply the filter
+            // - if the target column is not null, the row is matched, we apply the filter
+            if (toOneProperty && this.prop.nullable && options?.filter) {
+                qb.andWhere({
+                    $or: [
+                        { [field]: null },
+                        { [nestedAlias + '.' + core_1.Utils.getPrimaryKeyHash(this.prop.referencedPKs)]: { $ne: null } },
+                    ],
+                });
+            }
             if (!qb.hasFlag(core_1.QueryFlag.INFER_POPULATE)) {
                 qb._fields = prev;
             }

package/query/QueryBuilder.d.ts

@@ -299,6 +299,11 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     processPopulateHint(): void;
     private processPopulateWhere;
     private mergeOnConditions;
+    /**
+     * When adding an inner join on a left joined relation, we need to nest them,
+     * otherwise the inner join could discard rows of the root table.
+     */
+    private processNestedJoins;
     private hasToManyJoins;
     protected wrapPaginateSubQuery(meta: EntityMetadata): void;
     private wrapModifySubQuery;

package/query/QueryBuilder.js

@@ -189,10 +189,10 @@ class QueryBuilder {
             subquery = field[1] instanceof QueryBuilder ? field[1].getFormattedQuery() : field[1].toString();
             field = field[0];
         }
-        const prop = this.joinReference(field, alias, cond, type, path, schema, subquery);
+        const { prop, key } = this.joinReference(field, alias, cond, type, path, schema, subquery);
         const [fromAlias] = this.helper.splitField(field);
         if (subquery) {
-            this._joins[`${fromAlias}.${prop.name}#${alias}`].subquery = subquery;
+            this._joins[key].subquery = subquery;
         }
         const populate = this._joinedProps.get(fromAlias);
         const item = { field: prop.name, strategy: core_1.LoadStrategy.JOINED, children: [] };
@@ -927,7 +927,8 @@ class QueryBuilder {
                 prop.targetMeta = field.mainAlias.metadata;
                 field = field.getKnexQuery();
             }
-            this._joins[`${this.alias}.${prop.name}#${alias}`] = {
+            const key = `${this.alias}.${prop.name}#${alias}`;
+            this._joins[key] = {
                 prop,
                 alias,
                 type,
@@ -936,7 +937,7 @@ class QueryBuilder {
                 subquery: field.toString(),
                 ownerAlias: this.alias,
             };
-            return prop;
+            return { prop, key };
         }
         if (!subquery && type.includes('lateral')) {
             throw new Error(`Lateral join can be used only with a sub-query.`);
@@ -965,6 +966,7 @@ class QueryBuilder {
         path ??= `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? entityName)}.${prop.name}`;
         if (prop.kind === core_1.ReferenceKind.ONE_TO_MANY) {
             this._joins[aliasedName] = this.helper.joinOneToReference(prop, fromAlias, alias, type, cond, schema);
+            this._joins[aliasedName].path ??= path;
         }
         else if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY) {
             let pivotAlias = alias;
@@ -976,17 +978,18 @@ class QueryBuilder {
             const joins = this.helper.joinManyToManyReference(prop, fromAlias, alias, pivotAlias, type, cond, path, schema);
             Object.assign(this._joins, joins);
             this.createAlias(prop.pivotEntity, pivotAlias);
+            this._joins[aliasedName].path ??= path;
+            aliasedName = Object.keys(joins)[1];
         }
         else if (prop.kind === core_1.ReferenceKind.ONE_TO_ONE) {
             this._joins[aliasedName] = this.helper.joinOneToReference(prop, fromAlias, alias, type, cond, schema);
+            this._joins[aliasedName].path ??= path;
         }
         else { // MANY_TO_ONE
             this._joins[aliasedName] = this.helper.joinManyToOneReference(prop, fromAlias, alias, type, cond, schema);
+            this._joins[aliasedName].path ??= path;
         }
-        if (!this._joins[aliasedName].path && path) {
-            this._joins[aliasedName].path = path;
-        }
-        return prop;
+        return { prop, key: aliasedName };
     }
     prepareFields(fields, type = 'where') {
         const ret = [];
@@ -1161,6 +1164,7 @@ class QueryBuilder {
         const meta = this.mainAlias.metadata;
         this.applyDiscriminatorCondition();
         this.processPopulateHint();
+        this.processNestedJoins();
         if (meta && (this._fields?.includes('*') || this._fields?.includes(`${this.mainAlias.aliasName}.*`))) {
             meta.props
                 .filter(prop => prop.formula && (!prop.lazy || this.flags.has(core_1.QueryFlag.INCLUDE_LAZY_FORMULAS)))
@@ -1240,7 +1244,7 @@ class QueryBuilder {
         if (typeof this[key] === 'object') {
             const cond = CriteriaNodeFactory_1.CriteriaNodeFactory
                 .createNode(this.metadata, this.mainAlias.entityName, this[key])
-                .process(this, { matchPopulateJoins: true, ignoreBranching: true, preferNoBranch: true });
+                .process(this, { matchPopulateJoins: true, ignoreBranching: true, preferNoBranch: true, filter });
             // there might be new joins created by processing the `populateWhere` object
             joins = Object.values(this._joins);
             this.mergeOnConditions(joins, cond, filter);
@@ -1281,6 +1285,29 @@ class QueryBuilder {
             }
         }
     }
+    /**
+     * When adding an inner join on a left joined relation, we need to nest them,
+     * otherwise the inner join could discard rows of the root table.
+     */
+    processNestedJoins() {
+        if (this.flags.has(core_1.QueryFlag.DISABLE_NESTED_INNER_JOIN)) {
+            return;
+        }
+        const joins = Object.values(this._joins);
+        for (const join of joins) {
+            if (join.type === enums_1.JoinType.innerJoin) {
+                const parentJoin = joins.find(j => j.alias === join.ownerAlias);
+                // https://stackoverflow.com/a/56815807/3665878
+                if (parentJoin?.type === enums_1.JoinType.leftJoin || parentJoin?.type === enums_1.JoinType.nestedLeftJoin) {
+                    const nested = (parentJoin.nested ??= new Set());
+                    join.type = join.type === enums_1.JoinType.innerJoin
+                        ? enums_1.JoinType.nestedInnerJoin
+                        : enums_1.JoinType.nestedLeftJoin;
+                    nested.add(join);
+                }
+            }
+        }
+    }
     hasToManyJoins() {
         return Object.values(this._joins).some(join => {
             return [core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(join.prop.kind);

package/query/ScalarCriteriaNode.d.ts

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

package/query/ScalarCriteriaNode.js

@@ -9,7 +9,9 @@ const enums_1 = require("./enums");
  */
 class ScalarCriteriaNode extends CriteriaNode_1.CriteriaNode {
     process(qb, options) {
-        if (this.shouldJoin()) {
+        const matchPopulateJoins = options?.matchPopulateJoins || (this.prop && [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
+        const nestedAlias = qb.getAliasForJoinPath(this.getPath(), { ...options, matchPopulateJoins });
+        if (this.shouldJoin(qb, nestedAlias)) {
             const path = this.getPath();
             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);
@@ -30,10 +32,10 @@ class ScalarCriteriaNode extends CriteriaNode_1.CriteriaNode {
         return this.payload;
     }
     willAutoJoin(qb, alias, options) {
-        return this.shouldJoin();
+        return this.shouldJoin(qb, alias);
     }
-    shouldJoin() {
-        if (!this.parent || !this.prop) {
+    shouldJoin(qb, nestedAlias) {
+        if (!this.parent || !this.prop || (nestedAlias && [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(qb.type ?? enums_1.QueryType.SELECT))) {
             return false;
         }
         switch (this.prop.kind) {

package/schema/DatabaseTable.d.ts

@@ -1,4 +1,4 @@
-import { type Configuration, type DeferMode, type Dictionary, type EntityMetadata, type EntityProperty, type NamingStrategy } from '@mikro-orm/core';
+import { type Configuration, type DeferMode, type Dictionary, type EntityMetadata, type EntityProperty, type NamingStrategy, type IndexCallback } from '@mikro-orm/core';
 import type { SchemaHelper } from './SchemaHelper';
 import type { CheckDef, Column, ForeignKey, IndexDef } from '../typings';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -53,12 +53,13 @@ export declare class DatabaseTable {
     private getPropertyTypeForForeignKey;
     private getPropertyTypeForColumn;
     private getPropertyDefaultValue;
+    private processIndexExpression;
     addIndex(meta: EntityMetadata, index: {
-        properties: string | string[];
+        properties?: string | string[];
         name?: string;
         type?: string;
-        expression?: string;
-        deferMode?: DeferMode;
+        expression?: string | IndexCallback<any>;
+        deferMode?: DeferMode | `${DeferMode}`;
         options?: Dictionary;
     }, type: 'index' | 'unique' | 'primary'): void;
     addCheck(check: CheckDef): void;

package/schema/DatabaseTable.js

@@ -700,6 +700,18 @@ class DatabaseTable {
         }
         return '' + val;
     }
+    processIndexExpression(expression, meta) {
+        if (expression instanceof Function) {
+            const exp = expression({ name: this.name, schema: this.schema, toString() {
+                    if (this.schema) {
+                        return `${this.schema}.${this.name}`;
+                    }
+                    return this.name;
+                } }, meta.createColumnMappingObject());
+            return exp instanceof core_1.RawQueryFragment ? this.platform.formatQuery(exp.sql, exp.params) : exp;
+        }
+        return expression;
+    }
     addIndex(meta, index, type) {
         const properties = core_1.Utils.unique(core_1.Utils.flatten(core_1.Utils.asArray(index.properties).map(prop => {
             const parts = prop.split('.');
@@ -741,7 +753,7 @@ class DatabaseTable {
             primary: type === 'primary',
             unique: type !== 'index',
             type: index.type,
-            expression: index.expression,
+            expression: this.processIndexExpression(index.expression, meta),
             options: index.options,
             deferMode: index.deferMode,
         });

package/typings.d.ts

@@ -75,7 +75,7 @@ export interface IndexDef {
         storageEngineIndexType?: 'hash' | 'btree';
         predicate?: Knex.QueryBuilder;
     }>;
-    deferMode?: DeferMode;
+    deferMode?: DeferMode | `${DeferMode}`;
 }
 export interface CheckDef<T = unknown> {
     name: string;
@@ -172,6 +172,7 @@ export interface ICriteriaNodeProcessOptions {
     ignoreBranching?: boolean;
     preferNoBranch?: boolean;
     type?: 'orderBy';
+    filter?: boolean;
 }
 export interface ICriteriaNode<T extends object> {
     readonly entityName: string;