@mikro-orm/core 7.0.0-dev.32 → 7.0.0-dev.321

package/entity/index.d.ts

@@ -1,15 +1,15 @@
 export * from './EntityRepository.js';
 export * from './EntityIdentifier.js';
-export * from './EntityValidator.js';
+export * from './PolymorphicRef.js';
 export * from './EntityAssigner.js';
 export * from './EntityHelper.js';
 export * from './EntityFactory.js';
-export * from './ArrayCollection.js';
 export * from './Collection.js';
 export * from './EntityLoader.js';
 export * from './Reference.js';
 export * from './BaseEntity.js';
 export * from './WrappedEntity.js';
+export * from './validators.js';
 export * from './wrap.js';
 export * from './defineEntity.js';
 export * from './utils.js';

package/entity/index.js

@@ -1,15 +1,15 @@
 export * from './EntityRepository.js';
 export * from './EntityIdentifier.js';
-export * from './EntityValidator.js';
+export * from './PolymorphicRef.js';
 export * from './EntityAssigner.js';
 export * from './EntityHelper.js';
 export * from './EntityFactory.js';
-export * from './ArrayCollection.js';
 export * from './Collection.js';
 export * from './EntityLoader.js';
 export * from './Reference.js';
 export * from './BaseEntity.js';
 export * from './WrappedEntity.js';
+export * from './validators.js';
 export * from './wrap.js';
 export * from './defineEntity.js';
 export * from './utils.js';

package/entity/utils.d.ts

@@ -1,4 +1,4 @@
-import type { EntityMetadata, PopulateOptions } from '../typings.js';
+import type { EntityMetadata, PopulateHintOptions, PopulateOptions } from '../typings.js';
 import { LoadStrategy, ReferenceKind } from '../enums.js';
 /**
  * @internal
@@ -10,3 +10,8 @@ export declare function expandDotPaths<Entity>(meta: EntityMetadata<Entity>, pop
  * @internal
  */
 export declare function getLoadingStrategy(strategy: LoadStrategy | `${LoadStrategy}`, kind: ReferenceKind): LoadStrategy.SELECT_IN | LoadStrategy.JOINED;
+/**
+ * Applies per-relation overrides from `populateHints` to the normalized populate tree.
+ * @internal
+ */
+export declare function applyPopulateHints<Entity>(populate: PopulateOptions<Entity>[], hints: Record<string, PopulateHintOptions>): void;

package/entity/utils.js

