@mikro-orm/core 7.0.0-dev.33 → 7.0.0-dev.331

package/entity/EntityRepository.d.ts

@@ -2,7 +2,7 @@ import type { PopulatePath } from '../enums.js';
 import type { CreateOptions, EntityManager, MergeOptions } from '../EntityManager.js';
 import type { AssignOptions } from './EntityAssigner.js';
 import type { EntityData, EntityName, Primary, Loaded, FilterQuery, EntityDictionary, AutoPath, RequiredEntityData, Ref, EntityType, EntityDTO, MergeSelected, FromEntityType, IsSubset, MergeLoaded, ArrayElement } from '../typings.js';
-import type { CountOptions, DeleteOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, NativeInsertUpdateOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from '../drivers/IDatabaseDriver.js';
+import type { CountOptions, DeleteOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, NativeInsertUpdateOptions, StreamOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from '../drivers/IDatabaseDriver.js';
 import type { EntityLoaderOptions } from './EntityLoader.js';
 import type { Cursor } from '../utils/Cursor.js';
 export declare class EntityRepository<Entity extends object> {
@@ -80,11 +80,15 @@ export declare class EntityRepository<Entity extends object> {
     /**
      * @inheritDoc EntityManager.findByCursor
      */
-    findByCursor<Hint extends string = never, Fields extends string = '*', Excludes extends string = never, IncludeCount extends boolean = true>(where: FilterQuery<Entity>, options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>): Promise<Cursor<Entity, Hint, Fields, Excludes, IncludeCount>>;
+    findByCursor<Hint extends string = never, Fields extends string = '*', Excludes extends string = never, IncludeCount extends boolean = true>(options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>): Promise<Cursor<Entity, Hint, Fields, Excludes, IncludeCount>>;
     /**
      * Finds all entities of given type. You can pass additional options via the `options` parameter.
      */
     findAll<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: FindAllOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
+    /**
+     * @inheritDoc EntityManager.stream
+     */
+    stream<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: StreamOptions<Entity, Hint, Fields, Excludes>): AsyncIterableIterator<Loaded<Entity, Hint, Fields, Excludes>>;
     /**
      * @inheritDoc EntityManager.insert
      */
@@ -107,10 +111,26 @@ export declare class EntityRepository<Entity extends object> {
     map(result: EntityDictionary<Entity>, options?: {
         schema?: string;
     }): Entity;
+    /**
+     * Gets a reference to the entity identified by the given type and alternate key property without actually loading it.
+     * The key option specifies which property to use for identity map lookup instead of the primary key.
+     */
+    getReference<K extends string & keyof Entity>(id: Entity[K], options: Omit<GetReferenceOptions, 'key' | 'wrapped'> & {
+        key: K;
+        wrapped: true;
+    }): Ref<Entity>;
+    /**
+     * Gets a reference to the entity identified by the given type and alternate key property without actually loading it.
+     * The key option specifies which property to use for identity map lookup instead of the primary key.
+     */
+    getReference<K extends string & keyof Entity>(id: Entity[K], options: Omit<GetReferenceOptions, 'key'> & {
+        key: K;
+        wrapped?: false;
+    }): Entity;
     /**
      * Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
      */
-    getReference(id: Primary<Entity>, options: Omit<GetReferenceOptions, 'wrapped'> & {
+    getReference(id: Primary<Entity>, options: Omit<GetReferenceOptions, 'wrapped' | 'key'> & {
         wrapped: true;
     }): Ref<Entity>;
     /**
@@ -120,7 +140,7 @@ export declare class EntityRepository<Entity extends object> {
     /**
      * Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
      */
-    getReference(id: Primary<Entity>, options: Omit<GetReferenceOptions, 'wrapped'> & {
+    getReference(id: Primary<Entity>, options: Omit<GetReferenceOptions, 'wrapped' | 'key'> & {
         wrapped: false;
     }): Entity;
     /**
@@ -130,7 +150,7 @@ export declare class EntityRepository<Entity extends object> {
     /**
      * Loads specified relations in batch. This will execute one query for each relation, that will populate it on all the specified entities.
      */
-    populate<Ent extends Entity | Entity[], Hint extends string = never, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Fields extends string = '*', Excludes extends string = never>(entities: Ent, populate: AutoPath<Naked, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Naked, Fields, Excludes>): Promise<Ent extends object[] ? MergeLoaded<ArrayElement<Ent>, Naked, Hint, Fields, Excludes>[] : MergeLoaded<Ent, Naked, Hint, Fields, Excludes>>;
+    populate<Ent extends Entity | Entity[], Hint extends string = never, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Fields extends string = never, Excludes extends string = never>(entities: Ent, populate: AutoPath<Naked, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Naked, Fields, Excludes>): Promise<Ent extends object[] ? MergeLoaded<ArrayElement<Ent>, Naked, Hint, Fields, Excludes>[] : MergeLoaded<Ent, Naked, Hint, Fields, Excludes>>;
     /**
      * Creates new instance of given entity and populates it with given data.
      * The entity constructor will be used unless you provide `{ managed: true }` in the `options` parameter.
@@ -146,13 +166,13 @@ export declare class EntityRepository<Entity extends object> {
      * The newly created entity will be automatically marked for persistence via `em.persist` unless you disable this
      * behavior, either locally via `persist: false` option, or globally via `persistOnCreate` ORM config option.
      */
-    create<Convert extends boolean = false>(data: RequiredEntityData<Entity, never, Convert>, options?: CreateOptions<Convert>): Entity;
+    create<Convert extends boolean = false, Data extends RequiredEntityData<Entity, never, Convert> = RequiredEntityData<Entity, never, Convert>>(data: Data & IsSubset<RequiredEntityData<Entity, never, Convert>, Data>, options?: CreateOptions<Convert>): Entity;
     /**
      * Creates new instance of given entity and populates it with given data.
      * The entity constructor will be used unless you provide `{ managed: true }` in the `options` parameter.
      * The constructor will be given parameters based on the defined constructor of the entity. If the constructor
      * parameter matches a property name, its value will be extracted from `data`. If no matching property exists,
-     * the whole `data` parameter will be passed. This means we can also define `constructor(data: Partial<T>)` and
+     * the whole `data` parameter will be pass. This means we can also define `constructor(data: Partial<T>)` and
      * `em.create()` will pass the data into it (unless we have a property named `data` too).
      *
      * The parameters are strictly checked, you need to provide all required properties. You can use `OptionalProps`
@@ -162,7 +182,7 @@ export declare class EntityRepository<Entity extends object> {
      * The newly created entity will be automatically marked for persistence via `em.persist` unless you disable this
      * behavior, either locally via `persist: false` option, or globally via `persistOnCreate` ORM config option.
      */
-    create<Convert extends boolean = false>(data: EntityData<Entity, Convert>, options: CreateOptions<Convert> & {
+    create<Convert extends boolean = false, Data extends EntityData<Entity, Convert> = EntityData<Entity, Convert>>(data: Data & IsSubset<EntityData<Entity, Convert>, Data>, options: CreateOptions<Convert> & {
         partial: true;
     }): Entity;
     /**

package/entity/EntityRepository.js

@@ -90,8 +90,8 @@ export class EntityRepository {
     /**
      * @inheritDoc EntityManager.findByCursor
      */
-    async findByCursor(where, options) {
-        return this.getEntityManager().findByCursor(this.entityName, where, options);
+    async findByCursor(options) {
+        return this.getEntityManager().findByCursor(this.entityName, options);
     }
     /**
      * Finds all entities of given type. You can pass additional options via the `options` parameter.
@@ -99,6 +99,12 @@ export class EntityRepository {
     async findAll(options) {
         return this.getEntityManager().findAll(this.entityName, options);
     }
+    /**
+     * @inheritDoc EntityManager.stream
+     */
+    async *stream(options) {
+        yield* this.getEntityManager().stream(this.entityName, options);
+    }
     /**
      * @inheritDoc EntityManager.insert
      */

package/entity/PolymorphicRef.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Wrapper class for polymorphic relation reference data.
+ * Holds the discriminator value (type identifier) and the primary key value(s).
+ * Used internally to track polymorphic FK values before hydration.
+ */
+export declare class PolymorphicRef {
+    readonly discriminator: string;
+    id: unknown;
+    constructor(discriminator: string, id: unknown);
+    /** Returns `[discriminator, ...idValues]` tuple suitable for column-level expansion. */
+    toTuple(): unknown[];
+}

package/entity/PolymorphicRef.js

@@ -0,0 +1,18 @@
+import { Utils } from '../utils/Utils.js';
+/**
+ * Wrapper class for polymorphic relation reference data.
+ * Holds the discriminator value (type identifier) and the primary key value(s).
+ * Used internally to track polymorphic FK values before hydration.
+ */
+export class PolymorphicRef {
+    discriminator;
+    id;
+    constructor(discriminator, id) {
+        this.discriminator = discriminator;
+        this.id = id;
+    }
+    /** Returns `[discriminator, ...idValues]` tuple suitable for column-level expansion. */
+    toTuple() {
+        return [this.discriminator, ...Utils.asArray(this.id)];
+    }
+}

package/entity/Reference.d.ts

@@ -1,8 +1,8 @@
-import { inspect } from 'node:util';
 import type { AddEager, AddOptional, Dictionary, EntityClass, EntityKey, EntityProperty, Loaded, LoadedReference, Primary, Ref } from '../typings.js';
 import type { FindOneOptions, FindOneOrFailOptions } from '../drivers/IDatabaseDriver.js';
 export declare class Reference<T extends object> {
     private entity;
+    private property?;
     constructor(entity: T);
     static create<T extends object>(entity: T | Ref<T>): Ref<T>;
     static createFromPK<T extends object>(entityType: EntityClass<T>, pk: Primary<T>, options?: {
@@ -42,14 +42,11 @@ export declare class Reference<T extends object> {
     isInitialized(): boolean;
     populated(populated?: boolean): void;
     toJSON(...args: any[]): Dictionary;
-    /** @ignore */
-    [inspect.custom](depth?: number): string;
 }
 export declare class ScalarReference<Value> {
+    #private;
     private value?;
-    private initialized;
     private entity?;
-    private property?;
     constructor(value?: Value | undefined, initialized?: boolean);
     /**
      * Ensures the underlying entity is loaded first (without reloading it if it already is loaded).
@@ -65,8 +62,6 @@ export declare class ScalarReference<Value> {
     bind<Entity extends object>(entity: Entity, property: EntityKey<Entity>): void;
     unwrap(): Value | undefined;
     isInitialized(): boolean;
-    /** @ignore */
-    [inspect.custom](): string;
 }
 export interface LoadReferenceOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends FindOneOptions<T, P, F, E> {
     dataloader?: boolean;
@@ -77,7 +72,7 @@ export interface LoadReferenceOrFailOptions<T extends object, P extends string =
 /**
  * shortcut for `wrap(entity).toReference()`
  */
-export declare function ref<I extends unknown | Ref<unknown> | undefined | null, T extends I & {}>(entity: I): Ref<T> & LoadedReference<Loaded<T, AddEager<T>>> | AddOptional<typeof entity>;
+export declare function ref<I extends unknown | Ref<unknown> | undefined | null, T extends I & {}>(entity: I): (Ref<T> & LoadedReference<Loaded<T, AddEager<T>>>) | AddOptional<typeof entity>;
 /**
  * shortcut for `Reference.createFromPK(entityType, pk)`
  */

package/entity/Reference.js

@@ -1,10 +1,12 @@
-import { inspect } from 'node:util';
 import { DataloaderType } from '../enums.js';
 import { helper, wrap } from './wrap.js';
 import { Utils } from '../utils/Utils.js';
+import { QueryHelper } from '../utils/QueryHelper.js';
 import { NotFoundError } from '../errors.js';
+import { inspect } from '../logging/inspect.js';
 export class Reference {
     entity;
+    property;
     constructor(entity) {
         this.entity = entity;
         this.set(entity);
@@ -64,7 +66,9 @@ export class Reference {
      */
     static wrapReference(entity, prop) {
         if (entity && prop.ref && !Reference.isReference(entity)) {
-            return Reference.create(entity);
+            const ref = Reference.create(entity);
+            ref.property = prop;
+            return ref;
         }
         return entity;
     }
@@ -84,13 +88,15 @@ export class Reference {
         if (!wrapped.__em) {
             return this.entity;
         }
+        options = { ...options, filters: QueryHelper.mergePropertyFilters(this.property?.filters, options.filters) };
         if (this.isInitialized() && !options.refresh && options.populate) {
             await wrapped.__em.populate(this.entity, options.populate, options);
         }
         if (!this.isInitialized() || options.refresh) {
-            if (options.dataloader ?? [DataloaderType.ALL, DataloaderType.REFERENCE].includes(wrapped.__em.config.getDataloaderType())) {
-                // eslint-disable-next-line dot-notation
-                return wrapped.__em['refLoader'].load([this, options]);
+            if (options.dataloader ??
+                [DataloaderType.ALL, DataloaderType.REFERENCE].includes(wrapped.__em.config.getDataloaderType())) {
+                const dataLoader = await wrapped.__em.getDataLoader('ref');
+                return dataLoader.load([this, options]);
             }
             return wrapped.init(options);
         }
@@ -141,9 +147,9 @@ export class Reference {
         return wrap(this.entity).toJSON(...args);
     }
     /** @ignore */
-    [inspect.custom](depth = 2) {
+    [Symbol.for('nodejs.util.inspect.custom')](depth = 2) {
         const object = { ...this };
-        const hidden = ['meta'];
+        const hidden = ['meta', 'property'];
         hidden.forEach(k => delete object[k]);
         const ret = inspect(object, { depth });
         const wrapped = helper(this.entity);
@@ -156,12 +162,12 @@ export class Reference {
 }
 export class ScalarReference {
     value;
-    initialized;
     entity;
-    property;
+    #property;
+    #initialized;
     constructor(value, initialized = value != null) {
         this.value = value;
-        this.initialized = initialized;
+        this.#initialized = initialized;
     }
     /**
      * Ensures the underlying entity is loaded first (without reloading it if it already is loaded).
@@ -169,11 +175,11 @@ export class ScalarReference {
      */
     async load(options) {
         const opts = typeof options === 'object' ? options : { prop: options };
-        if (!this.initialized || opts.refresh) {
-            if (this.entity == null || this.property == null) {
+        if (!this.#initialized || opts.refresh) {
+            if (this.entity == null || this.#property == null) {
                 throw new Error('Cannot load scalar reference that is not bound to an entity property.');
             }
-            await helper(this.entity).populate([this.property], opts);
+            await helper(this.entity).populate([this.#property], opts);
         }
         return this.value;
     }
@@ -183,48 +189,75 @@ export class ScalarReference {
      */
     async loadOrFail(options = {}) {
         const ret = await this.load(options);
-        if (!ret) {
+        if (ret == null) {
             const wrapped = helper(this.entity);
             options.failHandler ??= wrapped.__em.config.get('findOneOrFailHandler');
             const entityName = this.entity.constructor.name;
-            const where = wrapped.getPrimaryKey();
-            throw new NotFoundError(`${entityName} (${where}) failed to load property '${this.property}'`);
+            throw NotFoundError.failedToLoadProperty(entityName, this.#property, wrapped.getPrimaryKey());
         }
         return ret;
     }
     set(value) {
         this.value = value;
-        this.initialized = true;
+        this.#initialized = true;
     }
     bind(entity, property) {
         this.entity = entity;
-        this.property = property;
+        this.#property = property;
         Object.defineProperty(this, 'entity', { enumerable: false, value: entity });
     }
     unwrap() {
         return this.value;
     }
     isInitialized() {
-        return this.initialized;
+        return this.#initialized;
     }
-    /* v8 ignore next 4 */
     /** @ignore */
-    [inspect.custom]() {
-        return this.initialized ? `Ref<${inspect(this.value)}>` : `Ref<?>`;
+    /* v8 ignore next */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.#initialized ? `Ref<${inspect(this.value)}>` : `Ref<?>`;
     }
 }
 Object.defineProperties(Reference.prototype, {
     __reference: { value: true, enumerable: false },
-    __meta: { get() { return this.entity.__meta; } },
-    __platform: { get() { return this.entity.__platform; } },
-    __helper: { get() { return this.entity.__helper; } },
-    $: { get() { return this.entity; } },
-    get: { get() { return () => this.entity; } },
+    __meta: {
+        get() {
+            return this.entity.__meta;
+        },
+    },
+    __platform: {
+        get() {
+            return this.entity.__platform;
+        },
+    },
+    __helper: {
+        get() {
+            return this.entity.__helper;
+        },
+    },
+    $: {
+        get() {
+            return this.entity;
+        },
+    },
+    get: {
+        get() {
+            return () => this.entity;
+        },
+    },
 });
 Object.defineProperties(ScalarReference.prototype, {
     __scalarReference: { value: true, enumerable: false },
-    $: { get() { return this.value; } },
-    get: { get() { return () => this.value; } },
+    $: {
+        get() {
+            return this.value;
+        },
+    },
+    get: {
+        get() {
+            return () => this.value;
+        },
+    },
 });
 /**
  * shortcut for `wrap(entity).toReference()`

package/entity/WrappedEntity.d.ts

@@ -1,7 +1,6 @@
 import type { PopulatePath } from '../enums.js';
-import { inspect } from 'node:util';
 import type { EntityManager } from '../EntityManager.js';
-import type { Dictionary, EntityData, EntityDictionary, EntityMetadata, IHydrator, EntityKey, PopulateOptions, Primary, AutoPath, Ref, AddEager, LoadedReference, EntityDTO, Loaded, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
+import type { Dictionary, EntityData, EntityDictionary, EntityMetadata, IHydrator, EntityKey, PopulateOptions, Primary, AutoPath, Ref, AddEager, LoadedReference, EntityDTO, Loaded, SerializeDTO, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
 import { Reference } from './Reference.js';
 import { type AssignOptions } from './EntityAssigner.js';
 import type { EntityLoaderOptions } from './EntityLoader.js';
@@ -9,9 +8,10 @@ import type { EntityIdentifier } from './EntityIdentifier.js';
 import type { SerializationContext } from '../serialization/SerializationContext.js';
 import { type SerializeOptions } from '../serialization/EntitySerializer.js';
 import type { FindOneOptions, LoadHint } from '../drivers/IDatabaseDriver.js';
+import type { Platform } from '../platforms/Platform.js';
+import type { Configuration } from '../utils/Configuration.js';
 export declare class WrappedEntity<Entity extends object> {
     __initialized: boolean;
-    __touched: boolean;
     __populated?: boolean;
     __managed?: boolean;
     __onLoadFired?: boolean;
@@ -41,18 +41,17 @@ export declare class WrappedEntity<Entity extends object> {
     private readonly pkGetterConverted?;
     constructor(entity: Entity, hydrator: IHydrator, pkGetter?: (e: Entity) => Primary<Entity>, pkSerializer?: (e: Entity) => string, pkGetterConverted?: (e: Entity) => Primary<Entity>);
     isInitialized(): boolean;
-    isTouched(): boolean;
     isManaged(): boolean;
     populated(populated?: boolean | undefined): void;
     setSerializationContext<Hint extends string = never, Fields extends string = '*', Exclude extends string = never>(options: LoadHint<Entity, Hint, Fields, Exclude>): void;
     toReference(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
     toObject<Ignored extends EntityKey<Entity> = never>(ignoreFields?: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
-    serialize<Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Entity, Hint, Exclude>): EntityDTO<Loaded<Entity, Hint>>;
+    serialize<Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Entity, Hint, Exclude>): SerializeDTO<Entity, Hint, Exclude>;
     toPOJO(): EntityDTO<Entity>;
     toJSON(...args: any[]): EntityDictionary<Entity>;
     assign<Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(data: Data & IsSubset<EntityData<Naked>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
     init<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
-    populate<Hint extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
+    populate<Hint extends string = never, Fields extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity, Fields>): Promise<Loaded<Entity, Hint>>;
     hasPrimaryKey(): boolean;
     getPrimaryKey(convertCustomTypes?: boolean): Primary<Entity> | null;
     getPrimaryKeys(convertCustomTypes?: boolean): Primary<Entity>[] | null;
@@ -61,9 +60,7 @@ export declare class WrappedEntity<Entity extends object> {
     setPrimaryKey(id: Primary<Entity> | null): void;
     getSerializedPrimaryKey(): string;
     get __meta(): EntityMetadata<Entity>;
-    get __platform(): import("../index.js").Platform;
-    get __config(): import("../index.js").Configuration<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("../index.js").Connection>, EntityManager<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("../index.js").Connection>>>;
+    get __platform(): Platform;
+    get __config(): Configuration;
     get __primaryKeys(): Primary<Entity>[];
-    /** @ignore */
-    [inspect.custom](): string;
 }

package/entity/WrappedEntity.js

@@ -1,4 +1,3 @@
-import { inspect } from 'node:util';
 import { Reference } from './Reference.js';
 import { EntityTransformer } from '../serialization/EntityTransformer.js';
 import { EntityAssigner } from './EntityAssigner.js';
@@ -15,7 +14,6 @@ export class WrappedEntity {
         this.pkSerializer = pkSerializer;
         this.pkGetterConverted = pkGetterConverted;
         this.__initialized = true;
-        this.__touched = false;
         this.__serializationContext = {};
         this.__loadedProperties = new Set();
         this.__data = {};
@@ -24,9 +22,6 @@ export class WrappedEntity {
     isInitialized() {
         return this.__initialized;
     }
-    isTouched() {
-        return this.__touched;
-    }
     isManaged() {
         return !!this.__managed;
     }
@@ -76,7 +71,11 @@ export class WrappedEntity {
         if (!this.__em) {
             throw ValidationError.entityNotManaged(this.entity);
         }
-        return this.__em.findOne(this.entity.constructor.name, this.entity, { ...options, refresh: true, schema: this.__schema });
+        return this.__em.findOne(this.entity.constructor, this.entity, {
+            ...options,
+            refresh: true,
+            schema: this.__schema,
+        });
     }
     async populate(populate, options = {}) {
         if (!this.__em) {
@@ -153,7 +152,7 @@ export class WrappedEntity {
         return Utils.getPrimaryKeyValues(this.entity, this.__meta);
     }
     /** @ignore */
-    [inspect.custom]() {
+    [Symbol.for('nodejs.util.inspect.custom')]() {
         return `[WrappedEntity<${this.__meta.className}>]`;
     }
 }