@mikro-orm/core 7.0.0-rc.3 → 7.0.1-dev.0

package/entity/defineEntity.d.ts

@@ -508,48 +508,35 @@ export declare class OneToManyOptionsBuilderOnlyMappedBy<Value extends object> e
 type EntityTarget = {
     '~entity': any;
 } | EntityClass;
-declare const propertyBuilders: {
-    bigint: <Mode extends "bigint" | "number" | "string" = "bigint">(mode?: Mode) => UniversalPropertyOptionsBuilder<(Mode extends "bigint" ? bigint : Mode extends "number" ? number : string) & {}, EmptyOptions, IncludeKeysForProperty>;
-    array: <T = string>(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string) => UniversalPropertyOptionsBuilder<T[], EmptyOptions, IncludeKeysForProperty>;
-    decimal: <Mode extends "number" | "string" = "string">(mode?: Mode) => UniversalPropertyOptionsBuilder<NonNullable<Mode extends "number" ? number : string>, EmptyOptions, IncludeKeysForProperty>;
+declare const propertyBuilders: PropertyBuilders;
+type PropertyBuildersOverrideKeys = 'bigint' | 'array' | 'decimal' | 'json' | 'datetime' | 'time' | 'enum';
+export type PropertyBuilders = {
+    [K in Exclude<keyof typeof types, PropertyBuildersOverrideKeys>]: () => UniversalPropertyOptionsBuilder<InferPropertyValueType<(typeof types)[K]>, EmptyOptions, IncludeKeysForProperty>;
+} & {
+    bigint: <Mode extends 'bigint' | 'number' | 'string' = 'bigint'>(mode?: Mode) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.bigint<Mode>>, EmptyOptions, IncludeKeysForProperty>;
+    array: <T = string>(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.array<T>>, EmptyOptions, IncludeKeysForProperty>;
+    decimal: <Mode extends 'number' | 'string' = 'string'>(mode?: Mode) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.decimal<Mode>>, EmptyOptions, IncludeKeysForProperty>;
     json: <T>() => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
     formula: <T>(formula: string | FormulaCallback<any>) => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
-    datetime: (length?: number) => UniversalPropertyOptionsBuilder<Date, EmptyOptions, IncludeKeysForProperty>;
-    time: (length?: number) => UniversalPropertyOptionsBuilder<any, EmptyOptions, IncludeKeysForProperty>;
+    datetime: (length?: number) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.datetime>, EmptyOptions, IncludeKeysForProperty>;
+    time: (length?: number) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.time>, EmptyOptions, IncludeKeysForProperty>;
     type: <T extends PropertyValueType>(type: T) => UniversalPropertyOptionsBuilder<InferPropertyValueType<T>, EmptyOptions, IncludeKeysForProperty>;
     enum: <const T extends (number | string)[] | (() => Dictionary)>(items?: T) => UniversalPropertyOptionsBuilder<T extends () => Dictionary ? ValueOf<ReturnType<T>> : T extends (infer Value)[] ? Value : T, EmptyOptions, IncludeKeysForEnumOptions>;
     embedded: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-        kind: "embedded";
+        kind: 'embedded';
     }>;
     manyToMany: <Target extends EntityTarget>(target: Target) => PropertyChain<InferEntity<Target>, EmptyOptions & {
-        kind: "m:n";
+        kind: 'm:n';
     }>;
     manyToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-        kind: "m:1";
+        kind: 'm:1';
     }>;
     oneToMany: <Target extends EntityTarget>(target: Target) => PropertyChain<InferEntity<Target>, EmptyOptions & {
-        kind: "1:m";
+        kind: '1:m';
     }>;
     oneToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-        kind: "1:1";
+        kind: '1:1';
     }>;
