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

package/metadata/MetadataStorage.js

@@ -2,6 +2,7 @@ import { EntityMetadata } from '../typings.js';
 import { Utils } from '../utils/Utils.js';
 import { MetadataError } from '../errors.js';
 import { EntityHelper } from '../entity/EntityHelper.js';
+import { EntitySchema } from './EntitySchema.js';
 function getGlobalStorage(namespace) {
     const key = `mikro-orm-${namespace}`;
     globalThis[key] = globalThis[key] || {};
@@ -10,9 +11,19 @@ function getGlobalStorage(namespace) {
 export class MetadataStorage {
     static PATH_SYMBOL = Symbol('MetadataStorage.PATH_SYMBOL');
     static metadata = getGlobalStorage('metadata');
-    metadata;
+    metadata = new Map();
+    idMap;
+    classNameMap;
+    uniqueNameMap;
     constructor(metadata = {}) {
-        this.metadata = Utils.copy(metadata, false);
+        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);
+        }
     }
     static getMetadata(entity, path) {
         const key = entity && path ? entity + '-' + Utils.hash(path) : null;
@@ -33,40 +44,74 @@ export class MetadataStorage {
     getAll() {
         return this.metadata;
     }
-    get(entityName, init = false, validate = true) {
-        entityName = Utils.className(entityName);
-        if (validate && !init && !this.has(entityName)) {
-            throw MetadataError.missingMetadata(entityName);
+    get(entityName, init = false) {
+        const exists = this.find(entityName);
+        if (exists) {
+            return exists;
         }
-        if (init && !this.has(entityName)) {
-            this.metadata[entityName] = new EntityMetadata();
+        const className = Utils.className(entityName);
+        if (!init) {
+            throw MetadataError.missingMetadata(className);
         }
-        return this.metadata[entityName];
+        const meta = new EntityMetadata({ class: entityName, name: className });
+        this.set(entityName, meta);
+        return meta;
     }
     find(entityName) {
         if (!entityName) {
             return;
         }
-        entityName = Utils.className(entityName);
-        return this.metadata[entityName];
+        const meta = this.metadata.get(entityName);
+        if (meta) {
+            return meta;
+        }
+        if (entityName instanceof EntitySchema) {
+            return this.metadata.get(entityName.meta.class) ?? entityName.meta;
+        }
+        return this.classNameMap[Utils.className(entityName)];
     }
-    has(entity) {
-        return entity in this.metadata;
+    has(entityName) {
+        return this.metadata.has(entityName);
     }
-    set(entity, meta) {
-        return this.metadata[entity] = meta;
+    set(entityName, meta) {
+        this.metadata.set(entityName, meta);
+        this.idMap[meta._id] = meta;
+        this.uniqueNameMap[meta.uniqueName] = meta;
+        this.classNameMap[Utils.className(entityName)] = meta;
+        return meta;
     }
-    reset(entity) {
-        delete this.metadata[entity];
+    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];
+        }
     }
     decorate(em) {
-        Object.values(this.metadata)
+        [...this.metadata.values()]
             .filter(meta => meta.prototype)
             .forEach(meta => EntityHelper.decorate(meta, em));
     }
     *[Symbol.iterator]() {
-        for (const meta of Object.values(this.metadata)) {
+        for (const meta of this.metadata.values()) {
             yield meta;
         }
     }
+    getById(id) {
+        return this.idMap[id];
+    }
+    getByClassName(className, validate = true) {
+        return this.validate(this.classNameMap[className], className, validate);
+    }
+    getByUniqueName(uniqueName, validate = true) {
+        return this.validate(this.uniqueNameMap[uniqueName], uniqueName, validate);
+    }
+    validate(meta, id, validate) {
+        if (!meta && validate) {
+            throw MetadataError.missingMetadata(id);
+        }
+        return meta;
+    }
 }

package/metadata/MetadataValidator.d.ts

@@ -1,11 +1,11 @@
-import type { EntityMetadata } from '../typings.js';
+import type { EntityMetadata, EntityName } from '../typings.js';
 import { type MetadataDiscoveryOptions } from '../utils/Configuration.js';
 import type { MetadataStorage } from './MetadataStorage.js';
 /**
  * @internal
  */
 export declare class MetadataValidator {
-    validateEntityDefinition<T>(metadata: MetadataStorage, name: string, options: MetadataDiscoveryOptions): void;
+    validateEntityDefinition<T>(metadata: MetadataStorage, name: EntityName<T>, options: MetadataDiscoveryOptions): void;
     validateDiscovered(discovered: EntityMetadata[], options: MetadataDiscoveryOptions): void;
     private validateReference;
     private validateBidirectional;

package/metadata/MetadataValidator.js

@@ -28,11 +28,11 @@ export class MetadataValidator {
         this.validateIndexes(meta, meta.uniques ?? [], 'unique');
         for (const prop of Utils.values(meta.properties)) {
             if (prop.kind !== ReferenceKind.SCALAR) {
-                this.validateReference(meta, prop, metadata, options);
-                this.validateBidirectional(meta, prop, metadata);
+                this.validateReference(meta, prop, options);
+                this.validateBidirectional(meta, prop);
             }
-            else if (metadata.has(prop.type)) {
-                throw MetadataError.propertyTargetsEntityType(meta, prop, metadata.get(prop.type));
+            else if (metadata.getByClassName(prop.type, false)) {
+                throw MetadataError.propertyTargetsEntityType(meta, prop, metadata.getByClassName(prop.type));
             }
         }
     }
@@ -40,17 +40,13 @@ export class MetadataValidator {
         if (discovered.length === 0 && options.warnWhenNoEntities) {
             throw MetadataError.noEntityDiscovered();
         }
-        const duplicates = Utils.findDuplicates(discovered.map(meta => meta.className));
-        if (duplicates.length > 0 && options.checkDuplicateEntities) {
-            throw MetadataError.duplicateEntityDiscovered(duplicates);
-        }
         const tableNames = discovered.filter(meta => !meta.abstract && meta === meta.root && (meta.tableName || meta.collection) && meta.schema !== '*');
         const duplicateTableNames = Utils.findDuplicates(tableNames.map(meta => {
             const tableName = meta.tableName || meta.collection;
             return (meta.schema ? '.' + meta.schema : '') + tableName;
         }));
-        if (duplicateTableNames.length > 0 && options.checkDuplicateTableNames && options.checkDuplicateEntities) {
-            throw MetadataError.duplicateEntityDiscovered(duplicateTableNames, 'table names');
+        if (duplicateTableNames.length > 0 && options.checkDuplicateTableNames) {
+            throw MetadataError.duplicateEntityDiscovered(duplicateTableNames);
         }
         // validate we found at least one entity (not just abstract/base entities)
         if (discovered.filter(meta => meta.name).length === 0 && options.warnWhenNoEntities) {
@@ -61,7 +57,7 @@ export class MetadataValidator {
             .replace(/\[]$/, '') // remove array suffix
             .replace(/\((.*)\)/, '$1'); // unwrap union types
         const name = (p) => {
-            if (typeof p === 'function') {
+            if (typeof p === 'function' && !p.prototype) {
                 return Utils.className(p());
             }
             return Utils.className(p);
@@ -85,12 +81,12 @@ export class MetadataValidator {
             }
         });
     }
-    validateReference(meta, prop, metadata, options) {
+    validateReference(meta, prop, options) {
         // references do have types
         if (!prop.type) {
             throw MetadataError.fromWrongTypeDefinition(meta, prop);
         }
-        const targetMeta = metadata.find(prop.type);
+        const targetMeta = prop.targetMeta;
         // references do have type of known entity
         if (!targetMeta) {
             throw MetadataError.fromWrongTypeDefinition(meta, prop);
@@ -102,30 +98,27 @@ export class MetadataValidator {
             throw MetadataError.nonPersistentCompositeProp(meta, prop);
         }
     }
-    validateBidirectional(meta, prop, metadata) {
+    validateBidirectional(meta, prop) {
         if (prop.inversedBy) {
-            const inverse = metadata.get(prop.type).properties[prop.inversedBy];
-            this.validateOwningSide(meta, prop, inverse, metadata);
+            this.validateOwningSide(meta, prop);
         }
         else if (prop.mappedBy) {
-            const inverse = metadata.get(prop.type).properties[prop.mappedBy];
-            this.validateInverseSide(meta, prop, inverse, metadata);
+            this.validateInverseSide(meta, prop);
         }
-        else {
+        else if (prop.kind === ReferenceKind.ONE_TO_MANY && !prop.mappedBy) {
             // 1:m property has `mappedBy`
-            if (prop.kind === ReferenceKind.ONE_TO_MANY && !prop.mappedBy) {
-                throw MetadataError.fromMissingOption(meta, prop, 'mappedBy');
-            }
+            throw MetadataError.fromMissingOption(meta, prop, 'mappedBy');
         }
     }
-    validateOwningSide(meta, prop, inverse, metadata) {
+    validateOwningSide(meta, prop) {
+        const inverse = prop.targetMeta.properties[prop.inversedBy];
         // has correct `inversedBy` on owning side
         if (!inverse) {
             throw MetadataError.fromWrongReference(meta, prop, 'inversedBy');
         }
-        const targetClassName = metadata.find(inverse.type)?.root.className;
+        const targetClass = inverse.targetMeta?.root.class;
         // has correct `inversedBy` reference type
-        if (inverse.type !== meta.className && targetClassName !== meta.root.className) {
+        if (inverse.type !== meta.className && targetClass !== meta.root.class) {
             throw MetadataError.fromWrongReference(meta, prop, 'inversedBy', inverse);
         }
         // inverse side is not defined as owner
@@ -133,13 +126,14 @@ export class MetadataValidator {
             throw MetadataError.fromWrongOwnership(meta, prop, 'inversedBy');
         }
     }
-    validateInverseSide(meta, prop, owner, metadata) {
+    validateInverseSide(meta, prop) {
+        const owner = prop.targetMeta.properties[prop.mappedBy];
         // has correct `mappedBy` on inverse side
         if (prop.mappedBy && !owner) {
             throw MetadataError.fromWrongReference(meta, prop, 'mappedBy');
         }
         // has correct `mappedBy` reference type
-        if (owner.type !== meta.className && metadata.find(owner.type)?.root.className !== meta.root.className) {
+        if (owner.type !== meta.className && owner.targetMeta?.root.class !== meta.root.class) {
             throw MetadataError.fromWrongReference(meta, prop, 'mappedBy', owner);
         }
         // owning side is not defined as inverse
@@ -182,7 +176,7 @@ export class MetadataValidator {
                     return [prop.embedded ? prop.embedded.join('.') : prop.name, prop.fieldNames[0]];
                 });
             });
-            throw MetadataError.duplicateFieldName(meta.className, pairs);
+            throw MetadataError.duplicateFieldName(meta.class, pairs);
         }
     }
     validateVersionField(meta) {

package/metadata/types.d.ts

@@ -308,7 +308,7 @@ export interface PropertyOptions<Owner> {
 }
 export interface ReferenceOptions<Owner, Target> extends PropertyOptions<Owner> {
     /** Set target entity type. */
-    entity?: string | (() => EntityName<Target>);
+    entity?: () => EntityName<Target>;
     /** Set what actions on owning entity should be cascaded to the relationship. Defaults to [Cascade.PERSIST, Cascade.MERGE] (see {@doclink cascading}). */
     cascade?: Cascade[];
     /** Always load the relationship. Discouraged for use with to-many relations for performance reasons. */
@@ -417,7 +417,7 @@ export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner
     /** Override default name for pivot table (see {@doclink naming-strategy | Naming Strategy}). */
     pivotTable?: string;
     /** Set pivot entity for this relation (see {@doclink collections#custom-pivot-table-entity | Custom pivot table entity}). */
-    pivotEntity?: string | (() => EntityName<any>);
+    pivotEntity?: () => EntityName;
     /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
     joinColumn?: string;
     /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
@@ -438,7 +438,7 @@ export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner
     createForeignKeyConstraint?: boolean;
 }
 export interface EmbeddedOptions<Owner, Target> extends PropertyOptions<Owner> {
-    entity?: string | (() => EntityName<Target> | EntityName<Target>[]);
+    entity?: () => EntityName<Target> | EntityName<Target>[];
     prefix?: string | boolean;
     prefixMode?: EmbeddedPrefixMode;
     object?: boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.114",
+  "version": "7.0.0-dev.115",
   "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.",
   "exports": {
     "./package.json": "./package.json",

package/serialization/EntitySerializer.js

@@ -69,13 +69,13 @@ export class EntitySerializer {
             if (!isVisible(meta, prop, options)) {
                 continue;
             }
-            const cycle = root.visit(meta.className, prop);
+            const cycle = root.visit(meta.class, prop);
             if (cycle && visited) {
                 continue;
             }
             const val = this.processProperty(prop, entity, options);
             if (!cycle) {
-                root.leave(meta.className, prop);
+                root.leave(meta.class, prop);
             }
             if (options.skipNull && Utils.isPlainObject(val)) {
                 Utils.dropUndefinedProperties(val, null);

package/serialization/EntityTransformer.js

@@ -57,19 +57,19 @@ export class EntityTransformer {
             if (!visible) {
                 continue;
             }
-            const populated = root.isMarkedAsPopulated(meta.className, prop);
-            const partiallyLoaded = root.isPartiallyLoaded(meta.className, prop);
+            const populated = root.isMarkedAsPopulated(meta.class, prop);
+            const partiallyLoaded = root.isPartiallyLoaded(meta.class, prop);
             const isPrimary = includePrimaryKeys && meta.properties[prop].primary;
             if (!partiallyLoaded && !populated && !isPrimary) {
                 continue;
             }
-            const cycle = root.visit(meta.className, prop);
+            const cycle = root.visit(meta.class, prop);
             if (cycle && visited) {
                 continue;
             }
             const val = EntityTransformer.processProperty(prop, entity, raw, populated);
             if (!cycle) {
-                root.leave(meta.className, prop);
+                root.leave(meta.class, prop);
             }
             if (isRaw(val)) {
                 throw new Error(`Trying to serialize raw SQL fragment: '${val.sql}'`);
@@ -86,7 +86,7 @@ export class EntityTransformer {
             // decorated get methods
             if (prop.getterName != null) {
                 const visible = !prop.hidden && entity[prop.getterName] instanceof Function;
-                const populated = root.isMarkedAsPopulated(meta.className, prop.name);
+                const populated = root.isMarkedAsPopulated(meta.class, prop.name);
                 if (visible) {
                     ret[this.propertyName(meta, prop.name, raw)] = this.processProperty(prop.getterName, entity, raw, populated);
                 }
@@ -94,7 +94,7 @@ export class EntityTransformer {
             else {
                 // decorated getters
                 const visible = !prop.hidden && typeof entity[prop.name] !== 'undefined';
-                const populated = root.isMarkedAsPopulated(meta.className, prop.name);
+                const populated = root.isMarkedAsPopulated(meta.class, prop.name);
                 if (visible) {
                     ret[this.propertyName(meta, prop.name, raw)] = this.processProperty(prop.name, entity, raw, populated);
                 }

package/serialization/SerializationContext.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEntity, EntityMetadata, PopulateOptions } from '../typings.js';
+import type { AnyEntity, EntityMetadata, EntityName, PopulateOptions } from '../typings.js';
 import type { Configuration } from '../utils/Configuration.js';
 /**
  * Helper that allows to keep track of where we are currently at when serializing complex entity graph with cycles.
@@ -10,21 +10,21 @@ export declare class SerializationContext<T extends object> {
     private readonly populate;
     private readonly fields?;
     private readonly exclude?;
-    readonly path: [string, string][];
+    readonly path: [EntityName, string][];
     readonly visited: Set<Partial<any>>;
     private entities;
     constructor(config: Configuration, populate?: PopulateOptions<T>[], fields?: Set<string> | undefined, exclude?: string[] | undefined);
     /**
      * Returns true when there is a cycle detected.
      */
-    visit(entityName: string, prop: string): boolean;
-    leave<U>(entityName: string, prop: string): void;
+    visit(entityName: EntityName, prop: string): boolean;
+    leave(entityName: EntityName, prop: string): void;
     close(): void;
     /**
      * When initializing new context, we need to propagate it to the whole entity graph recursively.
      */
     static propagate(root: SerializationContext<any>, entity: AnyEntity, isVisible: (meta: EntityMetadata, prop: string) => boolean): void;
-    isMarkedAsPopulated(entityName: string, prop: string): boolean;
-    isPartiallyLoaded(entityName: string, prop: string): boolean;
+    isMarkedAsPopulated(entityName: EntityName, prop: string): boolean;
+    isPartiallyLoaded(entityName: EntityName, prop: string): boolean;
     private register;
 }

package/typings.d.ts

@@ -206,10 +206,10 @@ export interface IWrappedEntityInternal<Entity extends object> extends IWrappedE
     };
 }
 export type AnyEntity<T = any> = Partial<T>;
-export type EntityClass<T> = Function & {
+export type EntityClass<T = any> = Function & {
     prototype: T;
 };
-export type EntityName<T> = string | EntityClass<T> | EntitySchema<T, any> | {
+export type EntityName<T = any> = EntityClass<T> | EntitySchema<T, any> | {
     name: string;
 };
 export type GetRepository<Entity extends {
@@ -326,6 +326,7 @@ export type AnyString = string & {};
 export interface EntityProperty<Owner = any, Target = any> {
     name: EntityKey<Owner>;
     entity: () => EntityName<Owner>;
+    target: EntityClass<Target>;
     type: keyof typeof types | AnyString;
     runtimeType: 'number' | 'string' | 'boolean' | 'bigint' | 'Buffer' | 'Date' | 'object' | 'any' | AnyString;
     targetMeta?: EntityMetadata<Target>;
@@ -396,7 +397,7 @@ export interface EntityProperty<Owner = any, Target = any> {
     fixedOrder?: boolean;
     fixedOrderColumn?: string;
     pivotTable: string;
-    pivotEntity: string;
+    pivotEntity: EntityClass<Target>;
     joinColumns: string[];
     ownColumns: string[];
     inverseJoinColumns: string[];
@@ -420,13 +421,14 @@ export declare class EntityMetadata<T = any> {
     readonly _id: number;
     readonly propertyOrder: Map<string, number>;
     constructor(meta?: Partial<EntityMetadata>);
-    addProperty(prop: Partial<EntityProperty<T>>, sync?: boolean): void;
+    addProperty(prop: Partial<EntityProperty<T>>): void;
     removeProperty(name: string, sync?: boolean): void;
     getPrimaryProps(flatten?: boolean): EntityProperty<T>[];
     getPrimaryProp(): EntityProperty<T>;
     createColumnMappingObject(): Dictionary<any>;
     get tableName(): string;
     set tableName(name: string);
+    get uniqueName(): string;
     sync(initIndexes?: boolean, config?: Configuration): void;
     private initIndexes;
     /** @internal */
@@ -446,11 +448,11 @@ export interface EntityMetadata<T = any> {
     expression?: string | ((em: any, where: ObjectQuery<T>, options: FindOptions<T, any, any, any>, stream?: boolean) => MaybePromise<Raw | object | string>);
     discriminatorColumn?: EntityKey<T> | AnyString;
     discriminatorValue?: number | string;
-    discriminatorMap?: Dictionary<string>;
+    discriminatorMap?: Dictionary<EntityClass>;
     embeddable: boolean;
     constructorParams?: (keyof T)[];
     forceConstructor: boolean;
-    extends: string;
+    extends?: EntityName<T>;
     collection: string;
     path: string;
     primaryKeys: EntityKey<T>[];
@@ -714,13 +716,13 @@ export interface MigrationObject {
 type EntityFromInput<T> = T extends readonly EntityName<infer U>[] ? U : T extends EntityName<infer U> ? U : never;
 type FilterDefResolved<T extends object = any> = {
     name: string;
-    cond: FilterQuery<T> | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<T, any, any, any> | FindOneOptions<T, any, any, any>, entityName?: EntityName<T>) => MaybePromise<FilterQuery<T>>);
+    cond: FilterQuery<T> | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<T, any, any, any> | FindOneOptions<T, any, any, any>, entityName?: string) => MaybePromise<FilterQuery<T>>);
     default?: boolean;
     entity?: EntityName<T> | EntityName<T>[];
     args?: boolean;
     strict?: boolean;
 };
-export type FilterDef<T extends EntityName<any> | readonly EntityName<any>[] = any> = FilterDefResolved<EntityFromInput<T>> & {
+export type FilterDef<T extends EntityName | readonly EntityName[] = any> = FilterDefResolved<EntityFromInput<T>> & {
     entity?: T;
 };
 export type Populate<T, P extends string = never> = readonly AutoPath<T, P, `${PopulatePath}`>[] | false;
@@ -813,12 +815,12 @@ export interface Highlighter {
     highlight(text: string): string;
 }
 export interface IMetadataStorage {
-    getAll(): Dictionary<EntityMetadata>;
-    get<T = any>(entity: string, init?: boolean, validate?: boolean): EntityMetadata<T>;
-    find<T = any>(entity: string): EntityMetadata<T> | undefined;
-    has(entity: string): boolean;
-    set(entity: string, meta: EntityMetadata): EntityMetadata;
-    reset(entity: string): void;
+    getAll(): Map<EntityName, EntityMetadata>;
+    get<T = any>(entity: EntityName<T>, init?: boolean, validate?: boolean): EntityMetadata<T>;
+    find<T = any>(entity: EntityName<T>): EntityMetadata<T> | undefined;
+    has<T>(entity: EntityName<T>): boolean;
+    set<T>(entity: EntityName<T>, meta: EntityMetadata): EntityMetadata;
+    reset<T>(entity: EntityName<T>): void;
 }
 export interface IHydrator {
     /**

package/typings.js

@@ -25,22 +25,20 @@ export class EntityMetadata {
         this.referencingProperties = [];
         this.concurrencyCheckKeys = new Set();
         Object.assign(this, meta);
-    }
-    addProperty(prop, sync = true) {
-        if (prop.pivotTable && !prop.pivotEntity) {
-            prop.pivotEntity = prop.pivotTable;
+        const name = meta.className ?? meta.name;
+        if (!this.class && name) {
+            this.class = ({ [name]: class {
+                } })[name];
         }
+    }
+    addProperty(prop) {
         this.properties[prop.name] = prop;
         this.propertyOrder.set(prop.name, this.props.length);
-        /* v8 ignore next */
-        if (sync) {
-            this.sync();
-        }
+        this.sync();
     }
     removeProperty(name, sync = true) {
         delete this.properties[name];
         this.propertyOrder.delete(name);
-        /* v8 ignore next */
         if (sync) {
             this.sync();
         }
@@ -74,6 +72,9 @@ export class EntityMetadata {
     set tableName(name) {
         this.collection = name;
     }
+    get uniqueName() {
+        return this.tableName + '_' + this._id;
+    }
     sync(initIndexes = false, config) {
         this.root ??= this;
         const props = Object.values(this.properties).sort((a, b) => this.propertyOrder.get(a.name) - this.propertyOrder.get(b.name));
@@ -100,7 +101,7 @@ export class EntityMetadata {
             return !prop.getter && !prop.setter && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind);
         });
         this.selfReferencing = this.relations.some(prop => {
-            return [this.className, this.root.className].includes(prop.targetMeta?.root.className ?? prop.type);
+            return this.root.uniqueName === prop.targetMeta?.root.uniqueName;
         });
         this.hasUniqueProps = this.uniques.length + this.uniqueProps.length > 0;
         this.virtual = !!this.expression;
@@ -191,4 +192,8 @@ export class EntityMetadata {
     clone() {
         return this;
     }
+    /** @ignore */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return `[${this.constructor.name}<${this.className}>]`;
+    }
 }

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

@@ -11,9 +11,8 @@ export declare class ChangeSet<T extends object> {
     getSerializedPrimaryKey(): string | null;
 }
 export interface ChangeSet<T> {
-    name: string;
-    rootName: string;
-    collection: string;
+    meta: EntityMetadata<T>;
+    rootMeta: EntityMetadata<T>;
     schema?: string;
     type: ChangeSetType;
     entity: T;

package/unit-of-work/ChangeSet.js

@@ -13,9 +13,8 @@ export class ChangeSet {
         this.type = type;
         this.payload = payload;
         this.meta = meta;
-        this.name = meta.className;
-        this.rootName = meta.root.className;
-        this.collection = meta.root.collection;
+        this.meta = meta;
+        this.rootMeta = meta.root;
         this.schema = helper(entity).__schema ?? meta.root.schema;
     }
     getPrimaryKey(object = false) {

package/unit-of-work/ChangeSetComputer.js

@@ -19,7 +19,7 @@ export class ChangeSetComputer {
         this.comparator = this.config.getComparator(this.metadata);
     }
     computeChangeSet(entity) {
-        const meta = this.metadata.get(entity.constructor.name);
+        const meta = this.metadata.get(entity.constructor);
         if (meta.readonly) {
             return null;
         }
@@ -91,7 +91,7 @@ export class ChangeSetComputer {
     computePayload(entity, ignoreUndefined = false) {
         const data = this.comparator.prepareEntity(entity);
         const wrapped = helper(entity);
-        const entityName = wrapped.__meta.className;
+        const entityName = wrapped.__meta.class;
         const originalEntityData = wrapped.__originalEntityData;
         if (!wrapped.__initialized) {
             for (const prop of wrapped.__meta.primaryKeys) {
@@ -132,7 +132,7 @@ export class ChangeSetComputer {
         const targets = Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
         targets.forEach(([target, idx]) => {
             if (!target.__helper.hasPrimaryKey()) {
-                Utils.setPayloadProperty(changeSet.payload, this.metadata.find(changeSet.name), prop, target.__helper.__identifier, idx);
+                Utils.setPayloadProperty(changeSet.payload, changeSet.meta, prop, target.__helper.__identifier, idx);
             }
         });
     }