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

package/unit-of-work/ChangeSetComputer.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChangeSetComputer = void 0;
-const Utils_1 = require("../utils/Utils");
-const ChangeSet_1 = require("./ChangeSet");
-const entity_1 = require("../entity");
-const enums_1 = require("../enums");
-class ChangeSetComputer {
+import { Utils } from '../utils/Utils.js';
+import { ChangeSet, ChangeSetType } from './ChangeSet.js';
+import { helper } from '../entity/wrap.js';
+import { ReferenceKind } from '../enums.js';
+export class ChangeSetComputer {
     validator;
     collectionUpdates;
     metadata;
@@ -27,20 +24,20 @@ class ChangeSetComputer {
         if (meta.readonly) {
             return null;
         }
-        const wrapped = (0, entity_1.helper)(entity);
-        const type = wrapped.__originalEntityData ? ChangeSet_1.ChangeSetType.UPDATE : ChangeSet_1.ChangeSetType.CREATE;
+        const wrapped = helper(entity);
+        const type = wrapped.__originalEntityData ? ChangeSetType.UPDATE : ChangeSetType.CREATE;
         const map = new Map();
         // Execute `onCreate` and `onUpdate` on properties recursively, saves `onUpdate` results
         // to the `map` as we want to apply those only if something else changed.
-        if (type === ChangeSet_1.ChangeSetType.CREATE) { // run update hooks only after we know there are other changes
+        if (type === ChangeSetType.CREATE) { // run update hooks only after we know there are other changes
             for (const prop of meta.hydrateProps) {
                 this.processPropertyInitializers(entity, prop, type, map);
             }
         }
-        if (type === ChangeSet_1.ChangeSetType.UPDATE && !wrapped.__initialized && !wrapped.isTouched()) {
+        if (type === ChangeSetType.UPDATE && !wrapped.__initialized && !wrapped.isTouched()) {
             return null;
         }
-        const changeSet = new ChangeSet_1.ChangeSet(entity, type, this.computePayload(entity), meta);
+        const changeSet = new ChangeSet(entity, type, this.computePayload(entity), meta);
         changeSet.originalEntity = wrapped.__originalEntityData;
         if (this.config.get('validate')) {
             this.validator.validate(changeSet.entity, changeSet.payload, meta);
@@ -48,12 +45,12 @@ class ChangeSetComputer {
         for (const prop of meta.relations.filter(prop => prop.persist !== false || prop.userDefined === false)) {
             this.processProperty(changeSet, prop);
         }
-        if (changeSet.type === ChangeSet_1.ChangeSetType.UPDATE && !Utils_1.Utils.hasObjectKeys(changeSet.payload)) {
+        if (changeSet.type === ChangeSetType.UPDATE && !Utils.hasObjectKeys(changeSet.payload)) {
             return null;
         }
         // Execute `onCreate` and `onUpdate` on properties recursively, saves `onUpdate` results
         // to the `map` as we want to apply those only if something else changed.
-        if (type === ChangeSet_1.ChangeSetType.UPDATE) {
+        if (type === ChangeSetType.UPDATE) {
             for (const prop of meta.hydrateProps) {
                 this.processPropertyInitializers(entity, prop, type, map);
             }
@@ -66,7 +63,7 @@ class ChangeSetComputer {
             }
             // Recompute the changeset, we need to merge this as here we ignore relations.
             const diff = this.computePayload(entity, true);
-            Utils_1.Utils.merge(changeSet.payload, diff);
+            Utils.merge(changeSet.payload, diff);
         }
         return changeSet;
     }
@@ -75,17 +72,17 @@ class ChangeSetComputer {
      */
     processPropertyInitializers(entity, prop, type, map, nested) {
         if (prop.onCreate
-            && type === ChangeSet_1.ChangeSetType.CREATE
+            && type === ChangeSetType.CREATE
             && (entity[prop.name] == null
-                || (Utils_1.Utils.isScalarReference(entity[prop.name]) && entity[prop.name].unwrap() == null))) {
+                || (Utils.isScalarReference(entity[prop.name]) && entity[prop.name].unwrap() == null))) {
             entity[prop.name] = prop.onCreate(entity, this.em);
         }
-        if (prop.onUpdate && type === ChangeSet_1.ChangeSetType.UPDATE) {
+        if (prop.onUpdate && type === ChangeSetType.UPDATE) {
             const pairs = map.get(entity) ?? [];
             pairs.push([prop.name, prop.onUpdate(entity, this.em)]);
             map.set(entity, pairs);
         }
-        if (prop.kind === enums_1.ReferenceKind.EMBEDDED && entity[prop.name]) {
+        if (prop.kind === ReferenceKind.EMBEDDED && entity[prop.name]) {
             for (const embeddedProp of prop.targetMeta.hydrateProps) {
                 this.processPropertyInitializers(entity[prop.name], embeddedProp, type, map, nested || prop.object);
             }
@@ -93,7 +90,7 @@ class ChangeSetComputer {
     }
     computePayload(entity, ignoreUndefined = false) {
         const data = this.comparator.prepareEntity(entity);
-        const wrapped = (0, entity_1.helper)(entity);
+        const wrapped = helper(entity);
         const entityName = wrapped.__meta.className;
         const originalEntityData = wrapped.__originalEntityData;
         if (!wrapped.__initialized) {
@@ -106,7 +103,7 @@ class ChangeSetComputer {
             const comparator = this.comparator.getEntityComparator(entityName);
             const diff = comparator(originalEntityData, data);
             if (ignoreUndefined) {
-                Utils_1.Utils.keys(diff)
+                Utils.keys(diff)
                     .filter(k => diff[k] === undefined)
                     .forEach(k => delete diff[k]);
             }
@@ -116,32 +113,32 @@ class ChangeSetComputer {
     }
     processProperty(changeSet, prop, target) {
         if (!target) {
-            const targets = Utils_1.Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
+            const targets = Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
             targets.forEach(([t]) => this.processProperty(changeSet, prop, t));
             return;
         }
-        if (Utils_1.Utils.isCollection(target)) { // m:n or 1:m
+        if (Utils.isCollection(target)) { // m:n or 1:m
             this.processToMany(prop, changeSet);
         }
-        if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
             this.processToOne(prop, changeSet);
         }
     }
     processToOne(prop, changeSet) {
-        const isToOneOwner = prop.kind === enums_1.ReferenceKind.MANY_TO_ONE || (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE && prop.owner);
+        const isToOneOwner = prop.kind === ReferenceKind.MANY_TO_ONE || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner);
         if (!isToOneOwner || prop.mapToPk) {
             return;
         }
-        const targets = Utils_1.Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
+        const targets = Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
         targets.forEach(([target, idx]) => {
             if (!target.__helper.hasPrimaryKey()) {
-                Utils_1.Utils.setPayloadProperty(changeSet.payload, this.metadata.find(changeSet.name), prop, target.__helper.__identifier, idx);
+                Utils.setPayloadProperty(changeSet.payload, this.metadata.find(changeSet.name), prop, target.__helper.__identifier, idx);
             }
         });
     }
     processToMany(prop, changeSet) {
         const target = changeSet.entity[prop.name];
-        if (!target.isDirty() && changeSet.type !== ChangeSet_1.ChangeSetType.CREATE) {
+        if (!target.isDirty() && changeSet.type !== ChangeSetType.CREATE) {
             return;
         }
         this.collectionUpdates.add(target);
@@ -150,4 +147,3 @@ class ChangeSetComputer {
         }
     }
 }
-exports.ChangeSetComputer = ChangeSetComputer;

package/unit-of-work/ChangeSetPersister.d.ts

@@ -1,9 +1,10 @@
-import type { MetadataStorage } from '../metadata';
-import type { Dictionary, EntityDictionary, EntityMetadata, IHydrator } from '../typings';
-import { type EntityFactory, type EntityValidator } from '../entity';
-import { type ChangeSet } from './ChangeSet';
-import { type Configuration } from '../utils/Configuration';
-import type { DriverMethodOptions, IDatabaseDriver } from '../drivers';
+import type { MetadataStorage } from '../metadata/MetadataStorage.js';
+import type { Dictionary, EntityDictionary, EntityMetadata, IHydrator } from '../typings.js';
+import { type EntityFactory } from '../entity/EntityFactory.js';
+import { type EntityValidator } from '../entity/EntityValidator.js';
+import { type ChangeSet } from './ChangeSet.js';
+import { type Configuration } from '../utils/Configuration.js';
+import type { DriverMethodOptions, IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
 export declare class ChangeSetPersister {
     private readonly driver;
     private readonly metadata;

package/unit-of-work/ChangeSetPersister.js

@@ -1,13 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChangeSetPersister = void 0;
-const entity_1 = require("../entity");
-const ChangeSet_1 = require("./ChangeSet");
-const RawQueryFragment_1 = require("../utils/RawQueryFragment");
-const Utils_1 = require("../utils/Utils");
-const errors_1 = require("../errors");
-const enums_1 = require("../enums");
-class ChangeSetPersister {
+import { EntityIdentifier } from '../entity/EntityIdentifier.js';
+import { helper } from '../entity/wrap.js';
+import { ChangeSetType } from './ChangeSet.js';
+import { isRaw } from '../utils/RawQueryFragment.js';
+import { Utils } from '../utils/Utils.js';
+import { OptimisticLockError } from '../errors.js';
+import { ReferenceKind } from '../enums.js';
+export class ChangeSetPersister {
     driver;
     metadata;
     hydrator;
@@ -60,7 +58,7 @@ class ChangeSetPersister {
         }
         const size = this.config.get('batchSize');
         const meta = changeSets[0].meta;
-        const pk = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
+        const pk = Utils.getPrimaryKeyHash(meta.primaryKeys);
         for (let i = 0; i < changeSets.length; i += size) {
             const chunk = changeSets.slice(i, i + size);
             const pks = chunk.map(cs => cs.getPrimaryKey());
@@ -86,12 +84,12 @@ class ChangeSetPersister {
         for (const prop of meta.relations) {
             this.processProperty(changeSet, prop);
         }
-        if (changeSet.type === ChangeSet_1.ChangeSetType.CREATE && this.config.get('validateRequired')) {
+        if (changeSet.type === ChangeSetType.CREATE && this.config.get('validateRequired')) {
             this.validator.validateRequired(changeSet.entity);
         }
     }
     async persistNewEntity(meta, changeSet, options) {
-        const wrapped = (0, entity_1.helper)(changeSet.entity);
+        const wrapped = helper(changeSet.entity);
         options = this.propagateSchemaFromMetadata(meta, options, {
             convertCustomTypes: false,
         });
@@ -133,7 +131,7 @@ class ChangeSetPersister {
         const res = await this.driver.nativeInsertMany(meta.className, changeSets.map(cs => cs.payload), options);
         for (let i = 0; i < changeSets.length; i++) {
             const changeSet = changeSets[i];
-            const wrapped = (0, entity_1.helper)(changeSet.entity);
+            const wrapped = helper(changeSet.entity);
             if (!wrapped.hasPrimaryKey()) {
                 const field = meta.getPrimaryProps()[0].fieldNames[0];
                 this.mapPrimaryKey(meta, res.rows[i][field], changeSet);
@@ -172,7 +170,7 @@ class ChangeSetPersister {
             }
         }
         if (tmp.length === 0 && meta.concurrencyCheckKeys.size > 0) {
-            throw errors_1.OptimisticLockError.lockFailed(changeSet.entity);
+            throw OptimisticLockError.lockFailed(changeSet.entity);
         }
     }
     async persistManagedEntitiesBatch(meta, changeSets, options) {
@@ -191,10 +189,10 @@ class ChangeSetPersister {
         }
         const res = await this.driver.nativeUpdateMany(meta.className, cond, payload, options);
         const map = new Map();
-        res.rows?.forEach(item => map.set(Utils_1.Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
+        res.rows?.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
         for (const changeSet of changeSets) {
             if (res.rows) {
-                const row = map.get((0, entity_1.helper)(changeSet.entity).getSerializedPrimaryKey());
+                const row = map.get(helper(changeSet.entity).getSerializedPrimaryKey());
                 this.mapReturnedValues(changeSet.entity, changeSet.payload, row, meta);
             }
             changeSet.persisted = true;
@@ -203,7 +201,7 @@ class ChangeSetPersister {
     mapPrimaryKey(meta, value, changeSet) {
         const prop = meta.properties[meta.primaryKeys[0]];
         const insertId = prop.customType ? prop.customType.convertToJSValue(value, this.platform) : value;
-        const wrapped = (0, entity_1.helper)(changeSet.entity);
+        const wrapped = helper(changeSet.entity);
         if (!wrapped.hasPrimaryKey()) {
             wrapped.setPrimaryKey(insertId);
         }
@@ -212,23 +210,25 @@ class ChangeSetPersister {
         // of using the raw value from db, we convert it back to the db value explicitly
         value = prop.customType ? prop.customType.convertToDatabaseValue(insertId, this.platform, { mode: 'serialization' }) : value;
         changeSet.payload[wrapped.__meta.primaryKeys[0]] = value;
-        wrapped.__identifier?.setValue(value);
+        if (wrapped.__identifier && !Array.isArray(wrapped.__identifier)) {
+            wrapped.__identifier.setValue(value);
+        }
     }
     /**
      * Sets populate flag to new entities so they are serialized like if they were loaded from the db
      */
     markAsPopulated(changeSet, meta) {
-        (0, entity_1.helper)(changeSet.entity).__schema = this.driver.getSchemaName(meta, changeSet);
+        helper(changeSet.entity).__schema = this.driver.getSchemaName(meta, changeSet);
         if (!this.config.get('populateAfterFlush')) {
             return;
         }
-        (0, entity_1.helper)(changeSet.entity).populated();
+        helper(changeSet.entity).populated();
         meta.relations.forEach(prop => {
             const value = changeSet.entity[prop.name];
-            if (Utils_1.Utils.isEntity(value, true)) {
+            if (Utils.isEntity(value, true)) {
                 value.__helper.populated();
             }
-            else if (Utils_1.Utils.isCollection(value)) {
+            else if (Utils.isCollection(value)) {
                 value.populated();
             }
         });
@@ -252,9 +252,9 @@ class ChangeSetPersister {
             return;
         }
         // skip entity references as they don't have version values loaded
-        changeSets = changeSets.filter(cs => (0, entity_1.helper)(cs.entity).__initialized);
+        changeSets = changeSets.filter(cs => helper(cs.entity).__initialized);
         const $or = changeSets.map(cs => {
-            const cond = Utils_1.Utils.getPrimaryKeyCond(cs.originalEntity, meta.primaryKeys.concat(...meta.concurrencyCheckKeys));
+            const cond = Utils.getPrimaryKeyCond(cs.originalEntity, meta.primaryKeys.concat(...meta.concurrencyCheckKeys));
             if (meta.versionProperty) {
                 // @ts-ignore
                 cond[meta.versionProperty] = this.platform.quoteVersionValue(cs.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
@@ -269,14 +269,14 @@ class ChangeSetPersister {
         if (res.length !== changeSets.length) {
             const compare = (a, b, keys) => keys.every(k => a[k] === b[k]);
             const entity = changeSets.find(cs => {
-                return !res.some(row => compare(Utils_1.Utils.getPrimaryKeyCond(cs.entity, primaryKeys), row, primaryKeys));
+                return !res.some(row => compare(Utils.getPrimaryKeyCond(cs.entity, primaryKeys), row, primaryKeys));
             }).entity;
-            throw errors_1.OptimisticLockError.lockFailed(entity);
+            throw OptimisticLockError.lockFailed(entity);
         }
     }
     checkOptimisticLock(meta, changeSet, res) {
         if ((meta.versionProperty || meta.concurrencyCheckKeys.size > 0) && res && !res.affectedRows) {
-            throw errors_1.OptimisticLockError.lockFailed(changeSet.entity);
+            throw OptimisticLockError.lockFailed(changeSet.entity);
         }
     }
     /**
@@ -285,18 +285,18 @@ class ChangeSetPersister {
      */
     async reloadVersionValues(meta, changeSets, options) {
         const reloadProps = meta.versionProperty && !this.usesReturningStatement ? [meta.properties[meta.versionProperty]] : [];
-        if (changeSets[0].type === ChangeSet_1.ChangeSetType.CREATE) {
+        if (changeSets[0].type === ChangeSetType.CREATE) {
             // do not reload things that already had a runtime value
             meta.props
                 .filter(prop => prop.persist !== false && (prop.autoincrement || prop.generated || prop.defaultRaw))
-                .filter(prop => (changeSets[0].entity[prop.name] == null && prop.defaultRaw !== 'null') || (0, RawQueryFragment_1.isRaw)(changeSets[0].entity[prop.name]))
+                .filter(prop => (changeSets[0].entity[prop.name] == null && prop.defaultRaw !== 'null') || isRaw(changeSets[0].entity[prop.name]))
                 .forEach(prop => reloadProps.push(prop));
         }
-        if (changeSets[0].type === ChangeSet_1.ChangeSetType.UPDATE) {
+        if (changeSets[0].type === ChangeSetType.UPDATE) {
             const returning = new Set();
             changeSets.forEach(cs => {
-                Utils_1.Utils.keys(cs.payload).forEach(k => {
-                    if ((0, RawQueryFragment_1.isRaw)(cs.payload[k]) && (0, RawQueryFragment_1.isRaw)(cs.entity[k])) {
+                Utils.keys(cs.payload).forEach(k => {
+                    if (isRaw(cs.payload[k]) && isRaw(cs.entity[k])) {
                         returning.add(meta.properties[k]);
                     }
                 });
@@ -313,22 +313,22 @@ class ChangeSetPersister {
             return;
         }
         reloadProps.unshift(...meta.getPrimaryProps());
-        const pk = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
+        const pk = Utils.getPrimaryKeyHash(meta.primaryKeys);
         const pks = changeSets.map(cs => {
-            const val = (0, entity_1.helper)(cs.entity).getPrimaryKey(true);
-            if (Utils_1.Utils.isPlainObject(val)) {
-                return Utils_1.Utils.getCompositeKeyValue(val, meta, false, this.platform);
+            const val = helper(cs.entity).getPrimaryKey(true);
+            if (Utils.isPlainObject(val)) {
+                return Utils.getCompositeKeyValue(val, meta, false, this.platform);
             }
             return val;
         });
         options = this.propagateSchemaFromMetadata(meta, options, {
-            fields: Utils_1.Utils.unique(reloadProps.map(prop => prop.name)),
+            fields: Utils.unique(reloadProps.map(prop => prop.name)),
         });
         const data = await this.driver.find(meta.className, { [pk]: { $in: pks } }, options);
         const map = new Map();
-        data.forEach(item => map.set(Utils_1.Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
+        data.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
         for (const changeSet of changeSets) {
-            const data = map.get((0, entity_1.helper)(changeSet.entity).getSerializedPrimaryKey());
+            const data = map.get(helper(changeSet.entity).getSerializedPrimaryKey());
             this.hydrator.hydrate(changeSet.entity, meta, data, this.factory, 'full', false, true);
             Object.assign(changeSet.payload, data); // merge to the changeset payload, so it gets saved to the entity snapshot
         }
@@ -336,21 +336,25 @@ class ChangeSetPersister {
     processProperty(changeSet, prop) {
         const meta = this.metadata.find(changeSet.name);
         const value = changeSet.payload[prop.name]; // for inline embeddables
-        if (value instanceof entity_1.EntityIdentifier) {
+        if (value instanceof EntityIdentifier) {
             changeSet.payload[prop.name] = value.getValue();
             return;
         }
-        if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && Array.isArray(value)) {
-            changeSet.payload[prop.name] = value.map(val => val instanceof entity_1.EntityIdentifier ? val.getValue() : val);
+        if (Array.isArray(value) && value.every(item => item instanceof EntityIdentifier)) {
+            changeSet.payload[prop.name] = value.map(item => item.getValue());
+            return;
+        }
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && Array.isArray(value)) {
+            changeSet.payload[prop.name] = value.map(val => val instanceof EntityIdentifier ? val.getValue() : val);
             return;
         }
         if (prop.name in changeSet.payload) {
             return;
         }
-        const values = Utils_1.Utils.unwrapProperty(changeSet.payload, meta, prop, true); // for object embeddables
+        const values = Utils.unwrapProperty(changeSet.payload, meta, prop, true); // for object embeddables
         values.forEach(([value, indexes]) => {
-            if (value instanceof entity_1.EntityIdentifier) {
-                Utils_1.Utils.setPayloadProperty(changeSet.payload, meta, prop, value.getValue(), indexes);
+            if (value instanceof EntityIdentifier) {
+                Utils.setPayloadProperty(changeSet.payload, meta, prop, value.getValue(), indexes);
             }
         });
     }
@@ -360,7 +364,7 @@ class ChangeSetPersister {
      * We do need to map to the change set payload too, as it will be used in the originalEntityData for new entities.
      */
     mapReturnedValues(entity, payload, row, meta, upsert = false) {
-        if ((!this.usesReturningStatement && !upsert) || !row || !Utils_1.Utils.hasObjectKeys(row)) {
+        if ((!this.usesReturningStatement && !upsert) || !row || !Utils.hasObjectKeys(row)) {
             return;
         }
         const mapped = this.comparator.mapResult(meta.className, row);
@@ -377,4 +381,3 @@ class ChangeSetPersister {
         Object.assign(payload, mapped);
     }
 }
-exports.ChangeSetPersister = ChangeSetPersister;

package/unit-of-work/CommitOrderCalculator.d.ts

@@ -1,4 +1,4 @@
-import type { Dictionary, EntityProperty } from '../typings';
+import type { Dictionary, EntityProperty } from '../typings.js';
 export declare const enum NodeState {
     NOT_VISITED = 0,
     IN_PROGRESS = 1,

package/unit-of-work/CommitOrderCalculator.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommitOrderCalculator = exports.NodeState = void 0;
-const enums_1 = require("../enums");
-var NodeState;
+import { ReferenceKind } from '../enums.js';
+export var NodeState;
 (function (NodeState) {
     NodeState[NodeState["NOT_VISITED"] = 0] = "NOT_VISITED";
     NodeState[NodeState["IN_PROGRESS"] = 1] = "IN_PROGRESS";
     NodeState[NodeState["VISITED"] = 2] = "VISITED";
-})(NodeState || (exports.NodeState = NodeState = {}));
+})(NodeState || (NodeState = {}));
 /**
  * CommitOrderCalculator implements topological sorting, which is an ordering
  * algorithm for directed graphs (DG) and/or directed acyclic graphs (DAG) by
@@ -18,7 +15,7 @@ var NodeState;
  * Based on https://github.com/doctrine/orm/blob/master/lib/Doctrine/ORM/Internal/CommitOrderCalculator.php
  * @internal
  */
-class CommitOrderCalculator {
+export class CommitOrderCalculator {
     /** Matrix of nodes, keys are provided hashes and values are the node definition objects. */
     nodes = {};
     /** Volatile variable holding calculated nodes during sorting process. */
@@ -42,8 +39,8 @@ class CommitOrderCalculator {
         this.nodes[from].dependencies[to] = { from, to, weight };
     }
     discoverProperty(prop, entityName) {
-        const toOneOwner = (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE && prop.owner) || prop.kind === enums_1.ReferenceKind.MANY_TO_ONE;
-        const toManyOwner = prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && prop.owner && !prop.pivotEntity;
+        const toOneOwner = (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner) || prop.kind === ReferenceKind.MANY_TO_ONE;
+        const toManyOwner = prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !prop.pivotEntity;
         if (!toOneOwner && !toManyOwner) {
             return;
         }
@@ -110,4 +107,3 @@ class CommitOrderCalculator {
         this.sortedNodeList.push(target.hash);
     }
 }
-exports.CommitOrderCalculator = CommitOrderCalculator;

package/unit-of-work/IdentityMap.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEntity, EntityMetadata } from '../typings';
+import type { AnyEntity, EntityMetadata } from '../typings.js';
 export declare class IdentityMap {
     private readonly defaultSchema?;
     constructor(defaultSchema?: string | undefined);

package/unit-of-work/IdentityMap.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IdentityMap = void 0;
-class IdentityMap {
+export class IdentityMap {
     defaultSchema;
     constructor(defaultSchema) {
         this.defaultSchema = defaultSchema;
@@ -73,4 +70,3 @@ class IdentityMap {
         return hash;
     }
 }
-exports.IdentityMap = IdentityMap;

package/unit-of-work/UnitOfWork.d.ts

@@ -1,10 +1,11 @@
-import type { AnyEntity, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary } from '../typings';
-import { Collection, Reference } from '../entity';
-import { ChangeSet, ChangeSetType } from './ChangeSet';
-import { ChangeSetPersister } from './ChangeSetPersister';
-import type { EntityManager } from '../EntityManager';
-import { IdentityMap } from './IdentityMap';
-import type { LockOptions } from '../drivers/IDatabaseDriver';
+import type { AnyEntity, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary } from '../typings.js';
+import { Collection } from '../entity/Collection.js';
+import { Reference } from '../entity/Reference.js';
+import { ChangeSet, ChangeSetType } from './ChangeSet.js';
+import { ChangeSetPersister } from './ChangeSetPersister.js';
+import type { EntityManager } from '../EntityManager.js';
+import { IdentityMap } from './IdentityMap.js';
+import type { LockOptions } from '../drivers/IDatabaseDriver.js';
 export declare class UnitOfWork {
     private readonly em;
     /** map of references to managed entities */