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

package/unit-of-work/UnitOfWork.js

@@ -1,20 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnitOfWork = void 0;
-const node_async_hooks_1 = require("node:async_hooks");
-const entity_1 = require("../entity");
-const ChangeSet_1 = require("./ChangeSet");
-const ChangeSetComputer_1 = require("./ChangeSetComputer");
-const ChangeSetPersister_1 = require("./ChangeSetPersister");
-const CommitOrderCalculator_1 = require("./CommitOrderCalculator");
-const Utils_1 = require("../utils/Utils");
-const enums_1 = require("../enums");
-const errors_1 = require("../errors");
-const events_1 = require("../events");
-const IdentityMap_1 = require("./IdentityMap");
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { Collection } from '../entity/Collection.js';
+import { EntityHelper } from '../entity/EntityHelper.js';
+import { helper } from '../entity/wrap.js';
+import { Reference } from '../entity/Reference.js';
+import { EntityIdentifier } from '../entity/EntityIdentifier.js';
+import { ChangeSet, ChangeSetType } from './ChangeSet.js';
+import { ChangeSetComputer } from './ChangeSetComputer.js';
+import { ChangeSetPersister } from './ChangeSetPersister.js';
+import { CommitOrderCalculator } from './CommitOrderCalculator.js';
+import { Utils } from '../utils/Utils.js';
+import { Cascade, DeferMode, EventType, LockMode, ReferenceKind } from '../enums.js';
+import { OptimisticLockError, ValidationError } from '../errors.js';
+import { TransactionEventBroadcaster } from '../events/TransactionEventBroadcaster.js';
+import { IdentityMap } from './IdentityMap.js';
 // to deal with validation for flush inside flush hooks and `Promise.all`