-    date: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    blob: () => UniversalPropertyOptionsBuilder<NonNullable<Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | null>, EmptyOptions, IncludeKeysForProperty>;
-    uint8array: () => UniversalPropertyOptionsBuilder<Uint8Array<ArrayBufferLike>, EmptyOptions, IncludeKeysForProperty>;
-    enumArray: () => UniversalPropertyOptionsBuilder<(string | number)[], EmptyOptions, IncludeKeysForProperty>;
-    integer: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-    smallint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-    tinyint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-    mediumint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-    float: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-    double: () => UniversalPropertyOptionsBuilder<NonNullable<string | number>, EmptyOptions, IncludeKeysForProperty>;
-    boolean: () => UniversalPropertyOptionsBuilder<NonNullable<boolean | null | undefined>, EmptyOptions, IncludeKeysForProperty>;
-    character: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    string: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    uuid: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    text: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    interval: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    unknown: () => UniversalPropertyOptionsBuilder<{}, EmptyOptions, IncludeKeysForProperty>;
 };
 /** Own keys + base entity keys (when TBase is not `never`). Guards against `keyof never = string | number | symbol`. */
 type AllKeys<TProperties, TBase> = keyof TProperties | (IsNever<TBase> extends true ? never : keyof TBase);
@@ -559,7 +546,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     extends?: {
         '~entity': TBase;
     } | EntityCtor<TBase>;
-    properties: TProperties | ((properties: typeof propertyBuilders) => TProperties);
+    properties: TProperties | ((properties: PropertyBuilders) => TProperties);
     primaryKeys?: TPK & InferPrimaryKey<TProperties>[];
     hooks?: DefineEntityHooks;
     repository?: () => TRepository;
@@ -595,53 +582,11 @@ export declare function defineEntity<const TEntity = any, const TProperties exte
     className?: TClassName;
     tableName?: TTableName;
     extends?: TBase;
-    properties: TProperties | ((properties: typeof propertyBuilders) => TProperties);
+    properties: TProperties | ((properties: PropertyBuilders) => TProperties);
     hooks?: DefineEntityHooks<TEntity>;
 }): EntitySchemaWithMeta<TClassName, TTableName, TEntity, TBase, TProperties, TClass>;
 export declare namespace defineEntity {
-    var properties: {
-        bigint: <Mode extends "bigint" | "number" | "string" = "bigint">(mode?: Mode) => UniversalPropertyOptionsBuilder<(Mode extends "bigint" ? bigint : Mode extends "number" ? number : string) & {}, EmptyOptions, IncludeKeysForProperty>;
-        array: <T = string>(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string) => UniversalPropertyOptionsBuilder<T[], EmptyOptions, IncludeKeysForProperty>;
-        decimal: <Mode extends "number" | "string" = "string">(mode?: Mode) => UniversalPropertyOptionsBuilder<NonNullable<Mode extends "number" ? number : string>, EmptyOptions, IncludeKeysForProperty>;
-        json: <T>() => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
-        formula: <T>(formula: string | FormulaCallback<any>) => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
-        datetime: (length?: number) => UniversalPropertyOptionsBuilder<Date, EmptyOptions, IncludeKeysForProperty>;
-        time: (length?: number) => UniversalPropertyOptionsBuilder<any, EmptyOptions, IncludeKeysForProperty>;
-        type: <T extends PropertyValueType>(type: T) => UniversalPropertyOptionsBuilder<InferPropertyValueType<T>, EmptyOptions, IncludeKeysForProperty>;
-        enum: <const T extends (number | string)[] | (() => Dictionary)>(items?: T) => UniversalPropertyOptionsBuilder<T extends () => Dictionary ? ValueOf<ReturnType<T>> : T extends (infer Value)[] ? Value : T, EmptyOptions, IncludeKeysForEnumOptions>;
-        embedded: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-            kind: "embedded";
-        }>;
-        manyToMany: <Target extends EntityTarget>(target: Target) => PropertyChain<InferEntity<Target>, EmptyOptions & {
-            kind: "m:n";
-        }>;
-        manyToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-            kind: "m:1";
-        }>;
-        oneToMany: <Target extends EntityTarget>(target: Target) => PropertyChain<InferEntity<Target>, EmptyOptions & {
-            kind: "1:m";
-        }>;
-        oneToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-            kind: "1:1";
-        }>;
-        date: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        blob: () => UniversalPropertyOptionsBuilder<NonNullable<Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | null>, EmptyOptions, IncludeKeysForProperty>;
-        uint8array: () => UniversalPropertyOptionsBuilder<Uint8Array<ArrayBufferLike>, EmptyOptions, IncludeKeysForProperty>;
-        enumArray: () => UniversalPropertyOptionsBuilder<(string | number)[], EmptyOptions, IncludeKeysForProperty>;
-        integer: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-        smallint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-        tinyint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-        mediumint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-        float: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-        double: () => UniversalPropertyOptionsBuilder<NonNullable<string | number>, EmptyOptions, IncludeKeysForProperty>;
-        boolean: () => UniversalPropertyOptionsBuilder<NonNullable<boolean | null | undefined>, EmptyOptions, IncludeKeysForProperty>;
-        character: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        string: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        uuid: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        text: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        interval: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        unknown: () => UniversalPropertyOptionsBuilder<{}, EmptyOptions, IncludeKeysForProperty>;
-    };
+    var properties: PropertyBuilders;
 }
 export { propertyBuilders as p };
 type EntityHookValue<T, K extends keyof EventSubscriber<T>> = (keyof T | NonNullable<EventSubscriber<T>[K]>)[];

