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

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,7 +42,7 @@ 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;
             this.mergeData(meta2, exists, data, options);
@@ -56,7 +53,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 +66,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' });
                     }
@@ -97,17 +94,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 +112,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 +121,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 +162,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 +208,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 +235,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 +248,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 +280,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 +310,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 +329,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
  */

package/entity/EntityHelper.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityHelper = void 0;
-const node_util_1 = require("node:util");
-const typings_1 = require("../typings");
-const EntityTransformer_1 = require("../serialization/EntityTransformer");
-const Reference_1 = require("./Reference");
-const Utils_1 = require("../utils/Utils");
-const WrappedEntity_1 = require("./WrappedEntity");
-const enums_1 = require("../enums");
-const wrap_1 = require("./wrap");
+import { inspect } from 'node:util';
+import { EagerProps, EntityRepositoryType, HiddenProps, OptionalProps, PrimaryKeyProp, } from '../typings.js';
+import { EntityTransformer } from '../serialization/EntityTransformer.js';
+import { Reference } from './Reference.js';
+import { Utils } from '../utils/Utils.js';
+import { WrappedEntity } from './WrappedEntity.js';
+import { ReferenceKind } from '../enums.js';
+import { helper } from './wrap.js';
 /**
  * @internal
  */
-class EntityHelper {
+export class EntityHelper {
     static decorate(meta, em) {
         const fork = em.fork(); // use fork so we can access `EntityFactory`
         const serializedPrimaryKey = meta.props.find(p => p.serializedPrimaryKey);
@@ -35,7 +32,7 @@ class EntityHelper {
         const prototype = meta.prototype;
         if (!prototype.toJSON) { // toJSON can be overridden
             prototype.toJSON = function (...args) {
-                return EntityTransformer_1.EntityTransformer.toObject(this, ...args.slice(meta.toJsonParams.length));
+                return EntityTransformer.toObject(this, ...args.slice(meta.toJsonParams.length));
             };
         }
     }
@@ -56,7 +53,7 @@ class EntityHelper {
             __helper: {
                 get() {
                     Object.defineProperty(this, '__helper', {
-                        value: new WrappedEntity_1.WrappedEntity(this, em.getHydrator(), ...helperParams),
+                        value: new WrappedEntity(this, em.getHydrator(), ...helperParams),
                         enumerable: false,
                         configurable: true,
                     });
@@ -78,8 +75,8 @@ class EntityHelper {
         Object
             .values(meta.properties)
             .forEach(prop => {
-            const isCollection = [enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind);
-            const isReference = [enums_1.ReferenceKind.ONE_TO_ONE, enums_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind) && (prop.inversedBy || prop.mappedBy) && !prop.mapToPk;
+            const isCollection = [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind);
+            const isReference = [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && (prop.inversedBy || prop.mappedBy) && !prop.mapToPk;
             if (isReference) {
                 Object.defineProperty(meta.prototype, prop.name, {
                     set(val) {
@@ -115,49 +112,49 @@ class EntityHelper {
     }
     static defineCustomInspect(meta) {
         // @ts-ignore
-        meta.prototype[node_util_1.inspect.custom] ??= function (depth = 2) {
+        meta.prototype[inspect.custom] ??= function (depth = 2) {
             const object = { ...this };
             // ensure we dont have internal symbols in the POJO
-            [typings_1.OptionalProps, typings_1.EntityRepositoryType, typings_1.PrimaryKeyProp, typings_1.EagerProps, typings_1.HiddenProps].forEach(sym => delete object[sym]);
+            [OptionalProps, EntityRepositoryType, PrimaryKeyProp, EagerProps, HiddenProps].forEach(sym => delete object[sym]);
             meta.props
                 .filter(prop => object[prop.name] === undefined)
                 .forEach(prop => delete object[prop.name]);
-            const ret = (0, node_util_1.inspect)(object, { depth });
+            const ret = inspect(object, { depth });
             let name = (this).constructor.name;
             const showEM = ['true', 't', '1'].includes(process.env.MIKRO_ORM_LOG_EM_ID?.toString().toLowerCase() ?? '');
             if (showEM) {
-                if ((0, wrap_1.helper)(this).__em) {
-                    name += ` [managed by ${(0, wrap_1.helper)(this).__em.id}]`;
+                if (helper(this).__em) {
+                    name += ` [managed by ${helper(this).__em.id}]`;
                 }
                 else {
                     name += ` [not managed]`;
                 }
             }
             // distinguish not initialized entities
-            if (!(0, wrap_1.helper)(this).__initialized) {
+            if (!helper(this).__initialized) {
                 name = `(${name})`;
             }
             return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
         };
     }
     static defineReferenceProperty(meta, prop, ref, hydrator) {
-        const wrapped = (0, wrap_1.helper)(ref);
+        const wrapped = helper(ref);
         Object.defineProperty(ref, prop.name, {
             get() {
-                return (0, wrap_1.helper)(ref).__data[prop.name];
+                return helper(ref).__data[prop.name];
             },
             set(val) {
-                const entity = Reference_1.Reference.unwrapReference(val ?? wrapped.__data[prop.name]);
-                const old = Reference_1.Reference.unwrapReference(wrapped.__data[prop.name]);
-                wrapped.__data[prop.name] = Reference_1.Reference.wrapReference(val, prop);
+                const entity = Reference.unwrapReference(val ?? wrapped.__data[prop.name]);
+                const old = Reference.unwrapReference(wrapped.__data[prop.name]);
+                wrapped.__data[prop.name] = Reference.wrapReference(val, prop);
                 // when propagation from inside hydration, we set the FK to the entity data immediately
                 if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
-                    wrapped.__originalEntityData[prop.name] = Utils_1.Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta.primaryKeys, true);
+                    wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta.primaryKeys, true);
                 }
                 else {
                     wrapped.__touched = !hydrator.isRunning();
                 }
-                EntityHelper.propagate(meta, entity, this, prop, Reference_1.Reference.unwrapReference(val), old);
+                EntityHelper.propagate(meta, entity, this, prop, Reference.unwrapReference(val), old);
             },
             enumerable: true,
             configurable: true,
@@ -172,51 +169,51 @@ class EntityHelper {
                 continue;
             }
             const inverse = value?.[prop2.name];
-            if (prop.kind === enums_1.ReferenceKind.MANY_TO_ONE && Utils_1.Utils.isCollection(inverse) && inverse.isInitialized()) {
+            if (prop.kind === ReferenceKind.MANY_TO_ONE && Utils.isCollection(inverse) && inverse.isInitialized()) {
                 inverse.addWithoutPropagation(owner);
-                (0, wrap_1.helper)(owner).__em?.getUnitOfWork().cancelOrphanRemoval(owner);
+                helper(owner).__em?.getUnitOfWork().cancelOrphanRemoval(owner);
             }
-            if (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE) {
-                if ((value != null && Reference_1.Reference.unwrapReference(inverse) !== owner) ||
+            if (prop.kind === ReferenceKind.ONE_TO_ONE) {
+                if ((value != null && Reference.unwrapReference(inverse) !== owner) ||
                     (value == null && entity?.[prop2.name] != null)) {
-                    if (entity && (!prop.owner || (0, wrap_1.helper)(entity).__initialized)) {
+                    if (entity && (!prop.owner || helper(entity).__initialized)) {
                         EntityHelper.propagateOneToOne(entity, owner, prop, prop2, value, old);
                     }
                     if (old && prop.orphanRemoval) {
-                        (0, wrap_1.helper)(old).__em?.getUnitOfWork().scheduleOrphanRemoval(old);
+                        helper(old).__em?.getUnitOfWork().scheduleOrphanRemoval(old);
                     }
                 }
             }
         }
     }
     static propagateOneToOne(entity, owner, prop, prop2, value, old) {
-        (0, wrap_1.helper)(entity).__pk = (0, wrap_1.helper)(entity).getPrimaryKey();
+        helper(entity).__pk = helper(entity).getPrimaryKey();
         // the inverse side will be changed on the `value` too, so we need to clean-up and schedule orphan removal there too
-        if (!prop.primary && !prop2.mapToPk && value?.[prop2.name] != null && Reference_1.Reference.unwrapReference(value[prop2.name]) !== entity) {
-            const other = Reference_1.Reference.unwrapReference(value[prop2.name]);
-            delete (0, wrap_1.helper)(other).__data[prop.name];
+        if (!prop.primary && !prop2.mapToPk && value?.[prop2.name] != null && Reference.unwrapReference(value[prop2.name]) !== entity) {
+            const other = Reference.unwrapReference(value[prop2.name]);
+            delete helper(other).__data[prop.name];
             if (prop2.orphanRemoval) {
-                (0, wrap_1.helper)(other).__em?.getUnitOfWork().scheduleOrphanRemoval(other);
+                helper(other).__em?.getUnitOfWork().scheduleOrphanRemoval(other);
             }
         }
         if (value == null) {
             entity[prop2.name] = value;
         }
         else if (prop2.mapToPk) {
-            entity[prop2.name] = (0, wrap_1.helper)(owner).getPrimaryKey();
+            entity[prop2.name] = helper(owner).getPrimaryKey();
         }
         else {
-            entity[prop2.name] = Reference_1.Reference.wrapReference(owner, prop);
+            entity[prop2.name] = Reference.wrapReference(owner, prop);
         }
         if (old?.[prop2.name] != null) {
-            delete (0, wrap_1.helper)(old).__data[prop2.name];
+            delete helper(old).__data[prop2.name];
         }
     }
     static ensurePropagation(entity) {
         if (entity.__gettersDefined) {
             return;
         }
-        const wrapped = (0, wrap_1.helper)(entity);
+        const wrapped = helper(entity);
         const meta = wrapped.__meta;
         const platform = wrapped.__platform;
         const serializedPrimaryKey = meta.props.find(p => p.serializedPrimaryKey);
@@ -250,4 +247,3 @@ class EntityHelper {
         }
     }
 }
-exports.EntityHelper = EntityHelper;

package/entity/EntityIdentifier.d.ts

@@ -1,4 +1,4 @@
-import type { IPrimaryKey } from '../typings';
+import type { IPrimaryKey } from '../typings.js';
 /**
  * @internal
  */

package/entity/EntityIdentifier.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityIdentifier = void 0;
 /**
  * @internal
  */
-class EntityIdentifier {
+export class EntityIdentifier {
     value;
     constructor(value) {
         this.value = value;
@@ -16,4 +13,3 @@ class EntityIdentifier {
         return this.value;
     }
 }
-exports.EntityIdentifier = EntityIdentifier;

package/entity/EntityLoader.d.ts

@@ -1,8 +1,8 @@
-import type { ConnectionType, Dictionary, FilterQuery, PopulateOptions } from '../typings';
-import type { EntityManager } from '../EntityManager';
-import { LoadStrategy, type LockMode, type PopulateHint, PopulatePath, type QueryOrderMap } from '../enums';
-import type { EntityField } from '../drivers/IDatabaseDriver';
-import type { LoggingOptions } from '../logging/Logger';
+import type { ConnectionType, Dictionary, FilterQuery, PopulateOptions } from '../typings.js';
+import type { EntityManager } from '../EntityManager.js';
+import { LoadStrategy, type LockMode, type PopulateHint, PopulatePath, type QueryOrderMap } from '../enums.js';
+import type { EntityField } from '../drivers/IDatabaseDriver.js';
+import type { LoggingOptions } from '../logging/Logger.js';
 export type EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL, Excludes extends string = never> = {
     where?: FilterQuery<Entity>;
     populateWhere?: PopulateHint | `${PopulateHint}`;