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

package/events/EventManager.js

@@ -1,24 +1,32 @@
 import { Utils } from '../utils/Utils.js';
 import { EventType, EventTypeMap } from '../enums.js';
 export class EventManager {
-    listeners = {};
-    entities = new Map();
-    cache = new Map();
-    subscribers = [];
+    #listeners = {};
+    #entities = new Map();
+    #cache = new Map();
+    #subscribers = new Set();
     constructor(subscribers) {
-        subscribers.forEach(subscriber => this.registerSubscriber(subscriber));
+        for (const subscriber of subscribers) {
+            this.registerSubscriber(subscriber);
+        }
     }
     registerSubscriber(subscriber) {
-        this.subscribers.push(subscriber);
-        this.entities.set(subscriber, this.getSubscribedEntities(subscriber));
-        this.cache.clear();
+        if (this.#subscribers.has(subscriber)) {
+            return;
+        }
+        this.#subscribers.add(subscriber);
+        this.#entities.set(subscriber, this.getSubscribedEntities(subscriber));
+        this.#cache.clear();
         Utils.keys(EventType)
             .filter(event => event in subscriber)
             .forEach(event => {
-            this.listeners[event] ??= [];
-            this.listeners[event].push(subscriber);
+            this.#listeners[event] ??= new Set();
+            this.#listeners[event].add(subscriber);
         });
     }
+    getSubscribers() {
+        return this.#subscribers;
+    }
     dispatchEvent(event, args, meta) {
         const listeners = [];
         const entity = args.entity;
@@ -27,47 +35,50 @@ export class EventManager {
         const hooks = (meta?.hooks[event] || []);
         listeners.push(...hooks.map(hook => {
             const prototypeHook = meta?.prototype[hook];
-            const handler = typeof hook === 'function' ? hook : entity[hook] ?? prototypeHook;
+            const handler = typeof hook === 'function' ? hook : (entity[hook] ?? prototypeHook);
             return handler.bind(entity);
         }));
-        for (const listener of this.listeners[event] || []) {
-            const entities = this.entities.get(listener);
-            if (entities.length === 0 || !entity || entities.includes(entity.constructor.name)) {
+        for (const listener of this.#listeners[event] ?? new Set()) {
+            const entities = this.#entities.get(listener);
+            if (entities.size === 0 || !entity || entities.has(entity.constructor.name)) {
                 listeners.push(listener[event].bind(listener));
             }
         }
         if (event === EventType.onInit) {
-            return listeners.forEach(listener => listener(args));
+            for (const listener of listeners) {
+                void listener(args);
+            }
+            return;
         }
         return Utils.runSerial(listeners, listener => listener(args));
     }
     hasListeners(event, meta) {
         const cacheKey = meta._id + EventTypeMap[event];
-        if (this.cache.has(cacheKey)) {
-            return this.cache.get(cacheKey);
+        if (this.#cache.has(cacheKey)) {
+            return this.#cache.get(cacheKey);
         }
         const hasHooks = meta.hooks[event]?.length;
         if (hasHooks) {
-            this.cache.set(cacheKey, true);
+            this.#cache.set(cacheKey, true);
             return true;
         }
-        for (const listener of this.listeners[event] ?? []) {
-            const entities = this.entities.get(listener);
-            if (entities.length === 0 || entities.includes(meta.className)) {
-                this.cache.set(cacheKey, true);
+        for (const listener of this.#listeners[event] ?? new Set()) {
+            const entities = this.#entities.get(listener);
+            if (entities.size === 0 || entities.has(meta.className)) {
+                this.#cache.set(cacheKey, true);
                 return true;
             }
         }
-        this.cache.set(cacheKey, false);
+        this.#cache.set(cacheKey, false);
         return false;
     }
     clone() {
-        return new EventManager(this.subscribers);
+        return new EventManager(this.#subscribers);
     }
     getSubscribedEntities(listener) {
         if (!listener.getSubscribedEntities) {
-            return [];
+            return new Set();
         }
-        return listener.getSubscribedEntities().map(name => Utils.className(name));
+        return new Set(listener.getSubscribedEntities().map(name => Utils.className(name)));
     }
 }

package/events/index.d.ts

@@ -1,3 +1,3 @@
-export * from './EventSubscriber.js';
+export type * from './EventSubscriber.js';
 export * from './EventManager.js';
 export * from './TransactionEventBroadcaster.js';

package/events/index.js

@@ -1,3 +1,2 @@
-export * from './EventSubscriber.js';
 export * from './EventManager.js';
 export * from './TransactionEventBroadcaster.js';

package/exceptions.js

@@ -9,10 +9,17 @@ export class DriverException extends Error {
     errmsg;
     constructor(previous) {
         super(previous.message);
-        Object.getOwnPropertyNames(previous).forEach(k => this[k] = previous[k]);
+        Object.getOwnPropertyNames(previous).forEach(k => (this[k] = previous[k]));
         this.name = this.constructor.name;
         Error.captureStackTrace(this, this.constructor);
-        this.stack += '\n\n' + previous.stack.split('\n').filter(l => l.trim().startsWith('at ')).join('\n');
+        if (previous.stack) {
+            this.stack +=
+                '\n\n' +
+                    previous.stack
+                        .split('\n')
+                        .filter(l => l.trim().startsWith('at '))
+                        .join('\n');
+        }
     }
 }
 /**

package/hydration/Hydrator.js

@@ -1,4 +1,4 @@
-/* v8 ignore start */
+/* v8 ignore next */
 export class Hydrator {
     metadata;
     platform;
@@ -45,4 +45,3 @@ export class Hydrator {
         entity[prop.name] = data[prop.name];
     }
 }
-/* v8 ignore stop */

package/hydration/ObjectHydrator.d.ts

@@ -1,22 +1,21 @@
 import type { EntityData, EntityMetadata } from '../typings.js';
 import { Hydrator } from './Hydrator.js';
 import type { EntityFactory } from '../entity/EntityFactory.js';
-type EntityHydrator<T extends object> = (entity: T, data: EntityData<T>, factory: EntityFactory, newEntity: boolean, convertCustomTypes: boolean, schema?: string, parentSchema?: string) => void;
+type EntityHydrator<T extends object> = (entity: T, data: EntityData<T>, factory: EntityFactory, newEntity: boolean, convertCustomTypes: boolean, schema?: string, parentSchema?: string, normalizeAccessors?: boolean) => void;
 export declare class ObjectHydrator extends Hydrator {
-    private readonly hydrators;
-    private tmpIndex;
+    #private;
     /**
      * @inheritDoc
      */
-    hydrate<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, type: 'full' | 'reference', newEntity?: boolean, convertCustomTypes?: boolean, schema?: string, parentSchema?: string): void;
+    hydrate<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, type: 'full' | 'reference', newEntity?: boolean, convertCustomTypes?: boolean, schema?: string, parentSchema?: string, normalizeAccessors?: boolean): void;
     /**
      * @inheritDoc
      */
-    hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string, parentSchema?: string): void;
+    hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string, parentSchema?: string, normalizeAccessors?: boolean): void;
     /**
      * @internal Highly performance-sensitive method.
      */
-    getEntityHydrator<T extends object>(meta: EntityMetadata<T>, type: 'full' | 'reference'): EntityHydrator<T>;
+    getEntityHydrator<T extends object>(meta: EntityMetadata<T>, type: 'full' | 'reference', normalizeAccessors?: boolean): EntityHydrator<T>;
     private createCollectionItemMapper;
     private wrap;
     private safeKey;

package/hydration/ObjectHydrator.js

@@ -1,42 +1,47 @@
 import { Hydrator } from './Hydrator.js';
 import { Collection } from '../entity/Collection.js';
 import { Reference, ScalarReference } from '../entity/Reference.js';
+import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 import { parseJsonSafe, Utils } from '../utils/Utils.js';
 import { ReferenceKind } from '../enums.js';
-import { RawQueryFragment } from '../utils/RawQueryFragment.js';
+import { Raw } from '../utils/RawQueryFragment.js';
+import { ValidationError } from '../errors.js';
 export class ObjectHydrator extends Hydrator {
-    hydrators = {
-        full: new Map(),
-        reference: new Map(),
+    #hydrators = {
+        'full~true': new Map(),
+        'full~false': new Map(),
+        'reference~true': new Map(),
+        'reference~false': new Map(),
     };
-    tmpIndex = 0;
+    #tmpIndex = 0;
     /**
      * @inheritDoc
      */
-    hydrate(entity, meta, data, factory, type, newEntity = false, convertCustomTypes = false, schema, parentSchema) {
-        const hydrate = this.getEntityHydrator(meta, type);
+    hydrate(entity, meta, data, factory, type, newEntity = false, convertCustomTypes = false, schema, parentSchema, normalizeAccessors) {
+        const hydrate = this.getEntityHydrator(meta, type, normalizeAccessors);
         const running = this.running;
         // the running state is used to consider propagation as hydration, saving the values directly to the entity data,
         // but we don't want that for new entities, their propagation should result in entity updates when flushing
         this.running = !newEntity;
-        Utils.callCompiledFunction(hydrate, entity, data, factory, newEntity, convertCustomTypes, schema, parentSchema);
+        Utils.callCompiledFunction(hydrate, entity, data, factory, newEntity, convertCustomTypes, schema, parentSchema, normalizeAccessors);
         this.running = running;
     }
     /**
      * @inheritDoc
      */
-    hydrateReference(entity, meta, data, factory, convertCustomTypes = false, schema, parentSchema) {
-        const hydrate = this.getEntityHydrator(meta, 'reference');
+    hydrateReference(entity, meta, data, factory, convertCustomTypes = false, schema, parentSchema, normalizeAccessors) {
+        const hydrate = this.getEntityHydrator(meta, 'reference', normalizeAccessors);
         const running = this.running;
         this.running = true;
-        Utils.callCompiledFunction(hydrate, entity, data, factory, false, convertCustomTypes, schema, parentSchema);
+        Utils.callCompiledFunction(hydrate, entity, data, factory, false, convertCustomTypes, schema, parentSchema, normalizeAccessors);
         this.running = running;
     }
     /**
      * @internal Highly performance-sensitive method.
      */
-    getEntityHydrator(meta, type) {
-        const exists = this.hydrators[type].get(meta.className);
+    getEntityHydrator(meta, type, normalizeAccessors = false) {
+        const key = `${type}~${normalizeAccessors}`;
+        const exists = this.#hydrators[key].get(meta.class);
         if (exists) {
             return exists;
         }
@@ -46,22 +51,27 @@ export class ObjectHydrator extends Hydrator {
         context.set('isPrimaryKey', Utils.isPrimaryKey);
         context.set('Collection', Collection);
         context.set('Reference', Reference);
+        context.set('PolymorphicRef', PolymorphicRef);
+        context.set('ValidationError', ValidationError);
         const registerCustomType = (prop, convertorKey, method, context) => {
             context.set(`${method}_${convertorKey}`, (val) => {
-                /* v8 ignore next 3 */
-                if (RawQueryFragment.isKnownFragment(val)) {
+                /* v8 ignore next */
+                if (Raw.isKnownFragment(val)) {
                     return val;
                 }
                 return prop.customType[method](val, this.platform, { mode: 'serialization' });
             });
             return convertorKey;
         };
-        const hydrateScalar = (prop, object, path, dataKey) => {
+        const hydrateScalar = (prop, path, dataKey) => {
             const entityKey = path.map(k => this.wrap(k)).join('');
             const tz = this.platform.getTimezone();
-            const convertorKey = path.filter(k => !k.match(/\[idx_\d+]/)).map(k => this.safeKey(k)).join('_');
+            const convertorKey = path
+                .filter(k => !/\[idx_\d+]/.exec(k))
+                .map(k => this.safeKey(k))
+                .join('_');
             const ret = [];
-            const idx = this.tmpIndex++;
+            const idx = this.#tmpIndex++;
             const nullVal = this.config.get('forceUndefined') ? 'undefined' : 'null';
             if (prop.getter && !prop.setter && prop.persist === false) {
                 return [];
@@ -131,24 +141,58 @@ export class ObjectHydrator extends Hydrator {
             const nullVal = this.config.get('forceUndefined') ? 'undefined' : 'null';
             ret.push(`  if (data${dataKey} === null) {\n    entity${entityKey} = ${nullVal};`);
             ret.push(`  } else if (typeof data${dataKey} !== 'undefined') {`);
-            ret.push(`    if (isPrimaryKey(data${dataKey}, true)) {`);
-            if (prop.ref) {
-                ret.push(`      entity${entityKey} = Reference.create(factory.createReference('${prop.type}', data${dataKey}, { merge: true, convertCustomTypes, schema }));`);
+            // For polymorphic: instanceof check; for regular: isPrimaryKey() check
+            const pkCheck = prop.polymorphic
+                ? `data${dataKey} instanceof PolymorphicRef`
+                : `isPrimaryKey(data${dataKey}, true)`;
+            ret.push(`    if (${pkCheck}) {`);
+            // When targetKey is set, pass the key option to createReference so it uses the alternate key
+            const keyOption = prop.targetKey ? `, key: '${prop.targetKey}'` : '';
+            if (prop.polymorphic) {
+                // For polymorphic: target class from discriminator map, PK from data.id
+                const discriminatorMapKey = this.safeKey(`discriminatorMap_${prop.name}_${this.#tmpIndex++}`);
+                context.set(discriminatorMapKey, prop.discriminatorMap);
+                ret.push(`      const targetClass = ${discriminatorMapKey}[data${dataKey}.discriminator];`);
+                ret.push(`      if (!targetClass) throw new ValidationError(\`Unknown discriminator value '\${data${dataKey}.discriminator}' for polymorphic relation '${prop.name}'. Valid values: \${Object.keys(${discriminatorMapKey}).join(', ')}\`);`);
+                if (prop.ref) {
+                    ret.push(`      entity${entityKey} = Reference.create(factory.createReference(targetClass, data${dataKey}.id, { merge: true, convertCustomTypes, normalizeAccessors, schema${keyOption} }));`);
+                }
+                else {
+                    ret.push(`      entity${entityKey} = factory.createReference(targetClass, data${dataKey}.id, { merge: true, convertCustomTypes, normalizeAccessors, schema${keyOption} });`);
+                }
             }
             else {
-                ret.push(`      entity${entityKey} = factory.createReference('${prop.type}', data${dataKey}, { merge: true, convertCustomTypes, schema });`);
+                // For regular: fixed target class, PK is the data itself
+                const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.#tmpIndex++}`);
+                context.set(targetKey, prop.targetMeta.class);
+                if (prop.ref) {
+                    ret.push(`      entity${entityKey} = Reference.create(factory.createReference(${targetKey}, data${dataKey}, { merge: true, convertCustomTypes, normalizeAccessors, schema${keyOption} }));`);
+                }
+                else {
+                    ret.push(`      entity${entityKey} = factory.createReference(${targetKey}, data${dataKey}, { merge: true, convertCustomTypes, normalizeAccessors, schema${keyOption} });`);
+                }
             }
             ret.push(`    } else if (data${dataKey} && typeof data${dataKey} === 'object') {`);
+            // For full entity hydration, polymorphic needs to determine target class from entity itself
+            let hydrateTargetExpr;
+            if (prop.polymorphic) {
+                hydrateTargetExpr = `data${dataKey}.constructor`;
+            }
+            else {
+                const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.#tmpIndex++}`);
+                context.set(targetKey, prop.targetMeta.class);
+                hydrateTargetExpr = targetKey;
+            }
             if (prop.ref) {
-                ret.push(`      entity${entityKey} = Reference.create(factory.${method}('${prop.type}', data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, schema }));`);
+                ret.push(`      entity${entityKey} = Reference.create(factory.${method}(${hydrateTargetExpr}, data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, normalizeAccessors, schema }));`);
             }
             else {
-                ret.push(`      entity${entityKey} = factory.${method}('${prop.type}', data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, schema });`);
+                ret.push(`      entity${entityKey} = factory.${method}(${hydrateTargetExpr}, data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, normalizeAccessors, schema });`);
             }
             ret.push(`    }`);
             ret.push(`  }`);
             if (prop.kind === ReferenceKind.ONE_TO_ONE) {
-                const meta2 = this.metadata.get(prop.type);
+                const meta2 = this.metadata.get(prop.targetMeta.class);
                 const prop2 = meta2.properties[prop.inversedBy || prop.mappedBy];
                 if (prop2 && !prop2.mapToPk) {
                     ret.push(`  if (data${dataKey} && entity${entityKey} && !entity${entityKey}.${this.safeKey(prop2.name)}) {`);
@@ -166,7 +210,7 @@ export class ObjectHydrator extends Hydrator {
         };
         const hydrateToMany = (prop, dataKey, entityKey) => {
             const ret = [];
-            ret.push(...this.createCollectionItemMapper(prop));
+            ret.push(...this.createCollectionItemMapper(prop, context));
             ret.push(`  if (data${dataKey} && !Array.isArray(data${dataKey}) && typeof data${dataKey} === 'object') {`);
             ret.push(`    data${dataKey} = [data${dataKey}];`);
             ret.push(`  }`);
@@ -193,7 +237,10 @@ export class ObjectHydrator extends Hydrator {
             return ret;
         };
         const registerEmbeddedPrototype = (prop, path) => {
-            const convertorKey = path.filter(k => !k.match(/\[idx_\d+]/)).map(k => this.safeKey(k)).join('_');
+            const convertorKey = path
+                .filter(k => !/\[idx_\d+]/.exec(k))
+                .map(k => this.safeKey(k))
+                .join('_');
             if (prop.targetMeta?.polymorphs) {
                 prop.targetMeta.polymorphs.forEach(meta => {
                     context.set(`prototype_${convertorKey}_${meta.className}`, meta.prototype);
@@ -240,7 +287,7 @@ export class ObjectHydrator extends Hydrator {
             else {
                 ret.push(`    const embeddedData = {`);
                 for (const childProp of Object.values(prop.embeddedProps)) {
-                    const key = childProp.embedded[1].match(/^\w+$/) ? childProp.embedded[1] : `'${childProp.embedded[1]}'`;
+                    const key = /^\w+$/.exec(childProp.embedded[1]) ? childProp.embedded[1] : `'${childProp.embedded[1]}'`;
                     ret.push(`      ${key}: data${this.wrap(childProp.name)},`);
                 }
                 ret.push(`    };`);
@@ -249,15 +296,18 @@ export class ObjectHydrator extends Hydrator {
                 prop.targetMeta.polymorphs.forEach(childMeta => {
                     const childProp = prop.embeddedProps[prop.targetMeta.discriminatorColumn];
                     const childDataKey = prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
+                    context.set(childMeta.className, childMeta.class);
                     // weak comparison as we can have numbers that might have been converted to strings due to being object keys
                     ret.push(`    if (data${childDataKey} == '${childMeta.discriminatorValue}') {`);
                     ret.push(`      if (entity${entityKey} == null) {`);
-                    ret.push(`        entity${entityKey} = factory.createEmbeddable('${childMeta.className}', embeddedData, { newEntity, convertCustomTypes });`);
+                    ret.push(`        entity${entityKey} = factory.createEmbeddable(${childMeta.className}, embeddedData, { newEntity, convertCustomTypes, normalizeAccessors });`);
                     ret.push(`      }`);
                     meta.props
                         .filter(p => p.embedded?.[0] === prop.name)
                         .forEach(childProp => {
-                        const childDataKey = prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
+                        const childDataKey = prop.object
+                            ? dataKey + this.wrap(childProp.embedded[1])
+                            : this.wrap(childProp.name);
                         const prop2 = childMeta.properties[childProp.embedded[1]];
                         const prop3 = {
                             ...prop2,
@@ -265,22 +315,26 @@ export class ObjectHydrator extends Hydrator {
                             embedded: childProp.embedded,
                             embeddedProps: childProp.embeddedProps,
                         };
-                        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                        ret.push(...hydrateProperty(prop3, childProp.object, [...path, childProp.embedded[1]], childDataKey).map(l => '    ' + l));
+                        ret.push(
+                        // eslint-disable-next-line @typescript-eslint/no-use-before-define, no-use-before-define
+                        ...hydrateProperty(prop3, childProp.object, [...path, childProp.embedded[1]], childDataKey).map(l => '    ' + l));
                     });
                     ret.push(`    }`);
                 });
             }
             else {
+                const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.#tmpIndex++}`);
+                context.set(targetKey, prop.targetMeta.class);
                 ret.push(`    if (entity${entityKey} == null) {`);
-                ret.push(`      entity${entityKey} = factory.createEmbeddable('${prop.targetMeta.className}', embeddedData, { newEntity, convertCustomTypes });`);
+                ret.push(`      entity${entityKey} = factory.createEmbeddable(${targetKey}, embeddedData, { newEntity, convertCustomTypes, normalizeAccessors });`);
                 ret.push(`    }`);
                 meta.props
                     .filter(p => p.embedded?.[0] === prop.name)
                     .forEach(childProp => {
                     const childDataKey = prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
-                    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                    ret.push(...hydrateProperty(childProp, prop.object, [...path, childProp.embedded[1]], childDataKey).map(l => '  ' + l));
+                    ret.push(
+                    // eslint-disable-next-line @typescript-eslint/no-use-before-define, no-use-before-define
+                    ...hydrateProperty(childProp, prop.object, [...path, childProp.embedded[1]], childDataKey).map(l => '  ' + l));
                 });
             }
             /* v8 ignore next */
@@ -298,7 +352,7 @@ export class ObjectHydrator extends Hydrator {
         const hydrateEmbeddedArray = (prop, path, dataKey) => {
             const entityKey = path.map(k => this.wrap(k)).join('');
             const ret = [];
-            const idx = this.tmpIndex++;
+            const idx = this.#tmpIndex++;
             registerEmbeddedPrototype(prop, path);
             parseObjectEmbeddable(prop, dataKey, ret);
             ret.push(`  if (Array.isArray(data${dataKey})) {`);
@@ -311,7 +365,8 @@ export class ObjectHydrator extends Hydrator {
         };
         const hydrateProperty = (prop, object = prop.object, path = [prop.name], dataKey) => {
             const entityKey = path.map(k => this.wrap(k)).join('');
-            dataKey = dataKey ?? (object ? entityKey : this.wrap(prop.name));
+            dataKey =
+                dataKey ?? (object ? entityKey : this.wrap(normalizeAccessors ? (prop.accessor ?? prop.name) : prop.name));
             const ret = [];
             if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.mapToPk) {
                 ret.push(...hydrateToOne(prop, dataKey, entityKey));
@@ -330,8 +385,9 @@ export class ObjectHydrator extends Hydrator {
                     }
                 }
             }
-            else { // ReferenceKind.SCALAR
-                ret.push(...hydrateScalar(prop, object, path, dataKey));
+            else {
+                // ReferenceKind.SCALAR
+                ret.push(...hydrateScalar(prop, path, dataKey));
             }
             if (this.config.get('forceUndefined')) {
                 ret.push(`  if (data${dataKey} === null) entity${entityKey} = undefined;`);
@@ -341,15 +397,16 @@ export class ObjectHydrator extends Hydrator {
         for (const prop of props) {
             lines.push(...hydrateProperty(prop));
         }
-        const code = `// compiled hydrator for entity ${meta.className} (${type})\n`
-            + `return function(entity, data, factory, newEntity, convertCustomTypes, schema) {\n`
-            + `${lines.join('\n')}\n}`;
-        const hydrator = Utils.createFunction(context, code);
-        this.hydrators[type].set(meta.className, hydrator);
+        const code = `// compiled hydrator for entity ${meta.className} (${type + normalizeAccessors ? ' normalized' : ''})\n` +
+            `return function(entity, data, factory, newEntity, convertCustomTypes, schema, parentSchema, normalizeAccessors) {\n` +
+            `${lines.join('\n')}\n}`;
+        const fnKey = `hydrator-${meta.uniqueName}-${type}-${normalizeAccessors}`;
+        const hydrator = Utils.createFunction(context, code, this.config.get('compiledFunctions'), fnKey);
+        this.#hydrators[key].set(meta.class, hydrator);
         return hydrator;
     }
-    createCollectionItemMapper(prop) {
-        const meta = this.metadata.get(prop.type);
+    createCollectionItemMapper(prop, context) {
+        const meta = this.metadata.get(prop.targetMeta.class);
         const lines = [];
         lines.push(`  const createCollectionItem_${this.safeKey(prop.name)} = (value, entity) => {`);
         const prop2 = prop.targetMeta.properties[prop.mappedBy];
@@ -358,17 +415,19 @@ export class ObjectHydrator extends Hydrator {
             lines.push(`      value = { ...value, ['${prop2.name}']: Reference.wrapReference(entity, { ref: ${prop2.ref} }) };`);
             lines.push(`    }`);
         }
-        lines.push(`    if (isPrimaryKey(value, ${meta.compositePK})) return factory.createReference('${prop.type}', value, { convertCustomTypes, schema, merge: true });`);
+        const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.#tmpIndex++}`);
+        context.set(targetKey, prop.targetMeta.class);
+        lines.push(`    if (isPrimaryKey(value, ${meta.compositePK})) return factory.createReference(${targetKey}, value, { convertCustomTypes, schema, normalizeAccessors, merge: true });`);
         lines.push(`    if (value && value.__entity) return value;`);
-        lines.push(`    return factory.create('${prop.type}', value, { newEntity, convertCustomTypes, schema, merge: true });`);
+        lines.push(`    return factory.create(${targetKey}, value, { newEntity, convertCustomTypes, schema, normalizeAccessors, merge: true });`);
         lines.push(`  }`);
         return lines;
     }
     wrap(key) {
-        if (key.match(/^\[.*]$/)) {
+        if (/^\[.*]$/.exec(key)) {
             return key;
         }
-        return key.match(/^\w+$/) ? `.${key}` : `['${key}']`;
+        return /^\w+$/.exec(key) ? `.${key}` : `['${key}']`;
     }
     safeKey(key) {
         return key.replace(/\W/g, '_');

package/index.d.ts

@@ -2,7 +2,8 @@
  * @packageDocumentation
  * @module core
  */
-export { Constructor, ConnectionType, Dictionary, PrimaryKeyProp, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, EntityMetadata, QBFilterQuery, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, EntityRepositoryType, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, EntityClassGroup, OptionalProps, EagerProps, HiddenProps, RequiredEntityData, CheckCallback, IndexCallback, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, NoInfer, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, Config, TypeConfig, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, type RequiredNullable, type DefineConfig, type Opt, type Hidden, } from './typings.js';
+export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, EntityName, } from './typings.js';
+export type { CompiledFunctions, Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, InferEntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, EntityDTOFlat, EntityDTOProp, SerializeDTO, MigrationDiff, GenerateOptions, FilterObject, IMigrationRunner, IEntityGenerator, ISeedManager, SeederObject, IMigratorStorage, RequiredEntityData, CheckCallback, IndexCallback, FormulaCallback, FormulaTable, SchemaTable, SchemaColumns, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, MigrationInfo, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, TypeConfig, AnyString, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, RequiredNullable, DefineConfig, Opt, Hidden, EntitySchemaWithMeta, InferEntity, CheckConstraint, GeneratedColumnCallback, FilterDef, EntityCtor, Subquery, PopulateHintOptions, Prefixes, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';
@@ -22,4 +23,3 @@ export * from './types/index.js';
 export * from './naming-strategy/index.js';
 export * from './metadata/index.js';
 export * from './cache/index.js';
-export * from './decorators/index.js';

package/index.js

@@ -2,7 +2,7 @@
  * @packageDocumentation
  * @module core
  */
-export { PrimaryKeyProp, EntityMetadata, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, } from './typings.js';
+export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, EntityName, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';
@@ -22,4 +22,3 @@ export * from './types/index.js';
 export * from './naming-strategy/index.js';
 export * from './metadata/index.js';
 export * from './cache/index.js';
-export * from './decorators/index.js';

package/logging/DefaultLogger.d.ts

@@ -29,5 +29,5 @@ export declare class DefaultLogger implements Logger {
     logQuery(context: {
         query: string;
     } & LogContext): void;
-    static create(options: LoggerOptions): DefaultLogger;
+    static create(this: void, options: LoggerOptions): DefaultLogger;
 }

package/logging/DefaultLogger.js

@@ -29,9 +29,7 @@ export class DefaultLogger {
         if (context?.level === 'warning') {
             message = colors.yellow(message);
         }
-        const label = context?.label
-            ? colors.cyan(`(${context.label}) `)
-            : '';
+        const label = context?.label ? colors.cyan(`(${context.label}) `) : '';
         this.writer(colors.grey(`[${namespace}] `) + label + message);
     }
     /**
@@ -60,7 +58,8 @@ export class DefaultLogger {
         if (namespace === 'deprecated') {
             const { ignoreDeprecations = false } = this.options;
             return Array.isArray(ignoreDeprecations)
-                ? !ignoreDeprecations.includes(context?.label ?? '')
+                ? /* v8 ignore next */
+                    !ignoreDeprecations.includes(context?.label ?? '')
                 : !ignoreDeprecations;
         }
         return !!debugMode && (!Array.isArray(debugMode) || debugMode.includes(namespace));

package/logging/SimpleLogger.d.ts

@@ -14,5 +14,5 @@ export declare class SimpleLogger extends DefaultLogger {
     logQuery(context: {
         query: string;
     } & LogContext): void;
-    static create(options: LoggerOptions): SimpleLogger;
+    static create(this: void, options: LoggerOptions): SimpleLogger;
 }

package/logging/colors.d.ts

@@ -5,5 +5,5 @@ export declare const colors: {
     yellow: (text: string) => string;
     grey: (text: string) => string;
     cyan: (text: string) => string;
-    enabled: () => boolean | "" | undefined;
+    enabled: () => boolean;
 };

package/logging/colors.js

@@ -1,9 +1,7 @@
-const bool = (v) => v && ['true', 't', '1'].includes(v.toLowerCase());
-const boolIfDefined = (v) => v != null ? bool(v) : true;
-const enabled = () => !bool(process.env.NO_COLOR)
-    && !bool(process.env.MIKRO_ORM_NO_COLOR)
-    && boolIfDefined(process.env.FORCE_COLOR)
-    && boolIfDefined(process.env.MIKRO_ORM_COLORS);
+import { getEnv } from '../utils/env-vars.js';
+const bool = (k) => ['true', 't', '1'].includes(getEnv(k)?.toLowerCase() ?? '');
+const boolIfDefined = (k) => (getEnv(k) != null ? bool(k) : true);
+const enabled = () => !bool('NO_COLOR') && !bool('MIKRO_ORM_NO_COLOR') && boolIfDefined('FORCE_COLOR') && boolIfDefined('MIKRO_ORM_COLORS');
 const wrap = (fn) => (text) => enabled() ? fn(text) : text;
 /** @internal */
 export const colors = {

package/logging/index.d.ts

@@ -1,4 +1,5 @@
 export * from './colors.js';
-export * from './Logger.js';
+export type * from './Logger.js';
 export * from './DefaultLogger.js';
 export * from './SimpleLogger.js';
+export * from './inspect.js';

package/logging/index.js

@@ -1,4 +1,4 @@
 export * from './colors.js';
-export * from './Logger.js';
 export * from './DefaultLogger.js';
 export * from './SimpleLogger.js';
+export * from './inspect.js';

package/logging/inspect.d.ts

@@ -0,0 +1,2 @@
+/** @internal */
+export declare function inspect(value: unknown, options?: Record<string, any>): string;

package/logging/inspect.js

@@ -0,0 +1,11 @@
+let nodeInspect;
+/** @internal */
+export function inspect(value, options) {
+    nodeInspect ??= globalThis.process?.getBuiltinModule?.('node:util').inspect;
+    /* v8 ignore else */
+    if (nodeInspect) {
+        return nodeInspect(value, options);
+    }
+    /* v8 ignore next */
+    return JSON.stringify(value, null, 2);
+}