@mikro-orm/core 7.0.0-dev.321 → 7.0.0-dev.322

package/metadata/MetadataStorage.d.ts

@@ -1,12 +1,8 @@
 import { type Dictionary, EntityMetadata, type EntityName } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
 export declare class MetadataStorage {
+    #private;
     static readonly PATH_SYMBOL: unique symbol;
-    private static readonly metadata;
-    private readonly metadata;
-    private readonly idMap;
-    private readonly classNameMap;
-    private readonly uniqueNameMap;
     constructor(metadata?: Dictionary<EntityMetadata>);
     static getMetadata(): Dictionary<EntityMetadata>;
     static getMetadata<T = any>(entity: string, path: string): EntityMetadata<T>;

package/metadata/MetadataStorage.js

@@ -10,39 +10,39 @@ function getGlobalStorage(namespace) {
 }
 export class MetadataStorage {
     static PATH_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.PATH_SYMBOL');
-    static metadata = getGlobalStorage('metadata');
-    metadata = new Map();
-    idMap;
-    classNameMap;
-    uniqueNameMap;
+    static #metadata = getGlobalStorage('metadata');
+    #metadataMap = new Map();
+    #idMap;
+    #classNameMap;
+    #uniqueNameMap;
     constructor(metadata = {}) {
-        this.idMap = {};
-        this.uniqueNameMap = {};
-        this.classNameMap = Utils.copy(metadata, false);
-        for (const meta of Object.values(this.classNameMap)) {
-            this.idMap[meta._id] = meta;
-            this.uniqueNameMap[meta.uniqueName] = meta;
-            this.metadata.set(meta.class, meta);
+        this.#idMap = {};
+        this.#uniqueNameMap = {};
+        this.#classNameMap = Utils.copy(metadata, false);
+        for (const meta of Object.values(this.#classNameMap)) {
+            this.#idMap[meta._id] = meta;
+            this.#uniqueNameMap[meta.uniqueName] = meta;
+            this.#metadataMap.set(meta.class, meta);
         }
     }
     static getMetadata(entity, path) {
         const key = entity && path ? entity + '-' + Utils.hash(path) : null;
-        if (key && !MetadataStorage.metadata[key]) {
-            MetadataStorage.metadata[key] = new EntityMetadata({ className: entity, path });
+        if (key && !MetadataStorage.#metadata[key]) {
+            MetadataStorage.#metadata[key] = new EntityMetadata({ className: entity, path });
         }
         if (key) {
-            return MetadataStorage.metadata[key];
+            return MetadataStorage.#metadata[key];
         }
-        return MetadataStorage.metadata;
+        return MetadataStorage.#metadata;
     }
     static isKnownEntity(name) {
-        return !!Object.values(this.metadata).find(meta => meta.className === name);
+        return !!Object.values(this.#metadata).find(meta => meta.className === name);
     }
     static clear() {
-        Object.keys(this.metadata).forEach(k => delete this.metadata[k]);
+        Object.keys(this.#metadata).forEach(k => delete this.#metadata[k]);
     }
     getAll() {
-        return this.metadata;
+        return this.#metadataMap;
     }
     get(entityName, init = false) {
         const exists = this.find(entityName);
@@ -61,50 +61,50 @@ export class MetadataStorage {
         if (!entityName) {
             return;
         }
-        const meta = this.metadata.get(entityName);
+        const meta = this.#metadataMap.get(entityName);
         if (meta) {
             return meta;
         }
         if (entityName instanceof EntitySchema) {
-            return this.metadata.get(entityName.meta.class) ?? entityName.meta;
+            return this.#metadataMap.get(entityName.meta.class) ?? entityName.meta;
         }
-        return this.classNameMap[Utils.className(entityName)];
+        return this.#classNameMap[Utils.className(entityName)];
     }
     has(entityName) {
-        return this.metadata.has(entityName);
+        return this.#metadataMap.has(entityName);
     }
     set(entityName, meta) {
-        this.metadata.set(entityName, meta);
-        this.idMap[meta._id] = meta;
-        this.uniqueNameMap[meta.uniqueName] = meta;
-        this.classNameMap[Utils.className(entityName)] = meta;
+        this.#metadataMap.set(entityName, meta);
+        this.#idMap[meta._id] = meta;
+        this.#uniqueNameMap[meta.uniqueName] = meta;
+        this.#classNameMap[Utils.className(entityName)] = meta;
         return meta;
     }
     reset(entityName) {
         const meta = this.find(entityName);
         if (meta) {
-            this.metadata.delete(meta.class);
-            delete this.idMap[meta._id];
-            delete this.uniqueNameMap[meta.uniqueName];
-            delete this.classNameMap[meta.className];
+            this.#metadataMap.delete(meta.class);
+            delete this.#idMap[meta._id];
+            delete this.#uniqueNameMap[meta.uniqueName];
+            delete this.#classNameMap[meta.className];
         }
     }
     decorate(em) {
-        [...this.metadata.values()].filter(meta => meta.prototype).forEach(meta => EntityHelper.decorate(meta, em));
+        [...this.#metadataMap.values()].filter(meta => meta.prototype).forEach(meta => EntityHelper.decorate(meta, em));
     }
     *[Symbol.iterator]() {
-        for (const meta of this.metadata.values()) {
+        for (const meta of this.#metadataMap.values()) {
             yield meta;
         }
     }
     getById(id) {
-        return this.idMap[id];
+        return this.#idMap[id];
     }
     getByClassName(className, validate = true) {
-        return this.validate(this.classNameMap[className], className, validate);
+        return this.validate(this.#classNameMap[className], className, validate);
     }
     getByUniqueName(uniqueName, validate = true) {
-        return this.validate(this.uniqueNameMap[uniqueName], uniqueName, validate);
+        return this.validate(this.#uniqueNameMap[uniqueName], uniqueName, validate);
     }
     validate(meta, id, validate) {
         if (!meta && validate) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.0-dev.321",
+  "version": "7.0.0-dev.322",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",

package/serialization/SerializationContext.d.ts

@@ -6,14 +6,10 @@ import type { Configuration } from '../utils/Configuration.js';
  * are defined in populate hint). If not, we proceed and call `leave` afterwards.
  */
 export declare class SerializationContext<T extends object> {
-    private readonly config;
-    private readonly populate;
-    private readonly fields?;
-    private readonly exclude?;
+    #private;
     readonly path: [EntityName, string][];
     readonly visited: Set<Partial<any>>;
-    private entities;
-    constructor(config: Configuration, populate?: PopulateOptions<T>[], fields?: Set<string> | undefined, exclude?: string[] | undefined);
+    constructor(config: Configuration, populate?: PopulateOptions<T>[], fields?: Set<string>, exclude?: string[]);
     /**
      * Returns true when there is a cycle detected.
      */

package/serialization/SerializationContext.js

@@ -6,18 +6,18 @@ import { helper } from '../entity/wrap.js';
  * are defined in populate hint). If not, we proceed and call `leave` afterwards.
  */
 export class SerializationContext {
-    config;
-    populate;
-    fields;
-    exclude;
     path = [];
     visited = new Set();
-    entities = new Set();
+    #entities = new Set();
+    #config;
+    #populate;
+    #fields;
+    #exclude;
     constructor(config, populate = [], fields, exclude) {
-        this.config = config;
-        this.populate = populate;
-        this.fields = fields;
-        this.exclude = exclude;
+        this.#config = config;
+        this.#populate = populate;
+        this.#fields = fields;
+        this.#exclude = exclude;
     }
     /**
      * Returns true when there is a cycle detected.
@@ -42,7 +42,7 @@ export class SerializationContext {
         }
     }
     close() {
-        for (const entity of this.entities) {
+        for (const entity of this.#entities) {
             delete helper(entity).__serializationContext.root;
         }
     }
@@ -73,7 +73,7 @@ export class SerializationContext {
         }
     }
     isMarkedAsPopulated(entityName, prop) {
-        let populate = this.populate ?? [];
+        let populate = this.#populate ?? [];
         for (const segment of this.path) {
             const hints = populate.filter(p => p.field === segment[1]);
             if (hints.length > 0) {
@@ -93,10 +93,10 @@ export class SerializationContext {
         return !!populate?.some(p => p.field === prop);
     }
     isPartiallyLoaded(entityName, prop) {
-        if (!this.fields) {
+        if (!this.#fields) {
             return true;
         }
-        let fields = [...this.fields];
+        let fields = [...this.#fields];
         for (const segment of this.path) {
             /* v8 ignore next */
             if (fields.length === 0) {
@@ -110,6 +110,6 @@ export class SerializationContext {
     }
     register(entity) {
         helper(entity).__serializationContext.root = this;
-        this.entities.add(entity);
+        this.#entities.add(entity);
     }
 }

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

@@ -3,12 +3,7 @@ import { ChangeSet } from './ChangeSet.js';
 import { type Collection } from '../entity/Collection.js';
 import type { EntityManager } from '../EntityManager.js';
 export declare class ChangeSetComputer {
-    private readonly em;
-    private readonly collectionUpdates;
-    private readonly comparator;
-    private readonly metadata;
-    private readonly platform;
-    private readonly config;
+    #private;
     constructor(em: EntityManager, collectionUpdates: Set<Collection<AnyEntity>>);
     computeChangeSet<T extends object>(entity: T): ChangeSet<T> | null;
     /**

package/unit-of-work/ChangeSetComputer.js

@@ -7,22 +7,22 @@ import { Reference } from '../entity/Reference.js';
 import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 import { ReferenceKind } from '../enums.js';
 export class ChangeSetComputer {
-    em;
-    collectionUpdates;
-    comparator;
-    metadata;
-    platform;
-    config;
+    #comparator;
+    #metadata;
+    #platform;
+    #config;
+    #em;
+    #collectionUpdates;
     constructor(em, collectionUpdates) {
-        this.em = em;
-        this.collectionUpdates = collectionUpdates;
-        this.config = this.em.config;
-        this.metadata = this.em.getMetadata();
-        this.platform = this.em.getPlatform();
-        this.comparator = this.config.getComparator(this.metadata);
+        this.#em = em;
+        this.#collectionUpdates = collectionUpdates;
+        this.#config = this.#em.config;
+        this.#metadata = this.#em.getMetadata();
+        this.#platform = this.#em.getPlatform();
+        this.#comparator = this.#config.getComparator(this.#metadata);
     }
     computeChangeSet(entity) {
-        const meta = this.metadata.get(entity.constructor);
+        const meta = this.#metadata.get(entity.constructor);
         if (meta.readonly) {
             return null;
         }
@@ -38,7 +38,7 @@ export class ChangeSetComputer {
             }
         }
         if (type === ChangeSetType.UPDATE && !wrapped.__initialized) {
-            const data = this.comparator.prepareEntity(entity);
+            const data = this.#comparator.prepareEntity(entity);
             if (Utils.equals(data, wrapped.__originalEntityData)) {
                 return null;
             }
@@ -79,11 +79,11 @@ export class ChangeSetComputer {
             type === ChangeSetType.CREATE &&
             (entity[prop.name] == null ||
                 (Utils.isScalarReference(entity[prop.name]) && entity[prop.name].unwrap() == null))) {
-            entity[prop.name] = prop.onCreate(entity, this.em);
+            entity[prop.name] = prop.onCreate(entity, this.#em);
         }
         if (prop.onUpdate && type === ChangeSetType.UPDATE) {
             const pairs = map.get(entity) ?? [];
-            pairs.push([prop.name, prop.onUpdate(entity, this.em)]);
+            pairs.push([prop.name, prop.onUpdate(entity, this.#em)]);
             map.set(entity, pairs);
         }
         if (prop.kind === ReferenceKind.EMBEDDED && entity[prop.name]) {
@@ -93,7 +93,7 @@ export class ChangeSetComputer {
         }
     }
     computePayload(entity, ignoreUndefined = false) {
-        const data = this.comparator.prepareEntity(entity);
+        const data = this.#comparator.prepareEntity(entity);
         const wrapped = helper(entity);
         const entityName = wrapped.__meta.class;
         const originalEntityData = wrapped.__originalEntityData;
@@ -104,7 +104,7 @@ export class ChangeSetComputer {
             return data;
         }
         if (originalEntityData) {
-            const comparator = this.comparator.getEntityComparator(entityName);
+            const comparator = this.#comparator.getEntityComparator(entityName);
             const diff = comparator(originalEntityData, data);
             if (ignoreUndefined) {
                 Utils.keys(diff)
@@ -144,7 +144,7 @@ export class ChangeSetComputer {
                 if (prop.targetKey && prop.targetMeta) {
                     const targetProp = prop.targetMeta.properties[prop.targetKey];
                     if (targetProp?.customType) {
-                        value = targetProp.customType.convertToDatabaseValue(value, this.platform, { mode: 'serialization' });
+                        value = targetProp.customType.convertToDatabaseValue(value, this.#platform, { mode: 'serialization' });
                     }
                 }
                 if (prop.polymorphic) {
@@ -163,9 +163,9 @@ export class ChangeSetComputer {
             return;
         }
         if (target.isDirty()) {
-            this.collectionUpdates.add(target);
+            this.#collectionUpdates.add(target);
         }
-        if (prop.owner && !this.platform.usesPivotTable()) {
+        if (prop.owner && !this.#platform.usesPivotTable()) {
             changeSet.payload[prop.name] = target.getItems(false).map((item) => {
                 return item.__helper.__identifier ?? item.__helper.getPrimaryKey();
             });

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

@@ -3,15 +3,7 @@ import { type ChangeSet } from './ChangeSet.js';
 import type { DriverMethodOptions } from '../drivers/IDatabaseDriver.js';
 import type { EntityManager } from '../EntityManager.js';
 export declare class ChangeSetPersister {
-    private readonly em;
-    private readonly platform;
-    private readonly comparator;
-    private readonly usesReturningStatement;
-    private readonly driver;
-    private readonly metadata;
-    private readonly hydrator;
-    private readonly factory;
-    private readonly config;
+    #private;
     constructor(em: EntityManager);
     executeInserts<T extends object>(changeSets: ChangeSet<T>[], options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
     executeUpdates<T extends object>(changeSets: ChangeSet<T>[], batched: boolean, options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;

package/unit-of-work/ChangeSetPersister.js

@@ -7,25 +7,25 @@ import { Utils } from '../utils/Utils.js';
 import { OptimisticLockError, ValidationError } from '../errors.js';
 import { ReferenceKind } from '../enums.js';
 export class ChangeSetPersister {
-    em;
-    platform;
-    comparator;
-    usesReturningStatement;
-    driver;
-    metadata;
-    hydrator;
-    factory;
-    config;
+    #platform;
+    #comparator;
+    #usesReturningStatement;
+    #driver;
+    #metadata;
+    #hydrator;
+    #factory;
+    #config;
+    #em;
     constructor(em) {
-        this.em = em;
-        this.driver = this.em.getDriver();
-        this.config = this.em.config;
-        this.metadata = this.em.getMetadata();
-        this.factory = this.em.getEntityFactory();
-        this.platform = this.driver.getPlatform();
-        this.hydrator = this.config.getHydrator(this.metadata);
-        this.comparator = this.config.getComparator(this.metadata);
-        this.usesReturningStatement = this.platform.usesReturningStatement() || this.platform.usesOutputStatement();
+        this.#em = em;
+        this.#driver = this.#em.getDriver();
+        this.#config = this.#em.config;
+        this.#metadata = this.#em.getMetadata();
+        this.#factory = this.#em.getEntityFactory();
+        this.#platform = this.#driver.getPlatform();
+        this.#hydrator = this.#config.getHydrator(this.#metadata);
+        this.#comparator = this.#config.getComparator(this.#metadata);
+        this.#usesReturningStatement = this.#platform.usesReturningStatement() || this.#platform.usesOutputStatement();
     }
     async executeInserts(changeSets, options, withSchema) {
         if (!withSchema) {
@@ -33,7 +33,7 @@ export class ChangeSetPersister {
         }
         const meta = changeSets[0].meta;
         changeSets.forEach(changeSet => this.processProperties(changeSet));
-        if (changeSets.length > 1 && this.config.get('useBatchInserts', this.platform.usesBatchInserts())) {
+        if (changeSets.length > 1 && this.#config.get('useBatchInserts', this.#platform.usesBatchInserts())) {
             return this.persistNewEntities(meta, changeSets, options);
         }
         for (const changeSet of changeSets) {
@@ -52,7 +52,7 @@ export class ChangeSetPersister {
         if (batched &&
             changeSets.length > 1 &&
             !hasMixedTypes &&
-            this.config.get('useBatchUpdates', this.platform.usesBatchUpdates())) {
+            this.#config.get('useBatchUpdates', this.#platform.usesBatchUpdates())) {
             return this.persistManagedEntities(meta, changeSets, options);
         }
         for (const changeSet of changeSets) {
@@ -63,14 +63,14 @@ export class ChangeSetPersister {
         if (!withSchema) {
             return this.runForEachSchema(changeSets, 'executeDeletes', options);
         }
-        const size = this.config.get('batchSize');
+        const size = this.#config.get('batchSize');
         const meta = changeSets[0].meta;
         const pk = Utils.getPrimaryKeyHash(meta.primaryKeys);
         for (let i = 0; i < changeSets.length; i += size) {
             const chunk = changeSets.slice(i, i + size);
             const pks = chunk.map(cs => cs.getPrimaryKey());
             options = this.prepareOptions(meta, options);
-            await this.driver.nativeDelete(meta.root.class, { [pk]: { $in: pks } }, options);
+            await this.#driver.nativeDelete(meta.root.class, { [pk]: { $in: pks } }, options);
         }
     }
     async runForEachSchema(changeSets, method, options, ...args) {
@@ -110,7 +110,7 @@ export class ChangeSetPersister {
         for (const prop of meta.relations) {
             this.processProperty(changeSet, prop);
         }
-        if (changeSet.type === ChangeSetType.CREATE && this.config.get('validateRequired')) {
+        if (changeSet.type === ChangeSetType.CREATE && this.#config.get('validateRequired')) {
             this.validateRequired(changeSet.entity);
         }
     }
@@ -121,7 +121,7 @@ export class ChangeSetPersister {
         });
         this.resolveTPTIdentifiers(changeSet);
         // Use changeSet's own meta for STI entities to get correct field mappings
-        const res = await this.driver.nativeInsertMany(changeSet.meta.class, [changeSet.payload], options);
+        const res = await this.#driver.nativeInsertMany(changeSet.meta.class, [changeSet.payload], options);
         if (!wrapped.hasPrimaryKey()) {
             this.mapPrimaryKey(meta, res.insertId ?? res.row?.[meta.primaryKeys[0]], changeSet);
         }
@@ -129,23 +129,23 @@ export class ChangeSetPersister {
         this.markAsPopulated(changeSet, meta);
         wrapped.__initialized = true;
         wrapped.__managed = true;
-        if (!this.usesReturningStatement) {
+        if (!this.#usesReturningStatement) {
             await this.reloadVersionValues(meta, [changeSet], options);
         }
         changeSet.persisted = true;
     }
     async persistNewEntities(meta, changeSets, options) {
-        const size = this.config.get('batchSize');
+        const size = this.#config.get('batchSize');
         for (let i = 0; i < changeSets.length; i += size) {
             const chunk = changeSets.slice(i, i + size);
             await this.persistNewEntitiesBatch(meta, chunk, options);
-            if (!this.usesReturningStatement) {
+            if (!this.#usesReturningStatement) {
                 await this.reloadVersionValues(meta, chunk, options);
             }
         }
     }
     prepareOptions(meta, options, additionalOptions) {
-        const loggerContext = Utils.merge({ id: this.em._id }, this.em.getLoggerContext({ disableContextResolution: true }));
+        const loggerContext = Utils.merge({ id: this.#em._id }, this.#em.getLoggerContext({ disableContextResolution: true }));
         return {
             ...options,
             ...additionalOptions,
@@ -161,7 +161,7 @@ export class ChangeSetPersister {
         for (const changeSet of changeSets) {
             this.resolveTPTIdentifiers(changeSet);
         }
-        const res = await this.driver.nativeInsertMany(meta.class, changeSets.map(cs => cs.payload), options);
+        const res = await this.#driver.nativeInsertMany(meta.class, changeSets.map(cs => cs.payload), options);
         for (let i = 0; i < changeSets.length; i++) {
             const changeSet = changeSets[i];
             const wrapped = helper(changeSet.entity);
@@ -187,7 +187,7 @@ export class ChangeSetPersister {
         changeSet.persisted = true;
     }
     async persistManagedEntities(meta, changeSets, options) {
-        const size = this.config.get('batchSize');
+        const size = this.#config.get('batchSize');
         for (let i = 0; i < changeSets.length; i += size) {
             const chunk = changeSets.slice(i, i + size);
             await this.persistManagedEntitiesBatch(meta, chunk, options);
@@ -220,9 +220,9 @@ export class ChangeSetPersister {
             cond.push(where);
             payload.push(changeSet.payload);
         }
-        const res = await this.driver.nativeUpdateMany(meta.class, cond, payload, options);
+        const res = await this.#driver.nativeUpdateMany(meta.class, cond, payload, options);
         const map = new Map();
-        res.rows?.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
+        res.rows?.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, true, this.#platform, true), item));
         for (const changeSet of changeSets) {
             if (res.rows) {
                 const row = map.get(helper(changeSet.entity).getSerializedPrimaryKey());
@@ -233,7 +233,7 @@ export class ChangeSetPersister {
     }
     mapPrimaryKey(meta, value, changeSet) {
         const prop = meta.properties[meta.primaryKeys[0]];
-        const insertId = prop.customType ? prop.customType.convertToJSValue(value, this.platform) : value;
+        const insertId = prop.customType ? prop.customType.convertToJSValue(value, this.#platform) : value;
         const wrapped = helper(changeSet.entity);
         if (!wrapped.hasPrimaryKey()) {
             wrapped.setPrimaryKey(insertId);
@@ -242,7 +242,7 @@ export class ChangeSetPersister {
         // but we need to have it as string so comparison works in change set tracking, so instead
         // of using the raw value from db, we convert it back to the db value explicitly
         value = prop.customType
-            ? prop.customType.convertToDatabaseValue(insertId, this.platform, { mode: 'serialization' })
+            ? prop.customType.convertToDatabaseValue(insertId, this.#platform, { mode: 'serialization' })
             : value;
         changeSet.payload[wrapped.__meta.primaryKeys[0]] = value;
         if (wrapped.__identifier && !Array.isArray(wrapped.__identifier)) {
@@ -253,8 +253,8 @@ export class ChangeSetPersister {
      * Sets populate flag to new entities so they are serialized like if they were loaded from the db
      */
     markAsPopulated(changeSet, meta) {
-        helper(changeSet.entity).__schema = this.driver.getSchemaName(meta, changeSet);
-        if (!this.config.get('populateAfterFlush')) {
+        helper(changeSet.entity).__schema = this.#driver.getSchemaName(meta, changeSet);
+        if (!this.#config.get('populateAfterFlush')) {
             return;
         }
         helper(changeSet.entity).populated();
@@ -275,13 +275,13 @@ export class ChangeSetPersister {
         });
         if (meta.concurrencyCheckKeys.size === 0 &&
             (!meta.versionProperty || changeSet.entity[meta.versionProperty] == null)) {
-            return this.driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
+            return this.#driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
         }
         if (meta.versionProperty) {
-            cond[meta.versionProperty] = this.platform.convertVersionValue(changeSet.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
+            cond[meta.versionProperty] = this.#platform.convertVersionValue(changeSet.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
         }
         this.checkConcurrencyKeys(meta, changeSet, cond);
-        return this.driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
+        return this.#driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
     }
     async checkOptimisticLocks(meta, changeSets, options) {
         if (meta.concurrencyCheckKeys.size === 0 &&
@@ -294,7 +294,7 @@ export class ChangeSetPersister {
             const cond = Utils.getPrimaryKeyCond(cs.originalEntity, meta.primaryKeys.concat(...meta.concurrencyCheckKeys));
             if (meta.versionProperty) {
                 // @ts-ignore
-                cond[meta.versionProperty] = this.platform.convertVersionValue(cs.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
+                cond[meta.versionProperty] = this.#platform.convertVersionValue(cs.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
             }
             return cond;
         });
@@ -302,7 +302,7 @@ export class ChangeSetPersister {
         options = this.prepareOptions(meta, options, {
             fields: primaryKeys,
         });
-        const res = await this.driver.find(meta.root.class, { $or }, options);
+        const res = await this.#driver.find(meta.root.class, { $or }, options);
         if (res.length !== changeSets.length) {
             const compare = (a, b, keys) => keys.every(k => a[k] === b[k]);
             const entity = changeSets.find(cs => {
@@ -321,7 +321,7 @@ export class ChangeSetPersister {
      * so we use a single query in case of both versioning and default values is used.
      */
     async reloadVersionValues(meta, changeSets, options) {
-        const reloadProps = meta.versionProperty && !this.usesReturningStatement ? [meta.properties[meta.versionProperty]] : [];
+        const reloadProps = meta.versionProperty && !this.#usesReturningStatement ? [meta.properties[meta.versionProperty]] : [];
         if (changeSets[0].type === ChangeSetType.CREATE) {
             for (const prop of meta.props) {
                 if (prop.persist === false) {
@@ -350,7 +350,7 @@ export class ChangeSetPersister {
                 });
             });
             // reload generated columns
-            if (!this.usesReturningStatement) {
+            if (!this.#usesReturningStatement) {
                 meta.props.filter(prop => prop.generated && !prop.primary).forEach(prop => reloadProps.push(prop));
                 reloadProps.push(...returning);
             }
@@ -363,19 +363,19 @@ export class ChangeSetPersister {
         const pks = changeSets.map(cs => {
             const val = helper(cs.entity).getPrimaryKey(true);
             if (Utils.isPlainObject(val)) {
-                return Utils.getCompositeKeyValue(val, meta, false, this.platform);
+                return Utils.getCompositeKeyValue(val, meta, false, this.#platform);
             }
             return val;
         });
         options = this.prepareOptions(meta, options, {
             fields: Utils.unique(reloadProps.map(prop => prop.name)),
         });
-        const data = await this.driver.find(meta.class, { [pk]: { $in: pks } }, options);
+        const data = await this.#driver.find(meta.class, { [pk]: { $in: pks } }, options);
         const map = new Map();
-        data.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, false, this.platform, true), item));
+        data.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, false, this.#platform, true), item));
         for (const changeSet of changeSets) {
             const data = map.get(helper(changeSet.entity).getSerializedPrimaryKey());
-            this.hydrator.hydrate(changeSet.entity, meta, data, this.factory, 'full', false, true);
+            this.#hydrator.hydrate(changeSet.entity, meta, data, this.#factory, 'full', false, true);
             Object.assign(changeSet.payload, data); // merge to the changeset payload, so it gets saved to the entity snapshot
         }
     }
@@ -431,17 +431,17 @@ export class ChangeSetPersister {
      * We do need to map to the change set payload too, as it will be used in the originalEntityData for new entities.
      */
     mapReturnedValues(entity, payload, row, meta, upsert = false) {
-        if ((!this.usesReturningStatement && !upsert) || !row || !Utils.hasObjectKeys(row)) {
+        if ((!this.#usesReturningStatement && !upsert) || !row || !Utils.hasObjectKeys(row)) {
             return;
         }
-        const mapped = this.comparator.mapResult(meta, row);
+        const mapped = this.#comparator.mapResult(meta, row);
         if (entity) {
-            this.hydrator.hydrate(entity, meta, mapped, this.factory, 'full', false, true);
+            this.#hydrator.hydrate(entity, meta, mapped, this.#factory, 'full', false, true);
         }
         if (upsert) {
             for (const prop of meta.props) {
                 if (prop.customType && prop.name in mapped) {
-                    mapped[prop.name] = prop.customType.convertToJSValue(mapped[prop.name], this.platform);
+                    mapped[prop.name] = prop.customType.convertToJSValue(mapped[prop.name], this.#platform);
                 }
             }
         }

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

@@ -26,10 +26,7 @@ export interface Edge {
  * @internal
  */
 export declare class CommitOrderCalculator {
-    /** Matrix of nodes, keys are provided hashes and values are the node definition objects. */
-    private nodes;
-    /** Volatile variable holding calculated nodes during sorting process. */
-    private sortedNodeList;
+    #private;
     /**
      * Checks for node existence in graph.
      */