@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.3

package/EntityManager.js

@@ -1,29 +1,30 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityManager = void 0;
-const node_util_1 = require("node:util");
-const dataloader_1 = __importDefault(require("dataloader"));
-const upsert_utils_1 = require("./utils/upsert-utils");
-const Utils_1 = require("./utils/Utils");
-const Cursor_1 = require("./utils/Cursor");
-const DataloaderUtils_1 = require("./utils/DataloaderUtils");
-const QueryHelper_1 = require("./utils/QueryHelper");
-const TransactionContext_1 = require("./utils/TransactionContext");
-const RawQueryFragment_1 = require("./utils/RawQueryFragment");
-const entity_1 = require("./entity");
-const unit_of_work_1 = require("./unit-of-work");
-const enums_1 = require("./enums");
-const events_1 = require("./events");
-const errors_1 = require("./errors");
+import { inspect } from 'node:util';
+import DataLoader from 'dataloader';
+import { getOnConflictReturningFields } 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 { EntityFactory } from './entity/EntityFactory.js';
+import { EntityAssigner } from './entity/EntityAssigner.js';
+import { EntityValidator } from './entity/EntityValidator.js';
+import { EntityLoader } from './entity/EntityLoader.js';
+import { Reference } from './entity/Reference.js';
+import { helper } from './entity/wrap.js';
+import { ChangeSet, ChangeSetType } from './unit-of-work/ChangeSet.js';
+import { UnitOfWork } from './unit-of-work/UnitOfWork.js';
+import { EventType, FlushMode, LoadStrategy, LockMode, PopulateHint, PopulatePath, QueryFlag, ReferenceKind, SCALAR_TYPES, } from './enums.js';
+import { EventManager } from './events/EventManager.js';
+import { TransactionEventBroadcaster } from './events/TransactionEventBroadcaster.js';
+import { OptimisticLockError, ValidationError } from './errors.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.
  * @template {IDatabaseDriver} Driver current driver type
  */
