@mikro-orm/core 7.0.0-dev.33 → 7.0.0-dev.331

package/EntityManager.js

@@ -1,15 +1,12 @@
-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';
 import { QueryHelper } from './utils/QueryHelper.js';
 import { TransactionContext } from './utils/TransactionContext.js';
-import { isRaw, RawQueryFragment } from './utils/RawQueryFragment.js';
+import { isRaw, Raw } 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,7 +16,7 @@ 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 { applyPopulateHints, 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
@@ -30,29 +27,27 @@ export class EntityManager {
     config;
     driver;
     metadata;
-    useContext;
     eventManager;
-    static counter = 1;
-    _id = EntityManager.counter++;
+    static #counter = 1;
+    /** @internal */
+    _id = EntityManager.#counter++;
     global = false;
     name;
-    refLoader = new DataLoader(DataloaderUtils.getRefBatchLoadFn(this));
-    colLoader = new DataLoader(DataloaderUtils.getColBatchLoadFn(this));
-    colLoaderMtoN = new DataLoader(DataloaderUtils.getManyToManyColBatchLoadFn(this));
-    validator;
-    repositoryMap = {};
-    entityLoader;
-    comparator;
-    entityFactory;
-    unitOfWork;
-    resultCache;
-    filters = {};
-    filterParams = {};
+    #loaders = {};
+    #repositoryMap = new Map();
+    #entityLoader;
+    #comparator;
+    #entityFactory;
+    #unitOfWork;
+    #resultCache;
+    #filters = {};
+    #filterParams = {};
     loggerContext;
-    transactionContext;
-    disableTransactions;
-    flushMode;
-    _schema;
+    #transactionContext;
+    #disableTransactions;
+    #flushMode;
+    #schema;
+    #useContext;
     /**
      * @internal
      */
@@ -60,16 +55,15 @@ export class EntityManager {
         this.config = config;
         this.driver = driver;
         this.metadata = metadata;
-        this.useContext = useContext;
         this.eventManager = eventManager;
-        this.entityLoader = new EntityLoader(this);
+        this.#useContext = useContext;
+        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');
-        this.entityFactory = new EntityFactory(this);
-        this.unitOfWork = new UnitOfWork(this);
+        this.#comparator = this.config.getComparator(this.metadata);
+        this.#resultCache = this.config.getResultCacheAdapter();
+        this.#disableTransactions = this.config.get('disableTransactions');
+        this.#entityFactory = new EntityFactory(this);
+        this.#unitOfWork = new UnitOfWork(this);
     }
     /**
      * Gets the Driver instance used by this EntityManager.
@@ -94,13 +88,12 @@ export class EntityManager {
      * Gets repository for given entity. You can pass either string name or entity class reference.
      */
     getRepository(entityName) {
-        entityName = Utils.className(entityName);
-        if (!this.repositoryMap[entityName]) {
-            const meta = this.metadata.get(entityName);
+        const meta = this.metadata.get(entityName);
+        if (!this.#repositoryMap.has(meta)) {
             const RepositoryClass = this.config.getRepositoryClass(meta.repository);
-            this.repositoryMap[entityName] = new RepositoryClass(this, entityName);
+            this.#repositoryMap.set(meta, new RepositoryClass(this, entityName));
         }
-        return this.repositoryMap[entityName];
+        return this.#repositoryMap.get(meta);
     }
     /**
      * Shortcut for `em.getRepository()`.
@@ -108,12 +101,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.
      */
@@ -128,16 +115,21 @@ export class EntityManager {
         const em = this.getContext();
         em.prepareOptions(options);
         await em.tryFlush(entityName, options);
-        entityName = Utils.className(entityName);
         where = await em.processWhere(entityName, where, options, 'read');
-        em.validator.validateParams(where);
-        options.orderBy = options.orderBy || {};
-        options.populate = await em.preparePopulate(entityName, options);
+        validateParams(where);
+        const meta = this.metadata.get(entityName);
+        if (meta.orderBy) {
+            options.orderBy = QueryHelper.mergeOrderBy(options.orderBy, meta.orderBy);
+        }
+        else {
+            options.orderBy ??= {};
+        }
+        options.populate = (await em.preparePopulate(entityName, options));
         const populate = options.populate;
         const cacheKey = em.cacheKey(entityName, options, 'em.find', where);
         const cached = await em.tryCache(entityName, options.cache, cacheKey, options.refresh, true);
         if (cached?.data) {
-            await em.entityLoader.populate(entityName, cached.data, populate, {
+            await em.#entityLoader.populate(entityName, cached.data, populate, {
                 ...options,
                 ...em.getPopulateWhere(where, options),
                 ignoreLazyScalarProperties: true,
@@ -145,20 +137,20 @@ export class EntityManager {
             });
             return cached.data;
         }
-        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, { ...where }, options);
-        const results = await em.driver.find(entityName, where, { ctx: em.transactionContext, em, ...options });
+        options.populateFilter = await this.getJoinedFilters(meta, options);
+        await em.processUnionWhere(entityName, options, 'read');
+        const results = await em.driver.find(entityName, where, { ctx: em.#transactionContext, em, ...options });
         if (results.length === 0) {
             await em.storeCache(options.cache, cached, []);
             return [];
         }
         const ret = [];
         for (const data of results) {
-            const entity = em.entityFactory.create(entityName, data, {
+            const entity = em.#entityFactory.create(entityName, data, {
                 merge: true,
                 refresh: options.refresh,
                 schema: options.schema,
@@ -167,13 +159,13 @@ export class EntityManager {
             ret.push(entity);
         }
         const unique = Utils.unique(ret);
-        await em.entityLoader.populate(entityName, unique, populate, {
+        await em.#entityLoader.populate(entityName, unique, populate, {
             ...options,
             ...em.getPopulateWhere(where, options),
             ignoreLazyScalarProperties: true,
             lookup: false,
         });
-        await em.unitOfWork.dispatchOnLoadEvent();
+        await em.#unitOfWork.dispatchOnLoadEvent();
         if (meta.virtual) {
             await em.storeCache(options.cache, cached, () => ret);
         }
@@ -182,6 +174,60 @@ 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);
+        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.
      */
@@ -195,7 +241,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 };
         }
@@ -204,25 +250,25 @@ 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.
      * If you want to set shared value for all contexts, be sure to use the root entity manager.
      */
     setFilterParams(name, args) {
-        this.getContext().filterParams[name] = args;
+        this.getContext().#filterParams[name] = args;
     }
     /**
      * Returns filter parameters for given filter set in this context.
      */
     getFilterParams(name) {
-        return this.getContext().filterParams[name];
+        return this.getContext().#filterParams[name];
     }
     /**
      * Sets logger context for this entity manager.
@@ -239,7 +285,7 @@ export class EntityManager {
         return em.loggerContext;
     }
     setFlushMode(flushMode) {
-        this.getContext(false).flushMode = flushMode;
+        this.getContext(false).#flushMode = flushMode;
     }
     async processWhere(entityName, where, options, type) {
         where = QueryHelper.processWhere({
@@ -254,23 +300,34 @@ export class EntityManager {
         where = this.applyDiscriminatorCondition(entityName, where);
         return where;
     }
+    async processUnionWhere(entityName, options, type) {
+        if (options.unionWhere?.length) {
+            if (!this.driver.getPlatform().supportsUnionWhere()) {
+                throw new Error(`unionWhere is only supported on SQL drivers`);
+            }
+            options.unionWhere = (await Promise.all(options.unionWhere.map(branch => this.processWhere(entityName, branch, options, type))));
+        }
+    }
     // this method only handles the problem for mongo driver, SQL drivers have their implementation inside QueryBuilder
     applyDiscriminatorCondition(entityName, where) {
         const meta = this.metadata.find(entityName);
-        if (!meta?.discriminatorValue) {
+        if (meta?.root.inheritanceType !== 'sti' || !meta?.discriminatorValue) {
             return where;
         }
-        const types = Object.values(meta.root.discriminatorMap).map(cls => this.metadata.find(cls));
+        const types = Object.values(meta.root.discriminatorMap).map(cls => this.metadata.get(cls));
         const children = [];
         const lookUpChildren = (ret, type) => {
             const children = types.filter(meta2 => meta2.extends === type);
-            children.forEach(m => lookUpChildren(ret, m.className));
+            children.forEach(m => lookUpChildren(ret, m.class));
             ret.push(...children.filter(c => c.discriminatorValue));
             return children;
         };
-        lookUpChildren(children, meta.className);
+        lookUpChildren(children, meta.class);
         /* v8 ignore next */
-        where[meta.root.discriminatorColumn] = children.length > 0 ? { $in: [meta.discriminatorValue, ...children.map(c => c.discriminatorValue)] } : meta.discriminatorValue;
+        where[meta.root.discriminatorColumn] =
+            children.length > 0
+                ? { $in: [meta.discriminatorValue, ...children.map(c => c.discriminatorValue)] }
+                : meta.discriminatorValue;
         return where;
     }
     createPopulateWhere(cond, options) {
@@ -284,60 +341,78 @@ export class EntityManager {
         }
         return ret;
     }
-    async getJoinedFilters(meta, cond, options) {
+    async getJoinedFilters(meta, options) {
+        // If user provided populateFilter, merge it with computed filters
+        const userFilter = options.populateFilter;
+        if (!this.config.get('filtersOnRelations') || !options.populate) {
+            return userFilter;
+        }
         const ret = {};
-        if (options.populate) {
-            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;
+        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.targetMeta.class, {}, 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);
                 }
-                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;
-                }
-                if (Utils.hasObjectKeys(where2)) {
-                    if (ret[field]) {
-                        Utils.merge(ret[field], where2);
-                    }
-                    else {
-                        ret[field] = where2;
-                    }
+                else {
+                    ret[field] = where2;
                 }
             }
         }
-        return ret;
+        // Merge user-provided populateFilter with computed filters
+        if (userFilter) {
+            Utils.merge(ret, userFilter);
+        }
+        return Utils.hasObjectKeys(ret) ? ret : undefined;
     }
     /**
      * 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?.class === prop.targetMeta.root.class && parent.propName === prop.inversedBy)) {
+                continue;
+            }
+            options = { ...options, filters: QueryHelper.mergePropertyFilters(prop.filters, options.filters) };
+            const cond = await this.applyFilters(prop.targetMeta.class, {}, options.filters, 'read', options);
             if (!Utils.isEmpty(cond)) {
                 const populated = options.populate.filter(({ field }) => field.split(':')[0] === prop.name);
                 let found = false;
-                if (populated.length > 0) {
-                    for (const hint of populated) {
-                        if (!hint.all) {
-                            hint.filter = true;
-                            found = true;
-                        }
-                        else if (hint.field === `${prop.name}:ref`) {
-                            found = true;
-                        }
+                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;
                     }
                 }
                 if (!found) {
@@ -345,27 +420,30 @@ export class EntityManager {
                 }
             }
         }
+        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 }, { class: meta.root.class, propName: prop.name });
+            }
+        }
     }
     /**
      * @internal
      */
     async applyFilters(entityName, where, options, type, findOptions) {
-        const meta = this.metadata.find(entityName);
+        const meta = this.metadata.get(entityName);
         const filters = [];
         const ret = [];
-        if (!meta) {
-            return where;
-        }
         const active = new Set();
         const push = (source) => {
-            const activeFilters = QueryHelper
-                .getActiveFilters(entityName, options, source)
-                .filter(f => !active.has(f.name));
+            const activeFilters = QueryHelper.getActiveFilters(meta, options, source).filter(f => !active.has(f.name));
             filters.push(...activeFilters);
             activeFilters.forEach(f => active.add(f.name));
         };
         push(this.config.get('filters'));
-        push(this.filters);
+        push(this.#filters);
         push(meta.filters);
         if (filters.length === 0) {
             return where;
@@ -374,24 +452,29 @@ 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];
+                // oxfmt-ignore
+                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}'`);
                 }
-                cond = await filter.cond(args, type, this, findOptions, entityName);
+                cond = await filter.cond(args, type, this, findOptions, Utils.className(entityName));
             }
             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));