package/enums.d.ts

@@ -45,7 +45,8 @@ export declare enum QueryOperator {
     $size = "size",// collection operators, sql only
     $hasKey = "?",// postgres only, json
     $hasKeys = "?&",// postgres only, json
-    $hasSomeKeys = "?|"
+    $hasSomeKeys = "?|",// postgres only, json
+    $elemMatch = "elemMatch"
 }
 export declare const ARRAY_OPERATORS: string[];
 export declare const JSON_KEY_OPERATORS: string[];

package/enums.js

@@ -48,6 +48,7 @@ export var QueryOperator;
     QueryOperator["$hasKey"] = "?";
     QueryOperator["$hasKeys"] = "?&";
     QueryOperator["$hasSomeKeys"] = "?|";
+    QueryOperator["$elemMatch"] = "elemMatch";
 })(QueryOperator || (QueryOperator = {}));
 export const ARRAY_OPERATORS = ['$eq', '$gt', '$gte', '$lt', '$lte', '$ne', '$overlap', '$contains', '$contained'];
 export const JSON_KEY_OPERATORS = ['$hasKey', '$hasKeys', '$hasSomeKeys'];

package/errors.d.ts

@@ -56,17 +56,17 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static duplicateFieldName(entityName: EntityName, names: [string, string][]): MetadataError;
     static multipleDecorators(entityName: string, propertyName: string): MetadataError;
     static missingMetadata(entity: string): MetadataError;