-class EntityManager {
+export class EntityManager {
     config;
     driver;
     metadata;
@@ -33,8 +34,8 @@ class EntityManager {
     _id = EntityManager.counter++;
     global = false;
     name;
-    refLoader = new dataloader_1.default(DataloaderUtils_1.DataloaderUtils.getRefBatchLoadFn(this));
-    colLoader = new dataloader_1.default(DataloaderUtils_1.DataloaderUtils.getColBatchLoadFn(this));
+    refLoader = new DataLoader(DataloaderUtils.getRefBatchLoadFn(this));
+    colLoader = new DataLoader(DataloaderUtils.getColBatchLoadFn(this));
     validator;
     repositoryMap = {};
     entityLoader;
@@ -52,20 +53,20 @@ class EntityManager {
     /**
      * @internal
      */
-    constructor(config, driver, metadata, useContext = true, eventManager = new events_1.EventManager(config.get('subscribers'))) {
+    constructor(config, driver, metadata, useContext = true, eventManager = new EventManager(config.get('subscribers'))) {
         this.config = config;
         this.driver = driver;
         this.metadata = metadata;
         this.useContext = useContext;
         this.eventManager = eventManager;
-        this.entityLoader = new entity_1.EntityLoader(this);
+        this.entityLoader = new EntityLoader(this);
         this.name = this.config.get('contextName');
-        this.validator = new entity_1.EntityValidator(this.config.get('strict'));
+        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 entity_1.EntityFactory(this);
-        this.unitOfWork = new unit_of_work_1.UnitOfWork(this);
+        this.entityFactory = new EntityFactory(this);
+        this.unitOfWork = new UnitOfWork(this);
     }
     /**
      * Gets the Driver instance used by this EntityManager.
@@ -90,7 +91,7 @@ class EntityManager {
      * Gets repository for given entity. You can pass either string name or entity class reference.
      */
     getRepository(entityName) {
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         if (!this.repositoryMap[entityName]) {
             const meta = this.metadata.get(entityName);
             const RepositoryClass = this.config.getRepositoryClass(meta.repository);
@@ -124,7 +125,7 @@ class EntityManager {
         const em = this.getContext();
         em.prepareOptions(options);
         await em.tryFlush(entityName, options);
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         where = await em.processWhere(entityName, where, options, 'read');
         em.validator.validateParams(where);
         options.orderBy = options.orderBy || {};
@@ -163,7 +164,7 @@ class EntityManager {
             });
             ret.push(entity);
         }
-        const unique = Utils_1.Utils.unique(ret);
+        const unique = Utils.unique(ret);
         await em.entityLoader.populate(entityName, unique, populate, {
             ...options,
             ...em.getPopulateWhere(where, options),
@@ -176,7 +177,7 @@ class EntityManager {
             await em.storeCache(options.cache, cached, () => ret);
         }
         else {
-            await em.storeCache(options.cache, cached, () => unique.map(e => (0, entity_1.helper)(e).toPOJO()));
+            await em.storeCache(options.cache, cached, () => unique.map(e => helper(e).toPOJO()));
         }
         return unique;
     }
@@ -190,11 +191,11 @@ class EntityManager {
         if (options.populateWhere === undefined) {
             options.populateWhere = this.config.get('populateWhere');
         }
-        if (options.populateWhere === enums_1.PopulateHint.ALL) {
+        if (options.populateWhere === PopulateHint.ALL) {
             return { where: {}, populateWhere: options.populateWhere };
         }
-        /* istanbul ignore next */
-        if (options.populateWhere === enums_1.PopulateHint.INFER) {
+        /* v8 ignore next 3 */
+        if (options.populateWhere === PopulateHint.INFER) {
             return { where, populateWhere: options.populateWhere };
         }
         return { where: options.populateWhere };
@@ -205,7 +206,7 @@ class EntityManager {
     addFilter(name, cond, entityName, enabled = true) {
         const options = { name, cond, default: enabled };
         if (entityName) {
-            options.entity = Utils_1.Utils.asArray(entityName).map(n => Utils_1.Utils.className(n));
+            options.entity = Utils.asArray(entityName).map(n => Utils.className(n));
         }
         this.getContext(false).filters[name] = options;
     }
@@ -240,7 +241,7 @@ class EntityManager {
         this.getContext(false).flushMode = flushMode;
     }
     async processWhere(entityName, where, options, type) {
-        where = QueryHelper_1.QueryHelper.processWhere({
+        where = QueryHelper.processWhere({
             where,
             entityName,
             metadata: this.metadata,
@@ -249,7 +250,7 @@ class EntityManager {
             aliased: type === 'read',
         });
         where = (await this.applyFilters(entityName, where, options.filters ?? {}, type, options));
-        where = await this.applyDiscriminatorCondition(entityName, where);
+        where = this.applyDiscriminatorCondition(entityName, where);
         return where;
     }
     // this method only handles the problem for mongo driver, SQL drivers have their implementation inside QueryBuilder
@@ -267,18 +268,18 @@ class EntityManager {
             return children;
         };
         lookUpChildren(children, meta.className);
-        /* istanbul ignore next */
+        /* v8 ignore next */
         where[meta.root.discriminatorColumn] = children.length > 0 ? { $in: [meta.discriminatorValue, ...children.map(c => c.discriminatorValue)] } : meta.discriminatorValue;
         return where;
     }
     createPopulateWhere(cond, options) {
         const ret = {};
         const populateWhere = options.populateWhere ?? this.config.get('populateWhere');
-        if (populateWhere === enums_1.PopulateHint.INFER) {
-            Utils_1.Utils.merge(ret, cond);
+        if (populateWhere === PopulateHint.INFER) {
+            Utils.merge(ret, cond);
         }
         else if (typeof populateWhere === 'object') {
-            Utils_1.Utils.merge(ret, populateWhere);
+            Utils.merge(ret, populateWhere);
         }
         return ret;
     }
@@ -288,18 +289,18 @@ class EntityManager {
             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')) === enums_1.LoadStrategy.JOINED && prop.kind !== enums_1.ReferenceKind.SCALAR;
+                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: enums_1.PopulateHint.ALL });
-                if (Utils_1.Utils.hasObjectKeys(where)) {
+                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_1.Utils.hasObjectKeys(where2)) {
+                if (Utils.hasObjectKeys(where2)) {
                     if (ret[field]) {
-                        Utils_1.Utils.merge(ret[field], where2);
+                        Utils.merge(ret[field], where2);
                     }
                     else {
                         ret[field] = where2;
@@ -317,19 +318,19 @@ class EntityManager {
             return;
         }
         const props = meta.relations.filter(prop => {
-            return !prop.object && [enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)
+            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);
-            if (!Utils_1.Utils.isEmpty(cond)) {
+            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);
                 }
                 else {
-                    ret.push({ field: `${prop.name}:ref`, strategy: enums_1.LoadStrategy.JOINED, filter: true });
+                    ret.push({ field: `${prop.name}:ref`, strategy: LoadStrategy.JOINED, filter: true });
                 }
             }
         }
@@ -346,7 +347,7 @@ class EntityManager {
         }
         const active = new Set();
         const push = (source) => {
-            const activeFilters = QueryHelper_1.QueryHelper
+            const activeFilters = QueryHelper
                 .getActiveFilters(entityName, options, source)
                 .filter(f => !active.has(f.name));
             filters.push(...activeFilters);
@@ -362,7 +363,7 @@ class EntityManager {
             let cond;
             if (filter.cond instanceof Function) {
                 // @ts-ignore
-                const args = Utils_1.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}'`);
                 }
@@ -371,7 +372,7 @@ class EntityManager {
             else {
                 cond = filter.cond;
             }
-            ret.push(QueryHelper_1.QueryHelper.processWhere({
+            ret.push(QueryHelper.processWhere({
                 where: cond,
                 entityName,
                 metadata: this.metadata,
@@ -379,7 +380,7 @@ class EntityManager {
                 aliased: type === 'read',
             }));
         }
-        const conds = [...ret, where].filter(c => Utils_1.Utils.hasObjectKeys(c));
+        const conds = [...ret, where].filter(c => Utils.hasObjectKeys(c));
         return conds.length > 1 ? { $and: conds } : conds[0];
     }
     /**
@@ -390,7 +391,7 @@ class EntityManager {
         const em = this.getContext(false);
         await em.tryFlush(entityName, options);
         options.flushMode = 'commit'; // do not try to auto flush again
-        return RawQueryFragment_1.RawQueryFragment.run(async () => {
+        return RawQueryFragment.run(async () => {
             return Promise.all([
                 em.find(entityName, where, options),
                 em.count(entityName, where, options),
@@ -451,13 +452,13 @@ class EntityManager {
      */
     async findByCursor(entityName, where, options) {
         const em = this.getContext(false);
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         options.overfetch ??= true;
-        if (Utils_1.Utils.isEmpty(options.orderBy)) {
+        if (Utils.isEmpty(options.orderBy)) {
             throw new Error('Explicit `orderBy` option required');
         }
         const [entities, count] = await em.findAndCount(entityName, where, options);
-        return new Cursor_1.Cursor(entities, count, options, this.metadata.get(entityName));
+        return new Cursor(entities, count, options, this.metadata.get(entityName));
     }
     /**
      * Refreshes the persistent state of an entity from the database, overriding any local changes that have not yet been
@@ -469,7 +470,7 @@ class EntityManager {
         if (!ret) {
             options.failHandler ??= this.config.get('findOneOrFailHandler');
             const entityName = entity.constructor.name;
-            const where = (0, entity_1.helper)(entity).getPrimaryKey();
+            const where = helper(entity).getPrimaryKey();
             throw options.failHandler(entityName, where);
         }
         return ret;
@@ -483,12 +484,12 @@ class EntityManager {
         const fork = this.fork({ keepTransactionContext: true });
         const entityName = entity.constructor.name;
         const reloaded = await fork.findOne(entityName, entity, {
-            schema: (0, entity_1.helper)(entity).__schema,
+            schema: helper(entity).__schema,
             ...options,
-            flushMode: enums_1.FlushMode.COMMIT,
+            flushMode: FlushMode.COMMIT,
         });
         if (reloaded) {
-            this.config.getHydrator(this.metadata).hydrate(entity, (0, entity_1.helper)(entity).__meta, (0, entity_1.helper)(reloaded).toPOJO(), this.getEntityFactory(), 'full');
+            this.config.getHydrator(this.metadata).hydrate(entity, helper(entity).__meta, helper(reloaded).toPOJO(), this.getEntityFactory(), 'full');
         }
         else {
             this.getUnitOfWork().unsetIdentity(entity);
@@ -507,13 +508,13 @@ class EntityManager {
             return ret;
         }
         const em = this.getContext();
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         em.prepareOptions(options);
         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
-        if (entity && !(0, entity_1.helper)(entity).__managed) {
+        if (entity && !helper(entity).__managed) {
             return entity;
         }
         await em.tryFlush(entityName, options);
@@ -521,7 +522,7 @@ class EntityManager {
         where = await em.processWhere(entityName, where, options, 'read');
         em.validator.validateEmptyWhere(where);
         em.checkLockRequirements(options.lockMode, meta);
-        const isOptimisticLocking = !Utils_1.Utils.isDefined(options.lockMode) || options.lockMode === enums_1.LockMode.OPTIMISTIC;
+        const isOptimisticLocking = !Utils.isDefined(options.lockMode) || options.lockMode === LockMode.OPTIMISTIC;
         if (entity && !em.shouldRefresh(meta, entity, options) && isOptimisticLocking) {
             return em.lockAndPopulate(meta, entity, where, options);
         }
@@ -560,7 +561,7 @@ class EntityManager {
         });
         await em.lockAndPopulate(meta, entity, where, options);
         await em.unitOfWork.dispatchOnLoadEvent();
-        await em.storeCache(options.cache, cached, () => (0, entity_1.helper)(entity).toPOJO());
+        await em.storeCache(options.cache, cached, () => helper(entity).toPOJO());
         return entity;
     }
     /**
@@ -583,9 +584,9 @@ class EntityManager {
         if (!entity || isStrictViolation) {
             const key = options.strict ? 'findExactlyOneOrFailHandler' : 'findOneOrFailHandler';
             options.failHandler ??= this.config.get(key);
-            entityName = Utils_1.Utils.className(entityName);
-            /* istanbul ignore next */
-            where = Utils_1.Utils.isEntity(where) ? (0, entity_1.helper)(where).getPrimaryKey() : where;
+            entityName = Utils.className(entityName);
+            /* v8 ignore next */
+            where = Utils.isEntity(where) ? helper(where).getPrimaryKey() : where;
             throw options.failHandler(entityName, where);
         }
         return entity;
@@ -630,22 +631,22 @@ class EntityManager {
             data = entityNameOrEntity;
         }
         else {
-            entityName = Utils_1.Utils.className(entityNameOrEntity);
+            entityName = Utils.className(entityNameOrEntity);
         }
         const meta = this.metadata.get(entityName);
-        const convertCustomTypes = !Utils_1.Utils.isEntity(data);
-        if (Utils_1.Utils.isEntity(data)) {
+        const convertCustomTypes = !Utils.isEntity(data);
+        if (Utils.isEntity(data)) {
             entity = data;
-            if ((0, entity_1.helper)(entity).__managed && (0, entity_1.helper)(entity).__em === em && !this.config.get('upsertManaged')) {
+            if (helper(entity).__managed && helper(entity).__em === em && !this.config.get('upsertManaged')) {
                 em.entityFactory.mergeData(meta, entity, data, { initialized: true });
                 return entity;
             }
-            where = (0, entity_1.helper)(entity).getPrimaryKey();
+            where = helper(entity).getPrimaryKey();
             data = em.comparator.prepareEntity(entity);
         }
         else {
-            data = Utils_1.Utils.copy(QueryHelper_1.QueryHelper.processParams(data));
-            where = Utils_1.Utils.extractPK(data, meta);
+            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);
                 if (exists) {
@@ -654,15 +655,15 @@ class EntityManager {
             }
         }
         const unique = options.onConflictFields ?? meta.props.filter(p => p.unique).map(p => p.name);
-        const propIndex = !(0, RawQueryFragment_1.isRaw)(unique) && unique.findIndex(p => data[p] != null);
+        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_1.Utils.asArray(u.properties).every(p => data[p] != null)) {
-                        where = Utils_1.Utils.asArray(u.properties).reduce((o, key) => {
+                    if (Utils.asArray(u.properties).every(p => data[p] != null)) {
+                        where = Utils.asArray(u.properties).reduce((o, key) => {
                             o[key] = data[key];
                             return o;
                         }, {});
@@ -671,10 +672,10 @@ class EntityManager {
                 }
             }
         }
-        data = QueryHelper_1.QueryHelper.processObjectParams(data);
+        data = QueryHelper.processObjectParams(data);
         em.validator.validateParams(data, 'insert data');
-        if (em.eventManager.hasListeners(enums_1.EventType.beforeUpsert, meta)) {
-            await em.eventManager.dispatchEvent(enums_1.EventType.beforeUpsert, { entity: data, em, meta }, meta);
+        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,
@@ -688,9 +689,9 @@ class EntityManager {
             initialized: true,
             schema: options.schema,
         });
-        const uniqueFields = options.onConflictFields ?? (Utils_1.Utils.isPlainObject(where) ? Object.keys(where) : meta.primaryKeys);
-        const returning = (0, upsert_utils_1.getOnConflictReturningFields)(meta, data, uniqueFields, options);
-        if (options.onConflictAction === 'ignore' || !(0, entity_1.helper)(entity).hasPrimaryKey() || (returning.length > 0 && !(this.getPlatform().usesReturningStatement() && ret.row))) {
+        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))) {
             const where = {};
             if (Array.isArray(uniqueFields)) {
                 for (const prop of uniqueFields) {
@@ -721,8 +722,8 @@ class EntityManager {
         // 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 });
-        if (em.eventManager.hasListeners(enums_1.EventType.afterUpsert, meta)) {
-            await em.eventManager.dispatchEvent(enums_1.EventType.afterUpsert, { entity, em, meta }, meta);
+        if (em.eventManager.hasListeners(EventType.afterUpsert, meta)) {
+            await em.eventManager.dispatchEvent(EventType.afterUpsert, { entity, em, meta }, meta);
         }
         return entity;
     }
@@ -768,19 +769,19 @@ class EntityManager {
             data = entityNameOrEntity;
         }
         else {
-            entityName = Utils_1.Utils.className(entityNameOrEntity);
+            entityName = Utils.className(entityNameOrEntity);
         }
         const batchSize = options.batchSize ?? this.config.get('batchSize');
         if (data.length > batchSize) {
             const ret = [];
             for (let i = 0; i < data.length; i += batchSize) {
                 const chunk = data.slice(i, i + batchSize);
-                ret.push(...await this.upsertMany(entityName, chunk, options));
+                ret.push(...(await this.upsertMany(entityName, chunk, options)));
             }
             return ret;
         }
         const meta = this.metadata.get(entityName);
-        const convertCustomTypes = !Utils_1.Utils.isEntity(data[0]);
+        const convertCustomTypes = !Utils.isEntity(data[0]);
         const allData = [];
         const allWhere = [];
         const entities = new Map();
@@ -788,20 +789,20 @@ class EntityManager {
         for (let i = 0; i < data.length; i++) {
             let row = data[i];
             let where;
-            if (Utils_1.Utils.isEntity(row)) {
+            if (Utils.isEntity(row)) {
                 const entity = row;
-                if ((0, entity_1.helper)(entity).__managed && (0, entity_1.helper)(entity).__em === em && !this.config.get('upsertManaged')) {
+                if (helper(entity).__managed && helper(entity).__em === em && !this.config.get('upsertManaged')) {
                     em.entityFactory.mergeData(meta, entity, row, { initialized: true });
                     entities.set(entity, row);
                     entitiesByData.set(row, entity);
                     continue;
                 }
-                where = (0, entity_1.helper)(entity).getPrimaryKey();
+                where = helper(entity).getPrimaryKey();
                 row = em.comparator.prepareEntity(entity);
             }
             else {
-                row = data[i] = Utils_1.Utils.copy(QueryHelper_1.QueryHelper.processParams(row));
-                where = Utils_1.Utils.extractPK(row, meta);
+                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);
                     if (exists) {
@@ -820,8 +821,8 @@ class EntityManager {
                 }
                 else if (meta.uniques.length > 0) {
                     for (const u of meta.uniques) {
-                        if (Utils_1.Utils.asArray(u.properties).every(p => row[p] != null)) {
-                            where = Utils_1.Utils.asArray(u.properties).reduce((o, key) => {
+                        if (Utils.asArray(u.properties).every(p => row[p] != null)) {
+                            where = Utils.asArray(u.properties).reduce((o, key) => {
                                 o[key] = row[key];
                                 return o;
                             }, {});
@@ -830,8 +831,8 @@ class EntityManager {
                     }
                 }
             }
-            row = QueryHelper_1.QueryHelper.processObjectParams(row);
-            where = QueryHelper_1.QueryHelper.processWhere({
+            row = QueryHelper.processObjectParams(row);
+            where = QueryHelper.processWhere({
                 where,
                 entityName,
                 metadata: this.metadata,
@@ -844,10 +845,10 @@ class EntityManager {
         if (entities.size === data.length) {
             return [...entities.keys()];
         }
-        if (em.eventManager.hasListeners(enums_1.EventType.beforeUpsert, meta)) {
+        if (em.eventManager.hasListeners(EventType.beforeUpsert, meta)) {
             for (const dto of data) {
                 const entity = entitiesByData.get(dto) ?? dto;
-                await em.eventManager.dispatchEvent(enums_1.EventType.beforeUpsert, { entity, em, meta }, meta);
+                await em.eventManager.dispatchEvent(EventType.beforeUpsert, { entity, em, meta }, meta);
             }
         }
         const res = await em.driver.nativeUpdateMany(entityName, allWhere, allData, {
@@ -860,27 +861,27 @@ class EntityManager {
         entitiesByData.clear();
         const loadPK = new Map();
         allData.forEach((row, i) => {
-            em.unitOfWork.getChangeSetPersister().mapReturnedValues(Utils_1.Utils.isEntity(data[i]) ? data[i] : null, Utils_1.Utils.isEntity(data[i]) ? {} : data[i], res.rows?.[i], meta, true);
-            const entity = Utils_1.Utils.isEntity(data[i]) ? data[i] : em.entityFactory.create(entityName, row, {
+            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 (!(0, entity_1.helper)(entity).hasPrimaryKey()) {
+            if (!helper(entity).hasPrimaryKey()) {
                 loadPK.set(entity, allWhere[i]);
             }
             entities.set(entity, row);
             entitiesByData.set(row, entity);
         });
         // skip if we got the PKs via returning statement (`rows`)
-        const uniqueFields = options.onConflictFields ?? (Utils_1.Utils.isPlainObject(allWhere[0]) ? Object.keys(allWhere[0]).flatMap(key => Utils_1.Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
-        const returning = (0, upsert_utils_1.getOnConflictReturningFields)(meta, data[0], uniqueFields, options);
+        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]] : []);
             for (const cond of loadPK.values()) {
-                Utils_1.Utils.keys(cond).forEach(key => add.add(key));
+                Utils.keys(cond).forEach(key => add.add(key));
             }
             const where = { $or: [] };
             data.forEach((item, idx) => {
@@ -906,7 +907,7 @@ class EntityManager {
                     });
                     return this.comparator.matching(entityName, cond, tmp);
                 });
-                /* istanbul ignore next */
+                /* v8 ignore next 3 */
                 if (!row) {
                     throw new Error(`Cannot find matching entity for condition ${JSON.stringify(cond)}`);
                 }
@@ -929,7 +930,7 @@ class EntityManager {
                         }, {});
                         return this.comparator.matching(entityName, cond, pk);
                     });
-                    /* istanbul ignore next */
+                    /* v8 ignore next 3 */
                     if (!row) {
                         throw new Error(`Cannot find matching entity for condition ${JSON.stringify(cond)}`);
                     }
@@ -942,9 +943,9 @@ class EntityManager {
             const snapshot = this.comparator.prepareEntity(entity);
             em.unitOfWork.register(entity, snapshot, { refresh: true });
         }
-        if (em.eventManager.hasListeners(enums_1.EventType.afterUpsert, meta)) {
+        if (em.eventManager.hasListeners(EventType.afterUpsert, meta)) {
             for (const [entity] of entities) {
-                await em.eventManager.dispatchEvent(enums_1.EventType.afterUpsert, { entity, em, meta }, meta);
+                await em.eventManager.dispatchEvent(EventType.afterUpsert, { entity, em, meta }, meta);
             }
         }
         return [...entities.keys()];
@@ -966,14 +967,14 @@ class EntityManager {
         });
         options.ctx ??= em.transactionContext;
         const propagateToUpperContext = !em.global || this.config.get('allowGlobalContext');
-        return TransactionContext_1.TransactionContext.create(fork, async () => {
+        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 => [unit_of_work_1.ChangeSetType.DELETE, unit_of_work_1.ChangeSetType.DELETE_EARLY].includes(cs.type))
+                                .filter(cs => [ChangeSetType.DELETE, ChangeSetType.DELETE_EARLY].includes(cs.type))
                                 .forEach(cs => em.unitOfWork.unsetIdentity(cs.entity));
                         },
                     });
@@ -988,7 +989,7 @@ class EntityManager {
                     }
                 }
                 return ret;
-            }, { ...options, eventBroadcaster: new events_1.TransactionEventBroadcaster(fork, { topLevelTransaction: !options.ctx }) });
+            }, { ...options, eventBroadcaster: new TransactionEventBroadcaster(fork, { topLevelTransaction: !options.ctx }) });
         });
     }
     /**
@@ -1001,7 +1002,7 @@ class EntityManager {
         const em = this.getContext(false);
         em.transactionContext = await em.getConnection('write').begin({
             ...options,
-            eventBroadcaster: new events_1.TransactionEventBroadcaster(em, { topLevelTransaction: !options.ctx }),
+            eventBroadcaster: new TransactionEventBroadcaster(em, { topLevelTransaction: !options.ctx }),
         });
     }
     /**
@@ -1014,10 +1015,10 @@ class EntityManager {
             return;
         }
         if (!em.transactionContext) {
-            throw errors_1.ValidationError.transactionRequired();
+            throw ValidationError.transactionRequired();
         }
         await em.flush();
-        await em.getConnection('write').commit(em.transactionContext, new events_1.TransactionEventBroadcaster(em));
+        await em.getConnection('write').commit(em.transactionContext, new TransactionEventBroadcaster(em));
         delete em.transactionContext;
     }
     /**
@@ -1029,9 +1030,9 @@ class EntityManager {
         }
         const em = this.getContext(false);
         if (!em.transactionContext) {
-            throw errors_1.ValidationError.transactionRequired();
+            throw ValidationError.transactionRequired();
         }
-        await em.getConnection('write').rollback(em.transactionContext, new events_1.TransactionEventBroadcaster(em));
+        await em.getConnection('write').rollback(em.transactionContext, new TransactionEventBroadcaster(em));
         delete em.transactionContext;
         em.unitOfWork.clearActionsQueue();
     }
@@ -1039,7 +1040,7 @@ class EntityManager {
      * Runs your callback wrapped inside a database transaction.
      */
     async lock(entity, lockMode, options = {}) {
-        options = Utils_1.Utils.isPlainObject(options) ? options : { lockVersion: options };
+        options = Utils.isPlainObject(options) ? options : { lockVersion: options };
         await this.getUnitOfWork().lock(entity, { lockMode, ...options });
     }
     /**
@@ -1054,25 +1055,25 @@ class EntityManager {
             data = entityNameOrEntity;
         }
         else {
-            entityName = Utils_1.Utils.className(entityNameOrEntity);
+            entityName = Utils.className(entityNameOrEntity);
         }
-        if (Utils_1.Utils.isEntity(data)) {
-            if (options.schema && (0, entity_1.helper)(data).getSchema() == null) {
-                (0, entity_1.helper)(data).setSchema(options.schema);
+        if (Utils.isEntity(data)) {
+            if (options.schema && helper(data).getSchema() == null) {
+                helper(data).setSchema(options.schema);
             }
-            if (!(0, entity_1.helper)(data).__managed) {
+            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);
                 // it can be also in the identity map if it had a PK value already
                 em.unitOfWork.unsetIdentity(data);
             }
-            const meta = (0, entity_1.helper)(data).__meta;
+            const meta = helper(data).__meta;
             const payload = em.comparator.prepareEntity(data);
-            const cs = new unit_of_work_1.ChangeSet(data, unit_of_work_1.ChangeSetType.CREATE, payload, meta);
+            const cs = new ChangeSet(data, ChangeSetType.CREATE, payload, meta);
             await em.unitOfWork.getChangeSetPersister().executeInserts([cs], { ctx: em.transactionContext, ...options });
             return cs.getPrimaryKey();
         }
-        data = QueryHelper_1.QueryHelper.processObjectParams(data);
+        data = QueryHelper.processObjectParams(data);
         em.validator.validateParams(data, 'insert data');
         const res = await em.driver.nativeInsert(entityName, data, { ctx: em.transactionContext, ...options });
         return res.insertId;
@@ -1089,30 +1090,30 @@ class EntityManager {
             data = entityNameOrEntities;
         }
         else {
-            entityName = Utils_1.Utils.className(entityNameOrEntities);
+            entityName = Utils.className(entityNameOrEntities);
         }
         if (data.length === 0) {
             return [];
         }
-        if (Utils_1.Utils.isEntity(data[0])) {
-            const meta = (0, entity_1.helper)(data[0]).__meta;
+        if (Utils.isEntity(data[0])) {
+            const meta = helper(data[0]).__meta;
             const css = data.map(row => {
-                if (options.schema && (0, entity_1.helper)(row).getSchema() == null) {
-                    (0, entity_1.helper)(row).setSchema(options.schema);
+                if (options.schema && helper(row).getSchema() == null) {
+                    helper(row).setSchema(options.schema);
                 }
-                if (!(0, entity_1.helper)(row).__managed) {
+                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);
                     // it can be also in the identity map if it had a PK value already
                     em.unitOfWork.unsetIdentity(row);
                 }
                 const payload = em.comparator.prepareEntity(row);
-                return new unit_of_work_1.ChangeSet(row, unit_of_work_1.ChangeSetType.CREATE, payload, meta);
+                return new ChangeSet(row, ChangeSetType.CREATE, payload, meta);
             });
             await em.unitOfWork.getChangeSetPersister().executeInserts(css, { ctx: em.transactionContext, ...options });
             return css.map(cs => cs.getPrimaryKey());
         }
-        data = data.map(row => QueryHelper_1.QueryHelper.processObjectParams(row));
+        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 });
         if (res.insertedIds) {
@@ -1126,8 +1127,8 @@ class EntityManager {
     async nativeUpdate(entityName, where, data, options = {}) {
         const em = this.getContext(false);
         em.prepareOptions(options);
-        entityName = Utils_1.Utils.className(entityName);
-        data = QueryHelper_1.QueryHelper.processObjectParams(data);
+        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');
@@ -1140,7 +1141,7 @@ class EntityManager {
     async nativeDelete(entityName, where, options = {}) {
         const em = this.getContext(false);
         em.prepareOptions(options);
-        entityName = Utils_1.Utils.className(entityName);
+        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 });
@@ -1150,12 +1151,12 @@ class EntityManager {
      * Maps raw database result to an entity and merges it to this EntityManager.
      */
     map(entityName, result, options = {}) {
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         const meta = this.metadata.get(entityName);
         const data = this.driver.mapResult(result, meta);
         Object.keys(data).forEach(k => {
             const prop = meta.properties[k];
-            if (prop && prop.kind === enums_1.ReferenceKind.SCALAR && enums_1.SCALAR_TYPES.includes(prop.runtimeType) && !prop.customType && (prop.setter || !prop.getter)) {
+            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);
             }
         });
@@ -1170,19 +1171,19 @@ class EntityManager {
      */
     merge(entityName, data, options = {}) {
         const em = this.getContext();
-        if (Utils_1.Utils.isEntity(entityName)) {
+        if (Utils.isEntity(entityName)) {
             return em.merge(entityName.constructor.name, entityName, data);
         }
         options.schema ??= em._schema;
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         em.validator.validatePrimaryKey(data, em.metadata.get(entityName));
         let entity = em.unitOfWork.tryGetById(entityName, data, options.schema, false);
-        if (entity && (0, entity_1.helper)(entity).__managed && (0, entity_1.helper)(entity).__initialized && !options.refresh) {
+        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_1.Utils.isEntity(data) ? data : em.entityFactory.create(entityName, data, { merge: true, ...options });
+        entity = Utils.isEntity(data) ? data : em.entityFactory.create(entityName, data, { merge: true, ...options });
         em.validator.validate(entity, data, childMeta ?? meta);
         em.unitOfWork.merge(entity);
         return entity;
@@ -1220,7 +1221,7 @@ class EntityManager {
      * Shortcut for `wrap(entity).assign(data, { em })`
      */
     assign(entity, data, options = {}) {
-        return entity_1.EntityAssigner.assign(entity, data, { em: this.getContext(), ...options });
+        return EntityAssigner.assign(entity, data, { em: this.getContext(), ...options });
     }
     /**
      * Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
@@ -1228,16 +1229,16 @@ class EntityManager {
     getReference(entityName, id, options = {}) {
         options.schema ??= this.schema;
         options.convertCustomTypes ??= false;
-        const meta = this.metadata.get(Utils_1.Utils.className(entityName));
-        if (Utils_1.Utils.isPrimaryKey(id)) {
+        const meta = this.metadata.get(Utils.className(entityName));
+        if (Utils.isPrimaryKey(id)) {
             if (meta.compositePK) {
-                throw errors_1.ValidationError.invalidCompositeIdentifier(meta);
+                throw ValidationError.invalidCompositeIdentifier(meta);
             }
             id = [id];
         }
         const entity = this.getEntityFactory().createReference(entityName, id, { merge: true, ...options });
         if (options.wrapped) {
-            return entity_1.Reference.create(entity);
+            return Reference.create(entity);
         }
         return entity;
     }
@@ -1251,7 +1252,7 @@ class EntityManager {
             schema: em._schema,
             ...options,
         };
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         await em.tryFlush(entityName, options);
         where = await em.processWhere(entityName, where, options, 'read');
         options.populate = await em.preparePopulate(entityName, options);
@@ -1278,20 +1279,20 @@ class EntityManager {
      */
     persist(entity) {
         const em = this.getContext();
-        if (Utils_1.Utils.isEntity(entity)) {
+        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 });
             return em;
         }
-        const entities = Utils_1.Utils.asArray(entity);
+        const entities = Utils.asArray(entity);
         for (const ent of entities) {
-            if (!Utils_1.Utils.isEntity(ent, true)) {
-                /* istanbul ignore next */
+            if (!Utils.isEntity(ent, true)) {
+                /* v8 ignore next */
                 const meta = typeof ent === 'object' ? em.metadata.find(ent.constructor.name) : undefined;
-                throw errors_1.ValidationError.notDiscoveredEntity(ent, meta);
+                throw ValidationError.notDiscoveredEntity(ent, meta);
             }
             // do not cascade just yet, cascading of entities in persist stack is done when flushing
-            em.unitOfWork.persist(entity_1.Reference.unwrapReference(ent), undefined, { cascade: false });
+            em.unitOfWork.persist(Reference.unwrapReference(ent), undefined, { cascade: false });
         }
         return this;
     }
@@ -1310,18 +1311,18 @@ class EntityManager {
      */
     remove(entity) {
         const em = this.getContext();
-        if (Utils_1.Utils.isEntity(entity)) {
+        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 });
             return em;
         }
-        const entities = Utils_1.Utils.asArray(entity, true);
+        const entities = Utils.asArray(entity, true);
         for (const ent of entities) {
-            if (!Utils_1.Utils.isEntity(ent, true)) {
+            if (!Utils.isEntity(ent, true)) {
                 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(entity_1.Reference.unwrapReference(ent), undefined, { cascade: false });
+            em.unitOfWork.remove(Reference.unwrapReference(ent), undefined, { cascade: false });
         }
         return em;
     }
@@ -1345,12 +1346,12 @@ class EntityManager {
     async tryFlush(entityName, options) {
         const em = this.getContext();
         const flushMode = options.flushMode ?? em.flushMode ?? em.config.get('flushMode');
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         const meta = em.metadata.get(entityName);
-        if (flushMode === enums_1.FlushMode.COMMIT) {
+        if (flushMode === FlushMode.COMMIT) {
             return;
         }
-        if (flushMode === enums_1.FlushMode.ALWAYS || em.getUnitOfWork().shouldAutoFlush(meta)) {
+        if (flushMode === FlushMode.ALWAYS || em.getUnitOfWork().shouldAutoFlush(meta)) {
             await em.flush();
         }
     }
@@ -1364,7 +1365,7 @@ class EntityManager {
      * Checks whether given property can be populated on the entity.
      */
     canPopulate(entityName, property) {
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         // eslint-disable-next-line prefer-const
         let [p, ...parts] = property.split('.');
         const meta = this.metadata.find(entityName);
@@ -1387,7 +1388,7 @@ class EntityManager {
      * Loads specified relations in batch. This will execute one query for each relation, that will populate it on all the specified entities.
      */
     async populate(entities, populate, options = {}) {
-        const arr = Utils_1.Utils.asArray(entities);
+        const arr = Utils.asArray(entities);
         if (arr.length === 0) {
             return entities;
         }
@@ -1408,7 +1409,7 @@ class EntityManager {
         options.freshEventManager ??= false;
         options.cloneEventManager ??= false;
         const eventManager = options.freshEventManager
-            ? new events_1.EventManager(em.config.get('subscribers'))
+            ? new EventManager(em.config.get('subscribers'))
             : options.cloneEventManager
                 ? em.eventManager.clone()
                 : em.eventManager;
@@ -1423,8 +1424,8 @@ class EntityManager {
             fork.transactionContext = em.transactionContext;
         }
         fork.filters = { ...em.filters };
-        fork.filterParams = Utils_1.Utils.copy(em.filterParams);
-        fork.loggerContext = Utils_1.Utils.merge({}, em.loggerContext, options.loggerContext);
+        fork.filterParams = Utils.copy(em.filterParams);
+        fork.loggerContext = Utils.merge({}, em.loggerContext, options.loggerContext);
         fork._schema = options.schema ?? em._schema;
         if (!options.clear) {
             for (const entity of em.unitOfWork.getIdentityMap()) {
@@ -1465,14 +1466,14 @@ class EntityManager {
         if (!this.useContext) {
             return this;
         }
-        let em = TransactionContext_1.TransactionContext.getEntityManager(this.name); // prefer the tx context
+        let em = TransactionContext.getEntityManager(this.name); // prefer the tx context
         if (em) {
             return em;
         }
         // no explicit tx started
         em = this.config.get('context')(this.name) ?? this;
         if (validate && !this.config.get('allowGlobalContext') && em.global) {
-            throw errors_1.ValidationError.cannotUseGlobalContext();
+            throw ValidationError.cannotUseGlobalContext();
         }
         return em;
     }
@@ -1513,7 +1514,7 @@ class EntityManager {
      */
     getMetadata(entityName) {
         if (entityName) {
-            entityName = Utils_1.Utils.className(entityName);
+            entityName = Utils.className(entityName);
             return this.metadata.get(entityName);
         }
         return this.metadata;
@@ -1528,15 +1529,15 @@ class EntityManager {
         if (!mode) {
             return;
         }
-        if (mode === enums_1.LockMode.OPTIMISTIC && !meta.versionProperty) {
-            throw errors_1.OptimisticLockError.notVersioned(meta);
+        if (mode === LockMode.OPTIMISTIC && !meta.versionProperty) {
+            throw OptimisticLockError.notVersioned(meta);
         }
-        if ([enums_1.LockMode.PESSIMISTIC_READ, enums_1.LockMode.PESSIMISTIC_WRITE].includes(mode) && !this.isInTransaction()) {
-            throw errors_1.ValidationError.transactionRequired();
+        if ([LockMode.PESSIMISTIC_READ, LockMode.PESSIMISTIC_WRITE].includes(mode) && !this.isInTransaction()) {
+            throw ValidationError.transactionRequired();
         }
     }
     async lockAndPopulate(meta, entity, where, options) {
-        if (!meta.virtual && options.lockMode === enums_1.LockMode.OPTIMISTIC) {
+        if (!meta.virtual && options.lockMode === LockMode.OPTIMISTIC) {
             await this.lock(entity, options.lockMode, {
                 lockVersion: options.lockVersion,
                 lockTableAliases: options.lockTableAliases,
@@ -1555,8 +1556,8 @@ class EntityManager {
     }
     buildFields(fields) {
         return fields.reduce((ret, f) => {
-            if (Utils_1.Utils.isPlainObject(f)) {
-                Utils_1.Utils.keys(f).forEach(ff => ret.push(...this.buildFields(f[ff]).map(field => `${ff}.${field}`)));
+            if (Utils.isPlainObject(f)) {
+                Utils.keys(f).forEach(ff => ret.push(...this.buildFields(f[ff]).map(field => `${ff}.${field}`)));
             }
             else {
                 ret.push(f);
@@ -1575,12 +1576,12 @@ class EntityManager {
             const pruneToOneRelations = (meta, fields) => {
                 const ret = [];
                 for (let field of fields) {
-                    if (field === enums_1.PopulatePath.ALL || field.startsWith(`${enums_1.PopulatePath.ALL}.`)) {
-                        ret.push(...meta.props.filter(prop => prop.lazy || [enums_1.ReferenceKind.SCALAR, enums_1.ReferenceKind.EMBEDDED].includes(prop.kind)).map(prop => prop.name));
+                    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));
                         continue;
                     }
                     field = field.split(':')[0];
-                    if (!field.includes('.') && ![enums_1.ReferenceKind.MANY_TO_ONE, enums_1.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;
                     }
@@ -1599,7 +1600,7 @@ class EntityManager {
                         ret.push(...inner.map(c => `${key}.${c}`));
                     }
                 }
-                return Utils_1.Utils.unique(ret);
+                return Utils.unique(ret);
             };
             options.populate = pruneToOneRelations(meta, this.buildFields(options.fields));
         }
@@ -1609,18 +1610,18 @@ class EntityManager {
             return populate;
         }
         if (typeof options.populate !== 'boolean') {
-            options.populate = Utils_1.Utils.asArray(options.populate).map(field => {
-                /* istanbul ignore next */
-                if (typeof field === 'boolean' || field === enums_1.PopulatePath.ALL) {
+            options.populate = Utils.asArray(options.populate).map(field => {
+                /* v8 ignore next 3 */
+                if (typeof field === 'boolean' || field === PopulatePath.ALL) {
                     return [{ field: meta.primaryKeys[0], strategy: options.strategy, all: !!field }]; //
                 }
                 // will be handled in QueryBuilder when processing the where condition via CriteriaNode
-                if (field === enums_1.PopulatePath.INFER) {
+                if (field === PopulatePath.INFER) {
                     options.flags ??= [];
-                    options.flags.push(enums_1.QueryFlag.INFER_POPULATE);
+                    options.flags.push(QueryFlag.INFER_POPULATE);
                     return [];
                 }
-                if (Utils_1.Utils.isString(field)) {
+                if (Utils.isString(field)) {
                     return [{ field, strategy: options.strategy }];
                 }
                 return [field];
@@ -1629,13 +1630,13 @@ class EntityManager {
         const populate = this.entityLoader.normalizePopulate(entityName, options.populate, options.strategy);
         const invalid = populate.find(({ field }) => !this.canPopulate(entityName, field));
         if (validate && invalid) {
-            throw errors_1.ValidationError.invalidPropertyName(entityName, invalid.field);
+            throw ValidationError.invalidPropertyName(entityName, invalid.field);
         }
         await this.autoJoinRefsForFilters(meta, { ...options, populate });
         return populate.map(field => {
             // 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 ? enums_1.LoadStrategy.SELECT_IN : (options.strategy ?? field.strategy);
+            field.strategy = all ? LoadStrategy.SELECT_IN : (options.strategy ?? field.strategy);
             return field;
         });
     }
@@ -1644,33 +1645,33 @@ class EntityManager {
      * some additional lazy properties, if so, we reload and merge the data from database
      */
     shouldRefresh(meta, entity, options) {
-        if (!(0, entity_1.helper)(entity).__initialized || options.refresh) {
+        if (!helper(entity).__initialized || options.refresh) {
             return true;
         }
         let autoRefresh;
         if (options.fields) {
-            autoRefresh = options.fields.some(field => !(0, entity_1.helper)(entity).__loadedProperties.has(field));
+            autoRefresh = options.fields.some(field => !helper(entity).__loadedProperties.has(field));
         }
         else {
             autoRefresh = meta.comparableProps.some(prop => {
-                const inlineEmbedded = prop.kind === enums_1.ReferenceKind.EMBEDDED && !prop.object;
-                return !inlineEmbedded && !prop.lazy && !(0, entity_1.helper)(entity).__loadedProperties.has(prop.name);
+                const inlineEmbedded = prop.kind === ReferenceKind.EMBEDDED && !prop.object;
+                return !inlineEmbedded && !prop.lazy && !helper(entity).__loadedProperties.has(prop.name);
             });
         }
         if (autoRefresh) {
             return true;
         }
         if (Array.isArray(options.populate)) {
-            return options.populate.some(field => !(0, entity_1.helper)(entity).__loadedProperties.has(field));
+            return options.populate.some(field => !helper(entity).__loadedProperties.has(field));
         }
         return !!options.populate;
     }
     prepareOptions(options) {
-        if (!Utils_1.Utils.isEmpty(options.fields) && !Utils_1.Utils.isEmpty(options.exclude)) {
-            throw new errors_1.ValidationError(`Cannot combine 'fields' and 'exclude' option.`);
+        if (!Utils.isEmpty(options.fields) && !Utils.isEmpty(options.exclude)) {
+            throw new ValidationError(`Cannot combine 'fields' and 'exclude' option.`);
         }
         options.schema ??= this._schema;
-        options.logging = Utils_1.Utils.merge({ id: this.id }, this.loggerContext, options.loggerContext, options.logging);
+        options.logging = Utils.merge({ id: this.id }, this.loggerContext, options.loggerContext, options.logging);
     }
     /**
      * @internal
@@ -1704,7 +1705,7 @@ class EntityManager {
                     recomputeSnapshot: true,
                 }));
             }
-            else if (Utils_1.Utils.isObject(cached) && merge) {
+            else if (Utils.isObject(cached) && merge) {
                 data = em.entityFactory.create(entityName, cached, {
                     merge: true,
                     convertCustomTypes: true,
@@ -1727,7 +1728,7 @@ class EntityManager {
         config ??= this.config.get('resultCache').global;
         if (config) {
             const em = this.getContext();
-            const expiration = Array.isArray(config) ? config[1] : (Utils_1.Utils.isNumber(config) ? config : undefined);
+            const expiration = Array.isArray(config) ? config[1] : (Utils.isNumber(config) ? config : undefined);
             await em.resultCache.set(key.key, data instanceof Function ? data() : data, '', expiration);
         }
     }
@@ -1768,8 +1769,7 @@ class EntityManager {
         return this.getContext(false)._id;
     }
     /** @ignore */
-    [node_util_1.inspect.custom]() {
+    [inspect.custom]() {
         return `[EntityManager<${this.id}>]`;
     }
 }
-exports.EntityManager = EntityManager;