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

package/entity/EntityAssigner.js

@@ -1,25 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assign = exports.EntityAssigner = void 0;
-const node_util_1 = require("node:util");
-const Collection_1 = require("./Collection");
-const Utils_1 = require("../utils/Utils");
-const Reference_1 = require("./Reference");
-const enums_1 = require("../enums");
-const EntityValidator_1 = require("./EntityValidator");
-const wrap_1 = require("./wrap");
-const EntityHelper_1 = require("./EntityHelper");
-const validator = new EntityValidator_1.EntityValidator(false);
-class EntityAssigner {
+import { inspect } from 'node:util';
+import { Collection } from './Collection.js';
+import { Utils } from '../utils/Utils.js';
+import { Reference } from './Reference.js';
+import { ReferenceKind, SCALAR_TYPES } from '../enums.js';
+import { EntityValidator } from './EntityValidator.js';
+import { helper, wrap } from './wrap.js';
+import { EntityHelper } from './EntityHelper.js';
+const validator = new EntityValidator(false);
+export class EntityAssigner {
     static assign(entity, data, options = {}) {
         let opts = options;
         if (opts.visited?.has(entity)) {
             return entity;
         }
-        EntityHelper_1.EntityHelper.ensurePropagation(entity);
+        EntityHelper.ensurePropagation(entity);
         opts.visited ??= new Set();
         opts.visited.add(entity);
-        const wrapped = (0, wrap_1.helper)(entity);
+        const wrapped = helper(entity);
         opts = {
             ...wrapped.__config.get('assign'),
             schema: wrapped.__schema,
@@ -45,37 +42,37 @@ class EntityAssigner {
         }
         const prop = { ...props[propName], name: propName };
         if (prop && options.onlyOwnProperties) {
-            if ([enums_1.ReferenceKind.MANY_TO_MANY, enums_1.ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
+            if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
                 return;
             }
-            if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-                value = Utils_1.Utils.extractPK(value, prop.targetMeta);
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+                value = Utils.extractPK(value, prop.targetMeta);
             }
         }
         if (propName in props && !prop.nullable && value == null) {
             throw new Error(`You must pass a non-${value} value to the property ${propName} of entity ${entity.constructor.name}.`);
         }
         // create collection instance if its missing so old items can be deleted with orphan removal
-        if ([enums_1.ReferenceKind.MANY_TO_MANY, enums_1.ReferenceKind.ONE_TO_MANY].includes(prop?.kind) && entity[prop.name] == null) {
-            entity[prop.name] = Collection_1.Collection.create(entity, prop.name, undefined, (0, wrap_1.helper)(entity).isInitialized());
+        if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop?.kind) && entity[prop.name] == null) {
+            entity[prop.name] = Collection.create(entity, prop.name, undefined, helper(entity).isInitialized());
         }
-        if (prop && Utils_1.Utils.isCollection(entity[prop.name])) {
+        if (prop && Utils.isCollection(entity[prop.name])) {
             return EntityAssigner.assignCollection(entity, entity[prop.name], value, prop, options.em, options);
         }
         const customType = prop?.customType;
-        if (options.convertCustomTypes && customType && prop.kind === enums_1.ReferenceKind.SCALAR && !Utils_1.Utils.isEntity(data)) {
+        if (options.convertCustomTypes && customType && prop.kind === ReferenceKind.SCALAR && !Utils.isEntity(data)) {
             value = customType.convertToJSValue(value, options.platform);
         }
-        if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop?.kind) && value != null) {
-            if (options.updateNestedEntities && Object.hasOwn(entity, propName) && Utils_1.Utils.isEntity(entity[propName], true) && Utils_1.Utils.isPlainObject(value)) {
-                const unwrappedEntity = Reference_1.Reference.unwrapReference(entity[propName]);
-                const wrapped = (0, wrap_1.helper)(unwrappedEntity);
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop?.kind) && value != null) {
+            if (options.updateNestedEntities && Object.hasOwn(entity, propName) && Utils.isEntity(entity[propName], true) && Utils.isPlainObject(value)) {
+                const unwrappedEntity = Reference.unwrapReference(entity[propName]);
+                const wrapped = helper(unwrappedEntity);
                 if (options.updateByPrimaryKey) {
-                    const pk = Utils_1.Utils.extractPK(value, prop.targetMeta);
+                    const pk = Utils.extractPK(value, prop.targetMeta);
                     if (pk) {
                         const ref = options.em.getReference(prop.type, pk, options);
                         // if the PK differs, we want to change the target entity, not update it
-                        const wrappedChild = (0, wrap_1.helper)(ref);
+                        const wrappedChild = helper(ref);
                         const sameTarget = wrappedChild.getSerializedPrimaryKey() === wrapped.getSerializedPrimaryKey();
                         if (wrappedChild.__managed && wrappedChild.isInitialized() && sameTarget) {
                             return EntityAssigner.assign(ref, value, options);
@@ -83,21 +80,21 @@ class EntityAssigner {
                     }
                     return EntityAssigner.assignReference(entity, value, prop, options.em, options);
                 }
-                if (wrapped.__managed && (0, wrap_1.wrap)(unwrappedEntity).isInitialized()) {
+                if (wrapped.__managed && wrap(unwrappedEntity).isInitialized()) {
                     return EntityAssigner.assign(unwrappedEntity, value, options);
                 }
             }
             return EntityAssigner.assignReference(entity, value, prop, options.em, options);
         }
-        if (prop.kind === enums_1.ReferenceKind.SCALAR && enums_1.SCALAR_TYPES.includes(prop.runtimeType) && (prop.setter || !prop.getter)) {
+        if (prop.kind === ReferenceKind.SCALAR && SCALAR_TYPES.includes(prop.runtimeType) && (prop.setter || !prop.getter)) {
             return entity[prop.name] = validator.validateProperty(prop, value, entity);
         }
-        if (prop.kind === enums_1.ReferenceKind.EMBEDDED && EntityAssigner.validateEM(options.em)) {
+        if (prop.kind === ReferenceKind.EMBEDDED && EntityAssigner.validateEM(options.em)) {
             return EntityAssigner.assignEmbeddable(entity, value, prop, options.em, options);
         }
-        if (options.mergeObjectProperties && Utils_1.Utils.isPlainObject(entity[propName]) && Utils_1.Utils.isPlainObject(value)) {
+        if (options.mergeObjectProperties && Utils.isPlainObject(entity[propName]) && Utils.isPlainObject(value)) {
             entity[propName] ??= {};
-            entity[propName] = Utils_1.Utils.merge({}, entity[propName], value);
+            entity[propName] = Utils.merge({}, entity[propName], value);
         }
         else if (!prop || prop.setter || !prop.getter) {
             entity[propName] = value;
@@ -110,18 +107,18 @@ class EntityAssigner {
      */
     static autoWireOneToOne(prop, entity) {
         const ref = entity[prop.name];
-        if (prop.kind !== enums_1.ReferenceKind.ONE_TO_ONE || !Utils_1.Utils.isEntity(ref)) {
+        if (prop.kind !== ReferenceKind.ONE_TO_ONE || !Utils.isEntity(ref)) {
             return;
         }
-        const meta2 = (0, wrap_1.helper)(ref).__meta;
+        const meta2 = helper(ref).__meta;
         const prop2 = meta2.properties[prop.inversedBy || prop.mappedBy];
-        /* istanbul ignore next */
+        /* v8 ignore next 7 */
         if (prop2 && !ref[prop2.name]) {
-            if (Reference_1.Reference.isReference(ref)) {
-                ref.unwrap()[prop2.name] = Reference_1.Reference.wrapReference(entity, prop2);
+            if (Reference.isReference(ref)) {
+                ref.unwrap()[prop2.name] = Reference.wrapReference(entity, prop2);
             }
             else {
-                ref[prop2.name] = Reference_1.Reference.wrapReference(entity, prop2);
+                ref[prop2.name] = Reference.wrapReference(entity, prop2);
             }
         }
     }
@@ -132,17 +129,17 @@ class EntityAssigner {
         return true;
     }
     static assignReference(entity, value, prop, em, options) {
-        if (Utils_1.Utils.isEntity(value, true)) {
-            entity[prop.name] = Reference_1.Reference.wrapReference(value, prop);
+        if (Utils.isEntity(value, true)) {
+            entity[prop.name] = Reference.wrapReference(value, prop);
         }
-        else if (Utils_1.Utils.isPrimaryKey(value, true) && EntityAssigner.validateEM(em)) {
-            entity[prop.name] = prop.mapToPk ? value : Reference_1.Reference.wrapReference(em.getReference(prop.type, value, options), prop);
+        else if (Utils.isPrimaryKey(value, true) && EntityAssigner.validateEM(em)) {
+            entity[prop.name] = prop.mapToPk ? value : Reference.wrapReference(em.getReference(prop.type, value, options), prop);
         }
-        else if (Utils_1.Utils.isPlainObject(value) && options.merge && EntityAssigner.validateEM(em)) {
-            entity[prop.name] = Reference_1.Reference.wrapReference(em.merge(prop.type, value, options), prop);
+        else if (Utils.isPlainObject(value) && options.merge && EntityAssigner.validateEM(em)) {
+            entity[prop.name] = Reference.wrapReference(em.merge(prop.type, value, options), prop);
         }
-        else if (Utils_1.Utils.isPlainObject(value) && EntityAssigner.validateEM(em)) {
-            entity[prop.name] = Reference_1.Reference.wrapReference(em.create(prop.type, value, options), prop);
+        else if (Utils.isPlainObject(value) && EntityAssigner.validateEM(em)) {
+            entity[prop.name] = Reference.wrapReference(em.create(prop.type, value, options), prop);
         }
         else {
             const name = entity.constructor.name;
@@ -152,32 +149,31 @@ class EntityAssigner {
     }
     static assignCollection(entity, collection, value, prop, em, options) {
         const invalid = [];
-        const items = Utils_1.Utils.asArray(value).map((item, idx) => {
+        const items = Utils.asArray(value).map((item, idx) => {
             // try to propagate missing owning side reference to the payload first
             const prop2 = prop.targetMeta?.properties[prop.mappedBy];
-            if (Utils_1.Utils.isPlainObject(item) && prop2 && item[prop2.name] == null) {
-                item = { ...item, [prop2.name]: Reference_1.Reference.wrapReference(entity, prop2) };
+            if (Utils.isPlainObject(item) && prop2 && item[prop2.name] == null) {
+                item = { ...item, [prop2.name]: Reference.wrapReference(entity, prop2) };
             }
-            if (options.updateNestedEntities && options.updateByPrimaryKey && Utils_1.Utils.isPlainObject(item)) {
-                const pk = Utils_1.Utils.extractPK(item, prop.targetMeta);
+            if (options.updateNestedEntities && options.updateByPrimaryKey && Utils.isPlainObject(item)) {
+                const pk = Utils.extractPK(item, prop.targetMeta);
                 if (pk && EntityAssigner.validateEM(em)) {
                     const ref = em.getUnitOfWork().getById(prop.type, pk, options.schema);
-                    /* istanbul ignore else */
                     if (ref) {
                         return EntityAssigner.assign(ref, item, options);
                     }
                 }
                 return this.createCollectionItem(item, em, prop, invalid, options);
             }
-            /* istanbul ignore next */
-            if (options.updateNestedEntities && !options.updateByPrimaryKey && collection[idx] && (0, wrap_1.helper)(collection[idx])?.isInitialized()) {
+            /* v8 ignore next 3 */
+            if (options.updateNestedEntities && !options.updateByPrimaryKey && collection[idx] && helper(collection[idx])?.isInitialized()) {
                 return EntityAssigner.assign(collection[idx], item, options);
             }
             return this.createCollectionItem(item, em, prop, invalid, options);
         });
         if (invalid.length > 0) {
             const name = entity.constructor.name;
-            throw new Error(`Invalid collection values provided for '${name}.${prop.name}' in ${name}.assign(): ${(0, node_util_1.inspect)(invalid)}`);
+            throw new Error(`Invalid collection values provided for '${name}.${prop.name}' in ${name}.assign(): ${inspect(invalid)}`);
         }
         if (Array.isArray(value)) {
             collection.set(items);
@@ -197,7 +193,7 @@ class EntityAssigner {
             entity[propName] = [];
         }
         if (prop.array) {
-            return Utils_1.Utils.asArray(value).forEach(item => {
+            return Utils.asArray(value).forEach(item => {
                 const tmp = {};
                 this.assignEmbeddable(tmp, item, { ...prop, array: false }, em, options);
                 entity[propName].push(...Object.values(tmp));
@@ -213,21 +209,20 @@ class EntityAssigner {
         });
     }
     static createCollectionItem(item, em, prop, invalid, options) {
-        if (Utils_1.Utils.isEntity(item)) {
+        if (Utils.isEntity(item)) {
             return item;
         }
-        if (Utils_1.Utils.isPrimaryKey(item) && EntityAssigner.validateEM(em)) {
+        if (Utils.isPrimaryKey(item) && EntityAssigner.validateEM(em)) {
             return em.getReference(prop.type, item, options);
         }
-        if (Utils_1.Utils.isPlainObject(item) && options.merge && EntityAssigner.validateEM(em)) {
+        if (Utils.isPlainObject(item) && options.merge && EntityAssigner.validateEM(em)) {
             return em.merge(prop.type, item, options);
         }
-        if (Utils_1.Utils.isPlainObject(item) && EntityAssigner.validateEM(em)) {
+        if (Utils.isPlainObject(item) && EntityAssigner.validateEM(em)) {
             return em.create(prop.type, item, options);
         }
         invalid.push(item);
         return item;
     }
 }
-exports.EntityAssigner = EntityAssigner;
-exports.assign = EntityAssigner.assign;
+export const assign = EntityAssigner.assign;

package/entity/EntityFactory.d.ts

@@ -1,6 +1,6 @@
-import type { EntityData, EntityMetadata, EntityName, New, Primary } from '../typings';
-import type { EntityManager } from '../EntityManager';
-import type { EntityComparator } from '../utils/EntityComparator';
+import type { EntityData, EntityMetadata, EntityName, New, Primary } from '../typings.js';
+import type { EntityManager } from '../EntityManager.js';
+import type { EntityComparator } from '../utils/EntityComparator.js';
 export interface FactoryOptions {
     initialized?: boolean;
     newEntity?: boolean;

package/entity/EntityFactory.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityFactory = void 0;
-const Utils_1 = require("../utils/Utils");
-const QueryHelper_1 = require("../utils/QueryHelper");
-const enums_1 = require("../enums");
-const Reference_1 = require("./Reference");
-const wrap_1 = require("./wrap");
-const EntityHelper_1 = require("./EntityHelper");
-class EntityFactory {
+import { Utils } from '../utils/Utils.js';
+import { QueryHelper } from '../utils/QueryHelper.js';
+import { EventType, ReferenceKind } from '../enums.js';
+import { Reference } from './Reference.js';
+import { helper } from './wrap.js';
+import { EntityHelper } from './EntityHelper.js';
+export class EntityFactory {
     em;
     driver;
     platform;
@@ -27,12 +24,12 @@ class EntityFactory {
         this.comparator = this.em.getComparator();
     }
     create(entityName, data, options = {}) {
-        data = Reference_1.Reference.unwrapReference(data);
+        data = Reference.unwrapReference(data);
         options.initialized ??= true;
         if (data.__entity) {
             return data;
         }
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         const meta = this.metadata.get(entityName);
         if (meta.virtual) {
             data = { ...data };
@@ -45,9 +42,10 @@ class EntityFactory {
         }
         const meta2 = this.processDiscriminatorColumn(meta, data);
         const exists = this.findEntity(data, meta2, options);
-        let wrapped = exists && (0, wrap_1.helper)(exists);
+        let wrapped = exists && helper(exists);
         if (wrapped && !options.refresh) {
             wrapped.__processing = true;
+            Utils.dropUndefinedProperties(data);
             this.mergeData(meta2, exists, data, options);
             wrapped.__processing = false;
             if (wrapped.isInitialized()) {
@@ -56,7 +54,7 @@ class EntityFactory {
         }
         data = { ...data };
         const entity = exists ?? this.createEntity(data, meta2, options);
-        wrapped = (0, wrap_1.helper)(entity);
+        wrapped = helper(entity);
         wrapped.__processing = true;
         wrapped.__initialized = options.initialized;
         if (options.newEntity || meta.forceConstructor || meta.virtual) {
@@ -69,11 +67,11 @@ class EntityFactory {
             if (options.convertCustomTypes) {
                 for (const prop of meta.props) {
                     if (prop.customType?.ensureComparable(meta, prop) && data[prop.name]) {
-                        if ([enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+                        if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
                             continue;
                         }
-                        if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isPlainObject(data[prop.name])) {
-                            data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
+                        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
+                            data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
                         }
                         data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, { key: prop.name, mode: 'hydration' });
                     }
@@ -89,7 +87,9 @@ class EntityFactory {
         }
         if (options.merge && wrapped.hasPrimaryKey()) {
             this.unitOfWork.register(entity, data, {
-                refresh: options.refresh && options.initialized,
+                // Always refresh to ensure the payload is in correct shape for joined strategy. When loading nested relations,
+                // they will be created early without `Type.ensureComparable` being properly handled, resulting in extra updates.
+                refresh: options.initialized,
                 newEntity: options.newEntity,
                 loaded: options.initialized,
             });
@@ -97,17 +97,17 @@ class EntityFactory {
                 wrapped.__originalEntityData = this.comparator.prepareEntity(entity);
             }
         }
-        if (this.eventManager.hasListeners(enums_1.EventType.onInit, meta2)) {
-            this.eventManager.dispatchEvent(enums_1.EventType.onInit, { entity, meta: meta2, em: this.em });
+        if (this.eventManager.hasListeners(EventType.onInit, meta2)) {
+            this.eventManager.dispatchEvent(EventType.onInit, { entity, meta: meta2, em: this.em });
         }
         wrapped.__processing = false;
         return entity;
     }
     mergeData(meta, entity, data, options = {}) {
         // merge unchanged properties automatically
-        data = QueryHelper_1.QueryHelper.processParams(data);
+        data = QueryHelper.processParams(data);
         const existsData = this.comparator.prepareEntity(entity);
-        const originalEntityData = (0, wrap_1.helper)(entity).__originalEntityData ?? {};
+        const originalEntityData = helper(entity).__originalEntityData ?? {};
         const diff = this.comparator.diffEntities(meta.className, originalEntityData, existsData);
         // version properties are not part of entity snapshots
         if (meta.versionProperty && data[meta.versionProperty] && data[meta.versionProperty] !== originalEntityData[meta.versionProperty]) {
@@ -115,8 +115,8 @@ class EntityFactory {
         }
         const diff2 = this.comparator.diffEntities(meta.className, existsData, data);
         // do not override values changed by user
-        Utils_1.Utils.keys(diff).forEach(key => delete diff2[key]);
-        Utils_1.Utils.keys(diff2).filter(key => {
+        Utils.keys(diff).forEach(key => delete diff2[key]);
+        Utils.keys(diff2).filter(key => {
             // ignore null values if there is already present non-null value
             if (existsData[key] != null) {
                 return diff2[key] == null;
@@ -124,40 +124,40 @@ class EntityFactory {
             return diff2[key] === undefined;
         }).forEach(key => delete diff2[key]);
         // but always add collection properties and formulas if they are part of the `data`
-        Utils_1.Utils.keys(data)
-            .filter(key => meta.properties[key]?.formula || [enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(meta.properties[key]?.kind))
+        Utils.keys(data)
+            .filter(key => meta.properties[key]?.formula || [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(meta.properties[key]?.kind))
             .forEach(key => diff2[key] = data[key]);
         // rehydrated with the new values, skip those changed by user
         this.hydrate(entity, meta, diff2, options);
         // we need to update the entity data only with keys that were not present before
         const nullVal = this.config.get('forceUndefined') ? undefined : null;
-        Utils_1.Utils.keys(diff2).forEach(key => {
+        Utils.keys(diff2).forEach(key => {
             const prop = meta.properties[key];
-            if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isPlainObject(data[prop.name])) {
-                diff2[key] = entity[prop.name] ? (0, wrap_1.helper)(entity[prop.name]).getPrimaryKey(options.convertCustomTypes) : null;
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
+                diff2[key] = entity[prop.name] ? helper(entity[prop.name]).getPrimaryKey(options.convertCustomTypes) : null;
             }
             originalEntityData[key] = diff2[key] === null ? nullVal : diff2[key];
-            (0, wrap_1.helper)(entity).__loadedProperties.add(key);
+            helper(entity).__loadedProperties.add(key);
         });
         // in case of joined loading strategy, we need to cascade the merging to possibly loaded relations manually
         meta.relations.forEach(prop => {
-            if ([enums_1.ReferenceKind.MANY_TO_MANY, enums_1.ReferenceKind.ONE_TO_MANY].includes(prop.kind) && Array.isArray(data[prop.name])) {
+            if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) && Array.isArray(data[prop.name])) {
                 // instead of trying to match the collection items (which could easily fail if the collection was loaded with different ordering),
                 // we just create the entity from scratch, which will automatically pick the right one from the identity map and call `mergeData` on it
                 data[prop.name]
-                    .filter(child => Utils_1.Utils.isPlainObject(child)) // objects with prototype can be PKs (e.g. `ObjectId`)
+                    .filter(child => Utils.isPlainObject(child)) // objects with prototype can be PKs (e.g. `ObjectId`)
                     .forEach(child => this.create(prop.type, child, options)); // we can ignore the value, we just care about the `mergeData` call
                 return;
             }
-            if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isPlainObject(data[prop.name]) && entity[prop.name] && (0, wrap_1.helper)(entity[prop.name]).__initialized) {
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name]) && entity[prop.name] && helper(entity[prop.name]).__initialized) {
                 this.create(prop.type, data[prop.name], options); // we can ignore the value, we just care about the `mergeData` call
             }
         });
-        (0, wrap_1.helper)(entity).__touched = false;
+        helper(entity).__touched = false;
     }
     createReference(entityName, id, options = {}) {
         options.convertCustomTypes ??= true;
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         const meta = this.metadata.get(entityName);
         const schema = this.driver.getSchemaName(meta, options);
         if (meta.simplePK) {
@@ -165,24 +165,24 @@ class EntityFactory {
             if (exists) {
                 return exists;
             }
-            const data = Utils_1.Utils.isPlainObject(id) ? id : { [meta.primaryKeys[0]]: Array.isArray(id) ? id[0] : id };
+            const data = Utils.isPlainObject(id) ? id : { [meta.primaryKeys[0]]: Array.isArray(id) ? id[0] : id };
             return this.create(entityName, data, { ...options, initialized: false });
         }
         if (Array.isArray(id)) {
-            id = Utils_1.Utils.getPrimaryKeyCondFromArray(id, meta);
+            id = Utils.getPrimaryKeyCondFromArray(id, meta);
         }
-        const pks = Utils_1.Utils.getOrderedPrimaryKeys(id, meta, this.platform, options.convertCustomTypes);
+        const pks = Utils.getOrderedPrimaryKeys(id, meta, this.platform, options.convertCustomTypes);
         const exists = this.unitOfWork.getById(entityName, pks, schema);
         if (exists) {
             return exists;
         }
-        if (Utils_1.Utils.isPrimaryKey(id)) {
+        if (Utils.isPrimaryKey(id)) {
             id = { [meta.primaryKeys[0]]: id };
         }
         return this.create(entityName, id, { ...options, initialized: false });
     }
     createEmbeddable(entityName, data, options = {}) {
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         data = { ...data };
         const meta = this.metadata.get(entityName);
         const meta2 = this.processDiscriminatorColumn(meta, data);
@@ -211,23 +211,23 @@ class EntityFactory {
             if (meta.virtual) {
                 return entity;
             }
-            (0, wrap_1.helper)(entity).__schema = schema;
+            helper(entity).__schema = schema;
             if (options.initialized) {
-                EntityHelper_1.EntityHelper.ensurePropagation(entity);
+                EntityHelper.ensurePropagation(entity);
             }
             return entity;
         }
         // creates new entity instance, bypassing constructor call as its already persisted entity
         const entity = Object.create(meta.class.prototype);
-        (0, wrap_1.helper)(entity).__managed = true;
-        (0, wrap_1.helper)(entity).__processing = !meta.embeddable && !meta.virtual;
-        (0, wrap_1.helper)(entity).__schema = schema;
+        helper(entity).__managed = true;
+        helper(entity).__processing = !meta.embeddable && !meta.virtual;
+        helper(entity).__schema = schema;
         if (options.merge && !options.newEntity) {
             this.hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, options.schema, options.parentSchema);
             this.unitOfWork.register(entity);
         }
         if (options.initialized) {
-            EntityHelper_1.EntityHelper.ensurePropagation(entity);
+            EntityHelper.ensurePropagation(entity);
         }
         return entity;
     }
@@ -238,9 +238,9 @@ class EntityFactory {
         else {
             this.hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options));
         }
-        Utils_1.Utils.keys(data).forEach(key => {
-            (0, wrap_1.helper)(entity)?.__loadedProperties.add(key);
-            (0, wrap_1.helper)(entity)?.__serializationContext.fields?.add(key);
+        Utils.keys(data).forEach(key => {
+            helper(entity)?.__loadedProperties.add(key);
+            helper(entity)?.__serializationContext.fields?.add(key);
         });
     }
     findEntity(data, meta, options) {
@@ -251,7 +251,7 @@ class EntityFactory {
         if (!Array.isArray(data) && meta.primaryKeys.some(pk => data[pk] == null)) {
             return undefined;
         }
-        const pks = Utils_1.Utils.getOrderedPrimaryKeys(data, meta, this.platform);
+        const pks = Utils.getOrderedPrimaryKeys(data, meta, this.platform);
         return this.unitOfWork.getById(meta.className, pks, schema);
     }
     processDiscriminatorColumn(meta, data) {
@@ -283,26 +283,26 @@ class EntityFactory {
      */
     extractConstructorParams(meta, data, options) {
         return meta.constructorParams.map(k => {
-            if (meta.properties[k] && [enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(meta.properties[k].kind) && data[k]) {
-                const pk = Reference_1.Reference.unwrapReference(data[k]);
+            if (meta.properties[k] && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(meta.properties[k].kind) && data[k]) {
+                const pk = Reference.unwrapReference(data[k]);
                 const entity = this.unitOfWork.getById(meta.properties[k].type, pk, options.schema);
                 if (entity) {
                     return entity;
                 }
-                if (Utils_1.Utils.isEntity(data[k])) {
+                if (Utils.isEntity(data[k])) {
                     return data[k];
                 }
-                const nakedPk = Utils_1.Utils.extractPK(data[k], meta.properties[k].targetMeta, true);
-                if (Utils_1.Utils.isObject(data[k]) && !nakedPk) {
+                const nakedPk = Utils.extractPK(data[k], meta.properties[k].targetMeta, true);
+                if (Utils.isObject(data[k]) && !nakedPk) {
                     return this.create(meta.properties[k].type, data[k], options);
                 }
                 const { newEntity, initialized, ...rest } = options;
                 const target = this.createReference(meta.properties[k].type, nakedPk, rest);
-                return Reference_1.Reference.wrapReference(target, meta.properties[k]);
+                return Reference.wrapReference(target, meta.properties[k]);
             }
-            if (meta.properties[k]?.kind === enums_1.ReferenceKind.EMBEDDED && data[k]) {
-                /* istanbul ignore next */
-                if (Utils_1.Utils.isEntity(data[k])) {
+            if (meta.properties[k]?.kind === ReferenceKind.EMBEDDED && data[k]) {
+                /* v8 ignore next 3 */
+                if (Utils.isEntity(data[k])) {
                     return data[k];
                 }
                 return this.createEmbeddable(meta.properties[k].type, data[k], options);
@@ -313,10 +313,10 @@ class EntityFactory {
                     if (!options.convertCustomTypes || !prop.customType || tmp[prop.name] == null) {
                         continue;
                     }
-                    if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isPlainObject(tmp[prop.name]) && !Utils_1.Utils.extractPK(tmp[prop.name], meta.properties[prop.name].targetMeta, true)) {
-                        tmp[prop.name] = Reference_1.Reference.wrapReference(this.create(meta.properties[prop.name].type, tmp[prop.name], options), prop);
+                    if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(tmp[prop.name]) && !Utils.extractPK(tmp[prop.name], meta.properties[prop.name].targetMeta, true)) {
+                        tmp[prop.name] = Reference.wrapReference(this.create(meta.properties[prop.name].type, tmp[prop.name], options), prop);
                     }
-                    else if (prop.kind === enums_1.ReferenceKind.SCALAR) {
+                    else if (prop.kind === ReferenceKind.SCALAR) {
                         tmp[prop.name] = prop.customType.convertToJSValue(tmp[prop.name], this.platform);
                     }
                 }
@@ -332,4 +332,3 @@ class EntityFactory {
         return this.em.getUnitOfWork(false);
     }
 }
-exports.EntityFactory = EntityFactory;

package/entity/EntityHelper.d.ts

@@ -1,5 +1,5 @@
-import type { EntityManager } from '../EntityManager';
-import { type EntityMetadata, type EntityProperty, type IHydrator } from '../typings';
+import type { EntityManager } from '../EntityManager.js';
+import { type EntityMetadata, type EntityProperty, type IHydrator } from '../typings.js';
 /**
  * @internal
  */