-    static invalidPrimaryKey(meta: EntityMetadata, prop: EntityProperty, requiredName: string): MetadataError<Partial<any>>;
-    static invalidManyToManyWithPivotEntity(meta1: EntityMetadata, prop1: EntityProperty, meta2: EntityMetadata, prop2: EntityProperty): MetadataError<Partial<any>>;
-    static targetIsAbstract(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
-    static nonPersistentCompositeProp(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
-    static propertyTargetsEntityType(meta: EntityMetadata, prop: EntityProperty, target: EntityMetadata): MetadataError<Partial<any>>;
-    static fromMissingOption(meta: EntityMetadata, prop: EntityProperty, option: string): MetadataError<Partial<any>>;
-    static targetKeyOnManyToMany(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
-    static targetKeyNotUnique(meta: EntityMetadata, prop: EntityProperty, target?: EntityMetadata): MetadataError<Partial<any>>;
-    static targetKeyNotFound(meta: EntityMetadata, prop: EntityProperty, target?: EntityMetadata): MetadataError<Partial<any>>;
-    static incompatiblePolymorphicTargets(meta: EntityMetadata, prop: EntityProperty, target1: EntityMetadata, target2: EntityMetadata, reason: string): MetadataError<Partial<any>>;
-    static dangerousPropertyName(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
+    static invalidPrimaryKey(meta: EntityMetadata, prop: EntityProperty, requiredName: string): MetadataError;
+    static invalidManyToManyWithPivotEntity(meta1: EntityMetadata, prop1: EntityProperty, meta2: EntityMetadata, prop2: EntityProperty): MetadataError;
+    static targetIsAbstract(meta: EntityMetadata, prop: EntityProperty): MetadataError;
+    static nonPersistentCompositeProp(meta: EntityMetadata, prop: EntityProperty): MetadataError;
+    static propertyTargetsEntityType(meta: EntityMetadata, prop: EntityProperty, target: EntityMetadata): MetadataError;
+    static fromMissingOption(meta: EntityMetadata, prop: EntityProperty, option: string): MetadataError;
+    static targetKeyOnManyToMany(meta: EntityMetadata, prop: EntityProperty): MetadataError;
+    static targetKeyNotUnique(meta: EntityMetadata, prop: EntityProperty, target?: EntityMetadata): MetadataError;
+    static targetKeyNotFound(meta: EntityMetadata, prop: EntityProperty, target?: EntityMetadata): MetadataError;
+    static incompatiblePolymorphicTargets(meta: EntityMetadata, prop: EntityProperty, target1: EntityMetadata, target2: EntityMetadata, reason: string): MetadataError;
+    static dangerousPropertyName(meta: EntityMetadata, prop: EntityProperty): MetadataError;
     static viewEntityWithoutExpression(meta: EntityMetadata): MetadataError;
     static mixedInheritanceStrategies(root: EntityMetadata, child: EntityMetadata): MetadataError;
     static tptNotSupportedByDriver(meta: EntityMetadata): MetadataError;

package/errors.js

@@ -34,19 +34,12 @@ export class ValidationError extends Error {
         return new ValidationError(`Entity ${entity.constructor.name} is not managed. An entity is managed if its fetched from the database or registered as new through EntityManager.persist()`);
     }
     static notEntity(owner, prop, data) {
-        const type = Object.prototype.toString
-            .call(data)
-            .match(/\[object (\w+)]/)[1]
-            .toLowerCase();
+        const type = /\[object (\w+)]/.exec(Object.prototype.toString.call(data))[1].toLowerCase();
         return new ValidationError(`Entity of type ${prop.type} expected for property ${owner.constructor.name}.${prop.name}, ${inspect(data)} of type ${type} given. If you are using Object.assign(entity, data), use em.assign(entity, data) instead.`);
     }
     static notDiscoveredEntity(data, meta, action = 'persist') {
         /* v8 ignore next */
-        const type = meta?.className ??
-            Object.prototype.toString
-                .call(data)
-                .match(/\[object (\w+)]/)[1]
-                .toLowerCase();
+        const type = meta?.className ?? /\[object (\w+)]/.exec(Object.prototype.toString.call(data))[1].toLowerCase();
         let err = `Trying to ${action} not discovered entity of type ${type}.`;
         if (meta) {
             err += ` Entity with this name was discovered, but not the prototype you are passing to the ORM. If using EntitySchema, be sure to point to the implementation via \`class\`.`;
@@ -63,10 +56,7 @@ export class ValidationError extends Error {
         return new ValidationError(`Invalid enum array items provided in ${entityName}: ${inspect(invalid)}`);
     }
     static invalidType(type, value, mode) {
-        const valueType = Object.prototype.toString
-            .call(value)
-            .match(/\[object (\w+)]/)[1]
-            .toLowerCase();
+        const valueType = /\[object (\w+)]/.exec(Object.prototype.toString.call(value))[1].toLowerCase();
         if (value instanceof Date) {
             value = value.toISOString();
         }

package/events/EventManager.d.ts

@@ -2,10 +2,7 @@ import type { EntityMetadata } from '../typings.js';
 import type { EventArgs, EventSubscriber, FlushEventArgs, TransactionEventArgs } from './EventSubscriber.js';
 import { EventType, type TransactionEventType } from '../enums.js';
 export declare class EventManager {
-    private readonly listeners;
-    private readonly entities;
-    private readonly cache;
-    private readonly subscribers;
+    #private;
     constructor(subscribers: Iterable<EventSubscriber>);
     registerSubscriber(subscriber: EventSubscriber): void;
     getSubscribers(): Set<EventSubscriber>;

package/events/EventManager.js

@@ -1,31 +1,31 @@
 import { Utils } from '../utils/Utils.js';
 import { EventType, EventTypeMap } from '../enums.js';
 export class EventManager {
-    listeners = {};
-    entities = new Map();
-    cache = new Map();
-    subscribers = new Set();
+    #listeners = {};
+    #entities = new Map();
+    #cache = new Map();
+    #subscribers = new Set();
     constructor(subscribers) {
         for (const subscriber of subscribers) {
             this.registerSubscriber(subscriber);
         }
     }
     registerSubscriber(subscriber) {
-        if (this.subscribers.has(subscriber)) {
+        if (this.#subscribers.has(subscriber)) {
             return;
         }
-        this.subscribers.add(subscriber);
-        this.entities.set(subscriber, this.getSubscribedEntities(subscriber));
-        this.cache.clear();
+        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] ??= new Set();
-            this.listeners[event].add(subscriber);
+            this.#listeners[event] ??= new Set();
+            this.#listeners[event].add(subscriber);
         });
     }
     getSubscribers() {
-        return this.subscribers;
+        return this.#subscribers;
     }
     dispatchEvent(event, args, meta) {
         const listeners = [];
@@ -38,39 +38,42 @@ export class EventManager {
             const handler = typeof hook === 'function' ? hook : (entity[hook] ?? prototypeHook);
             return handler.bind(entity);
         }));
-        for (const listener of this.listeners[event] ?? new Set()) {
-            const entities = this.entities.get(listener);
+        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] ?? new Set()) {
-            const entities = this.entities.get(listener);
+        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);
+                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) {

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

@@ -12,12 +12,14 @@ export class DriverException extends Error {
         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/ObjectHydrator.d.ts

@@ -3,8 +3,7 @@ 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, normalizeAccessors?: boolean) => void;
 export declare class ObjectHydrator extends Hydrator {
-    private readonly hydrators;
-    private tmpIndex;
+    #private;
     /**
      * @inheritDoc
      */

package/hydration/ObjectHydrator.js

@@ -7,13 +7,13 @@ import { ReferenceKind } from '../enums.js';
 import { Raw } from '../utils/RawQueryFragment.js';
 import { ValidationError } from '../errors.js';
 export class ObjectHydrator extends Hydrator {
-    hydrators = {
+    #hydrators = {
         'full~true': new Map(),
         'full~false': new Map(),
         'reference~true': new Map(),
         'reference~false': new Map(),
     };
-    tmpIndex = 0;
+    #tmpIndex = 0;
     /**
      * @inheritDoc
      */
@@ -41,7 +41,7 @@ export class ObjectHydrator extends Hydrator {
      */
     getEntityHydrator(meta, type, normalizeAccessors = false) {
         const key = `${type}~${normalizeAccessors}`;
-        const exists = this.hydrators[key].get(meta.class);
+        const exists = this.#hydrators[key].get(meta.class);
         if (exists) {
             return exists;
         }
@@ -67,11 +67,11 @@ export class ObjectHydrator extends Hydrator {
             const entityKey = path.map(k => this.wrap(k)).join('');
             const tz = this.platform.getTimezone();
             const convertorKey = path
-                .filter(k => !k.match(/\[idx_\d+]/))
+                .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 [];
@@ -150,7 +150,7 @@ export class ObjectHydrator extends Hydrator {
             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++}`);
+                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(', ')}\`);`);
@@ -163,7 +163,7 @@ export class ObjectHydrator extends Hydrator {
             }
             else {
                 // For regular: fixed target class, PK is the data itself
-                const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.tmpIndex++}`);
+                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} }));`);
@@ -179,7 +179,7 @@ export class ObjectHydrator extends Hydrator {
                 hydrateTargetExpr = `data${dataKey}.constructor`;
             }
             else {
-                const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.tmpIndex++}`);
+                const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.#tmpIndex++}`);
                 context.set(targetKey, prop.targetMeta.class);
                 hydrateTargetExpr = targetKey;
             }
@@ -238,7 +238,7 @@ export class ObjectHydrator extends Hydrator {
         };
         const registerEmbeddedPrototype = (prop, path) => {
             const convertorKey = path
-                .filter(k => !k.match(/\[idx_\d+]/))
+                .filter(k => !/\[idx_\d+]/.exec(k))
                 .map(k => this.safeKey(k))
                 .join('_');
             if (prop.targetMeta?.polymorphs) {
@@ -287,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(`    };`);
@@ -323,7 +323,7 @@ export class ObjectHydrator extends Hydrator {
                 });
             }
             else {
-                const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.tmpIndex++}`);
+                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(${targetKey}, embeddedData, { newEntity, convertCustomTypes, normalizeAccessors });`);
@@ -352,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})) {`);
@@ -402,7 +402,7 @@ export class ObjectHydrator extends Hydrator {
             `${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);
+        this.#hydrators[key].set(meta.class, hydrator);
         return hydrator;
     }
     createCollectionItemMapper(prop, context) {
@@ -415,7 +415,7 @@ export class ObjectHydrator extends Hydrator {
             lines.push(`      value = { ...value, ['${prop2.name}']: Reference.wrapReference(entity, { ref: ${prop2.ref} }) };`);
             lines.push(`    }`);
         }
-        const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.tmpIndex++}`);
+        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;`);
@@ -424,10 +424,10 @@ export class ObjectHydrator extends Hydrator {
         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/logging/DefaultLogger.js

@@ -68,7 +68,8 @@ export class DefaultLogger {
      * @inheritDoc
      */
     logQuery(context) {
-        if (!this.isEnabled('query', context)) {
+        const namespace = context.namespace ?? 'query';
+        if (!this.isEnabled(namespace, context)) {
             return;
         }
         /* v8 ignore next */
@@ -86,7 +87,7 @@ export class DefaultLogger {
         if (this.usesReplicas && context.connection) {
             msg += colors.cyan(` (via ${context.connection.type} connection '${context.connection.name}')`);
         }
-        return this.log('query', msg, context);
+        return this.log(namespace, msg, context);
     }
     static create(options) {
         return new DefaultLogger(options);

package/logging/Logger.d.ts

@@ -22,10 +22,11 @@ export interface Logger {
     setDebugMode(debugMode: boolean | LoggerNamespace[]): void;
     isEnabled(namespace: LoggerNamespace, context?: LogContext): boolean;
 }
-export type LoggerNamespace = 'query' | 'query-params' | 'schema' | 'discovery' | 'info' | 'deprecated';
+export type LoggerNamespace = 'query' | 'query-params' | 'schema' | 'discovery' | 'info' | 'deprecated' | 'slow-query';
 export interface LogContext extends Dictionary {
     query?: string;
     label?: string;
+    namespace?: LoggerNamespace;
     params?: readonly unknown[];
     took?: number;
     results?: number;

package/logging/colors.js

@@ -2,7 +2,7 @@ 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);
+const wrap = (fn) => (text) => enabled() ? fn(text) : text;
 /** @internal */
 export const colors = {
     red: wrap((text) => `\x1B[31m${text}\x1B[39m`),

package/logging/index.d.ts

@@ -1,5 +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,5 +1,4 @@
 export * from './colors.js';
-export * from './Logger.js';
 export * from './DefaultLogger.js';
 export * from './SimpleLogger.js';
 export * from './inspect.js';

package/metadata/EntitySchema.d.ts

@@ -47,7 +47,7 @@ export declare class EntitySchema<Entity = any, Base = never, Class extends Enti
      * When schema links the entity class via `class` option, this registry allows the lookup from opposite side,
      * so we can use the class in `entities` option just like the EntitySchema instance.
      */
-    static REGISTRY: Map<Partial<any>, EntitySchema<any, never, EntityCtor<any>>>;
+    static REGISTRY: Map<AnyEntity, EntitySchema>;
     /** @internal Type-level marker for fast entity type inference */
     readonly '~entity': Entity;
     private readonly _meta;

package/metadata/MetadataDiscovery.d.ts

@@ -4,15 +4,7 @@ import { MetadataStorage } from './MetadataStorage.js';
 import { EntitySchema } from './EntitySchema.js';
 import type { Platform } from '../platforms/Platform.js';
 export declare class MetadataDiscovery {
-    private readonly metadata;
-    private readonly platform;
-    private readonly config;
-    private readonly namingStrategy;
-    private readonly metadataProvider;
-    private readonly logger;
-    private readonly schemaHelper;
-    private readonly validator;
-    private readonly discovered;
+    #private;
     constructor(metadata: MetadataStorage, platform: Platform, config: Configuration);
     discover(preferTs?: boolean): Promise<MetadataStorage>;
     discoverSync(): MetadataStorage;