+        const conds = [...ret, where].filter(c => Utils.hasObjectKeys(c) || Raw.hasObjectFragments(c));
         return conds.length > 1 ? { $and: conds } : conds[0];
     }
     /**
@@ -402,12 +485,10 @@ export class EntityManager {
         const em = this.getContext(false);
         await em.tryFlush(entityName, options);
         options.flushMode = 'commit'; // do not try to auto flush again
-        return RawQueryFragment.run(async () => {
-            return Promise.all([
-                em.find(entityName, where, options),
-                em.count(entityName, where, options),
-            ]);
-        });
+        return Promise.all([
+            em.find(entityName, where, options),
+            em.count(entityName, where, options),
+        ]);
     }
     /**
      * Calls `em.find()` and `em.count()` with the same arguments (where applicable) and returns the results as {@apilink Cursor} object.
@@ -423,21 +504,21 @@ export class EntityManager {
      *     - POJO/entity instance
      *
      * ```ts
-     * const currentCursor = await em.findByCursor(User, {}, {
+     * const currentCursor = await em.findByCursor(User, {
      *   first: 10,
      *   after: previousCursor, // cursor instance
      *   orderBy: { id: 'desc' },
      * });
      *
      * // to fetch next page
-     * const nextCursor = await em.findByCursor(User, {}, {
+     * const nextCursor = await em.findByCursor(User, {
      *   first: 10,
      *   after: currentCursor.endCursor, // opaque string
      *   orderBy: { id: 'desc' },
      * });
      *
      * // to fetch next page
-     * const nextCursor2 = await em.findByCursor(User, {}, {
+     * const nextCursor2 = await em.findByCursor(User, {
      *   first: 10,
      *   after: { id: lastSeenId }, // entity-like POJO
      *   orderBy: { id: 'desc' },
@@ -465,16 +546,16 @@ export class EntityManager {
      * }
      * ```
      */
