@mikro-orm/core 7.0.0-rc.3 → 7.0.1-dev.0

package/unit-of-work/UnitOfWork.js

@@ -16,38 +16,38 @@ import { createAsyncContext } from '../utils/AsyncContext.js';
 // to deal with validation for flush inside flush hooks and `Promise.all`
 const insideFlush = createAsyncContext();
 export class UnitOfWork {
-    em;
     /** map of references to managed entities */
-    identityMap;
-    persistStack = new Set();
-    removeStack = new Set();
-    orphanRemoveStack = new Set();
-    changeSets = new Map();
-    collectionUpdates = new Set();
-    extraUpdates = new Set();
-    metadata;
-    platform;
-    eventManager;
-    comparator;
-    changeSetComputer;
-    changeSetPersister;
-    queuedActions = new Set();
-    loadedEntities = new Set();
-    flushQueue = [];
-    working = false;
+    #identityMap;
+    #persistStack = new Set();
+    #removeStack = new Set();
+    #orphanRemoveStack = new Set();
+    #changeSets = new Map();
+    #collectionUpdates = new Set();
+    #extraUpdates = new Set();
+    #metadata;
+    #platform;
+    #eventManager;
+    #comparator;
+    #changeSetComputer;
+    #changeSetPersister;
+    #queuedActions = new Set();
+    #loadedEntities = new Set();
+    #flushQueue = [];
+    #working = false;
+    #em;
     constructor(em) {
-        this.em = em;
-        this.metadata = this.em.getMetadata();
-        this.platform = this.em.getPlatform();
-        this.identityMap = new IdentityMap(this.platform.getDefaultSchemaName());
-        this.eventManager = this.em.getEventManager();
-        this.comparator = this.em.getComparator();
-        this.changeSetComputer = new ChangeSetComputer(this.em, this.collectionUpdates);
-        this.changeSetPersister = new ChangeSetPersister(this.em);
+        this.#em = em;
+        this.#metadata = this.#em.getMetadata();
+        this.#platform = this.#em.getPlatform();
+        this.#identityMap = new IdentityMap(this.#platform.getDefaultSchemaName());
+        this.#eventManager = this.#em.getEventManager();
+        this.#comparator = this.#em.getComparator();
+        this.#changeSetComputer = new ChangeSetComputer(this.#em, this.#collectionUpdates);
+        this.#changeSetPersister = new ChangeSetPersister(this.#em);
     }
     merge(entity, visited) {
         const wrapped = helper(entity);
-        wrapped.__em = this.em;
+        wrapped.__em = this.#em;
         if (!wrapped.hasPrimaryKey()) {
             return;
         }
@@ -56,11 +56,11 @@ export class UnitOfWork {
         if (!wrapped.__managed && visited) {
             return;
         }
-        this.identityMap.store(entity);
+        this.#identityMap.store(entity);
         // if visited is available, we are cascading, and need to be careful when resetting the entity data
         // 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.__originalEntityData = this.#comparator.prepareEntity(entity);
         }
         this.cascade(entity, Cascade.MERGE, visited ?? new Set());
     }
@@ -70,7 +70,7 @@ export class UnitOfWork {
      * @internal
      */
     normalizeEntityData(meta, data) {
-        const forceUndefined = this.em.config.get('forceUndefined');
+        const forceUndefined = this.#em.config.get('forceUndefined');
         for (const key of Utils.keys(data)) {
             const prop = meta.properties[key];
             if (!prop) {
@@ -92,12 +92,12 @@ export class UnitOfWork {
                 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, {
+                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' });
+                data[key] = prop.customType.convertToDatabaseValue(converted, this.#platform, { key, mode: 'hydration' });
             }
             if (forceUndefined) {
                 if (data[key] === null) {
@@ -110,17 +110,17 @@ export class UnitOfWork {
      * @internal
      */
     register(entity, data, options) {
-        this.identityMap.store(entity);
+        this.#identityMap.store(entity);
         EntityHelper.ensurePropagation(entity);
         if (options?.newEntity) {
             return entity;
         }
-        const forceUndefined = this.em.config.get('forceUndefined');
+        const forceUndefined = this.#em.config.get('forceUndefined');
         const wrapped = helper(entity);
         if (options?.loaded && wrapped.__initialized && !wrapped.__onLoadFired) {
-            this.loadedEntities.add(entity);
+            this.#loadedEntities.add(entity);
         }
-        wrapped.__em ??= this.em;
+        wrapped.__em ??= this.#em;
         wrapped.__managed = true;
         if (data && (options?.refresh || !wrapped.__originalEntityData)) {
             this.normalizeEntityData(wrapped.__meta, data);
@@ -138,13 +138,19 @@ export class UnitOfWork {
      * @internal
      */
     async dispatchOnLoadEvent() {
-        for (const entity of this.loadedEntities) {
-            if (this.eventManager.hasListeners(EventType.onLoad, entity.__meta)) {
-                await this.eventManager.dispatchEvent(EventType.onLoad, { entity, meta: entity.__meta, em: this.em });
+        for (const entity of this.#loadedEntities) {
+            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();
+        this.#loadedEntities.clear();
+    }
+    /**
+     * @internal
+     */
+    unmarkAsLoaded(entity) {
+        this.#loadedEntities.delete(entity);
     }
     /**
      * 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`.
@@ -153,7 +159,7 @@ export class UnitOfWork {
         if (id == null || (Array.isArray(id) && id.length === 0)) {
             return undefined;
         }
-        const meta = this.metadata.find(entityName).root;
+        const meta = this.#metadata.find(entityName).root;
         let hash;
         if (meta.simplePK) {
             hash = '' + id;
@@ -162,7 +168,7 @@ export class UnitOfWork {
             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, {
+                    return p.customType.convertToDatabaseValue(keys[i], this.#platform, {
                         key: p.name,
                         mode: 'hydration',
                     });
@@ -171,11 +177,11 @@ export class UnitOfWork {
             });
             hash = Utils.getPrimaryKeyHash(keys);
         }
-        schema ??= meta.schema ?? this.em.config.getSchema();
+        schema ??= meta.schema ?? this.#em.config.getSchema();
         if (schema) {
             hash = `${schema}:${hash}`;
         }
-        return this.identityMap.getByHash(meta, hash);
+        return this.#identityMap.getByHash(meta, hash);
     }
     /**
      * Returns entity from the identity map by an alternate key (non-PK property).
@@ -183,15 +189,15 @@ export class UnitOfWork {
      *                             If false (default), the value is assumed to be in JS format already.
      */
     getByKey(entityName, key, value, schema, convertCustomTypes) {
-        const meta = this.metadata.find(entityName).root;
-        schema ??= meta.schema ?? this.em.config.getSchema();
+        const meta = this.#metadata.find(entityName).root;
+        schema ??= meta.schema ?? this.#em.config.getSchema();
         const prop = meta.properties[key];
         // Convert from DB format to JS format if needed
         if (convertCustomTypes && prop?.customType) {
-            value = prop.customType.convertToJSValue(value, this.platform, { mode: 'hydration' });
+            value = prop.customType.convertToJSValue(value, this.#platform, { mode: 'hydration' });
         }
-        const hash = this.identityMap.getKeyHash(key, '' + value, schema);
-        return this.identityMap.getByHash(meta, hash);
+        const hash = this.#identityMap.getKeyHash(key, '' + value, schema);
+        return this.#identityMap.getByHash(meta, hash);
     }
     /**
      * Stores an entity in the identity map under an alternate key (non-PK property).
@@ -201,18 +207,18 @@ export class UnitOfWork {
      */
     storeByKey(entity, key, value, schema, convertCustomTypes) {
         const meta = entity.__meta.root;
-        schema ??= meta.schema ?? this.em.config.getSchema();
+        schema ??= meta.schema ?? this.#em.config.getSchema();
         const prop = meta.properties[key];
         // Convert from DB format to JS format if needed
         if (convertCustomTypes && prop?.customType) {
-            value = prop.customType.convertToJSValue(value, this.platform, { mode: 'hydration' });
+            value = prop.customType.convertToJSValue(value, this.#platform, { mode: 'hydration' });
         }
         // Set the property on the entity
         entity[key] = value;
-        this.identityMap.storeByKey(entity, key, '' + value, schema);
+        this.#identityMap.storeByKey(entity, key, '' + value, schema);
     }
     tryGetById(entityName, where, schema, strict = true) {
-        const pk = Utils.extractPK(where, this.metadata.find(entityName), strict);
+        const pk = Utils.extractPK(where, this.#metadata.find(entityName), strict);
         if (!pk) {
             return null;
         }
@@ -222,7 +228,7 @@ export class UnitOfWork {
      * Returns map of all managed entities.
      */
     getIdentityMap() {
-        return this.identityMap;
+        return this.#identityMap;
     }
     /**
      * Returns stored snapshot of entity state that is used for change set computation.
@@ -231,42 +237,42 @@ export class UnitOfWork {
         return helper(entity).__originalEntityData;
     }
     getPersistStack() {
-        return this.persistStack;
+        return this.#persistStack;
     }
     getRemoveStack() {
-        return this.removeStack;
+        return this.#removeStack;
     }
     getChangeSets() {
-        return [...this.changeSets.values()];
+        return [...this.#changeSets.values()];
     }
     getCollectionUpdates() {
-        return [...this.collectionUpdates];
+        return [...this.#collectionUpdates];
     }
     getExtraUpdates() {
-        return this.extraUpdates;
+        return this.#extraUpdates;
     }
     shouldAutoFlush(meta) {
         if (insideFlush.getStore()) {
             return false;
         }
-        if (this.queuedActions.has(meta.class) || this.queuedActions.has(meta.root.class)) {
+        if (this.#queuedActions.has(meta.class) || this.#queuedActions.has(meta.root.class)) {
             return true;
         }
-        if (meta.discriminatorMap && Object.values(meta.discriminatorMap).some(v => this.queuedActions.has(v))) {
+        if (meta.discriminatorMap && Object.values(meta.discriminatorMap).some(v => this.#queuedActions.has(v))) {
             return true;
         }
         return false;
     }
     clearActionsQueue() {
-        this.queuedActions.clear();
+        this.#queuedActions.clear();
     }
     computeChangeSet(entity, type) {
         const wrapped = helper(entity);
         if (type === ChangeSetType.DELETE || type === ChangeSetType.DELETE_EARLY) {
-            this.changeSets.set(entity, new ChangeSet(entity, type, {}, wrapped.__meta));
+            this.#changeSets.set(entity, new ChangeSet(entity, type, {}, wrapped.__meta));
             return;
         }
-        const cs = this.changeSetComputer.computeChangeSet(entity);
+        const cs = this.#changeSetComputer.computeChangeSet(entity);
         if (!cs || this.checkUniqueProps(cs)) {
             return;
         }
@@ -275,32 +281,32 @@ export class UnitOfWork {
             cs.type = type;
         }
         this.initIdentifier(entity);
-        this.changeSets.set(entity, cs);
-        this.persistStack.delete(entity);
-        wrapped.__originalEntityData = this.comparator.prepareEntity(entity);
+        this.#changeSets.set(entity, cs);
+        this.#persistStack.delete(entity);
+        wrapped.__originalEntityData = this.#comparator.prepareEntity(entity);
     }
     recomputeSingleChangeSet(entity) {
-        const changeSet = this.changeSets.get(entity);
+        const changeSet = this.#changeSets.get(entity);
         if (!changeSet) {
             return;
         }
-        const cs = this.changeSetComputer.computeChangeSet(entity);
+        const cs = this.#changeSetComputer.computeChangeSet(entity);
         if (cs && !this.checkUniqueProps(cs)) {
             Object.assign(changeSet.payload, cs.payload);
-            helper(entity).__originalEntityData = this.comparator.prepareEntity(entity);
+            helper(entity).__originalEntityData = this.#comparator.prepareEntity(entity);
         }
     }
     persist(entity, visited, options = {}) {
         EntityHelper.ensurePropagation(entity);
-        if (options.checkRemoveStack && this.removeStack.has(entity)) {
+        if (options.checkRemoveStack && this.#removeStack.has(entity)) {
             return;
         }
         const wrapped = helper(entity);
-        this.persistStack.add(entity);
-        this.queuedActions.add(wrapped.__meta.class);
-        this.removeStack.delete(entity);
+        this.#persistStack.add(entity);
+        this.#queuedActions.add(wrapped.__meta.class);
+        this.#removeStack.delete(entity);
         if (!wrapped.__managed && wrapped.hasPrimaryKey()) {
-            this.identityMap.store(entity);
+            this.#identityMap.store(entity);
         }
         if (options.cascade ?? true) {
             this.cascade(entity, Cascade.PERSIST, visited, options);
@@ -308,13 +314,13 @@ export class UnitOfWork {
     }
     remove(entity, visited, options = {}) {
         // allow removing not managed entities if they are not part of the persist stack
-        if (helper(entity).__managed || !this.persistStack.has(entity)) {
-            this.removeStack.add(entity);
-            this.queuedActions.add(helper(entity).__meta.class);
+        if (helper(entity).__managed || !this.#persistStack.has(entity)) {
+            this.#removeStack.add(entity);
+            this.#queuedActions.add(helper(entity).__meta.class);
         }
         else {
-            this.persistStack.delete(entity);
-            this.identityMap.delete(entity);
+            this.#persistStack.delete(entity);
+            this.#identityMap.delete(entity);
         }
         // remove from referencing relations that are nullable
         for (const prop of helper(entity).__meta.bidirectionalRelations) {
@@ -327,7 +333,7 @@ export class UnitOfWork {
                 }
                 continue;
             }
-            const target = relation && relation[inverseProp];
+            const target = relation?.[inverseProp];
             if (relation && Utils.isCollection(target)) {
                 target.removeWithoutPropagation(entity);
             }
@@ -337,12 +343,12 @@ export class UnitOfWork {
         }
     }
     async commit() {
-        if (this.working) {
+        if (this.#working) {
             if (insideFlush.getStore()) {
                 throw ValidationError.cannotCommit();
             }
             return new Promise((resolve, reject) => {
-                this.flushQueue.push(() => {
+                this.#flushQueue.push(() => {
                     return insideFlush.run(true, () => {
                         return this.doCommit().then(resolve, reject);
                     });
@@ -350,51 +356,51 @@ export class UnitOfWork {
             });
         }
         try {
-            this.working = true;
+            this.#working = true;
             await insideFlush.run(true, () => this.doCommit());
-            while (this.flushQueue.length) {
-                await this.flushQueue.shift()();
+            while (this.#flushQueue.length) {
+                await this.#flushQueue.shift()();
             }
         }
         finally {
             this.postCommitCleanup();
-            this.working = false;
+            this.#working = false;
         }
     }
     async doCommit() {
-        const oldTx = this.em.getTransactionContext();
+        const oldTx = this.#em.getTransactionContext();
         try {
-            await this.eventManager.dispatchEvent(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()) {
+            for (const cs of this.#changeSets.values()) {
                 cs.entity.__helper.__processing = true;
             }
-            await this.eventManager.dispatchEvent(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) {
-                await this.eventManager.dispatchEvent(EventType.afterFlush, { em: this.em, uow: this });
+            if (this.#changeSets.size === 0 && this.#collectionUpdates.size === 0 && this.#extraUpdates.size === 0) {
+                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');
+            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), {
+                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 TransactionEventBroadcaster(this.em),
+                    eventBroadcaster: new TransactionEventBroadcaster(this.#em),
                     loggerContext,
                 });
             }
             else {
-                await this.persistToDatabase(groups, this.em.getTransactionContext());
+                await this.persistToDatabase(groups, this.#em.getTransactionContext());
             }
             this.resetTransaction(oldTx);
-            for (const cs of this.changeSets.values()) {
+            for (const cs of this.#changeSets.values()) {
                 cs.entity.__helper.__processing = false;
             }
-            await this.eventManager.dispatchEvent(EventType.afterFlush, { em: this.em, uow: this });
+            await this.#eventManager.dispatchEvent(EventType.afterFlush, { em: this.#em, uow: this });
         }
         finally {
             this.resetTransaction(oldTx);
@@ -404,7 +410,7 @@ export class UnitOfWork {
         if (!this.getById(entity.constructor, helper(entity).__primaryKeys, helper(entity).__schema)) {
             throw ValidationError.entityNotManaged(entity);
         }
-        const meta = this.metadata.find(entity.constructor);
+        const meta = this.#metadata.find(entity.constructor);
         if (options.lockMode === LockMode.OPTIMISTIC) {
             await this.lockOptimistic(entity, meta, options.lockVersion);
         }
@@ -413,24 +419,24 @@ export class UnitOfWork {
         }
     }
     clear() {
-        this.identityMap.clear();
-        this.loadedEntities.clear();
+        this.#identityMap.clear();
+        this.#loadedEntities.clear();
         this.postCommitCleanup();
     }
     unsetIdentity(entity) {
-        this.identityMap.delete(entity);
+        this.#identityMap.delete(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()) {
+            for (const referrer of this.#identityMap.getStore(meta).values()) {
                 const rel = Reference.unwrapReference(referrer[prop.name]);
                 if (Utils.isCollection(rel)) {
                     rel.removeWithoutPropagation(entity);
                 }
                 else if (rel &&
                     (prop.mapToPk
-                        ? helper(this.em.getReference(prop.targetMeta.class, rel)).getSerializedPrimaryKey() === serializedPK
+                        ? helper(this.#em.getReference(prop.targetMeta.class, rel)).getSerializedPrimaryKey() === serializedPK
                         : rel === entity)) {
                     if (prop.formula) {
                         delete referrer[prop.name];
@@ -446,43 +452,43 @@ export class UnitOfWork {
         wrapped.__managed = false;
     }
     computeChangeSets() {
-        this.changeSets.clear();
+        this.#changeSets.clear();
         const visited = new Set();
-        for (const entity of this.removeStack) {
+        for (const entity of this.#removeStack) {
             this.cascade(entity, Cascade.REMOVE, visited);
         }
         visited.clear();
-        for (const entity of this.identityMap) {
-            if (!this.removeStack.has(entity) && !this.persistStack.has(entity) && !this.orphanRemoveStack.has(entity)) {
+        for (const entity of this.#identityMap) {
+            if (!this.#removeStack.has(entity) && !this.#persistStack.has(entity) && !this.#orphanRemoveStack.has(entity)) {
                 this.cascade(entity, Cascade.PERSIST, visited, { checkRemoveStack: true });
             }
         }
-        for (const entity of this.persistStack) {
+        for (const entity of this.#persistStack) {
             this.cascade(entity, Cascade.PERSIST, visited, { checkRemoveStack: true });
         }
         visited.clear();
-        for (const entity of this.persistStack) {
+        for (const entity of this.#persistStack) {
             this.findNewEntities(entity, visited);
         }
-        for (const entity of this.orphanRemoveStack) {
+        for (const entity of this.#orphanRemoveStack) {
             if (!helper(entity).__processing) {
-                this.removeStack.add(entity);
+                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()) {
+        for (const cs of this.#changeSets.values()) {
             if (cs.type === ChangeSetType.CREATE) {
                 inserts[cs.meta.uniqueName] ??= [];
                 inserts[cs.meta.uniqueName].push(cs);
             }
         }
-        for (const cs of this.changeSets.values()) {
+        for (const cs of this.#changeSets.values()) {
             if (cs.type === ChangeSetType.UPDATE) {
                 this.findEarlyUpdates(cs, inserts[cs.meta.uniqueName]);
             }
         }
-        for (const entity of this.removeStack) {
+        for (const entity of this.#removeStack) {
             const wrapped = helper(entity);
             /* v8 ignore next */
             if (wrapped.__processing) {
@@ -507,7 +513,7 @@ export class UnitOfWork {
         if (!props.some(prop => prop.name in changeSet.payload)) {
             return;
         }
-        for (const cs of this.changeSets.values()) {
+        for (const cs of this.#changeSets.values()) {
             for (const prop of props) {
                 if (prop.name in cs.payload && cs.rootMeta === changeSet.rootMeta && cs.type === changeSet.type) {
                     conflicts = true;
@@ -520,7 +526,7 @@ export class UnitOfWork {
         if (!conflicts) {
             return;
         }
-        this.extraUpdates.add([
+        this.#extraUpdates.add([
             changeSet.entity,
             props.map(p => p.name),
             props.map(p => changeSet.entity[p.name]),
@@ -535,21 +541,21 @@ export class UnitOfWork {
     scheduleOrphanRemoval(entity, visited) {
         if (entity) {
             const wrapped = helper(entity);
-            wrapped.__em = this.em;
-            this.orphanRemoveStack.add(entity);
-            this.queuedActions.add(wrapped.__meta.class);
+            wrapped.__em = this.#em;
+            this.#orphanRemoveStack.add(entity);
+            this.#queuedActions.add(wrapped.__meta.class);
             this.cascade(entity, Cascade.SCHEDULE_ORPHAN_REMOVAL, visited);
         }
     }
     cancelOrphanRemoval(entity, visited) {
-        this.orphanRemoveStack.delete(entity);
+        this.#orphanRemoveStack.delete(entity);
         this.cascade(entity, Cascade.CANCEL_ORPHAN_REMOVAL, visited);
     }
     getOrphanRemoveStack() {
-        return this.orphanRemoveStack;
+        return this.#orphanRemoveStack;
     }
     getChangeSetPersister() {
-        return this.changeSetPersister;
+        return this.#changeSetPersister;
     }
     findNewEntities(entity, visited, idx = 0, processed = new Set()) {
         if (visited.has(entity)) {
@@ -558,11 +564,11 @@ export class UnitOfWork {
         visited.add(entity);
         processed.add(entity);
         const wrapped = helper(entity);
-        if (wrapped.__processing || this.removeStack.has(entity) || this.orphanRemoveStack.has(entity)) {
+        if (wrapped.__processing || this.#removeStack.has(entity) || this.#orphanRemoveStack.has(entity)) {
             return;
         }
         // Set entityManager default schema
-        wrapped.__schema ??= this.em.schema;
+        wrapped.__schema ??= this.#em.schema;
         this.initIdentifier(entity);
         for (const prop of wrapped.__meta.relations) {
             const targets = Utils.unwrapProperty(entity, wrapped.__meta, prop);
@@ -571,14 +577,14 @@ export class UnitOfWork {
                 this.processReference(entity, prop, kind, visited, processed, idx);
             }
         }
-        const changeSet = this.changeSetComputer.computeChangeSet(entity);
+        const changeSet = this.#changeSetComputer.computeChangeSet(entity);
         if (changeSet && !this.checkUniqueProps(changeSet)) {
             // For TPT child entities, create changesets for each table in hierarchy
             if (wrapped.__meta.inheritanceType === 'tpt' && wrapped.__meta.tptParent) {
                 this.createTPTChangeSets(entity, changeSet);
             }
             else {
-                this.changeSets.set(entity, changeSet);
+                this.#changeSets.set(entity, changeSet);
             }
         }
     }
@@ -634,7 +640,7 @@ export class UnitOfWork {
             if (parentChangeSets.length > 0) {
                 leafCs.tptChangeSets = parentChangeSets;
             }
-            this.changeSets.set(entity, leafCs);
+            this.#changeSets.set(entity, leafCs);
         }
     }
     /**
@@ -734,7 +740,7 @@ export class UnitOfWork {
     }
     processToManyReference(collection, visited, processed, parent, prop) {
         if (this.isCollectionSelfReferenced(collection, processed)) {
-            this.extraUpdates.add([parent, prop.name, collection, undefined, ChangeSetType.UPDATE]);
+            this.#extraUpdates.add([parent, prop.name, collection, undefined, ChangeSetType.UPDATE]);
             const coll = new Collection(parent);
             coll.property = prop;
             parent[prop.name] = coll;
@@ -747,17 +753,17 @@ export class UnitOfWork {
     }
     async runHooks(type, changeSet, sync = false) {
         const meta = changeSet.meta;
-        if (!this.eventManager.hasListeners(type, meta)) {
+        if (!this.#eventManager.hasListeners(type, meta)) {
             return;
         }
         if (!sync) {
-            await this.eventManager.dispatchEvent(type, { entity: changeSet.entity, meta, em: this.em, changeSet });
+            await this.#eventManager.dispatchEvent(type, { entity: changeSet.entity, meta, em: this.#em, changeSet });
             return;
         }
-        const copy = this.comparator.prepareEntity(changeSet.entity);
-        await this.eventManager.dispatchEvent(type, { entity: changeSet.entity, meta, em: this.em, changeSet });
-        const current = this.comparator.prepareEntity(changeSet.entity);
-        const diff = this.comparator.diffEntities(changeSet.meta.class, copy, current);
+        const copy = this.#comparator.prepareEntity(changeSet.entity);
+        await this.#eventManager.dispatchEvent(type, { entity: changeSet.entity, meta, em: this.#em, changeSet });
+        const current = this.#comparator.prepareEntity(changeSet.entity);
+        const diff = this.#comparator.diffEntities(changeSet.meta.class, copy, current);
         Object.assign(changeSet.payload, diff);
         const wrapped = helper(changeSet.entity);
         if (wrapped.__identifier) {
@@ -772,19 +778,19 @@ export class UnitOfWork {
         }
     }
     postCommitCleanup() {
-        for (const cs of this.changeSets.values()) {
+        for (const cs of this.#changeSets.values()) {
             const wrapped = helper(cs.entity);
             wrapped.__processing = false;
             delete wrapped.__pk;
         }
-        this.persistStack.clear();
-        this.removeStack.clear();
-        this.orphanRemoveStack.clear();
-        this.changeSets.clear();
-        this.collectionUpdates.clear();
-        this.extraUpdates.clear();
-        this.queuedActions.clear();
-        this.working = false;
+        this.#persistStack.clear();
+        this.#removeStack.clear();
+        this.#orphanRemoveStack.clear();
+        this.#changeSets.clear();
+        this.#collectionUpdates.clear();
+        this.#extraUpdates.clear();
+        this.#queuedActions.clear();
+        this.#working = false;
     }
     cascade(entity, type, visited = new Set(), options = {}) {
         if (visited.has(entity)) {
@@ -844,10 +850,10 @@ export class UnitOfWork {
         return prop.cascade && (prop.cascade.includes(type) || prop.cascade.includes(Cascade.ALL));
     }
     async lockPessimistic(entity, options) {
-        if (!this.em.isInTransaction()) {
+        if (!this.#em.isInTransaction()) {
             throw ValidationError.transactionRequired();
         }
-        await this.em.getDriver().lockPessimistic(entity, { ctx: this.em.getTransactionContext(), ...options });
+        await this.#em.getDriver().lockPessimistic(entity, { ctx: this.#em.getTransactionContext(), ...options });
     }
     async lockOptimistic(entity, meta, version) {
         if (!meta.versionProperty) {
@@ -870,13 +876,15 @@ export class UnitOfWork {
         const target = Reference.unwrapReference(reference);
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && target && !prop.mapToPk) {
             if (!Utils.isEntity(target)) {
-                entity[prop.name] = this.em.getReference(prop.targetMeta.class, target, {
+                entity[prop.name] = this.#em.getReference(prop.targetMeta.class, target, {
                     wrapped: !!prop.ref,
                 });
             }
             else if (!helper(target).__initialized && !helper(target).__em) {
                 const pk = helper(target).getPrimaryKey();
-                entity[prop.name] = this.em.getReference(prop.targetMeta.class, pk, { wrapped: !!prop.ref });
+                entity[prop.name] = this.#em.getReference(prop.targetMeta.class, pk, {
+                    wrapped: !!prop.ref,
+                });
             }
         }
         // perf: set the `Collection._property` to skip the getter, as it can be slow when there are a lot of relations
@@ -893,7 +901,7 @@ export class UnitOfWork {
     }
     async persistToDatabase(groups, ctx) {
         if (ctx) {
-            this.em.setTransactionContext(ctx);
+            this.#em.setTransactionContext(ctx);
         }
         const commitOrder = this.getCommitOrder();
         const commitOrderReversed = [...commitOrder].reverse();
@@ -925,7 +933,7 @@ export class UnitOfWork {
         }
         // take snapshots of all persisted collections
         const visited = new Set();
-        for (const changeSet of this.changeSets.values()) {
+        for (const changeSet of this.#changeSets.values()) {
             this.takeCollectionSnapshots(changeSet.entity, visited);
         }
     }
@@ -936,13 +944,13 @@ export class UnitOfWork {
         const props = changeSets[0].meta.root.relations.filter(prop => {
             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()));
+                (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !this.#platform.usesPivotTable()));
         });
         for (const changeSet of changeSets) {
             this.findExtraUpdates(changeSet, props);
             await this.runHooks(EventType.beforeCreate, changeSet, true);
         }
-        await this.changeSetPersister.executeInserts(changeSets, { ctx });
+        await this.#changeSetPersister.executeInserts(changeSets, { ctx });
         for (const changeSet of changeSets) {
             this.register(changeSet.entity, changeSet.payload, { refresh: true });
             await this.runHooks(EventType.afterCreate, changeSet);
@@ -956,7 +964,7 @@ export class UnitOfWork {
             }
             if (Utils.isCollection(ref)) {
                 ref.getItems(false).some(item => {
-                    const cs = this.changeSets.get(Reference.unwrapReference(item));
+                    const cs = this.#changeSets.get(Reference.unwrapReference(item));
                     const isScheduledForInsert = cs?.type === ChangeSetType.CREATE && !cs.persisted;
                     if (isScheduledForInsert) {
                         this.scheduleExtraUpdate(changeSet, [prop]);
@@ -973,7 +981,7 @@ export class UnitOfWork {
             }
             // For TPT entities, check if the ROOT table's changeset has been persisted
             // (since the FK is to the root table, not the concrete entity's table)
-            let cs = this.changeSets.get(refEntity);
+            let cs = this.#changeSets.get(refEntity);
             if (cs?.tptChangeSets?.length) {
                 // Root table changeset is the last one (ordered immediate parent → root)
                 cs = cs.tptChangeSets[cs.tptChangeSets.length - 1];
@@ -1005,10 +1013,10 @@ export class UnitOfWork {
         for (const changeSet of changeSets) {
             await this.runHooks(EventType.beforeUpdate, changeSet, true);
         }
-        await this.changeSetPersister.executeUpdates(changeSets, batched, { ctx });
+        await this.#changeSetPersister.executeUpdates(changeSets, batched, { ctx });
         for (const changeSet of changeSets) {
             const wrapped = helper(changeSet.entity);
-            wrapped.__originalEntityData = this.comparator.prepareEntity(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) &&
@@ -1028,7 +1036,7 @@ export class UnitOfWork {
         for (const changeSet of changeSets) {
             await this.runHooks(EventType.beforeDelete, changeSet, true);
         }
-        await this.changeSetPersister.executeDeletes(changeSets, { ctx });
+        await this.#changeSetPersister.executeDeletes(changeSets, { ctx });
         for (const changeSet of changeSets) {
             this.unsetIdentity(changeSet.entity);
             await this.runHooks(EventType.afterDelete, changeSet);
@@ -1036,7 +1044,7 @@ export class UnitOfWork {
     }
     async commitExtraUpdates(type, ctx) {
         const extraUpdates = [];
-        for (const extraUpdate of this.extraUpdates) {
+        for (const extraUpdate of this.#extraUpdates) {
             if (extraUpdate[4] !== type) {
                 continue;
             }
@@ -1046,7 +1054,7 @@ export class UnitOfWork {
             else {
                 extraUpdate[0][extraUpdate[1]] = extraUpdate[2];
             }
-            const changeSet = this.changeSetComputer.computeChangeSet(extraUpdate[0]);
+            const changeSet = this.#changeSetComputer.computeChangeSet(extraUpdate[0]);
             if (changeSet) {
                 extraUpdates.push([changeSet, extraUpdate[3]]);
             }
@@ -1061,21 +1069,21 @@ export class UnitOfWork {
     }
     async commitCollectionUpdates(ctx) {
         this.filterCollectionUpdates();
-        const loggerContext = Utils.merge({ id: this.em._id }, this.em.getLoggerContext({ disableContextResolution: true }));
-        await this.em.getDriver().syncCollections(this.collectionUpdates, {
+        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,
+            schema: this.#em.schema,
             loggerContext,
         });
-        for (const coll of this.collectionUpdates) {
+        for (const coll of this.#collectionUpdates) {
             coll.takeSnapshot();
         }
     }
     filterCollectionUpdates() {
-        for (const coll of this.collectionUpdates) {
+        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()) {
+                if (this.#platform.usesPivotTable()) {
                     skip = false;
                 }
             }
@@ -1086,7 +1094,7 @@ export class UnitOfWork {
                 skip = false;
             }
             if (skip) {
-                this.collectionUpdates.delete(coll);
+                this.#collectionUpdates.delete(coll);
             }
         }
     }
@@ -1115,7 +1123,7 @@ export class UnitOfWork {
                 group.set(groupKey, classGroup);
             }
         };
-        for (const cs of this.changeSets.values()) {
+        for (const cs of this.#changeSets.values()) {
             addToGroup(cs);
             for (const parentCs of cs.tptChangeSets ?? []) {
                 addToGroup(parentCs);
@@ -1126,7 +1134,7 @@ export class UnitOfWork {
     getCommitOrder() {
         const calc = new CommitOrderCalculator();
         const set = new Set();
-        this.changeSets.forEach(cs => {
+        this.#changeSets.forEach(cs => {
             if (cs.meta.inheritanceType === 'tpt') {
                 set.add(cs.meta);
                 for (const parentCs of cs.tptChangeSets ?? []) {
@@ -1154,14 +1162,14 @@ export class UnitOfWork {
                 calc.addDependency(meta.tptParent._id, meta._id, 1);
             }
         }
-        return calc.sort().map(id => this.metadata.getById(id));
+        return calc.sort().map(id => this.#metadata.getById(id));
     }
     resetTransaction(oldTx) {
         if (oldTx) {
-            this.em.setTransactionContext(oldTx);
+            this.#em.setTransactionContext(oldTx);
         }
         else {
-            this.em.resetTransactionContext();
+            this.#em.resetTransactionContext();
         }
     }
     /**