@mikro-orm/core 7.0.0-dev.114 → 7.0.0-dev.115

package/unit-of-work/ChangeSetPersister.js

@@ -30,7 +30,7 @@ export class ChangeSetPersister {
         if (!withSchema) {
             return this.runForEachSchema(changeSets, 'executeInserts', options);
         }
-        const meta = this.metadata.find(changeSets[0].name);
+        const meta = changeSets[0].meta;
         changeSets.forEach(changeSet => this.processProperties(changeSet));
         if (changeSets.length > 1 && this.config.get('useBatchInserts', this.platform.usesBatchInserts())) {
             return this.persistNewEntities(meta, changeSets, options);
@@ -43,7 +43,7 @@ export class ChangeSetPersister {
         if (!withSchema) {
             return this.runForEachSchema(changeSets, 'executeUpdates', options, batched);
         }
-        const meta = this.metadata.find(changeSets[0].name);
+        const meta = changeSets[0].meta;
         changeSets.forEach(changeSet => this.processProperties(changeSet));
         if (batched && changeSets.length > 1 && this.config.get('useBatchUpdates', this.platform.usesBatchUpdates())) {
             return this.persistManagedEntities(meta, changeSets, options);
@@ -63,7 +63,7 @@ export class ChangeSetPersister {
             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.className, { [pk]: { $in: pks } }, options);
+            await this.driver.nativeDelete(meta.root.class, { [pk]: { $in: pks } }, options);
         }
     }
     async runForEachSchema(changeSets, method, options, ...args) {
@@ -99,7 +99,7 @@ export class ChangeSetPersister {
         }
     }
     processProperties(changeSet) {
-        const meta = this.metadata.find(changeSet.name);
+        const meta = changeSet.meta;
         for (const prop of meta.relations) {
             this.processProperty(changeSet, prop);
         }
@@ -112,7 +112,7 @@ export class ChangeSetPersister {
         options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
         });
-        const res = await this.driver.nativeInsertMany(meta.className, [changeSet.payload], options);
+        const res = await this.driver.nativeInsertMany(meta.class, [changeSet.payload], options);
         if (!wrapped.hasPrimaryKey()) {
             this.mapPrimaryKey(meta, res.insertId, changeSet);
         }
@@ -149,7 +149,7 @@ export class ChangeSetPersister {
             convertCustomTypes: false,
             processCollections: false,
         });
-        const res = await this.driver.nativeInsertMany(meta.className, 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);
@@ -167,7 +167,7 @@ export class ChangeSetPersister {
         }
     }
     async persistManagedEntity(changeSet, options) {
-        const meta = this.metadata.find(changeSet.name);
+        const meta = changeSet.meta;
         const res = await this.updateEntity(meta, changeSet, options);
         this.checkOptimisticLock(meta, changeSet, res);
         this.mapReturnedValues(changeSet.entity, changeSet.payload, res.row, meta);
@@ -208,7 +208,7 @@ export class ChangeSetPersister {
             cond.push(where);
             payload.push(changeSet.payload);
         }
-        const res = await this.driver.nativeUpdateMany(meta.className, 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));
         for (const changeSet of changeSets) {
@@ -260,13 +260,13 @@ export class ChangeSetPersister {
             convertCustomTypes: false,
         });
         if (meta.concurrencyCheckKeys.size === 0 && (!meta.versionProperty || changeSet.entity[meta.versionProperty] == null)) {
-            return this.driver.nativeUpdate(changeSet.name, cond, changeSet.payload, options);
+            return this.driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
         }
         if (meta.versionProperty) {
             cond[meta.versionProperty] = this.platform.quoteVersionValue(changeSet.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
         }
         this.checkConcurrencyKeys(meta, changeSet, cond);
-        return this.driver.nativeUpdate(changeSet.name, 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 && (!meta.versionProperty || changeSets.every(cs => cs.entity[meta.versionProperty] == null))) {
@@ -286,7 +286,7 @@ export class ChangeSetPersister {
         options = this.prepareOptions(meta, options, {
             fields: primaryKeys,
         });
-        const res = await this.driver.find(meta.root.className, { $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 => {
@@ -356,7 +356,7 @@ export class ChangeSetPersister {
         options = this.prepareOptions(meta, options, {
             fields: Utils.unique(reloadProps.map(prop => prop.name)),
         });
-        const data = await this.driver.find(meta.className, { [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));
         for (const changeSet of changeSets) {
@@ -366,7 +366,7 @@ export class ChangeSetPersister {
         }
     }
     processProperty(changeSet, prop) {
-        const meta = this.metadata.find(changeSet.name);
+        const meta = changeSet.meta;
         const value = changeSet.payload[prop.name]; // for inline embeddables
         if (value instanceof EntityIdentifier) {
             changeSet.payload[prop.name] = value.getValue();
@@ -399,7 +399,7 @@ export class ChangeSetPersister {
         if ((!this.usesReturningStatement && !upsert) || !row || !Utils.hasObjectKeys(row)) {
             return;
         }
-        const mapped = this.comparator.mapResult(meta.className, row);
+        const mapped = this.comparator.mapResult(meta, row);
         if (entity) {
             this.hydrator.hydrate(entity, meta, mapped, this.factory, 'full', false, true);
         }

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

@@ -1,17 +1,18 @@
-import type { Dictionary, EntityProperty } from '../typings.js';
+import type { EntityProperty } from '../typings.js';
 export declare const enum NodeState {
     NOT_VISITED = 0,
     IN_PROGRESS = 1,
     VISITED = 2
 }
+type Hash = number;
 export interface Node {
-    hash: string;
+    hash: Hash;
     state: NodeState;
-    dependencies: Dictionary<Edge>;
+    dependencies: Map<Hash, Edge>;
 }
 export interface Edge {
-    from: string;
-    to: string;
+    from: Hash;
+    to: Hash;
     weight: number;
 }
 /**
@@ -32,23 +33,23 @@ export declare class CommitOrderCalculator {
     /**
      * Checks for node existence in graph.
      */
-    hasNode(hash: string): boolean;
+    hasNode(hash: Hash): boolean;
     /**
      * Adds a new node to the graph, assigning its hash.
      */
-    addNode(hash: string): void;
+    addNode(hash: Hash): void;
     /**
      * Adds a new dependency (edge) to the graph using their hashes.
      */
-    addDependency(from: string, to: string, weight: number): void;
-    discoverProperty(prop: EntityProperty, entityName: string): void;
+    addDependency(from: Hash, to: Hash, weight: number): void;
+    discoverProperty(prop: EntityProperty, entityName: Hash): void;
     /**
      * Return a valid order list of all current nodes.
      * The desired topological sorting is the reverse post order of these searches.
      *
      * @internal Highly performance-sensitive method.
      */
-    sort(): string[];
+    sort(): Hash[];
     /**
      * Visit a given node definition for reordering.
      *
@@ -60,3 +61,4 @@ export declare class CommitOrderCalculator {
      */
     private visitOpenNode;
 }
+export {};

package/unit-of-work/CommitOrderCalculator.js

@@ -17,26 +17,26 @@ export var NodeState;
  */
 export class CommitOrderCalculator {
     /** Matrix of nodes, keys are provided hashes and values are the node definition objects. */
-    nodes = {};
+    nodes = new Map();
     /** Volatile variable holding calculated nodes during sorting process. */
     sortedNodeList = [];
     /**
      * Checks for node existence in graph.
      */
     hasNode(hash) {
-        return hash in this.nodes;
+        return this.nodes.has(hash);
     }
     /**
      * Adds a new node to the graph, assigning its hash.
      */
     addNode(hash) {
-        this.nodes[hash] = { hash, state: 0 /* NodeState.NOT_VISITED */, dependencies: {} };
+        this.nodes.set(hash, { hash, state: 0 /* NodeState.NOT_VISITED */, dependencies: new Map() });
     }
     /**
      * Adds a new dependency (edge) to the graph using their hashes.
      */
     addDependency(from, to, weight) {
-        this.nodes[from].dependencies[to] = { from, to, weight };
+        this.nodes.get(from).dependencies.set(to, { from, to, weight });
     }
     discoverProperty(prop, entityName) {
         const toOneOwner = (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner) || prop.kind === ReferenceKind.MANY_TO_ONE;
@@ -44,8 +44,8 @@ export class CommitOrderCalculator {
         if (!toOneOwner && !toManyOwner) {
             return;
         }
-        const propertyType = prop.targetMeta?.root.className;
-        if (!propertyType || !this.hasNode(propertyType)) {
+        const propertyType = prop.targetMeta?.root._id;
+        if (propertyType == null || !this.hasNode(propertyType)) {
             return;
         }
         this.addDependency(propertyType, entityName, prop.nullable || prop.persist === false ? 0 : 1);
@@ -57,14 +57,14 @@ export class CommitOrderCalculator {
      * @internal Highly performance-sensitive method.
      */
     sort() {
-        for (const vertex of Object.values(this.nodes)) {
+        for (const vertex of this.nodes.values()) {
             if (vertex.state !== 0 /* NodeState.NOT_VISITED */) {
                 continue;
             }
             this.visit(vertex);
         }
         const sortedList = this.sortedNodeList.reverse();
-        this.nodes = {};
+        this.nodes = new Map();
         this.sortedNodeList = [];
         return sortedList;
     }
@@ -75,8 +75,8 @@ export class CommitOrderCalculator {
      */
     visit(node) {
         node.state = 1 /* NodeState.IN_PROGRESS */;
-        for (const edge of Object.values(node.dependencies)) {
-            const target = this.nodes[edge.to];
+        for (const edge of node.dependencies.values()) {
+            const target = this.nodes.get(edge.to);
             switch (target.state) {
                 case 2 /* NodeState.VISITED */: break; // Do nothing, since node was already visited
                 case 1 /* NodeState.IN_PROGRESS */:
@@ -94,11 +94,11 @@ export class CommitOrderCalculator {
      * Visits all target's dependencies if in cycle with given node
      */
     visitOpenNode(node, target, edge) {
-        if (!target.dependencies[node.hash] || target.dependencies[node.hash].weight >= edge.weight) {
+        if (!target.dependencies.has(node.hash) || target.dependencies.get(node.hash).weight >= edge.weight) {
             return;
         }
-        for (const edge of Object.values(target.dependencies)) {
-            const targetNode = this.nodes[edge.to];
+        for (const edge of target.dependencies.values()) {
+            const targetNode = this.nodes.get(edge.to);
             if (targetNode.state === 0 /* NodeState.NOT_VISITED */) {
                 this.visit(targetNode);
             }

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

@@ -1,4 +1,4 @@
-import type { AnyEntity, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary } from '../typings.js';
+import type { AnyEntity, EntityData, EntityMetadata, EntityName, EntityProperty, FilterQuery, Primary } from '../typings.js';
 import { Collection } from '../entity/Collection.js';
 import { Reference } from '../entity/Reference.js';
 import { ChangeSet, ChangeSetType } from './ChangeSet.js';
@@ -45,8 +45,8 @@ export declare 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<T extends object>(entityName: string, id: Primary<T> | Primary<T>[], schema?: string, convertCustomTypes?: boolean): T | undefined;
-    tryGetById<T extends object>(entityName: string, where: FilterQuery<T>, schema?: string, strict?: boolean): T | null;
+    getById<T extends object>(entityName: EntityName<T>, id: Primary<T> | Primary<T>[], schema?: string, convertCustomTypes?: boolean): T | undefined;
+    tryGetById<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, schema?: string, strict?: boolean): T | null;
     /**
      * Returns map of all managed entities.
      */

package/unit-of-work/UnitOfWork.js

@@ -207,7 +207,7 @@ export class UnitOfWork {
         if (insideFlush.getStore()) {
             return false;
         }
-        if (this.queuedActions.has(meta.className) || this.queuedActions.has(meta.root.className)) {
+        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))) {
@@ -251,7 +251,7 @@ export class UnitOfWork {
         }
         const wrapped = helper(entity);
         this.persistStack.add(entity);
-        this.queuedActions.add(wrapped.__meta.className);
+        this.queuedActions.add(wrapped.__meta.class);
         this.removeStack.delete(entity);
         if (!wrapped.__managed && wrapped.hasPrimaryKey()) {
             this.identityMap.store(entity);
@@ -264,7 +264,7 @@ export class UnitOfWork {
         // 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.className);
+            this.queuedActions.add(helper(entity).__meta.class);
         }
         else {
             this.persistStack.delete(entity);
@@ -355,10 +355,10 @@ export class UnitOfWork {
         }
     }
     async lock(entity, options) {
-        if (!this.getById(entity.constructor.name, helper(entity).__primaryKeys, helper(entity).__schema)) {
+        if (!this.getById(entity.constructor, helper(entity).__primaryKeys, helper(entity).__schema)) {
             throw ValidationError.entityNotManaged(entity);
         }
-        const meta = this.metadata.find(entity.constructor.name);
+        const meta = this.metadata.find(entity.constructor);
         if (options.lockMode === LockMode.OPTIMISTIC) {
             await this.lockOptimistic(entity, meta, options.lockVersion);
         }
@@ -382,7 +382,7 @@ export class UnitOfWork {
                 if (Utils.isCollection(rel)) {
                     rel.removeWithoutPropagation(entity);
                 }
-                else if (rel && (prop.mapToPk ? helper(this.em.getReference(prop.type, rel)).getSerializedPrimaryKey() === serializedPK : rel === entity)) {
+                else if (rel && (prop.mapToPk ? helper(this.em.getReference(prop.targetMeta.class, rel)).getSerializedPrimaryKey() === serializedPK : rel === entity)) {
                     if (prop.formula) {
                         delete referrer[prop.name];
                     }
@@ -424,13 +424,13 @@ export class UnitOfWork {
         const inserts = {};
         for (const cs of this.changeSets.values()) {
             if (cs.type === ChangeSetType.CREATE) {
-                inserts[cs.meta.className] ??= [];
-                inserts[cs.meta.className].push(cs);
+                inserts[cs.meta.uniqueName] ??= [];
+                inserts[cs.meta.uniqueName].push(cs);
             }
         }
         for (const cs of this.changeSets.values()) {
             if (cs.type === ChangeSetType.UPDATE) {
-                this.findEarlyUpdates(cs, inserts[cs.meta.className]);
+                this.findEarlyUpdates(cs, inserts[cs.meta.uniqueName]);
             }
         }
         for (const entity of this.removeStack) {
@@ -441,7 +441,7 @@ export class UnitOfWork {
             }
             const deletePkHash = [wrapped.getSerializedPrimaryKey(), ...this.expandUniqueProps(entity)];
             let type = ChangeSetType.DELETE;
-            for (const cs of inserts[wrapped.__meta.className] ?? []) {
+            for (const cs of inserts[wrapped.__meta.uniqueName] ?? []) {
                 if (deletePkHash.some(hash => hash === cs.getSerializedPrimaryKey() || this.expandUniqueProps(cs.entity).find(child => hash === child))) {
                     type = ChangeSetType.DELETE_EARLY;
                 }
@@ -460,7 +460,7 @@ export class UnitOfWork {
         }
         for (const cs of this.changeSets.values()) {
             for (const prop of props) {
-                if (prop.name in cs.payload && cs.rootName === changeSet.rootName && cs.type === changeSet.type) {
+                if (prop.name in cs.payload && cs.rootMeta === changeSet.rootMeta && cs.type === changeSet.type) {
                     conflicts = true;
                     if (changeSet.payload[prop.name] == null) {
                         type = ChangeSetType.UPDATE_EARLY;
@@ -479,9 +479,10 @@ export class UnitOfWork {
     }
     scheduleOrphanRemoval(entity, visited) {
         if (entity) {
-            helper(entity).__em = this.em;
+            const wrapped = helper(entity);
+            wrapped.__em = this.em;
             this.orphanRemoveStack.add(entity);
-            this.queuedActions.add(entity.__meta.className);
+            this.queuedActions.add(wrapped.__meta.class);
             this.cascade(entity, Cascade.SCHEDULE_ORPHAN_REMOVAL, visited);
         }
     }
@@ -630,7 +631,7 @@ export class UnitOfWork {
         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.name, copy, current);
+        const diff = this.comparator.diffEntities(changeSet.meta.class, copy, current);
         Object.assign(changeSet.payload, diff);
         const wrapped = helper(changeSet.entity);
         if (wrapped.__identifier) {
@@ -739,26 +740,26 @@ export class UnitOfWork {
     }
     fixMissingReference(entity, prop) {
         const reference = entity[prop.name];
-        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 });
+        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, { wrapped: !!prop.ref });
             }
-            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 });
+            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 });
             }
         }
-        // perf: set the `Collection._property` to skip the getter, as it can be slow when there is a lot of relations
-        if (Utils.isCollection(kind)) {
-            kind.property = prop;
+        // perf: set the `Collection._property` to skip the getter, as it can be slow when there are a lot of relations
+        if (Utils.isCollection(target)) {
+            target.property = prop;
         }
         const isCollection = [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind);
-        if (isCollection && Array.isArray(kind)) {
+        if (isCollection && Array.isArray(target)) {
             const collection = new Collection(entity);
             collection.property = prop;
             entity[prop.name] = collection;
-            collection.set(kind);
+            collection.set(target);
         }
     }
     async persistToDatabase(groups, ctx) {
@@ -768,30 +769,30 @@ export class UnitOfWork {
         const commitOrder = this.getCommitOrder();
         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[ChangeSetType.DELETE_EARLY].get(name) ?? [], ctx);
+        for (const meta of commitOrderReversed) {
+            await this.commitDeleteChangeSets(groups[ChangeSetType.DELETE_EARLY].get(meta) ?? [], 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[ChangeSetType.UPDATE_EARLY].get(name) ?? [], ctx);
+        for (const meta of commitOrder) {
+            await this.commitUpdateChangeSets(groups[ChangeSetType.UPDATE_EARLY].get(meta) ?? [], ctx);
         }
         // extra updates
         await this.commitExtraUpdates(ChangeSetType.UPDATE_EARLY, ctx);
         // create
-        for (const name of commitOrder) {
-            await this.commitCreateChangeSets(groups[ChangeSetType.CREATE].get(name) ?? [], ctx);
+        for (const meta of commitOrder) {
+            await this.commitCreateChangeSets(groups[ChangeSetType.CREATE].get(meta) ?? [], ctx);
         }
         // update
-        for (const name of commitOrder) {
-            await this.commitUpdateChangeSets(groups[ChangeSetType.UPDATE].get(name) ?? [], ctx);
+        for (const meta of commitOrder) {
+            await this.commitUpdateChangeSets(groups[ChangeSetType.UPDATE].get(meta) ?? [], ctx);
         }
         // extra updates
         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[ChangeSetType.DELETE].get(name) ?? [], ctx);
+        for (const meta of commitOrderReversed) {
+            await this.commitDeleteChangeSets(groups[ChangeSetType.DELETE].get(meta) ?? [], ctx);
         }
         // take snapshots of all persisted collections
         const visited = new Set();
@@ -960,10 +961,10 @@ export class UnitOfWork {
         };
         for (const cs of this.changeSets.values()) {
             const group = groups[cs.type];
-            const classGroup = group.get(cs.rootName) ?? [];
+            const classGroup = group.get(cs.rootMeta) ?? [];
             classGroup.push(cs);
-            if (!group.has(cs.rootName)) {
-                group.set(cs.rootName, classGroup);
+            if (!group.has(cs.rootMeta)) {
+                group.set(cs.rootMeta, classGroup);
             }
         }
         return groups;
@@ -971,14 +972,14 @@ export class UnitOfWork {
     getCommitOrder() {
         const calc = new CommitOrderCalculator();
         const set = new Set();
-        this.changeSets.forEach(cs => set.add(cs.rootName));
-        set.forEach(entityName => calc.addNode(entityName));
-        for (const entityName of set) {
-            for (const prop of this.metadata.find(entityName).props) {
-                calc.discoverProperty(prop, entityName);
+        this.changeSets.forEach(cs => set.add(cs.rootMeta));
+        set.forEach(meta => calc.addNode(meta._id));
+        for (const meta of set) {
+            for (const prop of meta.relations) {
+                calc.discoverProperty(prop, meta._id);
             }
         }
-        return calc.sort();
+        return calc.sort().map(id => this.metadata.getById(id));
     }
     resetTransaction(oldTx) {
         if (oldTx) {

package/utils/AbstractSchemaGenerator.js

@@ -40,7 +40,7 @@ export class AbstractSchemaGenerator {
     }
     async clear(options) {
         for (const meta of this.getOrderedMetadata(options?.schema).reverse()) {
-            await this.driver.nativeDelete(meta.className, {}, options);
+            await this.driver.nativeDelete(meta.class, {}, options);
         }
         if (options?.clearIdentityMap ?? true) {
             this.clearIdentityMap();
@@ -90,21 +90,21 @@ export class AbstractSchemaGenerator {
         this.notImplemented();
     }
     getOrderedMetadata(schema) {
-        const metadata = Object.values(this.metadata.getAll()).filter(meta => {
-            const isRootEntity = meta.root.className === meta.className;
+        const metadata = [...this.metadata.getAll().values()].filter(meta => {
+            const isRootEntity = meta.root.class === meta.class;
             return isRootEntity && !meta.embeddable && !meta.virtual;
         });
         const calc = new CommitOrderCalculator();
-        metadata.forEach(meta => calc.addNode(meta.root.className));
+        metadata.forEach(meta => calc.addNode(meta.root._id));
         let meta = metadata.pop();
         while (meta) {
-            for (const prop of meta.props) {
-                calc.discoverProperty(prop, meta.root.className);
+            for (const prop of meta.relations) {
+                calc.discoverProperty(prop, meta.root._id);
             }
             meta = metadata.pop();
         }
         return calc.sort()
-            .map(cls => this.metadata.find(cls))
+            .map(cls => this.metadata.getById(cls))
             .filter(meta => {
             const targetSchema = meta.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
             return schema ? [schema, '*'].includes(targetSchema) : meta.schema !== '*';

package/utils/Configuration.d.ts

@@ -402,11 +402,6 @@ export interface MetadataDiscoveryOptions {
      * @default true
      */
     checkDuplicateFieldNames?: boolean;
-    /**
-     * Check for duplicate entities and throw an error if found.
-     * @default true
-     */
-    checkDuplicateEntities?: boolean;
     /**
      * Check for composite primary keys marked as `persist: false` and throw an error if found.
      * @default true

package/utils/DataloaderUtils.js

@@ -11,7 +11,7 @@ export class DataloaderUtils {
     static groupPrimaryKeysByEntityAndOpts(refsWithOpts) {
         const map = new Map();
         for (const [ref, opts] of refsWithOpts) {
-            /* The key is a combination of the className and a stringified version if the load options because we want
+            /* The key is a combination of the uniqueName (a unique table name based identifier) and a stringified version if the load options because we want
                to map each combination of entities/options into separate find queries in order to return accurate results.
                This could be further optimized finding the "lowest common denominator" among the different options
                for each Entity and firing a single query for each Entity instead of Entity+options combination.
@@ -24,7 +24,7 @@ export class DataloaderUtils {
                Thus such approach should probably be configurable, if not opt-in.
                NOTE: meta + opts multi maps (https://github.com/martian17/ds-js) might be a more elegant way
                to implement this but not necessarily faster.  */
-            const key = `${helper(ref).__meta.className}|${JSON.stringify(opts ?? {})}`;
+            const key = `${helper(ref).__meta.uniqueName}|${JSON.stringify(opts ?? {})}`;
             let primaryKeysSet = map.get(key);
             if (primaryKeysSet == null) {
                 primaryKeysSet = new Set();
@@ -42,9 +42,10 @@ export class DataloaderUtils {
         return async (refsWithOpts) => {
             const groupedIdsMap = DataloaderUtils.groupPrimaryKeysByEntityAndOpts(refsWithOpts);
             const promises = Array.from(groupedIdsMap).map(([key, idsSet]) => {
-                const className = key.substring(0, key.indexOf('|'));
+                const uniqueName = key.substring(0, key.indexOf('|'));
                 const opts = JSON.parse(key.substring(key.indexOf('|') + 1));
-                return em.find(className, Array.from(idsSet), opts);
+                const meta = em.getMetadata().getByUniqueName(uniqueName);
+                return em.find(meta.class, Array.from(idsSet), opts);
             });
             await Promise.all(promises);
             /* Instead of assigning each find result to the original reference we use a shortcut
@@ -70,7 +71,7 @@ export class DataloaderUtils {
             The value is another Map which we can use to filter the find query to get results pertaining to the collections that have been dataloaded:
             its keys are the props we are going to filter to and its values are the corresponding PKs.
             */
-            const key = `${col.property.targetMeta.className}|${JSON.stringify(opts ?? {})}`;
+            const key = `${col.property.targetMeta.uniqueName}|${JSON.stringify(opts ?? {})}`;
             let filterMap = entitiesMap.get(key); // We are going to use this map to filter the entities pertaining to the collections that have been dataloaded.
             if (filterMap == null) {
                 filterMap = new Map();
@@ -97,9 +98,10 @@ export class DataloaderUtils {
      */
     static entitiesAndOptsMapToQueries(entitiesAndOptsMap, em) {
         return Array.from(entitiesAndOptsMap, async ([key, filterMap]) => {
-            const className = key.substring(0, key.indexOf('|'));
+            const uniqueName = key.substring(0, key.indexOf('|'));
             const opts = JSON.parse(key.substring(key.indexOf('|') + 1));
-            const res = await em.find(className, opts?.where != null && Object.keys(opts.where).length > 0 ?
+            const meta = em.getMetadata().getByUniqueName(uniqueName);
+            const res = await em.find(meta.class, opts?.where != null && Object.keys(opts.where).length > 0 ?
                 {
                     $and: [
                         {
@@ -121,7 +123,7 @@ export class DataloaderUtils {
                     ...(opts.populate === false ? [] : opts.populate ?? []),
                     ...Array.from(filterMap.keys()).filter(
                     // We need to do so only if the inverse side is a collection, because we can already retrieve the PK from a reference without having to load it
-                    prop => em.getMetadata(className).properties[prop]?.ref !== true),
+                    prop => meta.properties[prop]?.ref !== true),
                 ],
             });
             return [key, res];
@@ -164,7 +166,7 @@ export class DataloaderUtils {
             // We need to filter the results in order to map each input collection
             // to a subset of each query matching the collection items.
             return collsWithOpts.map(([col, opts]) => {
-                const key = `${col.property.targetMeta.className}|${JSON.stringify(opts ?? {})}`;
+                const key = `${col.property.targetMeta.uniqueName}|${JSON.stringify(opts ?? {})}`;
                 const entities = resultsMap.get(key);
                 if (entities == null) {
                     // Should never happen
@@ -183,7 +185,7 @@ export class DataloaderUtils {
         return async (collsWithOpts) => {
             const groups = new Map();
             for (const [col, opts] of collsWithOpts) {
-                const key = `${col.property.targetMeta.className}.${col.property.name}|${JSON.stringify(opts ?? {})}`;
+                const key = `${col.property.targetMeta.uniqueName}.${col.property.name}|${JSON.stringify(opts ?? {})}`;
                 const value = groups.get(key) ?? [];
                 value.push([col, opts ?? {}]);
                 groups.set(key, value);
@@ -198,7 +200,7 @@ export class DataloaderUtils {
                 const owners = group.map(c => c[0].owner);
                 const $or = [];
                 // a bit of a hack, but we need to prefix the key, since we have only a column name, not a property name
-                const alias = em.config.getNamingStrategy().aliasName(prop.pivotEntity, 0);
+                const alias = em.config.getNamingStrategy().aliasName(Utils.className(prop.pivotEntity), 0);
                 const fk = `${alias}.${Utils.getPrimaryKeyHash(prop.joinColumns)}`;
                 for (const c of group) {
                     $or.push({ $and: [c[1]?.where ?? {}, { [fk]: c[0].owner }] });