-    async findByCursor(entityName, where, options) {
+    async findByCursor(entityName, options) {
         const em = this.getContext(false);
-        entityName = Utils.className(entityName);
         options.overfetch ??= true;
-        if (Utils.isEmpty(options.orderBy)) {
+        options.where ??= {};
+        if (Utils.isEmpty(options.orderBy) && !Raw.hasObjectFragments(options.orderBy)) {
             throw new Error('Explicit `orderBy` option required');
         }
         const [entities, count] = options.includeCount !== false
-            ? await em.findAndCount(entityName, where, options)
-            : [await em.find(entityName, where, options)];
+            ? await em.findAndCount(entityName, options.where, options)
+            : [await em.find(entityName, options.where, options)];
         return new Cursor(entities, count, options, this.metadata.get(entityName));
     }
     /**
@@ -486,9 +567,9 @@ export class EntityManager {
         const ret = await this.refresh(entity, options);
         if (!ret) {
             options.failHandler ??= this.config.get('findOneOrFailHandler');
-            const entityName = entity.constructor.name;
-            const where = helper(entity).getPrimaryKey();
-            throw options.failHandler(entityName, where);
+            const wrapped = helper(entity);
+            const where = wrapped.getPrimaryKey();
+            throw options.failHandler(wrapped.__meta.className, where);
         }
         return ret;
     }
@@ -499,29 +580,37 @@ export class EntityManager {
      */
     async refresh(entity, options = {}) {
         const fork = this.fork({ keepTransactionContext: true });
-        const entityName = entity.constructor.name;
-        const reloaded = await fork.findOne(entityName, entity, {
-            schema: helper(entity).__schema,
+        const wrapped = helper(entity);
+        const reloaded = await fork.findOne(wrapped.__meta.class, entity, {
+            schema: wrapped.__schema,
             ...options,
             flushMode: FlushMode.COMMIT,
         });
         const em = this.getContext();
         if (!reloaded) {
-            em.unitOfWork.unsetIdentity(entity);
+            em.#unitOfWork.unsetIdentity(entity);
             return null;
         }
         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);
-            helper(ref).__originalEntityData = this.comparator.prepareEntity(e);
+        for (const e of fork.#unitOfWork.getIdentityMap()) {
+            const ref = em.getReference(e.constructor, helper(e).getPrimaryKey());
+            const data = helper(e).serialize({ ignoreSerializers: true, includeHidden: true, convertCustomTypes: false });
+            em.config
+                .getHydrator(this.metadata)
+                .hydrate(ref, helper(ref).__meta, data, em.#entityFactory, 'full', false, false);
+            Utils.merge(helper(ref).__originalEntityData, this.#comparator.prepareEntity(e));
             found ||= ref === entity;
         }
         if (!found) {
-            const data = helper(reloaded).serialize({ ignoreSerializers: true, includeHidden: true });
-            em.config.getHydrator(this.metadata).hydrate(entity, helper(entity).__meta, data, em.entityFactory, 'full', false, true);
-            helper(entity).__originalEntityData = this.comparator.prepareEntity(reloaded);
+            const data = helper(reloaded).serialize({
+                ignoreSerializers: true,
+                includeHidden: true,
+                convertCustomTypes: 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;
     }
@@ -537,9 +626,8 @@ export class EntityManager {
             return ret;
         }
         const em = this.getContext();
-        entityName = Utils.className(entityName);
         em.prepareOptions(options);
-        let entity = em.unitOfWork.tryGetById(entityName, where, options.schema);
+        let entity = em.#unitOfWork.tryGetById(entityName, where, options.schema);
         // query for a not managed entity which is already in the identity map as it
         // was provided with a PK this entity does not exist in the db, there can't
         // be any relations to it, so no need to deal with the populate hint
@@ -549,19 +637,19 @@ 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);
-        options.populate = await em.preparePopulate(entityName, options);
+        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 !== undefined) {
             if (cached.data) {
-                await em.entityLoader.populate(entityName, [cached.data], options.populate, {
+                await em.#entityLoader.populate(entityName, [cached.data], options.populate, {
                     ...options,
                     ...em.getPopulateWhere(where, options),
                     ignoreLazyScalarProperties: true,
@@ -574,9 +662,10 @@ 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);
+        await em.processUnionWhere(entityName, options, 'read');
         const data = await em.driver.findOne(entityName, where, {
-            ctx: em.transactionContext,
+            ctx: em.#transactionContext,
             em,
             ...options,
         });
@@ -584,14 +673,14 @@ export class EntityManager {
             await em.storeCache(options.cache, cached, null);
             return null;
         }
-        entity = em.entityFactory.create(entityName, data, {
+        entity = em.#entityFactory.create(entityName, data, {
             merge: true,
             refresh: options.refresh,
             schema: options.schema,
             convertCustomTypes: true,
         });
         await em.lockAndPopulate(meta, entity, where, options);
-        await em.unitOfWork.dispatchOnLoadEvent();
+        await em.#unitOfWork.dispatchOnLoadEvent();
         await em.storeCache(options.cache, cached, () => helper(entity).toPOJO());
         return entity;
     }
@@ -615,10 +704,10 @@ export class EntityManager {
         if (!entity || isStrictViolation) {
             const key = options.strict ? 'findExactlyOneOrFailHandler' : 'findOneOrFailHandler';
             options.failHandler ??= this.config.get(key);
-            entityName = Utils.className(entityName);
+            const name = Utils.className(entityName);
             /* v8 ignore next */
             where = Utils.isEntity(where) ? helper(where).getPrimaryKey() : where;
-            throw options.failHandler(entityName, where);
+            throw options.failHandler(name, where);
         }
         return entity;
     }
@@ -658,71 +747,57 @@ export class EntityManager {
         let where;
         let entity = null;
         if (data === undefined) {
-            entityName = entityNameOrEntity.constructor.name;
+            entityName = entityNameOrEntity.constructor;
             data = entityNameOrEntity;
         }
         else {
-            entityName = Utils.className(entityNameOrEntity);
+            entityName = entityNameOrEntity;
         }
         const meta = this.metadata.get(entityName);
         const convertCustomTypes = !Utils.isEntity(data);
         if (Utils.isEntity(data)) {
             entity = data;
             if (helper(entity).__managed && helper(entity).__em === em && !this.config.get('upsertManaged')) {
-                em.entityFactory.mergeData(meta, entity, data, { initialized: true });
+                em.#entityFactory.mergeData(meta, entity, data, { initialized: true });
                 return entity;
             }
             where = helper(entity).getPrimaryKey();
-            data = em.comparator.prepareEntity(entity);
+            data = em.#comparator.prepareEntity(entity);
         }
         else {
             data = Utils.copy(QueryHelper.processParams(data));
             where = Utils.extractPK(data, meta);
             if (where && !this.config.get('upsertManaged')) {
-                const exists = em.unitOfWork.getById(entityName, where, options.schema);
+                const exists = em.#unitOfWork.getById(entityName, where, options.schema);
                 if (exists) {
                     return em.assign(exists, data);
                 }
             }
         }
-        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);
         }
         const ret = await em.driver.nativeUpdate(entityName, where, data, {
-            ctx: em.transactionContext,
+            ctx: em.#transactionContext,
             upsert: true,
             convertCustomTypes,
             ...options,
         });
-        em.unitOfWork.getChangeSetPersister().mapReturnedValues(entity, data, ret.row, meta, true);
-        entity ??= em.entityFactory.create(entityName, data, {
+        em.#unitOfWork.getChangeSetPersister().mapReturnedValues(entity, data, ret.row, meta, true);
+        entity ??= em.#entityFactory.create(entityName, data, {
             refresh: true,
             initialized: true,
             schema: options.schema,
         });
-        const uniqueFields = options.onConflictFields ?? (Utils.isPlainObject(where) ? Object.keys(where) : meta.primaryKeys);
+        const uniqueFields = options.onConflictFields ??
+            (Utils.isPlainObject(where) ? Object.keys(where) : meta.primaryKeys);
         const returning = getOnConflictReturningFields(meta, data, uniqueFields, options);
-        if (options.onConflictAction === 'ignore' || !helper(entity).hasPrimaryKey() || (returning.length > 0 && !(this.getPlatform().usesReturningStatement() && ret.row))) {
+        if (options.onConflictAction === 'ignore' ||
+            !helper(entity).hasPrimaryKey() ||
+            (returning.length > 0 && !(this.getPlatform().usesReturningStatement() && ret.row))) {
             const where = {};
             if (Array.isArray(uniqueFields)) {
                 for (const prop of uniqueFields) {
@@ -742,18 +817,18 @@ export class EntityManager {
                     where[meta.primaryKeys[0]] = ret.insertId;
                 }
             }
-            const data2 = await this.driver.findOne(meta.className, where, {
+            const data2 = await this.driver.findOne(meta.class, where, {
                 fields: returning,
-                ctx: em.transactionContext,
+                ctx: em.#transactionContext,
                 convertCustomTypes: true,
                 connectionType: 'write',
                 schema: options.schema,
             });
-            em.getHydrator().hydrate(entity, meta, data2, em.entityFactory, 'full', false, true);
+            em.getHydrator().hydrate(entity, meta, data2, em.#entityFactory, 'full', false, true);
         }
         // recompute the data as there might be some values missing (e.g. those with db column defaults)
-        const snapshot = this.comparator.prepareEntity(entity);
-        em.unitOfWork.register(entity, snapshot, { refresh: true });
+        const snapshot = this.#comparator.prepareEntity(entity);
+        em.#unitOfWork.register(entity, snapshot, { refresh: true });
         if (em.eventManager.hasListeners(EventType.afterUpsert, meta)) {
             await em.eventManager.dispatchEvent(EventType.afterUpsert, { entity, em, meta }, meta);
         }
@@ -797,11 +872,11 @@ export class EntityManager {
         let entityName;
         let propIndex;
         if (data === undefined) {
-            entityName = entityNameOrEntity[0].constructor.name;
+            entityName = entityNameOrEntity[0].constructor;
             data = entityNameOrEntity;
         }
         else {
-            entityName = Utils.className(entityNameOrEntity);
+            entityName = entityNameOrEntity;
         }
         const batchSize = options.batchSize ?? this.config.get('batchSize');
         if (data.length > batchSize) {
@@ -824,19 +899,19 @@ export class EntityManager {
             if (Utils.isEntity(row)) {
                 const entity = row;
                 if (helper(entity).__managed && helper(entity).__em === em && !this.config.get('upsertManaged')) {
-                    em.entityFactory.mergeData(meta, entity, row, { initialized: true });
+                    em.#entityFactory.mergeData(meta, entity, row, { initialized: true });
                     entities.set(entity, row);
                     entitiesByData.set(row, entity);
                     continue;
                 }
                 where = helper(entity).getPrimaryKey();
-                row = em.comparator.prepareEntity(entity);
+                row = em.#comparator.prepareEntity(entity);
             }
             else {
                 row = data[i] = Utils.copy(QueryHelper.processParams(row));
                 where = Utils.extractPK(row, meta);
                 if (where && !this.config.get('upsertManaged')) {
-                    const exists = em.unitOfWork.getById(entityName, where, options.schema);
+                    const exists = em.#unitOfWork.getById(entityName, where, options.schema);
                     if (exists) {
                         em.assign(exists, row);
                         entities.set(exists, row);
@@ -845,32 +920,20 @@ 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);
         }
@@ -884,7 +947,7 @@ export class EntityManager {
             }
         }
         const res = await em.driver.nativeUpdateMany(entityName, allWhere, allData, {
-            ctx: em.transactionContext,
+            ctx: em.#transactionContext,
             upsert: true,
             convertCustomTypes,
             ...options,
@@ -893,12 +956,16 @@ export class EntityManager {
         entitiesByData.clear();
         const loadPK = new Map();
         allData.forEach((row, i) => {
-            em.unitOfWork.getChangeSetPersister().mapReturnedValues(Utils.isEntity(data[i]) ? data[i] : null, Utils.isEntity(data[i]) ? {} : data[i], res.rows?.[i], meta, true);
-            const entity = Utils.isEntity(data[i]) ? data[i] : em.entityFactory.create(entityName, row, {
-                refresh: true,
-                initialized: true,
-                schema: options.schema,
-            });
+            em.#unitOfWork
+                .getChangeSetPersister()
+                .mapReturnedValues(Utils.isEntity(data[i]) ? data[i] : null, Utils.isEntity(data[i]) ? {} : data[i], res.rows?.[i], meta, true);
+            const entity = Utils.isEntity(data[i])
+                ? data[i]
+                : em.#entityFactory.create(entityName, row, {
+                    refresh: true,
+                    initialized: true,
+                    schema: options.schema,
+                });
             if (!helper(entity).hasPrimaryKey()) {
                 loadPK.set(entity, allWhere[i]);
             }
@@ -906,12 +973,15 @@ export class EntityManager {
             entitiesByData.set(row, entity);
         });
         // skip if we got the PKs via returning statement (`rows`)
+        // oxfmt-ignore
         const uniqueFields = options.onConflictFields ?? (Utils.isPlainObject(allWhere[0]) ? Object.keys(allWhere[0]).flatMap(key => Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
         const returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options);
         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));
             }
@@ -923,9 +993,11 @@ export class EntityManager {
                     where.$or[idx][prop] = item[prop];
                 });
             });
-            const data2 = await this.driver.find(meta.className, where, {
-                fields: returning.concat(...add).concat(...(Array.isArray(uniqueFields) ? uniqueFields : [])),
-                ctx: em.transactionContext,
+            const data2 = await this.driver.find(meta.class, where, {
+                fields: returning
+                    .concat(...add)
+                    .concat(...(Array.isArray(uniqueFields) ? uniqueFields : [])),
+                ctx: em.#transactionContext,
                 convertCustomTypes: true,
                 connectionType: 'write',
                 schema: options.schema,
@@ -938,13 +1010,13 @@ export class EntityManager {
                             tmp[k] = row[k];
                         }
                     });
-                    return this.comparator.matching(entityName, cond, tmp);
+                    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)}`);
                 }
-                em.getHydrator().hydrate(entity, meta, row, em.entityFactory, 'full', false, true);
+                em.getHydrator().hydrate(entity, meta, row, em.#entityFactory, 'full', false, true);
             }
             if (loadPK.size !== data2.length && Array.isArray(uniqueFields)) {
                 for (let i = 0; i < allData.length; i++) {
@@ -961,20 +1033,20 @@ export class EntityManager {
                             a[b] = item[b];
                             return a;
                         }, {});
-                        return this.comparator.matching(entityName, cond, pk);
+                        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)}`);
                     }
-                    em.getHydrator().hydrate(entity, meta, row, em.entityFactory, 'full');
+                    em.getHydrator().hydrate(entity, meta, row, em.#entityFactory, 'full');
                 }
             }
         }
         for (const [entity] of entities) {
             // recompute the data as there might be some values missing (e.g. those with db column defaults)
-            const snapshot = this.comparator.prepareEntity(entity);
-            em.unitOfWork.register(entity, snapshot, { refresh: true });
+            const snapshot = this.#comparator.prepareEntity(entity);
+            em.#unitOfWork.register(entity, snapshot, { refresh: true });
         }
         if (em.eventManager.hasListeners(EventType.afterUpsert, meta)) {
             for (const [entity] of entities) {
@@ -1011,7 +1083,7 @@ export class EntityManager {
      */
     async transactional(cb, options = {}) {
         const em = this.getContext(false);
-        if (this.disableTransactions || em.disableTransactions) {
+        if (this.#disableTransactions || em.#disableTransactions) {
             return cb(em);
         }
         const manager = new TransactionManager(this);
@@ -1021,11 +1093,11 @@ export class EntityManager {
      * Starts new transaction bound to this EntityManager. Use `ctx` parameter to provide the parent when nesting transactions.
      */
     async begin(options = {}) {
-        if (this.disableTransactions) {
+        if (this.#disableTransactions) {
             return;
         }
         const em = this.getContext(false);
-        em.transactionContext = await em.getConnection('write').begin({
+        em.#transactionContext = await em.getConnection('write').begin({
             ...options,
             eventBroadcaster: new TransactionEventBroadcaster(em, { topLevelTransaction: !options.ctx }),
         });
@@ -1035,31 +1107,31 @@ export class EntityManager {
      */
     async commit() {
         const em = this.getContext(false);
-        if (this.disableTransactions) {
+        if (this.#disableTransactions) {
             await em.flush();
             return;
         }
-        if (!em.transactionContext) {
+        if (!em.#transactionContext) {
             throw ValidationError.transactionRequired();
         }
         await em.flush();
-        await em.getConnection('write').commit(em.transactionContext, new TransactionEventBroadcaster(em));
-        delete em.transactionContext;
+        await em.getConnection('write').commit(em.#transactionContext, new TransactionEventBroadcaster(em));
+        em.#transactionContext = undefined;
     }
     /**
      * Rollbacks the transaction bound to this EntityManager.
      */
     async rollback() {
-        if (this.disableTransactions) {
+        if (this.#disableTransactions) {
             return;
         }
         const em = this.getContext(false);
-        if (!em.transactionContext) {
+        if (!em.#transactionContext) {
             throw ValidationError.transactionRequired();
         }
-        await em.getConnection('write').rollback(em.transactionContext, new TransactionEventBroadcaster(em));
-        delete em.transactionContext;
-        em.unitOfWork.clearActionsQueue();
+        await em.getConnection('write').rollback(em.#transactionContext, new TransactionEventBroadcaster(em));
+        em.#transactionContext = undefined;
+        em.#unitOfWork.clearActionsQueue();
     }
     /**
      * Runs your callback wrapped inside a database transaction.
@@ -1076,11 +1148,11 @@ export class EntityManager {
         em.prepareOptions(options);
         let entityName;
         if (data === undefined) {
-            entityName = entityNameOrEntity.constructor.name;
+            entityName = entityNameOrEntity.constructor;
             data = entityNameOrEntity;
         }
         else {
-            entityName = Utils.className(entityNameOrEntity);
+            entityName = entityNameOrEntity;
         }
         if (Utils.isEntity(data)) {
             if (options.schema && helper(data).getSchema() == null) {
@@ -1088,19 +1160,22 @@ export class EntityManager {
             }
             if (!helper(data).__managed) {
                 // the entity might have been created via `em.create()`, which adds it to the persist stack automatically
-                em.unitOfWork.getPersistStack().delete(data);
+                em.#unitOfWork.getPersistStack().delete(data);
                 // it can be also in the identity map if it had a PK value already
-                em.unitOfWork.unsetIdentity(data);
+                em.#unitOfWork.unsetIdentity(data);
             }
             const meta = helper(data).__meta;
-            const payload = em.comparator.prepareEntity(data);
+            const payload = em.#comparator.prepareEntity(data);
             const cs = new ChangeSet(data, ChangeSetType.CREATE, payload, meta);
-            await em.unitOfWork.getChangeSetPersister().executeInserts([cs], { ctx: em.transactionContext, ...options });
+            await em.#unitOfWork.getChangeSetPersister().executeInserts([cs], { ctx: em.#transactionContext, ...options });
             return cs.getPrimaryKey();
         }
         data = QueryHelper.processObjectParams(data);
-        em.validator.validateParams(data, 'insert data');
-        const res = await em.driver.nativeInsert(entityName, data, { ctx: em.transactionContext, ...options });
+        validateParams(data, 'insert data');
+        const res = await em.driver.nativeInsert(entityName, data, {
+            ctx: em.#transactionContext,
+            ...options,
+        });
         return res.insertId;
     }
     /**
@@ -1111,11 +1186,11 @@ export class EntityManager {
         em.prepareOptions(options);
         let entityName;
         if (data === undefined) {
-            entityName = entityNameOrEntities[0].constructor.name;
+            entityName = entityNameOrEntities[0].constructor;
             data = entityNameOrEntities;
         }
         else {
-            entityName = Utils.className(entityNameOrEntities);
+            entityName = entityNameOrEntities;
         }
         if (data.length === 0) {
             return [];
@@ -1128,19 +1203,22 @@ export class EntityManager {
                 }
                 if (!helper(row).__managed) {
                     // the entity might have been created via `em.create()`, which adds it to the persist stack automatically
-                    em.unitOfWork.getPersistStack().delete(row);
+                    em.#unitOfWork.getPersistStack().delete(row);
                     // it can be also in the identity map if it had a PK value already
-                    em.unitOfWork.unsetIdentity(row);
+                    em.#unitOfWork.unsetIdentity(row);
                 }
-                const payload = em.comparator.prepareEntity(row);
+                const payload = em.#comparator.prepareEntity(row);
                 return new ChangeSet(row, ChangeSetType.CREATE, payload, meta);
             });
-            await em.unitOfWork.getChangeSetPersister().executeInserts(css, { ctx: em.transactionContext, ...options });
+            await em.#unitOfWork.getChangeSetPersister().executeInserts(css, { ctx: em.#transactionContext, ...options });
             return css.map(cs => cs.getPrimaryKey());
         }
         data = data.map(row => QueryHelper.processObjectParams(row));
-        data.forEach(row => em.validator.validateParams(row, 'insert data'));
-        const res = await em.driver.nativeInsertMany(entityName, data, { ctx: em.transactionContext, ...options });
+        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;
         }
@@ -1152,12 +1230,16 @@ export class EntityManager {
     async nativeUpdate(entityName, where, data, options = {}) {
         const em = this.getContext(false);
         em.prepareOptions(options);
-        entityName = Utils.className(entityName);
+        await em.processUnionWhere(entityName, options, 'update');
         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');
-        const res = await em.driver.nativeUpdate(entityName, where, data, { ctx: em.transactionContext, ...options });
+        validateParams(data, 'update data');
+        validateParams(where, 'update condition');
+        const res = await em.driver.nativeUpdate(entityName, where, data, {
+            ctx: em.#transactionContext,
+            em,
+            ...options,
+        });
         return res.affectedRows;
     }
     /**
@@ -1166,28 +1248,36 @@ export class EntityManager {
     async nativeDelete(entityName, where, options = {}) {
         const em = this.getContext(false);
         em.prepareOptions(options);
-        entityName = Utils.className(entityName);
-        where = await em.processWhere(entityName, where, options, 'delete');
-        em.validator.validateParams(where, 'delete condition');
-        const res = await em.driver.nativeDelete(entityName, where, { ctx: em.transactionContext, ...options });
+        await em.processUnionWhere(entityName, options, 'delete');
+        where = (await em.processWhere(entityName, where, options, 'delete'));
+        validateParams(where, 'delete condition');
+        const res = await em.driver.nativeDelete(entityName, where, {
+            ctx: em.#transactionContext,
+            em,
+            ...options,
+        });
         return res.affectedRows;
     }
     /**
      * Maps raw database result to an entity and merges it to this EntityManager.
      */
     map(entityName, result, options = {}) {
-        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,
         });
     }
     /**
@@ -1196,34 +1286,23 @@ export class EntityManager {
      */
     merge(entityName, data, options = {}) {
         if (Utils.isEntity(entityName)) {
-            return this.merge(entityName.constructor.name, entityName, data);
+            return this.merge(entityName.constructor, entityName, data);
         }
         const em = options.disableContextResolution ? this : this.getContext();
-        options.schema ??= em._schema;
+        options.schema ??= em.#schema;
         options.validate ??= true;
         options.cascade ??= true;
-        entityName = Utils.className(entityName);
-        if (options.validate) {
-            em.validator.validatePrimaryKey(data, em.metadata.get(entityName));
-        }
-        let entity = em.unitOfWork.tryGetById(entityName, data, options.schema, false);
+        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);
         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 });
-        if (options.validate) {
-            em.validator.validate(entity, data, childMeta ?? meta);
-        }
+        entity = dataIsEntity
+            ? data
+            : em.#entityFactory.create(entityName, data, { merge: true, ...options });
         const visited = options.cascade ? undefined : new Set([entity]);
-        em.unitOfWork.merge(entity, visited);
+        em.#unitOfWork.merge(entity, visited);
         return entity;
     }
     /**
@@ -1243,11 +1322,12 @@ export class EntityManager {
      */
     create(entityName, data, options = {}) {
         const em = this.getContext();
-        options.schema ??= em._schema;
-        const entity = em.entityFactory.create(entityName, data, {
+        options.schema ??= em.#schema;
+        const entity = em.#entityFactory.create(entityName, data, {
             ...options,
             newEntity: !options.managed,
             merge: options.managed,
+            normalizeAccessors: true,
         });
         options.persist ??= em.config.get('persistOnCreate');
         if (options.persist && !this.getMetadata(entityName).embeddable) {
@@ -1267,7 +1347,7 @@ export class EntityManager {
     getReference(entityName, id, options = {}) {
         options.schema ??= this.schema;
         options.convertCustomTypes ??= false;
-        const meta = this.metadata.get(Utils.className(entityName));
+        const meta = this.metadata.get(entityName);
         if (Utils.isPrimaryKey(id)) {
             if (meta.compositePK) {
                 throw ValidationError.invalidCompositeIdentifier(meta);
@@ -1288,24 +1368,24 @@ export class EntityManager {
         // Shallow copy options since the object will be modified when deleting orderBy
         options = { ...options };
         em.prepareOptions(options);
-        entityName = Utils.className(entityName);
         await em.tryFlush(entityName, options);
         where = await em.processWhere(entityName, where, options, 'read');
-        options.populate = await em.preparePopulate(entityName, options);
+        options.populate = (await em.preparePopulate(entityName, options));
         options = { ...options };
         // save the original hint value so we know it was infer/all
         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;
+        await em.processUnionWhere(entityName, options, 'read');
         const cacheKey = em.cacheKey(entityName, options, 'em.count', where);
         const cached = await em.tryCache(entityName, options.cache, cacheKey);
         if (cached?.data !== undefined) {
             return cached.data;
         }
-        const count = await em.driver.count(entityName, where, { ctx: em.transactionContext, em, ...options });
+        const count = await em.driver.count(entityName, where, { ctx: em.#transactionContext, em, ...options });
         await em.storeCache(options.cache, cached, () => +count);
         return +count;
     }
@@ -1317,28 +1397,21 @@ export class EntityManager {
         const em = this.getContext();
         if (Utils.isEntity(entity)) {
             // do not cascade just yet, cascading of entities in persist stack is done when flushing
-            em.unitOfWork.persist(entity, undefined, { cascade: false });
+            em.#unitOfWork.persist(entity, undefined, { cascade: false });
             return em;
         }
         const entities = Utils.asArray(entity);
         for (const ent of entities) {
             if (!Utils.isEntity(ent, true)) {
                 /* v8 ignore next */
-                const meta = typeof ent === 'object' ? em.metadata.find(ent.constructor.name) : undefined;
+                const meta = typeof ent === 'object' ? em.metadata.find(ent.constructor) : undefined;
                 throw ValidationError.notDiscoveredEntity(ent, meta);
             }
             // do not cascade just yet, cascading of entities in persist stack is done when flushing
-            em.unitOfWork.persist(Reference.unwrapReference(ent), undefined, { cascade: false });
+            em.#unitOfWork.persist(Reference.unwrapReference(ent), undefined, { cascade: false });
         }
         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.
@@ -1349,7 +1422,7 @@ export class EntityManager {
         const em = this.getContext();
         if (Utils.isEntity(entity)) {
             // do not cascade just yet, cascading of entities in persist stack is done when flushing
-            em.unitOfWork.remove(entity, undefined, { cascade: false });
+            em.#unitOfWork.remove(entity, undefined, { cascade: false });
             return em;
         }
         const entities = Utils.asArray(entity, true);
@@ -1358,17 +1431,10 @@ export class EntityManager {
                 throw new Error(`You need to pass entity instance or reference to 'em.remove()'. To remove entities by condition, use 'em.nativeDelete()'.`);
             }
             // do not cascade just yet, cascading of entities in remove stack is done when flushing
-            em.unitOfWork.remove(Reference.unwrapReference(ent), undefined, { cascade: false });
+            em.#unitOfWork.remove(Reference.unwrapReference(ent), undefined, { cascade: false });
         }
         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.
@@ -1381,8 +1447,7 @@ export class EntityManager {
      */
     async tryFlush(entityName, options) {
         const em = this.getContext();
-        const flushMode = options.flushMode ?? em.flushMode ?? em.config.get('flushMode');
-        entityName = Utils.className(entityName);
+        const flushMode = options.flushMode ?? em.#flushMode ?? em.config.get('flushMode');
         const meta = em.metadata.get(entityName);
         if (flushMode === FlushMode.COMMIT) {
             return;
@@ -1395,13 +1460,12 @@ export class EntityManager {
      * Clears the EntityManager. All entities that are currently managed by this EntityManager become detached.
      */
     clear() {
-        this.getContext().unitOfWork.clear();
+        this.getContext().#unitOfWork.clear();
     }
     /**
      * Checks whether given property can be populated on the entity.
      */
     canPopulate(entityName, property) {
-        entityName = Utils.className(entityName);
         // eslint-disable-next-line prefer-const
         let [p, ...parts] = property.split('.');
         const meta = this.metadata.find(entityName);
@@ -1411,12 +1475,11 @@ export class EntityManager {
         if (p.includes(':')) {
             p = p.split(':', 2)[0];
         }
-        const ret = p in meta.root.properties;
-        if (!ret) {
-            return !!this.metadata.find(property)?.pivotTable;
-        }
+        // For TPT inheritance, check the entity's own properties, not just the root's
+        // For STI, meta.properties includes all properties anyway
+        const ret = p in meta.properties;
         if (parts.length > 0) {
-            return this.canPopulate((meta.root.properties)[p].type, parts.join('.'));
+            return this.canPopulate(meta.properties[p].targetMeta.class, parts.join('.'));
         }
         return ret;
     }
@@ -1430,9 +1493,9 @@ 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);
-        await em.entityLoader.populate(entityName, arr, preparedPopulate, options);
+        const entityName = arr[0].constructor;
+        const preparedPopulate = await em.preparePopulate(entityName, { populate: populate, filters: options.filters }, options.validate);
+        await em.#entityLoader.populate(entityName, arr, preparedPopulate, options);
         return entities;
     }
     /**
@@ -1453,25 +1516,26 @@ export class EntityManager {
         const allowGlobalContext = em.config.get('allowGlobalContext');
         em.config.set('allowGlobalContext', true);
         const fork = new em.constructor(em.config, em.driver, em.metadata, options.useContext, eventManager);
-        fork.setFlushMode(options.flushMode ?? em.flushMode);
-        fork.disableTransactions = options.disableTransactions ?? this.disableTransactions ?? this.config.get('disableTransactions');
+        fork.setFlushMode(options.flushMode ?? em.#flushMode);
+        fork.#disableTransactions =
+            options.disableTransactions ?? this.#disableTransactions ?? this.config.get('disableTransactions');
         em.config.set('allowGlobalContext', allowGlobalContext);
         if (options.keepTransactionContext) {
-            fork.transactionContext = em.transactionContext;
+            fork.#transactionContext = em.#transactionContext;
         }
-        fork.filters = { ...em.filters };
-        fork.filterParams = Utils.copy(em.filterParams);
+        fork.#filters = { ...em.#filters };
+        fork.#filterParams = Utils.copy(em.#filterParams);
         fork.loggerContext = Utils.merge({}, em.loggerContext, options.loggerContext);
-        fork._schema = options.schema ?? em._schema;
+        fork.#schema = options.schema ?? em.#schema;
         if (!options.clear) {
-            for (const entity of em.unitOfWork.getIdentityMap()) {
-                fork.unitOfWork.register(entity);
+            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.getPersistStack()) {
+                fork.#unitOfWork.persist(entity);
             }
-            for (const entity of em.unitOfWork.getOrphanRemoveStack()) {
-                fork.unitOfWork.getOrphanRemoveStack().add(entity);
+            for (const entity of em.#unitOfWork.getOrphanRemoveStack()) {
+                fork.#unitOfWork.getOrphanRemoveStack().add(entity);
             }
         }
         return fork;
@@ -1481,21 +1545,21 @@ export class EntityManager {
      */
     getUnitOfWork(useContext = true) {
         if (!useContext) {
-            return this.unitOfWork;
+            return this.#unitOfWork;
         }
-        return this.getContext().unitOfWork;
+        return this.getContext().#unitOfWork;
     }
     /**
      * Gets the EntityFactory used by the EntityManager.
      */
     getEntityFactory() {
-        return this.getContext().entityFactory;
+        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;
+        return this.getContext().#entityLoader;
     }
     /**
      * Gets the Hydrator used by the EntityManager.
@@ -1508,7 +1572,7 @@ export class EntityManager {
      * @internal
      */
     getContext(validate = true) {
-        if (!this.useContext) {
+        if (!this.#useContext) {
             return this;
         }
         let em = TransactionContext.getEntityManager(this.name); // prefer the tx context
@@ -1529,13 +1593,13 @@ export class EntityManager {
      * Checks whether this EntityManager is currently operating inside a database transaction.
      */
     isInTransaction() {
-        return !!this.getContext(false).transactionContext;
+        return !!this.getContext(false).#transactionContext;
     }
     /**
      * Gets the transaction context (driver dependent object used to make sure queries are executed on same connection).
      */
     getTransactionContext() {
-        return this.getContext(false).transactionContext;
+        return this.getContext(false).#transactionContext;
     }
     /**
      * Sets the transaction context.
@@ -1545,21 +1609,20 @@ export class EntityManager {
             this.resetTransactionContext();
         }
         else {
-            this.getContext(false).transactionContext = ctx;
+            this.getContext(false).#transactionContext = ctx;
         }
     }
     /**
      * Resets the transaction context.
      */
     resetTransactionContext() {
-        delete this.getContext(false).transactionContext;
+        this.getContext(false).#transactionContext = undefined;
     }
     /**
      * Gets the `MetadataStorage` (without parameters) or `EntityMetadata` instance when provided with the `entityName` parameter.
      */
     getMetadata(entityName) {
         if (entityName) {
-            entityName = Utils.className(entityName);
             return this.metadata.get(entityName);
         }
         return this.metadata;
@@ -1568,7 +1631,7 @@ export class EntityManager {
      * Gets the EntityComparator.
      */
     getComparator() {
-        return this.comparator;
+        return this.#comparator;
     }
     checkLockRequirements(mode, meta) {
         if (!mode) {
@@ -1588,8 +1651,8 @@ export class EntityManager {
                 lockTableAliases: options.lockTableAliases,
             });
         }
-        const preparedPopulate = await this.preparePopulate(meta.className, options);
-        await this.entityLoader.populate(meta.className, [entity], preparedPopulate, {
+        const preparedPopulate = await this.preparePopulate(meta.class, options);
+        await this.#entityLoader.populate(meta.class, [entity], preparedPopulate, {
             ...options,
             ...this.getPopulateWhere(where, options),
             orderBy: options.populateOrderBy ?? options.orderBy,
@@ -1609,6 +1672,7 @@ export class EntityManager {
             return ret;
         }, []);
     }
+    /** @internal */
     async preparePopulate(entityName, options, validate = true) {
         if (options.populate === false) {
             return [];
@@ -1621,11 +1685,14 @@ export class EntityManager {
                 const ret = [];
                 for (let field of fields) {
                     if (field === PopulatePath.ALL || field.startsWith(`${PopulatePath.ALL}.`)) {
-                        ret.push(...meta.props.filter(prop => prop.lazy || [ReferenceKind.SCALAR, ReferenceKind.EMBEDDED].includes(prop.kind)).map(prop => prop.name));
+                        ret.push(...meta.props
+                            .filter(prop => prop.lazy || [ReferenceKind.SCALAR, ReferenceKind.EMBEDDED].includes(prop.kind))
+                            .map(prop => prop.name));
                         continue;
                     }
                     field = field.split(':')[0];
-                    if (!field.includes('.') && ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(meta.properties[field].kind)) {
+                    if (!field.includes('.') &&
+                        ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(meta.properties[field].kind)) {
                         ret.push(field);
                         continue;
                     }
@@ -1649,13 +1716,14 @@ export class EntityManager {
             options.populate = pruneToOneRelations(meta, this.buildFields(options.fields));
         }
         if (!options.populate) {
-            const populate = this.entityLoader.normalizePopulate(entityName, [], options.strategy);
+            const populate = this.#entityLoader.normalizePopulate(entityName, [], options.strategy, true, options.exclude);
             await this.autoJoinRefsForFilters(meta, { ...options, populate });
             return populate;
         }
         if (typeof options.populate !== 'boolean') {
-            options.populate = Utils.asArray(options.populate).map(field => {
-                /* v8 ignore next 3 */
+            options.populate = Utils.asArray(options.populate)
+                .map(field => {
+                /* v8 ignore next */
                 if (typeof field === 'boolean' || field === PopulatePath.ALL) {
                     return [{ field: meta.primaryKeys[0], strategy: options.strategy, all: !!field }]; //
                 }
@@ -1665,24 +1733,28 @@ 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];
-            }).flat();
+            })
+                .flat();
         }
-        const populate = this.entityLoader.normalizePopulate(entityName, options.populate, options.strategy);
+        const populate = this.#entityLoader.normalizePopulate(entityName, options.populate, options.strategy, true, options.exclude);
         const invalid = populate.find(({ field }) => !this.canPopulate(entityName, field));
         if (validate && invalid) {
             throw ValidationError.invalidPropertyName(entityName, invalid.field);
         }
         await this.autoJoinRefsForFilters(meta, { ...options, populate });
-        return populate.map(field => {
+        for (const field of populate) {
             // force select-in strategy when populating all relations as otherwise we could cause infinite loops when self-referencing
             const all = field.all ?? (Array.isArray(options.populate) && options.populate.includes('*'));
             field.strategy = all ? LoadStrategy.SELECT_IN : (options.strategy ?? field.strategy);
-            return field;
-        });
+        }
+        if (options.populateHints) {
+            applyPopulateHints(populate, options.populateHints);
+        }
+        return populate;
     }
     /**
      * when the entity is found in identity map, we check if it was partially loaded or we are trying to populate
@@ -1702,7 +1774,7 @@ export class EntityManager {
                 return !inlineEmbedded && !prop.lazy && !helper(entity).__loadedProperties.has(prop.name);
             });
         }
-        if (autoRefresh) {
+        if (autoRefresh || options.filters) {
             return true;
         }
         if (Array.isArray(options.populate)) {
@@ -1714,7 +1786,7 @@ export class EntityManager {
         if (!Utils.isEmpty(options.fields) && !Utils.isEmpty(options.exclude)) {
             throw new ValidationError(`Cannot combine 'fields' and 'exclude' option.`);
         }
-        options.schema ??= this._schema;
+        options.schema ??= this.#schema;
         options.logging = options.loggerContext = Utils.merge({ id: this.id }, this.loggerContext, options.loggerContext, options.logging);
     }
     /**
@@ -1726,7 +1798,7 @@ export class EntityManager {
         for (const k of ['ctx', 'strategy', 'flushMode', 'logging', 'loggerContext']) {
             delete opts[k];
         }
-        return [entityName, method, opts, where];
+        return [Utils.className(entityName), method, opts, where];
     }
     /**
      * @internal
@@ -1738,31 +1810,27 @@ export class EntityManager {
         }
         const em = this.getContext();
         const cacheKey = Array.isArray(config) ? config[0] : JSON.stringify(key);
-        const cached = await em.resultCache.get(cacheKey);
+        const cached = await em.#resultCache.get(cacheKey);
         if (!cached) {
             return { key: cacheKey, data: cached };
         }
         let data;
+        const createOptions = {
+            merge: true,
+            convertCustomTypes: false,
+            refresh,
+            recomputeSnapshot: true,
+        };
         if (Array.isArray(cached) && merge) {
-            data = cached.map(item => em.entityFactory.create(entityName, item, {
-                merge: true,
-                convertCustomTypes: true,
-                refresh,
-                recomputeSnapshot: true,
-            }));
+            data = cached.map(item => em.#entityFactory.create(entityName, item, createOptions));
         }
         else if (Utils.isObject(cached) && merge) {
-            data = em.entityFactory.create(entityName, cached, {
-                merge: true,
-                convertCustomTypes: true,
-                refresh,
-                recomputeSnapshot: true,
-            });
+            data = em.#entityFactory.create(entityName, cached, createOptions);
         }
         else {
             data = cached;
         }
-        await em.unitOfWork.dispatchOnLoadEvent();
+        await em.#unitOfWork.dispatchOnLoadEvent();
         return { key: cacheKey, data };
     }
     /**
@@ -1772,8 +1840,8 @@ 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);
-            await em.resultCache.set(key.key, data instanceof Function ? data() : data, '', expiration);
+            const expiration = Array.isArray(config) ? config[1] : typeof config === 'number' ? config : undefined;
+            await em.#resultCache.set(key.key, data instanceof Function ? data() : data, '', expiration);
         }
     }
     /**
@@ -1789,21 +1857,38 @@ export class EntityManager {
      * ```
      */
     async clearCache(cacheKey) {
-        await this.getContext().resultCache.remove(cacheKey);
+        await this.getContext().#resultCache.remove(cacheKey);
     }
     /**
      * Returns the default schema of this EntityManager. Respects the context, so global EM will give you the contextual schema
      * if executed inside request context handler.
      */
     get schema() {
-        return this.getContext(false)._schema;
+        return this.getContext(false).#schema;
     }
     /**
      * Sets the default schema of this EntityManager. Respects the context, so global EM will set the contextual schema
      * if executed inside request context handler.
      */
     set schema(schema) {
-        this.getContext(false)._schema = schema ?? undefined;
+        this.getContext(false).#schema = schema ?? undefined;
+    }
+    /** @internal */
+    async getDataLoader(type) {
+        const em = this.getContext();
+        if (em.#loaders[type]) {
+            return em.#loaders[type];
+        }
+        const { DataloaderUtils } = await import('@mikro-orm/core/dataloader');
+        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
@@ -1813,7 +1898,7 @@ export class EntityManager {
         return this.getContext(false)._id;
     }
     /** @ignore */
-    [inspect.custom]() {
+    [Symbol.for('nodejs.util.inspect.custom')]() {
         return `[EntityManager<${this.id}>]`;
     }
 }