@@ -17,15 +17,17 @@ function expandNestedPopulate(parentProp, parts, strategy, all) {
  * @internal
  */
 export function expandDotPaths(meta, populate, normalized = false) {
-    const ret = normalized ? populate : Utils.asArray(populate).map(field => {
-        if (typeof field === 'string') {
-            return { field };
-        }
-        /* v8 ignore next 3 */
-        return typeof field === 'boolean' || field.field === PopulatePath.ALL
-            ? { all: !!field, field: meta.primaryKeys[0] }
-            : field;
-    });
+    const ret = normalized
+        ? populate
+        : Utils.asArray(populate).map(field => {
+            if (typeof field === 'string') {
+                return { field };
+            }
+            /* v8 ignore next */
+            return typeof field === 'boolean' || field.field === PopulatePath.ALL
+                ? { all: !!field, field: meta.primaryKeys[0] }
+                : field;
+        });
     for (const p of ret) {
         if (!p.field.includes('.')) {
             continue;
@@ -35,8 +37,8 @@ export function expandDotPaths(meta, populate, normalized = false) {
         p.children ??= [];
         const prop = meta.properties[p.field];
         if (parts[0] === PopulatePath.ALL) {
-            prop.targetMeta.props
-                .filter(prop => prop.lazy || prop.kind !== ReferenceKind.SCALAR)
+            prop
+                .targetMeta.props.filter(prop => prop.lazy || prop.kind !== ReferenceKind.SCALAR)
                 .forEach(prop => p.children.push({ field: prop.name, strategy: p.strategy }));
         }
         else if (prop.kind === ReferenceKind.EMBEDDED) {
@@ -67,3 +69,36 @@ export function getLoadingStrategy(strategy, kind) {
     }
     return strategy;
 }
+function findPopulateEntry(populate, parts) {
+    let current = populate;
+    for (let i = 0; i < parts.length; i++) {
+        const entry = current.find(p => p.field.split(':')[0] === parts[i]);
+        if (!entry) {
+            return undefined;
+        }
+        if (i === parts.length - 1) {
+            return entry;
+        }
+        current = (entry.children ?? []);
+    }
+    /* v8 ignore next */
+    return undefined;
+}
+/**
+ * Applies per-relation overrides from `populateHints` to the normalized populate tree.
+ * @internal
+ */
+export function applyPopulateHints(populate, hints) {
+    for (const [path, hint] of Object.entries(hints)) {
+        const entry = findPopulateEntry(populate, path.split('.'));
+        if (!entry) {
+            continue;
+        }
+        if (hint.strategy != null) {
+            entry.strategy = hint.strategy;
+        }
+        if (hint.joinType != null) {
+            entry.joinType = hint.joinType;
+        }
+    }
+}

package/entity/validators.d.ts

@@ -0,0 +1,11 @@
+import type { EntityData, EntityMetadata, EntityProperty, FilterQuery } from '../typings.js';
+/** @internal */
+export declare function validateProperty<T extends object>(prop: EntityProperty, givenValue: any, entity: T): void;
+/** @internal */
+export declare function validateEntity<T extends object>(entity: T, meta: EntityMetadata<T>): void;
+/** @internal */
+export declare function validateParams(params: any, type?: string, field?: string): void;
+/** @internal */
+export declare function validatePrimaryKey<T>(entity: EntityData<T>, meta: EntityMetadata<T>): void;
+/** @internal */
+export declare function validateEmptyWhere<T>(where: FilterQuery<T>): void;

package/entity/validators.js

@@ -0,0 +1,66 @@
+import { Utils } from '../utils/Utils.js';
+import { ValidationError } from '../errors.js';
+import { isRaw, Raw } from '../utils/RawQueryFragment.js';
+import { SCALAR_TYPES } from '../enums.js';
+/** @internal */
+export function validateProperty(prop, givenValue, entity) {
+    if (givenValue == null || isRaw(givenValue)) {
+        return;
+    }
+    const expectedType = prop.runtimeType;
+    const propName = prop.embedded ? prop.name.replace(/~/g, '.') : prop.name;
+    const givenType = Utils.getObjectType(givenValue);
+    if (prop.enum && prop.items) {
+        /* v8 ignore next */
+        if (!prop.items.some(it => it === givenValue)) {
+            throw ValidationError.fromWrongPropertyType(entity, propName, expectedType, givenType, givenValue);
+        }
+    }
+    else {
+        if (givenType !== expectedType && SCALAR_TYPES.has(expectedType)) {
+            throw ValidationError.fromWrongPropertyType(entity, propName, expectedType, givenType, givenValue);
+        }
+    }
+}
+function getValue(o, prop) {
+    if (prop.embedded && prop.embedded[0] in o) {
+        return o[prop.embedded[0]]?.[prop.embedded[1]];
+    }
+    /* v8 ignore next */
+    if (prop.ref) {
+        return o[prop.name]?.unwrap();
+    }
+    return o[prop.name];
+}
+/** @internal */
+export function validateEntity(entity, meta) {
+    for (const prop of meta.validateProps) {
+        validateProperty(prop, getValue(entity, prop), entity);
+    }
+}
+/** @internal */
+export function validateParams(params, type = 'search condition', field) {
+    if (Utils.isPrimaryKey(params) || Utils.isEntity(params)) {
+        return;
+    }
+    if (Array.isArray(params)) {
+        return params.forEach(item => validateParams(item, type, field));
+    }
+    if (Utils.isPlainObject(params)) {
+        Object.keys(params).forEach(k => validateParams(params[k], type, k));
+    }
+}
+/** @internal */
+export function validatePrimaryKey(entity, meta) {
+    const pkExists = meta.primaryKeys.every(pk => entity[pk] != null) ||
+        (meta.serializedPrimaryKey && entity[meta.serializedPrimaryKey] != null);
+    if (!entity || !pkExists) {
+        throw ValidationError.fromMergeWithoutPK(meta);
+    }
+}
+/** @internal */
+export function validateEmptyWhere(where) {
+    if (Utils.isEmpty(where) && !Raw.hasObjectFragments(where)) {
+        throw new Error(`You cannot call 'EntityManager.findOne()' with empty 'where' parameter`);
+    }
+}

package/enums.d.ts

@@ -1,4 +1,4 @@
-import type { Dictionary, EntityKey, ExpandProperty } from './typings.js';
+import type { EntityKey, ExpandProperty } from './typings.js';
 import type { Transaction } from './connections/Connection.js';
 import type { LogContext } from './logging/Logger.js';
 export declare enum FlushMode {
@@ -42,6 +42,7 @@ export declare enum QueryOperator {
     $none = "none",// collection operators, sql only
     $some = "some",// collection operators, sql only
     $every = "every",// collection operators, sql only
+    $size = "size",// collection operators, sql only
     $hasKey = "?",// postgres only, json
     $hasKeys = "?&",// postgres only, json
     $hasSomeKeys = "?|"
@@ -71,7 +72,6 @@ export type QueryOrderKeys<T> = QueryOrderKeysFlat | QueryOrderMap<T>;
 export type QueryOrderMap<T> = {
     [K in EntityKey<T>]?: QueryOrderKeys<ExpandProperty<T[K]>>;
 };
-export type QBQueryOrderMap<T> = QueryOrderMap<T> | Dictionary;
 export interface FlatQueryOrderMap {
     [x: string]: QueryOrderKeysFlat;
 }
@@ -89,7 +89,7 @@ export declare enum QueryFlag {
     IDENTITY_INSERT = "IDENTITY_INSERT",// mssql only
     OUTPUT_TABLE = "OUTPUT_TABLE"
 }
-export declare const SCALAR_TYPES: string[];
+export declare const SCALAR_TYPES: Set<string>;
 export declare enum ReferenceKind {
     SCALAR = "scalar",
     ONE_TO_ONE = "1:1",
@@ -170,11 +170,11 @@ export declare enum TransactionPropagation {
 }
 export interface TransactionOptions {
     ctx?: Transaction;
-    propagation?: TransactionPropagation;
-    isolationLevel?: IsolationLevel;
+    propagation?: TransactionPropagation | `${TransactionPropagation}`;
+    isolationLevel?: IsolationLevel | `${IsolationLevel}`;
     readOnly?: boolean;
     clear?: boolean;
-    flushMode?: FlushMode;
+    flushMode?: FlushMode | `${FlushMode}`;
     ignoreNestedTransactions?: boolean;
     loggerContext?: LogContext;
 }
@@ -184,3 +184,5 @@ export declare enum DeferMode {
     INITIALLY_IMMEDIATE = "immediate",
     INITIALLY_DEFERRED = "deferred"
 }
+/** With `absolute` the prefix is set at the root of the entity (regardless of the nesting level) */
+export type EmbeddedPrefixMode = 'absolute' | 'relative';

package/enums.js

@@ -44,26 +44,13 @@ export var QueryOperator;
     QueryOperator["$none"] = "none";
     QueryOperator["$some"] = "some";
     QueryOperator["$every"] = "every";
+    QueryOperator["$size"] = "size";
     QueryOperator["$hasKey"] = "?";
     QueryOperator["$hasKeys"] = "?&";
     QueryOperator["$hasSomeKeys"] = "?|";
 })(QueryOperator || (QueryOperator = {}));
-export const ARRAY_OPERATORS = [
-    '$eq',
-    '$gt',
-    '$gte',
-    '$lt',
-    '$lte',
-    '$ne',
-    '$overlap',
-    '$contains',
-    '$contained',
-];
-export const JSON_KEY_OPERATORS = [
-    '$hasKey',
-    '$hasKeys',
-    '$hasSomeKeys',
-];
+export const ARRAY_OPERATORS = ['$eq', '$gt', '$gte', '$lt', '$lte', '$ne', '$overlap', '$contains', '$contained'];
+export const JSON_KEY_OPERATORS = ['$hasKey', '$hasKeys', '$hasSomeKeys'];
 export var QueryOrder;
 (function (QueryOrder) {
     QueryOrder["ASC"] = "ASC";
@@ -99,7 +86,16 @@ export var QueryFlag;
     QueryFlag["IDENTITY_INSERT"] = "IDENTITY_INSERT";
     QueryFlag["OUTPUT_TABLE"] = "OUTPUT_TABLE";
 })(QueryFlag || (QueryFlag = {}));
-export const SCALAR_TYPES = ['string', 'number', 'boolean', 'bigint', 'Date', 'Buffer', 'RegExp'];
+export const SCALAR_TYPES = new Set([
+    'string',
+    'number',
+    'boolean',
+    'bigint',
+    'Uint8Array',
+    'Date',
+    'Buffer',
+    'RegExp',
+]);
 export var ReferenceKind;
 (function (ReferenceKind) {
     ReferenceKind["SCALAR"] = "scalar";

package/errors.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEntity, Constructor, Dictionary, EntityMetadata, EntityProperty, IPrimaryKey } from './typings.js';
+import type { AnyEntity, Constructor, Dictionary, EntityMetadata, EntityName, EntityProperty, IPrimaryKey } from './typings.js';
 export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Error {
     readonly entity?: T | undefined;
     constructor(message: string, entity?: T | undefined);
@@ -8,13 +8,14 @@ export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Er
     getEntity(): AnyEntity | undefined;
     static fromWrongPropertyType(entity: AnyEntity, property: string, expectedType: string, givenType: string, givenValue: string): ValidationError;
     static fromWrongRepositoryType(entityName: string, repoType: string, method: string): ValidationError;
-    static fromCollectionNotInitialized(entity: AnyEntity, prop: EntityProperty): ValidationError;
     static fromMergeWithoutPK(meta: EntityMetadata): ValidationError;
     static transactionRequired(): ValidationError;
     static entityNotManaged(entity: AnyEntity): ValidationError;
     static notEntity(owner: AnyEntity, prop: EntityProperty, data: any): ValidationError;
     static notDiscoveredEntity(data: any, meta?: EntityMetadata, action?: string): ValidationError;
-    static invalidPropertyName(entityName: string, invalid: string): ValidationError;
+    static invalidPropertyName(entityName: EntityName, invalid: string): ValidationError;
+    static invalidCollectionValues(entityName: string, propName: string, invalid: unknown): ValidationError;
+    static invalidEnumArrayItems(entityName: string, invalid: unknown): ValidationError;
     static invalidType(type: Constructor<any>, value: any, mode: string): ValidationError;
     static propertyRequired(entity: AnyEntity, property: EntityProperty): ValidationError;
     static cannotModifyInverseCollection(owner: AnyEntity, property: EntityProperty): ValidationError;
@@ -23,9 +24,10 @@ export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Er
     static invalidCompositeIdentifier(meta: EntityMetadata): ValidationError;
     static cannotCommit(): ValidationError;
     static cannotUseGlobalContext(): ValidationError;
-    static cannotUseOperatorsInsideEmbeddables(className: string, propName: string, payload: unknown): ValidationError;
-    static cannotUseGroupOperatorsInsideScalars(className: string, propName: string, payload: unknown): ValidationError;
-    static invalidEmbeddableQuery(className: string, propName: string, embeddableType: string): ValidationError;
+    static cannotUseOperatorsInsideEmbeddables(entityName: EntityName, propName: string, payload: unknown): ValidationError;
+    static cannotUseGroupOperatorsInsideScalars(entityName: EntityName, propName: string, payload: unknown): ValidationError;
+    static invalidEmbeddableQuery(entityName: EntityName, propName: string, embeddableType: string): ValidationError;
+    static invalidQueryCondition(cond: unknown): ValidationError;
 }
 export declare class CursorError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {
     static entityNotPopulated(entity: AnyEntity, prop: string): ValidationError;
@@ -44,15 +46,14 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static fromWrongOwnership(meta: EntityMetadata, prop: EntityProperty, key: 'inversedBy' | 'mappedBy'): MetadataError;
     static fromWrongReferenceKind(meta: EntityMetadata, owner: EntityProperty, prop: EntityProperty): MetadataError;
     static fromInversideSidePrimary(meta: EntityMetadata, owner: EntityProperty, prop: EntityProperty): MetadataError;
-    static entityNotFound(name: string, path: string): MetadataError;
     static unknownIndexProperty(meta: EntityMetadata, prop: string, type: string): MetadataError;
     static multipleVersionFields(meta: EntityMetadata, fields: string[]): MetadataError;
     static invalidVersionFieldType(meta: EntityMetadata): MetadataError;
-    static fromUnknownEntity(className: string, source: string): MetadataError;
+    static fromUnknownEntity(entityName: string, source: string): MetadataError;
     static noEntityDiscovered(): MetadataError;
     static onlyAbstractEntitiesDiscovered(): MetadataError;
-    static duplicateEntityDiscovered(paths: string[], subject?: string): MetadataError;
-    static duplicateFieldName(className: string, names: [string, string][]): MetadataError;
+    static duplicateEntityDiscovered(paths: string[]): MetadataError;
+    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>>;
@@ -61,11 +62,20 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     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 viewEntityWithoutExpression(meta: EntityMetadata): MetadataError;
+    static mixedInheritanceStrategies(root: EntityMetadata, child: EntityMetadata): MetadataError;
+    static tptNotSupportedByDriver(meta: EntityMetadata): MetadataError;
     private static fromMessage;
 }
 export declare class NotFoundError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {
     static findOneFailed(name: string, where: Dictionary | IPrimaryKey): NotFoundError;
     static findExactlyOneFailed(name: string, where: Dictionary | IPrimaryKey): NotFoundError;
+    static failedToLoadProperty(name: string, propName: string, where: unknown): NotFoundError;
 }
 export declare class TransactionStateError extends ValidationError {
     static requiredTransactionNotFound(propagation: string): TransactionStateError;

package/errors.js

@@ -1,4 +1,5 @@
-import { inspect } from 'node:util';
+import { inspect } from './logging/inspect.js';
+import { Utils } from './utils/Utils.js';
 export class ValidationError extends Error {
     entity;
     constructor(message, entity) {
@@ -23,11 +24,6 @@ export class ValidationError extends Error {
         const msg = `Trying to use EntityRepository.${method}() with '${entityName}' entity while the repository is of type '${repoType}'`;
         return new ValidationError(msg);
     }
-    static fromCollectionNotInitialized(entity, prop) {
-        const entityName = entity.constructor.name;
-        const msg = `${entityName}.${prop.name} is not initialized, define it as '${prop.name} = new Collection<${prop.type}>(this);'`;
-        return new ValidationError(msg);
-    }
     static fromMergeWithoutPK(meta) {
         return new ValidationError(`You cannot merge entity '${meta.className}' without identifier!`);
     }
@@ -38,12 +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\`.`;
@@ -51,10 +47,16 @@ export class ValidationError extends Error {
         return new ValidationError(err);
     }
     static invalidPropertyName(entityName, invalid) {
-        return new ValidationError(`Entity '${entityName}' does not have property '${invalid}'`);
+        return new ValidationError(`Entity '${Utils.className(entityName)}' does not have property '${invalid}'`);
+    }
+    static invalidCollectionValues(entityName, propName, invalid) {
+        return new ValidationError(`Invalid collection values provided for '${entityName}.${propName}' in ${entityName}.assign(): ${inspect(invalid)}`);
+    }
+    static invalidEnumArrayItems(entityName, invalid) {
+        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();
         }
@@ -67,8 +69,8 @@ export class ValidationError extends Error {
     static cannotModifyInverseCollection(owner, property) {
         const inverseCollection = `${owner.constructor.name}.${property.name}`;
         const ownerCollection = `${property.type}.${property.mappedBy}`;
-        const error = `You cannot modify inverse side of M:N collection ${inverseCollection} when the owning side is not initialized. `
-            + `Consider working with the owning side instead (${ownerCollection}).`;
+        const error = `You cannot modify inverse side of M:N collection ${inverseCollection} when the owning side is not initialized. ` +
+            `Consider working with the owning side instead (${ownerCollection}).`;
         return new ValidationError(error, owner);
     }
     static cannotModifyReadonlyCollection(owner, property) {
@@ -77,7 +79,7 @@ export class ValidationError extends Error {
     static cannotRemoveFromCollectionWithoutOrphanRemoval(owner, property) {
         const options = [
             ' - add `orphanRemoval: true` to the collection options',
-            ' - add `deleteRule: \'cascade\'` to the owning side options',
+            " - add `deleteRule: 'cascade'` to the owning side options",
             ' - add `nullable: true` to the owning side options',
         ].join('\n');
         return new ValidationError(`Removing items from collection ${owner.constructor.name}.${property.name} without \`orphanRemoval: true\` would break non-null constraint on the owning side. You have several options: \n${options}`, owner);
@@ -89,16 +91,20 @@ export class ValidationError extends Error {
         return new ValidationError('You cannot call em.flush() from inside lifecycle hook handlers');
     }
     static cannotUseGlobalContext() {
-        return new ValidationError('Using global EntityManager instance methods for context specific actions is disallowed. If you need to work with the global instance\'s identity map, use `allowGlobalContext` configuration option or `fork()` instead.');
+        return new ValidationError("Using global EntityManager instance methods for context specific actions is disallowed. If you need to work with the global instance's identity map, use `allowGlobalContext` configuration option or `fork()` instead.");
+    }
+    static cannotUseOperatorsInsideEmbeddables(entityName, propName, payload) {
+        return new ValidationError(`Using operators inside embeddables is not allowed, move the operator above. (property: ${Utils.className(entityName)}.${propName}, payload: ${inspect(payload)})`);
     }
-    static cannotUseOperatorsInsideEmbeddables(className, propName, payload) {
-        return new ValidationError(`Using operators inside embeddables is not allowed, move the operator above. (property: ${className}.${propName}, payload: ${inspect(payload)})`);
+    static cannotUseGroupOperatorsInsideScalars(entityName, propName, payload) {
+        return new ValidationError(`Using group operators ($and/$or) inside scalar properties is not allowed, move the operator above. (property: ${Utils.className(entityName)}.${propName}, payload: ${inspect(payload)})`);
     }
-    static cannotUseGroupOperatorsInsideScalars(className, propName, payload) {
-        return new ValidationError(`Using group operators ($and/$or) inside scalar properties is not allowed, move the operator above. (property: ${className}.${propName}, payload: ${inspect(payload)})`);
+    static invalidEmbeddableQuery(entityName, propName, embeddableType) {
+        return new ValidationError(`Invalid query for entity '${Utils.className(entityName)}', property '${propName}' does not exist in embeddable '${embeddableType}'`);
     }
-    static invalidEmbeddableQuery(className, propName, embeddableType) {
-        return new ValidationError(`Invalid query for entity '${className}', property '${propName}' does not exist in embeddable '${embeddableType}'`);
+    /* v8 ignore next */
+    static invalidQueryCondition(cond) {
+        return new ValidationError(`Invalid query condition: ${inspect(cond, { depth: 5 })}`);
     }
 }
 export class CursorError extends ValidationError {
@@ -154,22 +160,18 @@ export class MetadataError extends ValidationError {
     static fromInversideSidePrimary(meta, owner, prop) {
         return new MetadataError(`${meta.className}.${prop.name} cannot be primary key as it is defined as inverse side. Maybe you should swap the use of 'inversedBy' and 'mappedBy'.`);
     }
-    /* v8 ignore next 3 */
-    static entityNotFound(name, path) {
-        return new MetadataError(`Entity '${name}' not found in ${path}`);
-    }
     static unknownIndexProperty(meta, prop, type) {
         return new MetadataError(`Entity ${meta.className} has wrong ${type} definition: '${prop}' does not exist. You need to use property name, not column name.`);
     }
     static multipleVersionFields(meta, fields) {
-        return new MetadataError(`Entity ${meta.className} has multiple version properties defined: '${fields.join('\', \'')}'. Only one version property is allowed per entity.`);
+        return new MetadataError(`Entity ${meta.className} has multiple version properties defined: '${fields.join("', '")}'. Only one version property is allowed per entity.`);
     }
     static invalidVersionFieldType(meta) {
         const prop = meta.properties[meta.versionProperty];
         return new MetadataError(`Version property ${meta.className}.${prop.name} has unsupported type '${prop.type}'. Only 'number' and 'Date' are allowed.`);
     }
-    static fromUnknownEntity(className, source) {
-        return new MetadataError(`Entity '${className}' was not discovered, please make sure to provide it in 'entities' array when initializing the ORM (used in ${source})`);
+    static fromUnknownEntity(entityName, source) {
+        return new MetadataError(`Entity '${entityName}' was not discovered, please make sure to provide it in 'entities' array when initializing the ORM (used in ${source})`);
     }
     static noEntityDiscovered() {
         return new MetadataError('No entities were discovered');
@@ -177,11 +179,11 @@ export class MetadataError extends ValidationError {
     static onlyAbstractEntitiesDiscovered() {
         return new MetadataError('Only abstract entities were discovered, maybe you forgot to use @Entity() decorator? This can also happen when you have multiple `@mikro-orm/core` packages installed side by side.');
     }
-    static duplicateEntityDiscovered(paths, subject = 'entity names') {
-        return new MetadataError(`Duplicate ${subject} are not allowed: ${paths.join(', ')}`);
+    static duplicateEntityDiscovered(paths) {
+        return new MetadataError(`Duplicate table names are not allowed: ${paths.join(', ')}`);
     }
-    static duplicateFieldName(className, names) {
-        return new MetadataError(`Duplicate fieldNames are not allowed: ${names.map(n => `${className}.${n[0]} (fieldName: '${n[1]}')`).join(', ')}`);
+    static duplicateFieldName(entityName, names) {
+        return new MetadataError(`Duplicate fieldNames are not allowed: ${names.map(n => `${Utils.className(entityName)}.${n[0]} (fieldName: '${n[1]}')`).join(', ')}`);
     }
     static multipleDecorators(entityName, propertyName) {
         return new MetadataError(`Multiple property decorators used on '${entityName}.${propertyName}' property`);
@@ -211,6 +213,32 @@ export class MetadataError extends ValidationError {
     static fromMissingOption(meta, prop, option) {
         return this.fromMessage(meta, prop, `is missing '${option}' option`);
     }
+    static targetKeyOnManyToMany(meta, prop) {
+        return this.fromMessage(meta, prop, `uses 'targetKey' option which is not supported for ManyToMany relations`);
+    }
+    static targetKeyNotUnique(meta, prop, target) {
+        const targetName = target?.className ?? prop.type;
+        return this.fromMessage(meta, prop, `has 'targetKey' set to '${prop.targetKey}', but ${targetName}.${prop.targetKey} is not marked as unique`);
+    }
+    static targetKeyNotFound(meta, prop, target) {
+        const targetName = target?.className ?? prop.type;
+        return this.fromMessage(meta, prop, `has 'targetKey' set to '${prop.targetKey}', but ${targetName}.${prop.targetKey} does not exist`);
+    }
+    static incompatiblePolymorphicTargets(meta, prop, target1, target2, reason) {
+        return this.fromMessage(meta, prop, `has incompatible polymorphic targets ${target1.className} and ${target2.className}: ${reason}`);
+    }
+    static dangerousPropertyName(meta, prop) {
+        return this.fromMessage(meta, prop, `uses a dangerous property name '${prop.name}' which could lead to prototype pollution. Please use a different property name.`);
+    }
+    static viewEntityWithoutExpression(meta) {
+        return new MetadataError(`View entity ${meta.className} is missing 'expression'. View entities must have an expression defining the SQL query.`);
+    }
+    static mixedInheritanceStrategies(root, child) {
+        return new MetadataError(`Entity ${child.className} cannot mix STI (Single Table Inheritance) and TPT (Table-Per-Type) inheritance. Root entity ${root.className} uses STI (discriminatorColumn) but also has inheritance: 'tpt'. Choose one inheritance strategy per hierarchy.`);
+    }
+    static tptNotSupportedByDriver(meta) {
+        return new MetadataError(`Entity ${meta.className} uses TPT (Table-Per-Type) inheritance which is not supported by the current driver. TPT requires SQL JOINs and is only available with SQL drivers.`);
+    }
     static fromMessage(meta, prop, message) {
         return new MetadataError(`${meta.className}.${prop.name} ${message}`);
     }
@@ -222,6 +250,10 @@ export class NotFoundError extends ValidationError {
     static findExactlyOneFailed(name, where) {
         return new NotFoundError(`Wrong number of ${name} entities found for query ${inspect(where)}, expected exactly one`);
     }
+    static failedToLoadProperty(name, propName, where) {
+        const whereString = typeof where === 'object' ? inspect(where) : where;
+        return new NotFoundError(`${name} (${whereString}) failed to load property '${propName}'`);
+    }
 }
 export class TransactionStateError extends ValidationError {
     static requiredTransactionNotFound(propagation) {

package/events/EventManager.d.ts

@@ -6,8 +6,9 @@ export declare class EventManager {
     private readonly entities;
     private readonly cache;
     private readonly subscribers;
-    constructor(subscribers: EventSubscriber[]);
+    constructor(subscribers: Iterable<EventSubscriber>);
     registerSubscriber(subscriber: EventSubscriber): void;
+    getSubscribers(): Set<EventSubscriber>;
     dispatchEvent<T extends object>(event: TransactionEventType, args: TransactionEventArgs, meta?: EntityMetadata<T>): unknown;
     dispatchEvent<T extends object>(event: EventType.onInit, args: Partial<EventArgs<T>>, meta?: EntityMetadata<T>): unknown;
     dispatchEvent<T extends object>(event: EventType, args: Partial<EventArgs<T> | FlushEventArgs>, meta?: EntityMetadata<T>): Promise<unknown>;