-const insideFlush = new node_async_hooks_1.AsyncLocalStorage();
-class UnitOfWork {
+const insideFlush = new AsyncLocalStorage();
+export class UnitOfWork {
     em;
     /** map of references to managed entities */
     identityMap;
@@ -38,14 +39,14 @@ class UnitOfWork {
         this.em = em;
         this.metadata = this.em.getMetadata();
         this.platform = this.em.getPlatform();
-        this.identityMap = new IdentityMap_1.IdentityMap(this.platform.getDefaultSchemaName());
+        this.identityMap = new IdentityMap(this.platform.getDefaultSchemaName());
         this.eventManager = this.em.getEventManager();
         this.comparator = this.em.getComparator();
-        this.changeSetComputer = new ChangeSetComputer_1.ChangeSetComputer(this.em.getValidator(), this.collectionUpdates, this.metadata, this.platform, this.em.config, this.em);
-        this.changeSetPersister = new ChangeSetPersister_1.ChangeSetPersister(this.em.getDriver(), this.metadata, this.em.config.getHydrator(this.metadata), this.em.getEntityFactory(), this.em.getValidator(), this.em.config);
+        this.changeSetComputer = new ChangeSetComputer(this.collectionUpdates, this.metadata, this.platform, this.em.config, this.em);
+        this.changeSetPersister = new ChangeSetPersister(this.em.getDriver(), this.metadata, this.em.config.getHydrator(this.metadata), this.em.getEntityFactory(), this.em.config, this.em);
     }
     merge(entity, visited) {
-        const wrapped = (0, entity_1.helper)(entity);
+        const wrapped = helper(entity);
         wrapped.__em = this.em;
         if (!wrapped.hasPrimaryKey()) {
             return;
@@ -60,52 +61,68 @@ class UnitOfWork {
         // as there can be some entity with already changed state that is not yet flushed
         if (wrapped.__initialized && (!visited || !wrapped.__originalEntityData)) {
             wrapped.__originalEntityData = this.comparator.prepareEntity(entity);
-            wrapped.__touched = false;
         }
-        this.cascade(entity, enums_1.Cascade.MERGE, visited ?? new Set());
+        this.cascade(entity, Cascade.MERGE, visited ?? new Set());
+    }
+    /**
+     * Entity data can wary in its shape, e.g. we might get a deep relation graph with joined strategy, but for diffing,
+     * we need to normalize the shape, so relation values are only raw FKs. This method handles that.
+     * @internal
+     */
+    normalizeEntityData(meta, data) {
+        const forceUndefined = this.em.config.get('forceUndefined');
+        for (const key of Utils.keys(data)) {
+            const prop = meta.properties[key];
+            if (!prop) {
+                continue;
+            }
+            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, true);
+            }
+            else if (prop.kind === ReferenceKind.EMBEDDED && !prop.object && Utils.isPlainObject(data[prop.name])) {
+                for (const p of prop.targetMeta.props) {
+                    /* v8 ignore next */
+                    const prefix = prop.prefix === false ? '' : prop.prefix === true ? prop.name + '_' : prop.prefix;
+                    data[prefix + p.name] = data[prop.name][p.name];
+                }
+                data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
+            }
+            if (prop.hydrate === false && prop.customType?.ensureComparable(meta, prop)) {
+                const converted = prop.customType.convertToJSValue(data[key], this.platform, { key, mode: 'hydration', force: true });
+                data[key] = prop.customType.convertToDatabaseValue(converted, this.platform, { key, mode: 'hydration' });
+            }
+            if (forceUndefined) {
+                if (data[key] === null) {
+                    data[key] = undefined;
+                }
+            }
+        }
     }
     /**
      * @internal
      */
     register(entity, data, options) {
         this.identityMap.store(entity);
-        entity_1.EntityHelper.ensurePropagation(entity);
+        EntityHelper.ensurePropagation(entity);
         if (options?.newEntity) {
             return entity;
         }
         const forceUndefined = this.em.config.get('forceUndefined');
-        const wrapped = (0, entity_1.helper)(entity);
+        const wrapped = helper(entity);
         if (options?.loaded && wrapped.__initialized && !wrapped.__onLoadFired) {
             this.loadedEntities.add(entity);
         }
         wrapped.__em ??= this.em;
         wrapped.__managed = true;
         if (data && (options?.refresh || !wrapped.__originalEntityData)) {
-            for (const key of Utils_1.Utils.keys(data)) {
+            this.normalizeEntityData(wrapped.__meta, data);
+            for (const key of Utils.keys(data)) {
                 const prop = wrapped.__meta.properties[key];
-                if (!prop) {
-                    continue;
-                }
-                wrapped.__loadedProperties.add(key);
-                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);
-                }
-                else if (prop.kind === enums_1.ReferenceKind.EMBEDDED && !prop.object && Utils_1.Utils.isPlainObject(data[prop.name])) {
-                    for (const p of prop.targetMeta.props) {
-                        /* istanbul ignore next */
-                        const prefix = prop.prefix === false ? '' : prop.prefix === true ? prop.name + '_' : prop.prefix;
-                        data[prefix + p.name] = data[prop.name][p.name];
-                    }
-                    data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
-                }
-                if (forceUndefined) {
-                    if (data[key] === null) {
-                        data[key] = undefined;
-                    }
+                if (prop) {
+                    wrapped.__loadedProperties.add(key);
                 }
             }
             wrapped.__originalEntityData = data;
-            wrapped.__touched = false;
         }
         return entity;
     }
@@ -114,9 +131,9 @@ class UnitOfWork {
      */
     async dispatchOnLoadEvent() {
         for (const entity of this.loadedEntities) {
-            if (this.eventManager.hasListeners(enums_1.EventType.onLoad, entity.__meta)) {
-                await this.eventManager.dispatchEvent(enums_1.EventType.onLoad, { entity, meta: entity.__meta, em: this.em });
-                (0, entity_1.helper)(entity).__onLoadFired = true;
+            if (this.eventManager.hasListeners(EventType.onLoad, entity.__meta)) {
+                await this.eventManager.dispatchEvent(EventType.onLoad, { entity, meta: entity.__meta, em: this.em });
+                helper(entity).__onLoadFired = true;
             }
         }
         this.loadedEntities.clear();
@@ -124,7 +141,7 @@ class UnitOfWork {
     /**
      * Returns entity from the identity map. For composite keys, you need to pass an array of PKs in the same order as they are defined in `meta.primaryKeys`.
      */
-    getById(entityName, id, schema) {
+    getById(entityName, id, schema, convertCustomTypes) {
         if (id == null || (Array.isArray(id) && id.length === 0)) {
             return undefined;
         }
@@ -134,8 +151,17 @@ class UnitOfWork {
             hash = '' + id;
         }
         else {
-            const keys = Array.isArray(id) ? Utils_1.Utils.flatten(id) : [id];
-            hash = Utils_1.Utils.getPrimaryKeyHash(keys);
+            let keys = Array.isArray(id) ? Utils.flatten(id) : [id];
+            keys = meta.getPrimaryProps(true).map((p, i) => {
+                if (!convertCustomTypes && p.customType) {
+                    return p.customType.convertToDatabaseValue(keys[i], this.platform, {
+                        key: p.name,
+                        mode: 'hydration',
+                    });
+                }
+                return keys[i];
+            });
+            hash = Utils.getPrimaryKeyHash(keys);
         }
         schema ??= meta.schema ?? this.em.config.getSchema();
         if (schema) {
@@ -144,7 +170,7 @@ class UnitOfWork {
         return this.identityMap.getByHash(meta, hash);
     }
     tryGetById(entityName, where, schema, strict = true) {
-        const pk = Utils_1.Utils.extractPK(where, this.metadata.find(entityName), strict);
+        const pk = Utils.extractPK(where, this.metadata.find(entityName), strict);
         if (!pk) {
             return null;
         }
@@ -160,7 +186,7 @@ class UnitOfWork {
      * Returns stored snapshot of entity state that is used for change set computation.
      */
     getOriginalEntityData(entity) {
-        return (0, entity_1.helper)(entity).__originalEntityData;
+        return helper(entity).__originalEntityData;
     }
     getPersistStack() {
         return this.persistStack;
@@ -184,10 +210,8 @@ class UnitOfWork {
         if (this.queuedActions.has(meta.className) || this.queuedActions.has(meta.root.className)) {
             return true;
         }
-        for (const entity of this.identityMap.getStore(meta).values()) {
-            if ((0, entity_1.helper)(entity).__initialized && (0, entity_1.helper)(entity).isTouched()) {
-                return true;
-            }
+        if (meta.discriminatorMap && Object.values(meta.discriminatorMap).some(v => this.queuedActions.has(v))) {
+            return true;
         }
         return false;
     }
@@ -195,9 +219,9 @@ class UnitOfWork {
         this.queuedActions.clear();
     }
     computeChangeSet(entity, type) {
-        const wrapped = (0, entity_1.helper)(entity);
+        const wrapped = helper(entity);
         if (type) {
-            this.changeSets.set(entity, new ChangeSet_1.ChangeSet(entity, type, {}, wrapped.__meta));
+            this.changeSets.set(entity, new ChangeSet(entity, type, {}, wrapped.__meta));
             return;
         }
         const cs = this.changeSetComputer.computeChangeSet(entity);
@@ -208,7 +232,6 @@ class UnitOfWork {
         this.changeSets.set(entity, cs);
         this.persistStack.delete(entity);
         wrapped.__originalEntityData = this.comparator.prepareEntity(entity);
-        wrapped.__touched = false;
     }
     recomputeSingleChangeSet(entity) {
         const changeSet = this.changeSets.get(entity);
@@ -216,19 +239,17 @@ class UnitOfWork {
             return;
         }
         const cs = this.changeSetComputer.computeChangeSet(entity);
-        /* istanbul ignore else */
         if (cs && !this.checkUniqueProps(cs)) {
             Object.assign(changeSet.payload, cs.payload);
-            (0, entity_1.helper)(entity).__originalEntityData = this.comparator.prepareEntity(entity);
-            (0, entity_1.helper)(entity).__touched = false;
+            helper(entity).__originalEntityData = this.comparator.prepareEntity(entity);
         }
     }
     persist(entity, visited, options = {}) {
-        entity_1.EntityHelper.ensurePropagation(entity);
+        EntityHelper.ensurePropagation(entity);
         if (options.checkRemoveStack && this.removeStack.has(entity)) {
             return;
         }
-        const wrapped = (0, entity_1.helper)(entity);
+        const wrapped = helper(entity);
         this.persistStack.add(entity);
         this.queuedActions.add(wrapped.__meta.className);
         this.removeStack.delete(entity);
@@ -236,43 +257,43 @@ class UnitOfWork {
             this.identityMap.store(entity);
         }
         if (options.cascade ?? true) {
-            this.cascade(entity, enums_1.Cascade.PERSIST, visited, options);
+            this.cascade(entity, Cascade.PERSIST, visited, options);
         }
     }
     remove(entity, visited, options = {}) {
         // allow removing not managed entities if they are not part of the persist stack
-        if ((0, entity_1.helper)(entity).__managed || !this.persistStack.has(entity)) {
+        if (helper(entity).__managed || !this.persistStack.has(entity)) {
             this.removeStack.add(entity);
-            this.queuedActions.add((0, entity_1.helper)(entity).__meta.className);
+            this.queuedActions.add(helper(entity).__meta.className);
         }
         else {
             this.persistStack.delete(entity);
             this.identityMap.delete(entity);
         }
         // remove from referencing relations that are nullable
-        for (const prop of (0, entity_1.helper)(entity).__meta.bidirectionalRelations) {
+        for (const prop of helper(entity).__meta.bidirectionalRelations) {
             const inverseProp = prop.mappedBy || prop.inversedBy;
-            const relation = entity_1.Reference.unwrapReference(entity[prop.name]);
+            const relation = Reference.unwrapReference(entity[prop.name]);
             const prop2 = prop.targetMeta.properties[inverseProp];
-            if (prop.kind === enums_1.ReferenceKind.ONE_TO_MANY && prop2.nullable && Utils_1.Utils.isCollection(relation)) {
+            if (prop.kind === ReferenceKind.ONE_TO_MANY && prop2.nullable && Utils.isCollection(relation)) {
                 for (const item of relation.getItems(false)) {
                     delete item[inverseProp];
                 }
                 continue;
             }
             const target = relation && relation[inverseProp];
-            if (relation && Utils_1.Utils.isCollection(target)) {
+            if (relation && Utils.isCollection(target)) {
                 target.removeWithoutPropagation(entity);
             }
         }
         if (options.cascade ?? true) {
-            this.cascade(entity, enums_1.Cascade.REMOVE, visited);
+            this.cascade(entity, Cascade.REMOVE, visited);
         }
     }
     async commit() {
         if (this.working) {
             if (insideFlush.getStore()) {
-                throw errors_1.ValidationError.cannotCommit();
+                throw ValidationError.cannotCommit();
             }
             return new Promise((resolve, reject) => {
                 this.flushQueue.push(() => {
@@ -297,23 +318,27 @@ class UnitOfWork {
     async doCommit() {
         const oldTx = this.em.getTransactionContext();
         try {
-            await this.eventManager.dispatchEvent(enums_1.EventType.beforeFlush, { em: this.em, uow: this });
+            await this.eventManager.dispatchEvent(EventType.beforeFlush, { em: this.em, uow: this });
             this.computeChangeSets();
             for (const cs of this.changeSets.values()) {
                 cs.entity.__helper.__processing = true;
             }
-            await this.eventManager.dispatchEvent(enums_1.EventType.onFlush, { em: this.em, uow: this });
+            await this.eventManager.dispatchEvent(EventType.onFlush, { em: this.em, uow: this });
+            this.filterCollectionUpdates();
             // nothing to do, do not start transaction
             if (this.changeSets.size === 0 && this.collectionUpdates.size === 0 && this.extraUpdates.size === 0) {
-                return void await this.eventManager.dispatchEvent(enums_1.EventType.afterFlush, { em: this.em, uow: this });
+                await this.eventManager.dispatchEvent(EventType.afterFlush, { em: this.em, uow: this });
+                return;
             }
             const groups = this.getChangeSetGroups();
             const platform = this.em.getPlatform();
             const runInTransaction = !this.em.isInTransaction() && platform.supportsTransactions() && this.em.config.get('implicitTransactions');
             if (runInTransaction) {
+                const loggerContext = Utils.merge({ id: this.em._id }, this.em.getLoggerContext({ disableContextResolution: true }));
                 await this.em.getConnection('write').transactional(trx => this.persistToDatabase(groups, trx), {
                     ctx: oldTx,
-                    eventBroadcaster: new events_1.TransactionEventBroadcaster(this.em),
+                    eventBroadcaster: new TransactionEventBroadcaster(this.em),
+                    loggerContext,
                 });
             }
             else {
@@ -323,18 +348,18 @@ class UnitOfWork {
             for (const cs of this.changeSets.values()) {
                 cs.entity.__helper.__processing = false;
             }
-            await this.eventManager.dispatchEvent(enums_1.EventType.afterFlush, { em: this.em, uow: this });
+            await this.eventManager.dispatchEvent(EventType.afterFlush, { em: this.em, uow: this });
         }
         finally {
             this.resetTransaction(oldTx);
         }
     }
     async lock(entity, options) {
-        if (!this.getById(entity.constructor.name, (0, entity_1.helper)(entity).__primaryKeys, (0, entity_1.helper)(entity).__schema)) {
-            throw errors_1.ValidationError.entityNotManaged(entity);
+        if (!this.getById(entity.constructor.name, helper(entity).__primaryKeys, helper(entity).__schema)) {
+            throw ValidationError.entityNotManaged(entity);
         }
         const meta = this.metadata.find(entity.constructor.name);
-        if (options.lockMode === enums_1.LockMode.OPTIMISTIC) {
+        if (options.lockMode === LockMode.OPTIMISTIC) {
             await this.lockOptimistic(entity, meta, options.lockVersion);
         }
         else if (options.lockMode != null) {
@@ -348,78 +373,77 @@ class UnitOfWork {
     }
     unsetIdentity(entity) {
         this.identityMap.delete(entity);
-        const wrapped = (0, entity_1.helper)(entity);
+        const wrapped = helper(entity);
         const serializedPK = wrapped.getSerializedPrimaryKey();
         // remove references of this entity in all managed entities, otherwise flushing could reinsert the entity
         for (const { meta, prop } of wrapped.__meta.referencingProperties) {
             for (const referrer of this.identityMap.getStore(meta).values()) {
-                const rel = entity_1.Reference.unwrapReference(referrer[prop.name]);
-                if (Utils_1.Utils.isCollection(rel)) {
+                const rel = Reference.unwrapReference(referrer[prop.name]);
+                if (Utils.isCollection(rel)) {
                     rel.removeWithoutPropagation(entity);
                 }
-                else if (rel && (prop.mapToPk ? (0, entity_1.helper)(this.em.getReference(prop.type, rel)).getSerializedPrimaryKey() === serializedPK : rel === entity)) {
+                else if (rel && (prop.mapToPk ? helper(this.em.getReference(prop.type, rel)).getSerializedPrimaryKey() === serializedPK : rel === entity)) {
                     if (prop.formula) {
                         delete referrer[prop.name];
                     }
                     else {
-                        delete (0, entity_1.helper)(referrer).__data[prop.name];
+                        delete helper(referrer).__data[prop.name];
                     }
                 }
             }
         }
         delete wrapped.__identifier;
         delete wrapped.__originalEntityData;
-        wrapped.__touched = false;
         wrapped.__managed = false;
     }
     computeChangeSets() {
         this.changeSets.clear();
         const visited = new Set();
         for (const entity of this.removeStack) {
-            this.cascade(entity, enums_1.Cascade.REMOVE, visited);
+            this.cascade(entity, Cascade.REMOVE, visited);
         }
         visited.clear();
-        for (const entity of this.persistStack) {
-            this.cascade(entity, enums_1.Cascade.PERSIST, visited, { checkRemoveStack: true });
-        }
         for (const entity of this.identityMap) {
             if (!this.removeStack.has(entity) && !this.persistStack.has(entity) && !this.orphanRemoveStack.has(entity)) {
-                this.cascade(entity, enums_1.Cascade.PERSIST, visited, { checkRemoveStack: true });
+                this.cascade(entity, Cascade.PERSIST, visited, { checkRemoveStack: true });
             }
         }
+        for (const entity of this.persistStack) {
+            this.cascade(entity, Cascade.PERSIST, visited, { checkRemoveStack: true });
+        }
         visited.clear();
         for (const entity of this.persistStack) {
             this.findNewEntities(entity, visited);
         }
         for (const entity of this.orphanRemoveStack) {
-            if (!(0, entity_1.helper)(entity).__processing) {
+            if (!helper(entity).__processing) {
                 this.removeStack.add(entity);
             }
         }
         // Check insert stack if there are any entities matching something from delete stack. This can happen when recreating entities.
         const inserts = {};
         for (const cs of this.changeSets.values()) {
-            if (cs.type === ChangeSet_1.ChangeSetType.CREATE) {
+            if (cs.type === ChangeSetType.CREATE) {
                 inserts[cs.meta.className] ??= [];
                 inserts[cs.meta.className].push(cs);
             }
         }
         for (const cs of this.changeSets.values()) {
-            if (cs.type === ChangeSet_1.ChangeSetType.UPDATE) {
+            if (cs.type === ChangeSetType.UPDATE) {
                 this.findEarlyUpdates(cs, inserts[cs.meta.className]);
             }
         }
         for (const entity of this.removeStack) {
-            const wrapped = (0, entity_1.helper)(entity);
-            /* istanbul ignore next */
+            const wrapped = helper(entity);
+            /* v8 ignore next */
             if (wrapped.__processing) {
                 continue;
             }
             const deletePkHash = [wrapped.getSerializedPrimaryKey(), ...this.expandUniqueProps(entity)];
-            let type = ChangeSet_1.ChangeSetType.DELETE;
+            let type = ChangeSetType.DELETE;
             for (const cs of inserts[wrapped.__meta.className] ?? []) {
                 if (deletePkHash.some(hash => hash === cs.getSerializedPrimaryKey() || this.expandUniqueProps(cs.entity).find(child => hash === child))) {
-                    type = ChangeSet_1.ChangeSetType.DELETE_EARLY;
+                    type = ChangeSetType.DELETE_EARLY;
                 }
             }
             this.computeChangeSet(entity, type);
@@ -430,7 +454,7 @@ class UnitOfWork {
             return;
         }
         let conflicts = false;
-        let type = ChangeSet_1.ChangeSetType.UPDATE;
+        let type = ChangeSetType.UPDATE;
         if (!props.some(prop => prop.name in changeSet.payload)) {
             return;
         }
@@ -439,7 +463,7 @@ class UnitOfWork {
                 if (prop.name in cs.payload && cs.rootName === changeSet.rootName && cs.type === changeSet.type) {
                     conflicts = true;
                     if (changeSet.payload[prop.name] == null) {
-                        type = ChangeSet_1.ChangeSetType.UPDATE_EARLY;
+                        type = ChangeSetType.UPDATE_EARLY;
                     }
                 }
             }
@@ -455,15 +479,15 @@ class UnitOfWork {
     }
     scheduleOrphanRemoval(entity, visited) {
         if (entity) {
-            (0, entity_1.helper)(entity).__em = this.em;
+            helper(entity).__em = this.em;
             this.orphanRemoveStack.add(entity);
             this.queuedActions.add(entity.__meta.className);
-            this.cascade(entity, enums_1.Cascade.SCHEDULE_ORPHAN_REMOVAL, visited);
+            this.cascade(entity, Cascade.SCHEDULE_ORPHAN_REMOVAL, visited);
         }
     }
     cancelOrphanRemoval(entity, visited) {
         this.orphanRemoveStack.delete(entity);
-        this.cascade(entity, enums_1.Cascade.CANCEL_ORPHAN_REMOVAL, visited);
+        this.cascade(entity, Cascade.CANCEL_ORPHAN_REMOVAL, visited);
     }
     getOrphanRemoveStack() {
         return this.orphanRemoveStack;
@@ -477,7 +501,7 @@ class UnitOfWork {
         }
         visited.add(entity);
         processed.add(entity);
-        const wrapped = (0, entity_1.helper)(entity);
+        const wrapped = helper(entity);
         if (wrapped.__processing || this.removeStack.has(entity) || this.orphanRemoveStack.has(entity)) {
             return;
         }
@@ -485,9 +509,9 @@ class UnitOfWork {
         wrapped.__schema ??= this.em.schema;
         this.initIdentifier(entity);
         for (const prop of wrapped.__meta.relations) {
-            const targets = Utils_1.Utils.unwrapProperty(entity, wrapped.__meta, prop);
+            const targets = Utils.unwrapProperty(entity, wrapped.__meta, prop);
             for (const [target] of targets) {
-                const kind = entity_1.Reference.unwrapReference(target);
+                const kind = Reference.unwrapReference(target);
                 this.processReference(entity, prop, kind, visited, processed, idx);
             }
         }
@@ -500,37 +524,37 @@ class UnitOfWork {
      * Returns `true` when the change set should be skipped as it will be empty after the extra update.
      */
     checkUniqueProps(changeSet) {
-        if (changeSet.type !== ChangeSet_1.ChangeSetType.UPDATE) {
+        if (changeSet.type !== ChangeSetType.UPDATE) {
             return false;
         }
         // when changing a unique nullable property (or a 1:1 relation), we can't do it in a single
         // query as it would cause unique constraint violations
         const uniqueProps = changeSet.meta.uniqueProps.filter(prop => {
-            return (prop.nullable || changeSet.type !== ChangeSet_1.ChangeSetType.CREATE);
+            return (prop.nullable || changeSet.type !== ChangeSetType.CREATE);
         });
         this.scheduleExtraUpdate(changeSet, uniqueProps);
-        return changeSet.type === ChangeSet_1.ChangeSetType.UPDATE && !Utils_1.Utils.hasObjectKeys(changeSet.payload);
+        return changeSet.type === ChangeSetType.UPDATE && !Utils.hasObjectKeys(changeSet.payload);
     }
     expandUniqueProps(entity) {
-        const wrapped = (0, entity_1.helper)(entity);
+        const wrapped = helper(entity);
         if (!wrapped.__meta.hasUniqueProps) {
             return [];
         }
         const simpleUniqueHashes = wrapped.__meta.uniqueProps.map(prop => {
             if (entity[prop.name] != null) {
-                return prop.kind === enums_1.ReferenceKind.SCALAR || prop.mapToPk ? entity[prop.name] : (0, entity_1.helper)(entity[prop.name]).getSerializedPrimaryKey();
+                return prop.kind === ReferenceKind.SCALAR || prop.mapToPk ? entity[prop.name] : helper(entity[prop.name]).getSerializedPrimaryKey();
             }
             if (wrapped.__originalEntityData?.[prop.name] != null) {
-                return Utils_1.Utils.getPrimaryKeyHash(Utils_1.Utils.asArray(wrapped.__originalEntityData[prop.name]));
+                return Utils.getPrimaryKeyHash(Utils.asArray(wrapped.__originalEntityData[prop.name]));
             }
             return undefined;
         }).filter(i => i);
         const compoundUniqueHashes = wrapped.__meta.uniques.map(unique => {
-            const props = Utils_1.Utils.asArray(unique.properties);
+            const props = Utils.asArray(unique.properties);
             if (props.every(prop => entity[prop] != null)) {
-                return Utils_1.Utils.getPrimaryKeyHash(props.map(p => {
+                return Utils.getPrimaryKeyHash(props.map(p => {
                     const prop = wrapped.__meta.properties[p];
-                    return prop.kind === enums_1.ReferenceKind.SCALAR || prop.mapToPk ? entity[prop.name] : (0, entity_1.helper)(entity[prop.name]).getSerializedPrimaryKey();
+                    return prop.kind === ReferenceKind.SCALAR || prop.mapToPk ? entity[prop.name] : helper(entity[prop.name]).getSerializedPrimaryKey();
                 }));
             }
             return undefined;
@@ -538,32 +562,41 @@ class UnitOfWork {
         return simpleUniqueHashes.concat(compoundUniqueHashes);
     }
     initIdentifier(entity) {
-        const wrapped = entity && (0, entity_1.helper)(entity);
+        const wrapped = entity && helper(entity);
         if (!wrapped || wrapped.__identifier || wrapped.hasPrimaryKey()) {
             return;
         }
-        const pk = wrapped.__meta.getPrimaryProps()[0];
-        if (pk.kind === enums_1.ReferenceKind.SCALAR) {
-            wrapped.__identifier = new entity_1.EntityIdentifier();
+        const pks = wrapped.__meta.getPrimaryProps();
+        const idents = [];
+        for (const pk of pks) {
+            if (pk.kind === ReferenceKind.SCALAR) {
+                idents.push(new EntityIdentifier(entity[pk.name]));
+            }
+            else if (entity[pk.name]) {
+                this.initIdentifier(entity[pk.name]);
+                idents.push(helper(entity[pk.name])?.__identifier);
+            }
+        }
+        if (pks.length === 1) {
+            wrapped.__identifier = idents[0];
         }
-        else if (entity[pk.name]) {
-            this.initIdentifier(entity[pk.name]);
-            wrapped.__identifier = (0, entity_1.helper)(entity[pk.name])?.__identifier;
+        else {
+            wrapped.__identifier = idents;
         }
     }
     processReference(parent, prop, kind, visited, processed, idx) {
-        const isToOne = prop.kind === enums_1.ReferenceKind.MANY_TO_ONE || prop.kind === enums_1.ReferenceKind.ONE_TO_ONE;
-        if (isToOne && Utils_1.Utils.isEntity(kind)) {
+        const isToOne = prop.kind === ReferenceKind.MANY_TO_ONE || prop.kind === ReferenceKind.ONE_TO_ONE;
+        if (isToOne && Utils.isEntity(kind)) {
             return this.processToOneReference(kind, visited, processed, idx);
         }
-        if (Utils_1.Utils.isCollection(kind)) {
+        if (Utils.isCollection(kind)) {
             kind.getItems(false)
                 .filter(item => !item.__helper.__originalEntityData)
                 .forEach(item => {
                 // propagate schema from parent
-                item.__helper.__schema ??= (0, entity_1.helper)(parent).__schema;
+                item.__helper.__schema ??= helper(parent).__schema;
             });
-            if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && kind.isDirty()) {
+            if (prop.kind === ReferenceKind.MANY_TO_MANY && kind.isDirty()) {
                 this.processToManyReference(kind, visited, processed, parent, prop);
             }
         }
@@ -575,8 +608,8 @@ class UnitOfWork {
     }
     processToManyReference(collection, visited, processed, parent, prop) {
         if (this.isCollectionSelfReferenced(collection, processed)) {
-            this.extraUpdates.add([parent, prop.name, collection, undefined, ChangeSet_1.ChangeSetType.UPDATE]);
-            const coll = new entity_1.Collection(parent);
+            this.extraUpdates.add([parent, prop.name, collection, undefined, ChangeSetType.UPDATE]);
+            const coll = new Collection(parent);
             coll.property = prop;
             parent[prop.name] = coll;
             return;
@@ -599,14 +632,21 @@ class UnitOfWork {
         const current = this.comparator.prepareEntity(changeSet.entity);
         const diff = this.comparator.diffEntities(changeSet.name, copy, current);
         Object.assign(changeSet.payload, diff);
-        const wrapped = (0, entity_1.helper)(changeSet.entity);
-        if (wrapped.__identifier && diff[wrapped.__meta.primaryKeys[0]]) {
-            wrapped.__identifier.setValue(diff[wrapped.__meta.primaryKeys[0]]);
+        const wrapped = helper(changeSet.entity);
+        if (wrapped.__identifier) {
+            const idents = Utils.asArray(wrapped.__identifier);
+            let i = 0;
+            for (const pk of wrapped.__meta.primaryKeys) {
+                if (diff[pk]) {
+                    idents[i].setValue(diff[pk]);
+                }
+                i++;
+            }
         }
     }
     postCommitCleanup() {
         for (const cs of this.changeSets.values()) {
-            const wrapped = (0, entity_1.helper)(cs.entity);
+            const wrapped = helper(cs.entity);
             wrapped.__processing = false;
             delete wrapped.__pk;
         }
@@ -625,23 +665,23 @@ class UnitOfWork {
         }
         visited.add(entity);
         switch (type) {
-            case enums_1.Cascade.PERSIST:
+            case Cascade.PERSIST:
                 this.persist(entity, visited, options);
                 break;
-            case enums_1.Cascade.MERGE:
+            case Cascade.MERGE:
                 this.merge(entity, visited);
                 break;
-            case enums_1.Cascade.REMOVE:
+            case Cascade.REMOVE:
                 this.remove(entity, visited, options);
                 break;
-            case enums_1.Cascade.SCHEDULE_ORPHAN_REMOVAL:
+            case Cascade.SCHEDULE_ORPHAN_REMOVAL:
                 this.scheduleOrphanRemoval(entity, visited);
                 break;
-            case enums_1.Cascade.CANCEL_ORPHAN_REMOVAL:
+            case Cascade.CANCEL_ORPHAN_REMOVAL:
                 this.cancelOrphanRemoval(entity, visited);
                 break;
         }
-        for (const prop of (0, entity_1.helper)(entity).__meta.relations) {
+        for (const prop of helper(entity).__meta.relations) {
             this.cascadeReference(entity, prop, type, visited, options);
         }
     }
@@ -650,72 +690,72 @@ class UnitOfWork {
         if (!this.shouldCascade(prop, type)) {
             return;
         }
-        const kind = entity_1.Reference.unwrapReference(entity[prop.name]);
-        if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isEntity(kind)) {
+        const kind = Reference.unwrapReference(entity[prop.name]);
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isEntity(kind)) {
             return this.cascade(kind, type, visited, options);
         }
         const collection = kind;
-        if ([enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind) && collection) {
+        if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind) && collection) {
             for (const item of collection.getItems(false)) {
                 this.cascade(item, type, visited, options);
             }
         }
     }
     isCollectionSelfReferenced(collection, processed) {
-        const filtered = collection.getItems(false).filter(item => !(0, entity_1.helper)(item).__originalEntityData);
+        const filtered = collection.getItems(false).filter(item => !helper(item).__originalEntityData);
         return filtered.some(items => processed.has(items));
     }
     shouldCascade(prop, type) {
-        if ([enums_1.Cascade.REMOVE, enums_1.Cascade.SCHEDULE_ORPHAN_REMOVAL, enums_1.Cascade.CANCEL_ORPHAN_REMOVAL, enums_1.Cascade.ALL].includes(type) && prop.orphanRemoval) {
+        if ([Cascade.REMOVE, Cascade.SCHEDULE_ORPHAN_REMOVAL, Cascade.CANCEL_ORPHAN_REMOVAL, Cascade.ALL].includes(type) && prop.orphanRemoval) {
             return true;
         }
         // ignore user settings for merge, it is kept only for back compatibility, this should have never been configurable
-        if (type === enums_1.Cascade.MERGE) {
+        if (type === Cascade.MERGE) {
             return true;
         }
-        return prop.cascade && (prop.cascade.includes(type) || prop.cascade.includes(enums_1.Cascade.ALL));
+        return prop.cascade && (prop.cascade.includes(type) || prop.cascade.includes(Cascade.ALL));
     }
     async lockPessimistic(entity, options) {
         if (!this.em.isInTransaction()) {
-            throw errors_1.ValidationError.transactionRequired();
+            throw ValidationError.transactionRequired();
         }
         await this.em.getDriver().lockPessimistic(entity, { ctx: this.em.getTransactionContext(), ...options });
     }
     async lockOptimistic(entity, meta, version) {
         if (!meta.versionProperty) {
-            throw errors_1.OptimisticLockError.notVersioned(meta);
+            throw OptimisticLockError.notVersioned(meta);
         }
-        if (!Utils_1.Utils.isDefined(version)) {
+        if (typeof version === 'undefined') {
             return;
         }
-        const wrapped = (0, entity_1.helper)(entity);
+        const wrapped = helper(entity);
         if (!wrapped.__initialized) {
             await wrapped.init();
         }
         const previousVersion = entity[meta.versionProperty];
         if (previousVersion !== version) {
-            throw errors_1.OptimisticLockError.lockFailedVersionMismatch(entity, version, previousVersion);
+            throw OptimisticLockError.lockFailedVersionMismatch(entity, version, previousVersion);
         }
     }
     fixMissingReference(entity, prop) {
         const reference = entity[prop.name];
-        const kind = entity_1.Reference.unwrapReference(reference);
-        if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && kind && !prop.mapToPk) {
-            if (!Utils_1.Utils.isEntity(kind)) {
+        const kind = Reference.unwrapReference(reference);
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && kind && !prop.mapToPk) {
+            if (!Utils.isEntity(kind)) {
                 entity[prop.name] = this.em.getReference(prop.type, kind, { wrapped: !!prop.ref });
             }
-            else if (!(0, entity_1.helper)(kind).__initialized && !(0, entity_1.helper)(kind).__em) {
-                const pk = (0, entity_1.helper)(kind).getPrimaryKey();
+            else if (!helper(kind).__initialized && !helper(kind).__em) {
+                const pk = helper(kind).getPrimaryKey();
                 entity[prop.name] = this.em.getReference(prop.type, pk, { wrapped: !!prop.ref });
             }
         }
         // perf: set the `Collection._property` to skip the getter, as it can be slow when there is a lot of relations
-        if (Utils_1.Utils.isCollection(kind)) {
+        if (Utils.isCollection(kind)) {
             kind.property = prop;
         }
-        const isCollection = [enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind);
+        const isCollection = [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind);
         if (isCollection && Array.isArray(kind)) {
-            const collection = new entity_1.Collection(entity);
+            const collection = new Collection(entity);
             collection.property = prop;
             entity[prop.name] = collection;
             collection.set(kind);
@@ -729,29 +769,29 @@ class UnitOfWork {
         const commitOrderReversed = [...commitOrder].reverse();
         // early delete - when we recreate entity in the same UoW, we need to issue those delete queries before inserts
         for (const name of commitOrderReversed) {
-            await this.commitDeleteChangeSets(groups[ChangeSet_1.ChangeSetType.DELETE_EARLY].get(name) ?? [], ctx);
+            await this.commitDeleteChangeSets(groups[ChangeSetType.DELETE_EARLY].get(name) ?? [], ctx);
         }
         // early update - when we recreate entity in the same UoW, we need to issue those delete queries before inserts
         for (const name of commitOrder) {
-            await this.commitUpdateChangeSets(groups[ChangeSet_1.ChangeSetType.UPDATE_EARLY].get(name) ?? [], ctx);
+            await this.commitUpdateChangeSets(groups[ChangeSetType.UPDATE_EARLY].get(name) ?? [], ctx);
         }
         // extra updates
-        await this.commitExtraUpdates(ChangeSet_1.ChangeSetType.UPDATE_EARLY, ctx);
+        await this.commitExtraUpdates(ChangeSetType.UPDATE_EARLY, ctx);
         // create
         for (const name of commitOrder) {
-            await this.commitCreateChangeSets(groups[ChangeSet_1.ChangeSetType.CREATE].get(name) ?? [], ctx);
+            await this.commitCreateChangeSets(groups[ChangeSetType.CREATE].get(name) ?? [], ctx);
         }
         // update
         for (const name of commitOrder) {
-            await this.commitUpdateChangeSets(groups[ChangeSet_1.ChangeSetType.UPDATE].get(name) ?? [], ctx);
+            await this.commitUpdateChangeSets(groups[ChangeSetType.UPDATE].get(name) ?? [], ctx);
         }
         // extra updates
-        await this.commitExtraUpdates(ChangeSet_1.ChangeSetType.UPDATE, ctx);
+        await this.commitExtraUpdates(ChangeSetType.UPDATE, ctx);
         // collection updates
         await this.commitCollectionUpdates(ctx);
         // delete - entity deletions need to be in reverse commit order
         for (const name of commitOrderReversed) {
-            await this.commitDeleteChangeSets(groups[ChangeSet_1.ChangeSetType.DELETE].get(name) ?? [], ctx);
+            await this.commitDeleteChangeSets(groups[ChangeSetType.DELETE].get(name) ?? [], ctx);
         }
         // take snapshots of all persisted collections
         const visited = new Set();
@@ -764,30 +804,30 @@ class UnitOfWork {
             return;
         }
         const props = changeSets[0].meta.root.relations.filter(prop => {
-            return (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE && prop.owner)
-                || prop.kind === enums_1.ReferenceKind.MANY_TO_ONE
-                || (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && prop.owner && !this.platform.usesPivotTable());
+            return (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner)
+                || prop.kind === ReferenceKind.MANY_TO_ONE
+                || (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !this.platform.usesPivotTable());
         });
         for (const changeSet of changeSets) {
             this.findExtraUpdates(changeSet, props);
-            await this.runHooks(enums_1.EventType.beforeCreate, changeSet, true);
+            await this.runHooks(EventType.beforeCreate, changeSet, true);
         }
         await this.changeSetPersister.executeInserts(changeSets, { ctx });
         for (const changeSet of changeSets) {
             this.register(changeSet.entity, changeSet.payload, { refresh: true });
-            await this.runHooks(enums_1.EventType.afterCreate, changeSet);
+            await this.runHooks(EventType.afterCreate, changeSet);
         }
     }
     findExtraUpdates(changeSet, props) {
         for (const prop of props) {
             const ref = changeSet.entity[prop.name];
-            if (!ref || prop.deferMode === enums_1.DeferMode.INITIALLY_DEFERRED) {
+            if (!ref || prop.deferMode === DeferMode.INITIALLY_DEFERRED) {
                 continue;
             }
-            if (Utils_1.Utils.isCollection(ref)) {
+            if (Utils.isCollection(ref)) {
                 ref.getItems(false).some(item => {
-                    const cs = this.changeSets.get(entity_1.Reference.unwrapReference(item));
-                    const isScheduledForInsert = cs && cs.type === ChangeSet_1.ChangeSetType.CREATE && !cs.persisted;
+                    const cs = this.changeSets.get(Reference.unwrapReference(item));
+                    const isScheduledForInsert = cs && cs.type === ChangeSetType.CREATE && !cs.persisted;
                     if (isScheduledForInsert) {
                         this.scheduleExtraUpdate(changeSet, [prop]);
                         return true;
@@ -795,8 +835,8 @@ class UnitOfWork {
                     return false;
                 });
             }
-            const cs = this.changeSets.get(entity_1.Reference.unwrapReference(ref));
-            const isScheduledForInsert = cs && cs.type === ChangeSet_1.ChangeSetType.CREATE && !cs.persisted;
+            const cs = this.changeSets.get(Reference.unwrapReference(ref));
+            const isScheduledForInsert = cs && cs.type === ChangeSetType.CREATE && !cs.persisted;
             if (isScheduledForInsert) {
                 this.scheduleExtraUpdate(changeSet, [prop]);
             }
@@ -805,14 +845,14 @@ class UnitOfWork {
     findEarlyUpdates(changeSet, inserts = []) {
         const props = changeSet.meta.uniqueProps;
         for (const prop of props) {
-            const insert = inserts.find(c => Utils_1.Utils.equals(c.payload[prop.name], changeSet.originalEntity[prop.name]));
+            const insert = inserts.find(c => Utils.equals(c.payload[prop.name], changeSet.originalEntity[prop.name]));
             const propEmpty = changeSet.payload[prop.name] === null || changeSet.payload[prop.name] === undefined;
             if (prop.name in changeSet.payload &&
                 insert &&
                 // We only want to update early if the unique property on the changeset is going to be empty, so that
                 // the previous unique value can be set on a different entity without constraint issues
                 propEmpty) {
-                changeSet.type = ChangeSet_1.ChangeSetType.UPDATE_EARLY;
+                changeSet.type = ChangeSetType.UPDATE_EARLY;
             }
         }
     }
@@ -821,14 +861,21 @@ class UnitOfWork {
             return;
         }
         for (const changeSet of changeSets) {
-            await this.runHooks(enums_1.EventType.beforeUpdate, changeSet, true);
+            await this.runHooks(EventType.beforeUpdate, changeSet, true);
         }
         await this.changeSetPersister.executeUpdates(changeSets, batched, { ctx });
         for (const changeSet of changeSets) {
-            (0, entity_1.helper)(changeSet.entity).__originalEntityData = this.comparator.prepareEntity(changeSet.entity);
-            (0, entity_1.helper)(changeSet.entity).__touched = false;
-            (0, entity_1.helper)(changeSet.entity).__initialized = true;
-            await this.runHooks(enums_1.EventType.afterUpdate, changeSet);
+            const wrapped = helper(changeSet.entity);
+            wrapped.__originalEntityData = this.comparator.prepareEntity(changeSet.entity);
+            if (!wrapped.__initialized) {
+                for (const prop of changeSet.meta.relations) {
+                    if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) && changeSet.entity[prop.name] == null) {
+                        changeSet.entity[prop.name] = Collection.create(changeSet.entity, prop.name, undefined, wrapped.isInitialized());
+                    }
+                }
+                wrapped.__initialized = true;
+            }
+            await this.runHooks(EventType.afterUpdate, changeSet);
         }
     }
     async commitDeleteChangeSets(changeSets, ctx) {
@@ -836,12 +883,12 @@ class UnitOfWork {
             return;
         }
         for (const changeSet of changeSets) {
-            await this.runHooks(enums_1.EventType.beforeDelete, changeSet, true);
+            await this.runHooks(EventType.beforeDelete, changeSet, true);
         }
         await this.changeSetPersister.executeDeletes(changeSets, { ctx });
         for (const changeSet of changeSets) {
             this.unsetIdentity(changeSet.entity);
-            await this.runHooks(enums_1.EventType.afterDelete, changeSet);
+            await this.runHooks(EventType.afterDelete, changeSet);
         }
     }
     async commitExtraUpdates(type, ctx) {
@@ -870,23 +917,34 @@ class UnitOfWork {
         }
     }
     async commitCollectionUpdates(ctx) {
-        const collectionUpdates = [];
+        this.filterCollectionUpdates();
+        const loggerContext = Utils.merge({ id: this.em._id }, this.em.getLoggerContext({ disableContextResolution: true }));
+        await this.em.getDriver().syncCollections(this.collectionUpdates, {
+            ctx,
+            schema: this.em.schema,
+            loggerContext,
+        });
         for (const coll of this.collectionUpdates) {
+            coll.takeSnapshot();
+        }
+    }
+    filterCollectionUpdates() {
+        for (const coll of this.collectionUpdates) {
+            let skip = true;
             if (coll.property.owner || coll.getItems(false).filter(item => !item.__helper.__initialized).length > 0) {
                 if (this.platform.usesPivotTable()) {
-                    collectionUpdates.push(coll);
+                    skip = false;
                 }
             }
-            else if (coll.property.kind === enums_1.ReferenceKind.ONE_TO_MANY && coll.getSnapshot() === undefined) {
-                collectionUpdates.push(coll);
+            else if (coll.property.kind === ReferenceKind.ONE_TO_MANY && coll.getSnapshot() === undefined) {
+                skip = false;
             }
-            else if (coll.property.kind === enums_1.ReferenceKind.MANY_TO_MANY && !coll.property.owner) {
-                collectionUpdates.push(coll);
+            else if (coll.property.kind === ReferenceKind.MANY_TO_MANY && !coll.property.owner) {
+                skip = false;
+            }
+            if (skip) {
+                this.collectionUpdates.delete(coll);
             }
-        }
-        await this.em.getDriver().syncCollections(collectionUpdates, { ctx });
-        for (const coll of this.collectionUpdates) {
-            coll.takeSnapshot();
         }
     }
     /**
@@ -894,11 +952,11 @@ class UnitOfWork {
      */
     getChangeSetGroups() {
         const groups = {
-            [ChangeSet_1.ChangeSetType.CREATE]: new Map(),
-            [ChangeSet_1.ChangeSetType.UPDATE]: new Map(),
-            [ChangeSet_1.ChangeSetType.DELETE]: new Map(),
-            [ChangeSet_1.ChangeSetType.UPDATE_EARLY]: new Map(),
-            [ChangeSet_1.ChangeSetType.DELETE_EARLY]: new Map(),
+            [ChangeSetType.CREATE]: new Map(),
+            [ChangeSetType.UPDATE]: new Map(),
+            [ChangeSetType.DELETE]: new Map(),
+            [ChangeSetType.UPDATE_EARLY]: new Map(),
+            [ChangeSetType.DELETE_EARLY]: new Map(),
         };
         for (const cs of this.changeSets.values()) {
             const group = groups[cs.type];
@@ -911,7 +969,7 @@ class UnitOfWork {
         return groups;
     }
     getCommitOrder() {
-        const calc = new CommitOrderCalculator_1.CommitOrderCalculator();
+        const calc = new CommitOrderCalculator();
         const set = new Set();
         this.changeSets.forEach(cs => set.add(cs.rootName));
         set.forEach(entityName => calc.addNode(entityName));
@@ -938,16 +996,15 @@ class UnitOfWork {
             return;
         }
         visited.add(entity);
-        (0, entity_1.helper)(entity)?.__meta.relations.forEach(prop => {
+        helper(entity)?.__meta.relations.forEach(prop => {
             const value = entity[prop.name];
-            if (Utils_1.Utils.isCollection(value)) {
+            if (Utils.isCollection(value)) {
                 value.takeSnapshot();
             }
             // cascade to m:1 relations as we need to snapshot the 1:m inverse side (for `removeAll()` with orphan removal)
-            if (prop.kind === enums_1.ReferenceKind.MANY_TO_ONE && value) {
-                this.takeCollectionSnapshots(entity_1.Reference.unwrapReference(value), visited);
+            if (prop.kind === ReferenceKind.MANY_TO_ONE && value) {
+                this.takeCollectionSnapshots(Reference.unwrapReference(value), visited);
             }
         });
     }
 }
-exports.UnitOfWork = UnitOfWork;