@mikro-orm/core 7.0.0-dev.8 → 7.0.0-dev.81

package/EntityManager.js

@@ -1,6 +1,5 @@
 import { inspect } from 'node:util';
-import DataLoader from 'dataloader';
-import { getOnConflictReturningFields } from './utils/upsert-utils.js';
+import { getOnConflictReturningFields, getWhereCondition } from './utils/upsert-utils.js';
 import { Utils } from './utils/Utils.js';
 import { Cursor } from './utils/Cursor.js';
 import { DataloaderUtils } from './utils/DataloaderUtils.js';
@@ -9,7 +8,7 @@ import { TransactionContext } from './utils/TransactionContext.js';
 import { isRaw, RawQueryFragment } from './utils/RawQueryFragment.js';
 import { EntityFactory } from './entity/EntityFactory.js';
 import { EntityAssigner } from './entity/EntityAssigner.js';
-import { EntityValidator } from './entity/EntityValidator.js';
+import { validateEmptyWhere, validateParams, validatePrimaryKey, validateProperty } from './entity/validators.js';
 import { EntityLoader } from './entity/EntityLoader.js';
 import { Reference } from './entity/Reference.js';
 import { helper } from './entity/wrap.js';
@@ -19,6 +18,8 @@ import { EventType, FlushMode, LoadStrategy, LockMode, PopulateHint, PopulatePat
 import { EventManager } from './events/EventManager.js';
 import { TransactionEventBroadcaster } from './events/TransactionEventBroadcaster.js';
 import { OptimisticLockError, ValidationError } from './errors.js';
+import { getLoadingStrategy } from './entity/utils.js';
+import { TransactionManager } from './utils/TransactionManager.js';
 /**
  * The EntityManager is the central access point to ORM functionality. It is a facade to all different ORM subsystems
  * such as UnitOfWork, Query Language, and Repository API.
@@ -34,9 +35,7 @@ export class EntityManager {
     _id = EntityManager.counter++;
     global = false;
     name;
-    refLoader = new DataLoader(DataloaderUtils.getRefBatchLoadFn(this));
-    colLoader = new DataLoader(DataloaderUtils.getColBatchLoadFn(this));
-    validator;
+    loaders = {};
     repositoryMap = {};
     entityLoader;
     comparator;
@@ -61,7 +60,6 @@ export class EntityManager {
         this.eventManager = eventManager;
         this.entityLoader = new EntityLoader(this);
         this.name = this.config.get('contextName');
-        this.validator = new EntityValidator(this.config.get('strict'));
         this.comparator = this.config.getComparator(this.metadata);
         this.resultCache = this.config.getResultCacheAdapter();
         this.disableTransactions = this.config.get('disableTransactions');
@@ -105,12 +103,6 @@ export class EntityManager {
     repo(entityName) {
         return this.getRepository(entityName);
     }
-    /**
-     * Gets EntityValidator instance
-     */
-    getValidator() {
-        return this.validator;
-    }
     /**
      * Finds all entities matching your `where` query. You can pass additional options via the `options` parameter.
      */
@@ -127,7 +119,7 @@ export class EntityManager {
         await em.tryFlush(entityName, options);
         entityName = Utils.className(entityName);
         where = await em.processWhere(entityName, where, options, 'read');
-        em.validator.validateParams(where);
+        validateParams(where);
         options.orderBy = options.orderBy || {};
         options.populate = await em.preparePopulate(entityName, options);
         const populate = options.populate;
@@ -137,7 +129,6 @@ export class EntityManager {
             await em.entityLoader.populate(entityName, cached.data, populate, {
                 ...options,
                 ...em.getPopulateWhere(where, options),
-                convertCustomTypes: false,
                 ignoreLazyScalarProperties: true,
                 lookup: false,
             });
@@ -148,7 +139,7 @@ export class EntityManager {
         // save the original hint value so we know it was infer/all
         options._populateWhere = options.populateWhere ?? this.config.get('populateWhere');
         options.populateWhere = this.createPopulateWhere({ ...where }, options);
-        options.populateFilter = await this.getJoinedFilters(meta, { ...where }, options);
+        options.populateFilter = await this.getJoinedFilters(meta, options);
         const results = await em.driver.find(entityName, where, { ctx: em.transactionContext, em, ...options });
         if (results.length === 0) {
             await em.storeCache(options.cache, cached, []);
@@ -168,7 +159,6 @@ export class EntityManager {
         await em.entityLoader.populate(entityName, unique, populate, {
             ...options,
             ...em.getPopulateWhere(where, options),
-            convertCustomTypes: false,
             ignoreLazyScalarProperties: true,
             lookup: false,
         });
@@ -181,6 +171,61 @@ export class EntityManager {
         }
         return unique;
     }
+    /**
+     * Finds all entities and returns an async iterable (async generator) that yields results one by one.
+     * The results are merged and mapped to entity instances, without adding them to the identity map.
+     * You can disable merging by passing the options `{ mergeResults: false }`.
+     * With `mergeResults` disabled, to-many collections will contain at most one item, and you will get duplicate
+     * root entities when there are multiple items in the populated collection.
+     * This is useful for processing large datasets without loading everything into memory at once.
+     *
+     * ```ts
+     * const stream = em.stream(Book, { populate: ['author'] });
+     *
+     * for await (const book of stream) {
+     *   // book is an instance of Book entity
+     *   console.log(book.title, book.author.name);
+     * }
+     * ```
+     */
+    async *stream(entityName, options = {}) {
+        const em = this.getContext();
+        em.prepareOptions(options);
+        options.strategy = 'joined';
+        await em.tryFlush(entityName, options);
+        entityName = Utils.className(entityName);
+        const where = await em.processWhere(entityName, options.where ?? {}, options, 'read');
+        validateParams(where);
+        options.orderBy = options.orderBy || {};
+        options.populate = await em.preparePopulate(entityName, options);
+        const meta = this.metadata.get(entityName);
+        options = { ...options };
+        // save the original hint value so we know it was infer/all
+        options._populateWhere = options.populateWhere ?? this.config.get('populateWhere');
+        options.populateWhere = this.createPopulateWhere({ ...where }, options);
+        options.populateFilter = await this.getJoinedFilters(meta, options);
+        const stream = em.driver.stream(entityName, where, {
+            ctx: em.transactionContext,
+            mapResults: false,
+            ...options,
+        });
+        for await (const data of stream) {
+            const fork = em.fork();
+            const entity = fork.entityFactory.create(entityName, data, {
+                refresh: options.refresh,
+                schema: options.schema,
+                convertCustomTypes: true,
+            });
+            helper(entity).setSerializationContext({
+                populate: options.populate,
+                fields: options.fields,
+                exclude: options.exclude,
+            });
+            await fork.unitOfWork.dispatchOnLoadEvent();
+            fork.clear();
+            yield entity;
+        }
+    }
     /**
      * Finds all entities of given type, optionally matching the `where` condition provided in the `options` parameter.
      */
@@ -194,7 +239,7 @@ export class EntityManager {
         if (options.populateWhere === PopulateHint.ALL) {
             return { where: {}, populateWhere: options.populateWhere };
         }
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (options.populateWhere === PopulateHint.INFER) {
             return { where, populateWhere: options.populateWhere };
         }
@@ -203,12 +248,12 @@ export class EntityManager {
     /**
      * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
      */
-    addFilter(name, cond, entityName, enabled = true) {
-        const options = { name, cond, default: enabled };
-        if (entityName) {
-            options.entity = Utils.asArray(entityName).map(n => Utils.className(n));
+    addFilter(options) {
+        if (options.entity) {
+            options.entity = Utils.asArray(options.entity).map(n => Utils.className(n));
         }
-        this.getContext(false).filters[name] = options;
+        options.default ??= true;
+        this.getContext(false).filters[options.name] = options;
     }
     /**
      * Sets filter parameter values globally inside context defined by this entity manager.
@@ -232,8 +277,8 @@ export class EntityManager {
     /**
      * Gets logger context for this entity manager.
      */
-    getLoggerContext() {
-        const em = this.getContext();
+    getLoggerContext(options) {
+        const em = options?.disableContextResolution ? this : this.getContext();
         em.loggerContext ??= {};
         return em.loggerContext;
     }
@@ -283,28 +328,39 @@ export class EntityManager {
         }
         return ret;
     }
-    async getJoinedFilters(meta, cond, options) {
+    async getJoinedFilters(meta, options) {
+        if (!this.config.get('filtersOnRelations') || !options.populate) {
+            return undefined;
+        }
         const ret = {};
-        if (options.populate) {
-            for (const hint of options.populate) {
-                const field = hint.field.split(':')[0];
-                const prop = meta.properties[field];
-                const joined = (prop.strategy || options.strategy || hint.strategy || this.config.get('loadStrategy')) === LoadStrategy.JOINED && prop.kind !== ReferenceKind.SCALAR;
-                if (!joined && !hint.filter) {
-                    continue;
-                }
-                const where = await this.applyFilters(prop.type, {}, options.filters ?? {}, 'read', { ...options, populate: hint.children });
-                const where2 = await this.getJoinedFilters(prop.targetMeta, {}, { ...options, populate: hint.children, populateWhere: PopulateHint.ALL });
-                if (Utils.hasObjectKeys(where)) {
-                    ret[field] = ret[field] ? { $and: [where, ret[field]] } : where;
+        for (const hint of options.populate) {
+            const field = hint.field.split(':')[0];
+            const prop = meta.properties[field];
+            const strategy = getLoadingStrategy(prop.strategy || hint.strategy || options.strategy || this.config.get('loadStrategy'), prop.kind);
+            const joined = strategy === LoadStrategy.JOINED && prop.kind !== ReferenceKind.SCALAR;
+            if (!joined && !hint.filter) {
+                continue;
+            }
+            const filters = QueryHelper.mergePropertyFilters(prop.filters, options.filters);
+            const where = await this.applyFilters(prop.type, {}, filters, 'read', {
+                ...options,
+                populate: hint.children,
+            });
+            const where2 = await this.getJoinedFilters(prop.targetMeta, {
+                ...options,
+                filters,
+                populate: hint.children,
+                populateWhere: PopulateHint.ALL,
+            });
+            if (Utils.hasObjectKeys(where)) {
+                ret[field] = ret[field] ? { $and: [where, ret[field]] } : where;
+            }
+            if (where2 && Utils.hasObjectKeys(where2)) {
+                if (ret[field]) {
+                    Utils.merge(ret[field], where2);
                 }
-                if (Utils.hasObjectKeys(where2)) {
-                    if (ret[field]) {
-                        Utils.merge(ret[field], where2);
-                    }
-                    else {
-                        ret[field] = where2;
-                    }
+                else {
+                    ret[field] = where2;
                 }
             }
         }
@@ -313,27 +369,45 @@ export class EntityManager {
     /**
      * When filters are active on M:1 or 1:1 relations, we need to ref join them eagerly as they might affect the FK value.
      */
-    async autoJoinRefsForFilters(meta, options) {
-        if (!meta || !this.config.get('autoJoinRefsForFilters')) {
+    async autoJoinRefsForFilters(meta, options, parent) {
+        if (!meta || !this.config.get('autoJoinRefsForFilters') || options.filters === false) {
             return;
         }
-        const props = meta.relations.filter(prop => {
-            return !prop.object && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)
-                && ((options.fields?.length ?? 0) === 0 || options.fields?.some(f => prop.name === f || prop.name.startsWith(`${String(f)}.`)));
-        });
         const ret = options.populate;
-        for (const prop of props) {
-            const cond = await this.applyFilters(prop.type, {}, options.filters ?? {}, 'read', options);
+        for (const prop of meta.relations) {
+            if (prop.object
+                || ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)
+                || !((options.fields?.length ?? 0) === 0 || options.fields?.some(f => prop.name === f || prop.name.startsWith(`${String(f)}.`)))
+                || (parent?.className === prop.targetMeta.root.className && parent.propName === prop.inversedBy)) {
+                continue;
+            }
+            options = { ...options, filters: QueryHelper.mergePropertyFilters(prop.filters, options.filters) };
+            const cond = await this.applyFilters(prop.type, {}, options.filters, 'read', options);
             if (!Utils.isEmpty(cond)) {
                 const populated = options.populate.filter(({ field }) => field.split(':')[0] === prop.name);
-                if (populated.length > 0) {
-                    populated.forEach(hint => hint.filter = true);
+                let found = false;
+                for (const hint of populated) {
+                    if (!hint.all) {
+                        hint.filter = true;
+                    }
+                    const strategy = getLoadingStrategy(prop.strategy || hint.strategy || options.strategy || this.config.get('loadStrategy'), prop.kind);
+                    if (hint.field === `${prop.name}:ref` || (hint.filter && strategy === LoadStrategy.JOINED)) {
+                        found = true;
+                    }
                 }
-                else {
+                if (!found) {
                     ret.push({ field: `${prop.name}:ref`, strategy: LoadStrategy.JOINED, filter: true });
                 }
             }
         }
+        for (const hint of ret) {
+            const [field, ref] = hint.field.split(':');
+            const prop = meta?.properties[field];
+            if (prop && !ref) {
+                hint.children ??= [];
+                await this.autoJoinRefsForFilters(prop.targetMeta, { ...options, populate: hint.children }, { className: meta.root.className, propName: prop.name });
+            }
+        }
     }
     /**
      * @internal
@@ -363,7 +437,7 @@ export class EntityManager {
             let cond;
             if (filter.cond instanceof Function) {
                 // @ts-ignore
-                const args = Utils.isPlainObject(options[filter.name]) ? options[filter.name] : this.getContext().filterParams[filter.name];
+                const args = Utils.isPlainObject(options?.[filter.name]) ? options[filter.name] : this.getContext().filterParams[filter.name];
                 if (!args && filter.cond.length > 0 && filter.args !== false) {
                     throw new Error(`No arguments provided for filter '${filter.name}'`);
                 }
@@ -372,13 +446,17 @@ export class EntityManager {
             else {
                 cond = filter.cond;
             }
-            ret.push(QueryHelper.processWhere({
+            cond = QueryHelper.processWhere({
                 where: cond,
                 entityName,
                 metadata: this.metadata,
                 platform: this.driver.getPlatform(),
                 aliased: type === 'read',
-            }));
+            });
+            if (filter.strict) {
+                Object.defineProperty(cond, '__strict', { value: filter.strict, enumerable: false });
+            }
+            ret.push(cond);
         }
         const conds = [...ret, where].filter(c => Utils.hasObjectKeys(c));
         return conds.length > 1 ? { $and: conds } : conds[0];
@@ -433,6 +511,10 @@ export class EntityManager {
      * });
      * ```
      *
+     * The options also support an `includeCount` (true by default) option. If set to false, the `totalCount` is not
+     * returned as part of the cursor. This is useful for performance reason, when you don't care about the total number
+     * of pages.
+     *
      * The `Cursor` object provides the following interface:
      *
      * ```ts
@@ -442,7 +524,7 @@ export class EntityManager {
      *     User { ... },
      *     User { ... },
      *   ],
-     *   totalCount: 50,
+     *   totalCount: 50, // not included if `includeCount: false`
      *   startCursor: 'WzRd',
      *   endCursor: 'WzZd',
      *   hasPrevPage: true,
@@ -457,7 +539,9 @@ export class EntityManager {
         if (Utils.isEmpty(options.orderBy)) {
             throw new Error('Explicit `orderBy` option required');
         }
-        const [entities, count] = await em.findAndCount(entityName, where, options);
+        const [entities, count] = options.includeCount !== false
+            ? await em.findAndCount(entityName, where, options)
+            : [await em.find(entityName, where, options)];
         return new Cursor(entities, count, options, this.metadata.get(entityName));
     }
     /**
@@ -483,18 +567,31 @@ export class EntityManager {
     async refresh(entity, options = {}) {
         const fork = this.fork({ keepTransactionContext: true });
         const entityName = entity.constructor.name;
+        const wrapped = helper(entity);
         const reloaded = await fork.findOne(entityName, entity, {
-            schema: helper(entity).__schema,
+            schema: wrapped.__schema,
             ...options,
             flushMode: FlushMode.COMMIT,
         });
-        if (reloaded) {
-            this.config.getHydrator(this.metadata).hydrate(entity, helper(entity).__meta, helper(reloaded).toPOJO(), this.getEntityFactory(), 'full');
+        const em = this.getContext();
+        if (!reloaded) {
+            em.unitOfWork.unsetIdentity(entity);
+            return null;
         }
-        else {
-            this.getUnitOfWork().unsetIdentity(entity);
+        let found = false;
+        for (const e of fork.unitOfWork.getIdentityMap()) {
+            const ref = em.getReference(e.constructor.name, helper(e).getPrimaryKey());
+            const data = helper(e).serialize({ ignoreSerializers: true, includeHidden: true });
+            em.config.getHydrator(this.metadata).hydrate(ref, helper(ref).__meta, data, em.entityFactory, 'full', false, true);
+            Utils.merge(helper(ref).__originalEntityData, this.comparator.prepareEntity(e));
+            found ||= ref === entity;
         }
-        return reloaded ? entity : reloaded;
+        if (!found) {
+            const data = helper(reloaded).serialize({ ignoreSerializers: true, includeHidden: true });
+            em.config.getHydrator(this.metadata).hydrate(entity, wrapped.__meta, data, em.entityFactory, 'full', false, true);
+            Utils.merge(wrapped.__originalEntityData, this.comparator.prepareEntity(reloaded));
+        }
+        return entity;
     }
     /**
      * Finds first entity matching your `where` query.
@@ -520,31 +617,32 @@ export class EntityManager {
         await em.tryFlush(entityName, options);
         const meta = em.metadata.get(entityName);
         where = await em.processWhere(entityName, where, options, 'read');
-        em.validator.validateEmptyWhere(where);
+        validateEmptyWhere(where);
         em.checkLockRequirements(options.lockMode, meta);
-        const isOptimisticLocking = !Utils.isDefined(options.lockMode) || options.lockMode === LockMode.OPTIMISTIC;
+        const isOptimisticLocking = options.lockMode == null || options.lockMode === LockMode.OPTIMISTIC;
         if (entity && !em.shouldRefresh(meta, entity, options) && isOptimisticLocking) {
             return em.lockAndPopulate(meta, entity, where, options);
         }
-        em.validator.validateParams(where);
+        validateParams(where);
         options.populate = await em.preparePopulate(entityName, options);
         const cacheKey = em.cacheKey(entityName, options, 'em.findOne', where);
         const cached = await em.tryCache(entityName, options.cache, cacheKey, options.refresh, true);
-        if (cached?.data) {
-            await em.entityLoader.populate(entityName, [cached.data], options.populate, {
-                ...options,
-                ...em.getPopulateWhere(where, options),
-                convertCustomTypes: false,
-                ignoreLazyScalarProperties: true,
-                lookup: false,
-            });
+        if (cached?.data !== undefined) {
+            if (cached.data) {
+                await em.entityLoader.populate(entityName, [cached.data], options.populate, {
+                    ...options,
+                    ...em.getPopulateWhere(where, options),
+                    ignoreLazyScalarProperties: true,
+                    lookup: false,
+                });
+            }
             return cached.data;
         }
         options = { ...options };
         // save the original hint value so we know it was infer/all
         options._populateWhere = options.populateWhere ?? this.config.get('populateWhere');
         options.populateWhere = this.createPopulateWhere({ ...where }, options);
-        options.populateFilter = await this.getJoinedFilters(meta, { ...where }, options);
+        options.populateFilter = await this.getJoinedFilters(meta, options);
         const data = await em.driver.findOne(entityName, where, {
             ctx: em.transactionContext,
             em,
@@ -655,26 +753,9 @@ export class EntityManager {
                 }
             }
         }
-        const unique = options.onConflictFields ?? meta.props.filter(p => p.unique).map(p => p.name);
-        const propIndex = !isRaw(unique) && unique.findIndex(p => data[p] != null);
-        if (options.onConflictFields || where == null) {
-            if (propIndex !== false && propIndex >= 0) {
-                where = { [unique[propIndex]]: data[unique[propIndex]] };
-            }
-            else if (meta.uniques.length > 0) {
-                for (const u of meta.uniques) {
-                    if (Utils.asArray(u.properties).every(p => data[p] != null)) {
-                        where = Utils.asArray(u.properties).reduce((o, key) => {
-                            o[key] = data[key];
-                            return o;
-                        }, {});
-                        break;
-                    }
-                }
-            }
-        }
+        where = getWhereCondition(meta, options.onConflictFields, data, where).where;
         data = QueryHelper.processObjectParams(data);
-        em.validator.validateParams(data, 'insert data');
+        validateParams(data, 'insert data');
         if (em.eventManager.hasListeners(EventType.beforeUpsert, meta)) {
             await em.eventManager.dispatchEvent(EventType.beforeUpsert, { entity: data, em, meta }, meta);
         }
@@ -717,6 +798,7 @@ export class EntityManager {
                 ctx: em.transactionContext,
                 convertCustomTypes: true,
                 connectionType: 'write',
+                schema: options.schema,
             });
             em.getHydrator().hydrate(entity, meta, data2, em.entityFactory, 'full', false, true);
         }
@@ -814,32 +896,18 @@ export class EntityManager {
                     }
                 }
             }
-            const unique = meta.props.filter(p => p.unique).map(p => p.name);
-            propIndex = unique.findIndex(p => row[p] != null);
-            if (options.onConflictFields || where == null) {
-                if (propIndex >= 0) {
-                    where = { [unique[propIndex]]: row[unique[propIndex]] };
-                }
-                else if (meta.uniques.length > 0) {
-                    for (const u of meta.uniques) {
-                        if (Utils.asArray(u.properties).every(p => row[p] != null)) {
-                            where = Utils.asArray(u.properties).reduce((o, key) => {
-                                o[key] = row[key];
-                                return o;
-                            }, {});
-                            break;
-                        }
-                    }
-                }
-            }
-            row = QueryHelper.processObjectParams(row);
+            const unique = options.onConflictFields ?? meta.props.filter(p => p.unique).map(p => p.name);
+            propIndex = !isRaw(unique) && unique.findIndex(p => data[p] ?? data[p.substring(0, p.indexOf('.'))] != null);
+            const tmp = getWhereCondition(meta, options.onConflictFields, row, where);
+            propIndex = tmp.propIndex;
             where = QueryHelper.processWhere({
-                where,
+                where: tmp.where,
                 entityName,
                 metadata: this.metadata,
                 platform: this.getPlatform(),
             });
-            em.validator.validateParams(row, 'insert data');
+            row = QueryHelper.processObjectParams(row);
+            validateParams(row, 'insert data');
             allData.push(row);
             allWhere.push(where);
         }
@@ -880,7 +948,7 @@ export class EntityManager {
         const reloadFields = returning.length > 0 && !(this.getPlatform().usesReturningStatement() && res.rows?.length);
         if (options.onConflictAction === 'ignore' || (!res.rows?.length && loadPK.size > 0) || reloadFields) {
             const unique = meta.hydrateProps.filter(p => !p.lazy).map(p => p.name);
-            const add = new Set(propIndex >= 0 ? [unique[propIndex]] : []);
+            const add = new Set(propIndex !== false && propIndex >= 0 ? [unique[propIndex]] : []);
             for (const cond of loadPK.values()) {
                 Utils.keys(cond).forEach(key => add.add(key));
             }
@@ -897,6 +965,7 @@ export class EntityManager {
                 ctx: em.transactionContext,
                 convertCustomTypes: true,
                 connectionType: 'write',
+                schema: options.schema,
             });
             for (const [entity, cond] of loadPK.entries()) {
                 const row = data2.find(row => {
@@ -908,7 +977,7 @@ export class EntityManager {
                     });
                     return this.comparator.matching(entityName, cond, tmp);
                 });
-                /* v8 ignore next 3 */
+                /* v8 ignore next */
                 if (!row) {
                     throw new Error(`Cannot find matching entity for condition ${JSON.stringify(cond)}`);
                 }
@@ -931,7 +1000,7 @@ export class EntityManager {
                         }, {});
                         return this.comparator.matching(entityName, cond, pk);
                     });
-                    /* v8 ignore next 3 */
+                    /* v8 ignore next */
                     if (!row) {
                         throw new Error(`Cannot find matching entity for condition ${JSON.stringify(cond)}`);
                     }
@@ -953,45 +1022,37 @@ export class EntityManager {
     }
     /**
      * Runs your callback wrapped inside a database transaction.
+     *
+     * If a transaction is already active, a new savepoint (nested transaction) will be created by default. This behavior
+     * can be controlled via the `propagation` option. Use the provided EntityManager instance for all operations that
+     * should be part of the transaction. You can safely use a global EntityManager instance from a DI container, as this
+     * method automatically creates an async context for the transaction.
+     *
+     * **Concurrency note:** When running multiple transactions concurrently (e.g. in parallel requests or jobs), use the
+     * `clear: true` option. This ensures the callback runs in a clear fork of the EntityManager, providing full isolation
+     * between concurrent transactional handlers. Using `clear: true` is an alternative to forking explicitly and calling
+     * the method on the new fork – it already provides the necessary isolation for safe concurrent usage.
+     *
+     * **Propagation note:** Changes made within a transaction (whether top-level or nested) are always propagated to the
+     * parent context, unless the parent context is a global one. If you want to avoid that, fork the EntityManager first
+     * and then call this method on the fork.
+     *
+     * **Example:**
+     * ```ts
+     * await em.transactional(async (em) => {
+     *   const author = new Author('Jon');
+     *   em.persist(author);
+     *   // flush is called automatically at the end of the callback
+     * });
+     * ```
      */
     async transactional(cb, options = {}) {
         const em = this.getContext(false);
         if (this.disableTransactions || em.disableTransactions) {
             return cb(em);
         }
-        const fork = em.fork({
-            clear: options.clear ?? false, // state will be merged once resolves
-            flushMode: options.flushMode,
-            cloneEventManager: true,
-            disableTransactions: options.ignoreNestedTransactions,
-            loggerContext: options.loggerContext,
-        });
-        options.ctx ??= em.transactionContext;
-        const propagateToUpperContext = !em.global || this.config.get('allowGlobalContext');
-        return TransactionContext.create(fork, async () => {
-            return fork.getConnection().transactional(async (trx) => {
-                fork.transactionContext = trx;
-                if (propagateToUpperContext) {
-                    fork.eventManager.registerSubscriber({
-                        afterFlush(args) {
-                            args.uow.getChangeSets()
-                                .filter(cs => [ChangeSetType.DELETE, ChangeSetType.DELETE_EARLY].includes(cs.type))
-                                .forEach(cs => em.unitOfWork.unsetIdentity(cs.entity));
-                        },
-                    });
-                }
-                const ret = await cb(fork);
-                await fork.flush();
-                if (propagateToUpperContext) {
-                    // ensure all entities from inner context are merged to the upper one
-                    for (const entity of fork.unitOfWork.getIdentityMap()) {
-                        em.unitOfWork.register(entity);
-                        entity.__helper.__em = em;
-                    }
-                }
-                return ret;
-            }, { ...options, eventBroadcaster: new TransactionEventBroadcaster(fork, { topLevelTransaction: !options.ctx }) });
-        });
+        const manager = new TransactionManager(this);
+        return manager.handle(cb, options);
     }
     /**
      * Starts new transaction bound to this EntityManager. Use `ctx` parameter to provide the parent when nesting transactions.
@@ -1075,7 +1136,7 @@ export class EntityManager {
             return cs.getPrimaryKey();
         }
         data = QueryHelper.processObjectParams(data);
-        em.validator.validateParams(data, 'insert data');
+        validateParams(data, 'insert data');
         const res = await em.driver.nativeInsert(entityName, data, { ctx: em.transactionContext, ...options });
         return res.insertId;
     }
@@ -1115,7 +1176,7 @@ export class EntityManager {
             return css.map(cs => cs.getPrimaryKey());
         }
         data = data.map(row => QueryHelper.processObjectParams(row));
-        data.forEach(row => em.validator.validateParams(row, 'insert data'));
+        data.forEach(row => validateParams(row, 'insert data'));
         const res = await em.driver.nativeInsertMany(entityName, data, { ctx: em.transactionContext, ...options });
         if (res.insertedIds) {
             return res.insertedIds;
@@ -1131,8 +1192,8 @@ export class EntityManager {
         entityName = Utils.className(entityName);
         data = QueryHelper.processObjectParams(data);
         where = await em.processWhere(entityName, where, { ...options, convertCustomTypes: false }, 'update');
-        em.validator.validateParams(data, 'update data');
-        em.validator.validateParams(where, 'update condition');
+        validateParams(data, 'update data');
+        validateParams(where, 'update condition');
         const res = await em.driver.nativeUpdate(entityName, where, data, { ctx: em.transactionContext, ...options });
         return res.affectedRows;
     }
@@ -1144,7 +1205,7 @@ export class EntityManager {
         em.prepareOptions(options);
         entityName = Utils.className(entityName);
         where = await em.processWhere(entityName, where, options, 'delete');
-        em.validator.validateParams(where, 'delete condition');
+        validateParams(where, 'delete condition');
         const res = await em.driver.nativeDelete(entityName, where, { ctx: em.transactionContext, ...options });
         return res.affectedRows;
     }
@@ -1155,15 +1216,17 @@ export class EntityManager {
         entityName = Utils.className(entityName);
         const meta = this.metadata.get(entityName);
         const data = this.driver.mapResult(result, meta);
-        Object.keys(data).forEach(k => {
+        for (const k of Object.keys(data)) {
             const prop = meta.properties[k];
-            if (prop && prop.kind === ReferenceKind.SCALAR && SCALAR_TYPES.includes(prop.runtimeType) && !prop.customType && (prop.setter || !prop.getter)) {
-                data[k] = this.validator.validateProperty(prop, data[k], data);
+            if (prop?.kind === ReferenceKind.SCALAR && SCALAR_TYPES.has(prop.runtimeType) && !prop.customType && (prop.setter || !prop.getter)) {
+                validateProperty(prop, data[k], data);
             }
-        });
+        }
         return this.merge(entityName, data, {
             convertCustomTypes: true,
-            refresh: true, ...options,
+            refresh: true,
+            validate: false,
+            ...options,
         });
     }
     /**
@@ -1171,22 +1234,28 @@ export class EntityManager {
      * via second parameter. By default, it will return already loaded entities without modifying them.
      */
     merge(entityName, data, options = {}) {
-        const em = this.getContext();
         if (Utils.isEntity(entityName)) {
-            return em.merge(entityName.constructor.name, entityName, data);
+            return this.merge(entityName.constructor.name, entityName, data);
         }
+        const em = options.disableContextResolution ? this : this.getContext();
         options.schema ??= em._schema;
+        options.validate ??= true;
+        options.cascade ??= true;
         entityName = Utils.className(entityName);
-        em.validator.validatePrimaryKey(data, em.metadata.get(entityName));
+        validatePrimaryKey(data, em.metadata.get(entityName));
         let entity = em.unitOfWork.tryGetById(entityName, data, options.schema, false);
         if (entity && helper(entity).__managed && helper(entity).__initialized && !options.refresh) {
             return entity;
         }
-        const meta = em.metadata.find(entityName);
-        const childMeta = em.metadata.getByDiscriminatorColumn(meta, data);
-        entity = Utils.isEntity(data) ? data : em.entityFactory.create(entityName, data, { merge: true, ...options });
-        em.validator.validate(entity, data, childMeta ?? meta);
-        em.unitOfWork.merge(entity);
+        const dataIsEntity = Utils.isEntity(data);
+        if (options.keepIdentity && entity && dataIsEntity && entity !== data) {
+            helper(entity).__data = helper(data).__data;
+            helper(entity).__originalEntityData = helper(data).__originalEntityData;
+            return entity;
+        }
+        entity = dataIsEntity ? data : em.entityFactory.create(entityName, data, { merge: true, ...options });
+        const visited = options.cascade ? undefined : new Set([entity]);
+        em.unitOfWork.merge(entity, visited);
         return entity;
     }
     /**
@@ -1211,6 +1280,7 @@ export class EntityManager {
             ...options,
             newEntity: !options.managed,
             merge: options.managed,
+            normalizeAccessors: true,
         });
         options.persist ??= em.config.get('persistOnCreate');
         if (options.persist && !this.getMetadata(entityName).embeddable) {
@@ -1249,10 +1319,8 @@ export class EntityManager {
     async count(entityName, where = {}, options = {}) {
         const em = this.getContext(false);
         // Shallow copy options since the object will be modified when deleting orderBy
-        options = {
-            schema: em._schema,
-            ...options,
-        };
+        options = { ...options };
+        em.prepareOptions(options);
         entityName = Utils.className(entityName);
         await em.tryFlush(entityName, options);
         where = await em.processWhere(entityName, where, options, 'read');
@@ -1262,15 +1330,15 @@ export class EntityManager {
         const meta = em.metadata.find(entityName);
         options._populateWhere = options.populateWhere ?? this.config.get('populateWhere');
         options.populateWhere = this.createPopulateWhere({ ...where }, options);
-        options.populateFilter = await this.getJoinedFilters(meta, { ...where }, options);
-        em.validator.validateParams(where);
+        options.populateFilter = await this.getJoinedFilters(meta, options);
+        validateParams(where);
         delete options.orderBy;
         const cacheKey = em.cacheKey(entityName, options, 'em.count', where);
         const cached = await em.tryCache(entityName, options.cache, cacheKey);
-        if (cached?.data) {
+        if (cached?.data !== undefined) {
             return cached.data;
         }
-        const count = await em.driver.count(entityName, where, { ctx: em.transactionContext, ...options });
+        const count = await em.driver.count(entityName, where, { ctx: em.transactionContext, em, ...options });
         await em.storeCache(options.cache, cached, () => +count);
         return +count;
     }
@@ -1297,13 +1365,6 @@ export class EntityManager {
         }
         return this;
     }
-    /**
-     * Persists your entity immediately, flushing all not yet persisted changes to the database too.
-     * Equivalent to `em.persist(e).flush()`.
-     */
-    async persistAndFlush(entity) {
-        await this.persist(entity).flush();
-    }
     /**
      * Marks entity for removal.
      * A removed entity will be removed from the database at or before transaction commit or as a result of the flush operation.
@@ -1327,13 +1388,6 @@ export class EntityManager {
         }
         return em;
     }
-    /**
-     * Removes an entity instance immediately, flushing all not yet persisted changes to the database too.
-     * Equivalent to `em.remove(e).flush()`
-     */
-    async removeAndFlush(entity) {
-        await this.remove(entity).flush();
-    }
     /**
      * Flushes all changes to objects that have been queued up to now to the database.
      * This effectively synchronizes the in-memory state of managed objects with the database.
@@ -1396,7 +1450,7 @@ export class EntityManager {
         const em = this.getContext();
         em.prepareOptions(options);
         const entityName = arr[0].constructor.name;
-        const preparedPopulate = await em.preparePopulate(entityName, { populate: populate }, options.validate);
+        const preparedPopulate = await em.preparePopulate(entityName, { populate: populate, filters: options.filters }, options.validate);
         await em.entityLoader.populate(entityName, arr, preparedPopulate, options);
         return entities;
     }
@@ -1432,6 +1486,9 @@ export class EntityManager {
             for (const entity of em.unitOfWork.getIdentityMap()) {
                 fork.unitOfWork.register(entity);
             }
+            for (const entity of em.unitOfWork.getPersistStack()) {
+                fork.unitOfWork.persist(entity);
+            }
             for (const entity of em.unitOfWork.getOrphanRemoveStack()) {
                 fork.unitOfWork.getOrphanRemoveStack().add(entity);
             }
@@ -1453,6 +1510,12 @@ export class EntityManager {
     getEntityFactory() {
         return this.getContext().entityFactory;
     }
+    /**
+     * @internal use `em.populate()` as the user facing API, this is exposed only for internal usage
+     */
+    getEntityLoader() {
+        return this.getContext().entityLoader;
+    }
     /**
      * Gets the Hydrator used by the EntityManager.
      */
@@ -1549,7 +1612,6 @@ export class EntityManager {
             ...options,
             ...this.getPopulateWhere(where, options),
             orderBy: options.populateOrderBy ?? options.orderBy,
-            convertCustomTypes: false,
             ignoreLazyScalarProperties: true,
             lookup: false,
         });
@@ -1612,7 +1674,7 @@ export class EntityManager {
         }
         if (typeof options.populate !== 'boolean') {
             options.populate = Utils.asArray(options.populate).map(field => {
-                /* v8 ignore next 3 */
+                /* v8 ignore next */
                 if (typeof field === 'boolean' || field === PopulatePath.ALL) {
                     return [{ field: meta.primaryKeys[0], strategy: options.strategy, all: !!field }]; //
                 }
@@ -1622,7 +1684,7 @@ export class EntityManager {
                     options.flags.push(QueryFlag.INFER_POPULATE);
                     return [];
                 }
-                if (Utils.isString(field)) {
+                if (typeof field === 'string') {
                     return [{ field, strategy: options.strategy }];
                 }
                 return [field];
@@ -1672,7 +1734,7 @@ export class EntityManager {
             throw new ValidationError(`Cannot combine 'fields' and 'exclude' option.`);
         }
         options.schema ??= this._schema;
-        options.logging = Utils.merge({ id: this.id }, this.loggerContext, options.loggerContext, options.logging);
+        options.logging = options.loggerContext = Utils.merge({ id: this.id }, this.loggerContext, options.loggerContext, options.logging);
     }
     /**
      * @internal
@@ -1696,31 +1758,31 @@ export class EntityManager {
         const em = this.getContext();
         const cacheKey = Array.isArray(config) ? config[0] : JSON.stringify(key);
         const cached = await em.resultCache.get(cacheKey);
-        if (cached) {
-            let data;
-            if (Array.isArray(cached) && merge) {
-                data = cached.map(item => em.entityFactory.create(entityName, item, {
-                    merge: true,
-                    convertCustomTypes: true,
-                    refresh,
-                    recomputeSnapshot: true,
-                }));
-            }
-            else if (Utils.isObject(cached) && merge) {
-                data = em.entityFactory.create(entityName, cached, {
-                    merge: true,
-                    convertCustomTypes: true,
-                    refresh,
-                    recomputeSnapshot: true,
-                });
-            }
-            else {
-                data = cached;
-            }
-            await em.unitOfWork.dispatchOnLoadEvent();
-            return { key: cacheKey, data };
+        if (!cached) {
+            return { key: cacheKey, data: cached };
+        }
+        let data;
+        if (Array.isArray(cached) && merge) {
+            data = cached.map(item => em.entityFactory.create(entityName, item, {
+                merge: true,
+                convertCustomTypes: true,
+                refresh,
+                recomputeSnapshot: true,
+            }));
+        }
+        else if (Utils.isObject(cached) && merge) {
+            data = em.entityFactory.create(entityName, cached, {
+                merge: true,
+                convertCustomTypes: true,
+                refresh,
+                recomputeSnapshot: true,
+            });
         }
-        return { key: cacheKey };
+        else {
+            data = cached;
+        }
+        await em.unitOfWork.dispatchOnLoadEvent();
+        return { key: cacheKey, data };
     }
     /**
      * @internal
@@ -1729,7 +1791,7 @@ export class EntityManager {
         config ??= this.config.get('resultCache').global;
         if (config) {
             const em = this.getContext();
-            const expiration = Array.isArray(config) ? config[1] : (Utils.isNumber(config) ? config : undefined);
+            const expiration = Array.isArray(config) ? config[1] : (typeof config === 'number' ? config : undefined);
             await em.resultCache.set(key.key, data instanceof Function ? data() : data, '', expiration);
         }
     }
@@ -1762,6 +1824,19 @@ export class EntityManager {
     set schema(schema) {
         this.getContext(false)._schema = schema ?? undefined;
     }
+    /** @internal */
+    async getDataLoader(type) {
+        const em = this.getContext();
+        if (em.loaders[type]) {
+            return em.loaders[type];
+        }
+        const DataLoader = await DataloaderUtils.getDataLoader();
+        switch (type) {
+            case 'ref': return (em.loaders[type] ??= new DataLoader(DataloaderUtils.getRefBatchLoadFn(em)));
+            case '1:m': return (em.loaders[type] ??= new DataLoader(DataloaderUtils.getColBatchLoadFn(em)));
+            case 'm:n': return (em.loaders[type] ??= new DataLoader(DataloaderUtils.getManyToManyColBatchLoadFn(em)));
+        }
+    }
     /**
      * Returns the ID of this EntityManager. Respects the context, so global EM will give you the contextual ID
      * if executed inside request context handler.