@mikro-orm/core 7.0.0-dev.21 → 7.0.0-dev.211

package/entity/validators.js

@@ -0,0 +1,65 @@
+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

@@ -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 = "?|"
@@ -85,9 +86,11 @@ export declare enum QueryFlag {
     INCLUDE_LAZY_FORMULAS = "INCLUDE_LAZY_FORMULAS",
     AUTO_JOIN_ONE_TO_ONE_OWNER = "AUTO_JOIN_ONE_TO_ONE_OWNER",
     INFER_POPULATE = "INFER_POPULATE",
-    IDENTITY_INSERT = "IDENTITY_INSERT"
+    DISABLE_NESTED_INNER_JOIN = "DISABLE_NESTED_INNER_JOIN",
+    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",
@@ -108,7 +111,8 @@ export declare enum Cascade {
 }
 export declare enum LoadStrategy {
     SELECT_IN = "select-in",
-    JOINED = "joined"
+    JOINED = "joined",
+    BALANCED = "balanced"
 }
 export declare enum DataloaderType {
     NONE = 0,
@@ -156,12 +160,22 @@ export declare enum EventType {
 }
 export declare const EventTypeMap: Record<EventType, number>;
 export type TransactionEventType = EventType.beforeTransactionStart | EventType.afterTransactionStart | EventType.beforeTransactionCommit | EventType.afterTransactionCommit | EventType.beforeTransactionRollback | EventType.afterTransactionRollback;
+export declare enum TransactionPropagation {
+    REQUIRED = "required",
+    REQUIRES_NEW = "requires_new",
+    NESTED = "nested",
+    NOT_SUPPORTED = "not_supported",
+    SUPPORTS = "supports",
+    MANDATORY = "mandatory",
+    NEVER = "never"
+}
 export interface TransactionOptions {
     ctx?: Transaction;
-    isolationLevel?: IsolationLevel;
+    propagation?: TransactionPropagation | `${TransactionPropagation}`;
+    isolationLevel?: IsolationLevel | `${IsolationLevel}`;
     readOnly?: boolean;
     clear?: boolean;
-    flushMode?: FlushMode;
+    flushMode?: FlushMode | `${FlushMode}`;
     ignoreNestedTransactions?: boolean;
     loggerContext?: LogContext;
 }
@@ -171,3 +185,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,6 +44,7 @@ export var QueryOperator;
     QueryOperator["$none"] = "none";
     QueryOperator["$some"] = "some";
     QueryOperator["$every"] = "every";
+    QueryOperator["$size"] = "size";
     QueryOperator["$hasKey"] = "?";
     QueryOperator["$hasKeys"] = "?&";
     QueryOperator["$hasSomeKeys"] = "?|";
@@ -95,9 +96,11 @@ export var QueryFlag;
     QueryFlag["INCLUDE_LAZY_FORMULAS"] = "INCLUDE_LAZY_FORMULAS";
     QueryFlag["AUTO_JOIN_ONE_TO_ONE_OWNER"] = "AUTO_JOIN_ONE_TO_ONE_OWNER";
     QueryFlag["INFER_POPULATE"] = "INFER_POPULATE";
+    QueryFlag["DISABLE_NESTED_INNER_JOIN"] = "DISABLE_NESTED_INNER_JOIN";
     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";
@@ -122,6 +125,7 @@ export var LoadStrategy;
 (function (LoadStrategy) {
     LoadStrategy["SELECT_IN"] = "select-in";
     LoadStrategy["JOINED"] = "joined";
+    LoadStrategy["BALANCED"] = "balanced";
 })(LoadStrategy || (LoadStrategy = {}));
 export var DataloaderType;
 (function (DataloaderType) {
@@ -175,6 +179,16 @@ export const EventTypeMap = Object.keys(EventType).reduce((a, b, i) => {
     a[b] = i;
     return a;
 }, {});
+export var TransactionPropagation;
+(function (TransactionPropagation) {
+    TransactionPropagation["REQUIRED"] = "required";
+    TransactionPropagation["REQUIRES_NEW"] = "requires_new";
+    TransactionPropagation["NESTED"] = "nested";
+    TransactionPropagation["NOT_SUPPORTED"] = "not_supported";
+    TransactionPropagation["SUPPORTS"] = "supports";
+    TransactionPropagation["MANDATORY"] = "mandatory";
+    TransactionPropagation["NEVER"] = "never";
+})(TransactionPropagation || (TransactionPropagation = {}));
 export class PlainObject {
 }
 export var DeferMode;

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,8 +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 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;
@@ -43,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>>;
@@ -60,9 +62,21 @@ 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): MetadataError<Partial<any>>;
+    static targetKeyNotFound(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
+    static dangerousPropertyName(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
+    static viewEntityWithoutExpression(meta: EntityMetadata): MetadataError;
+    static materializedWithoutView(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;
+    static transactionNotAllowed(propagation: string): TransactionStateError;
+    static invalidPropagation(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!`);
     }
@@ -51,7 +47,13 @@ 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();
@@ -91,11 +93,18 @@ export class ValidationError extends Error {
     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.');
     }
-    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 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 invalidEmbeddableQuery(className, propName, embeddableType) {
-        return new ValidationError(`Invalid query for entity '${className}', property '${propName}' does not exist in embeddable '${embeddableType}'`);
+    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 invalidEmbeddableQuery(entityName, propName, embeddableType) {
+        return new ValidationError(`Invalid query for entity '${Utils.className(entityName)}', 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 {
@@ -151,10 +160,6 @@ 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.`);
     }
@@ -165,8 +170,8 @@ export class MetadataError extends ValidationError {
         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');
@@ -174,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`);
@@ -208,6 +213,24 @@ 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) {
+        return this.fromMessage(meta, prop, `has 'targetKey' set to '${prop.targetKey}', but ${prop.type}.${prop.targetKey} is not marked as unique. The target property must have a unique constraint.`);
+    }
+    static targetKeyNotFound(meta, prop) {
+        return this.fromMessage(meta, prop, `has 'targetKey' set to '${prop.targetKey}', but ${prop.type}.${prop.targetKey} does not exist`);
+    }
+    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 materializedWithoutView(meta) {
+        return new MetadataError(`Entity ${meta.className} has 'materialized: true' but is missing 'view: true'. Materialized views must also be marked as views.`);
+    }
     static fromMessage(meta, prop, message) {
         return new MetadataError(`${meta.className}.${prop.name} ${message}`);
     }
@@ -219,4 +242,19 @@ 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) {
+        return new TransactionStateError(`No existing transaction found for transaction marked with propagation "${propagation}"`);
+    }
+    static transactionNotAllowed(propagation) {
+        return new TransactionStateError(`Existing transaction found for transaction marked with propagation "${propagation}"`);
+    }
+    static invalidPropagation(propagation) {
+        return new TransactionStateError(`Unsupported transaction propagation type: ${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>;

package/events/EventManager.js

@@ -4,21 +4,29 @@ export class EventManager {
     listeners = {};
     entities = new Map();
     cache = new Map();
-    subscribers = [];
+    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);
+        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;
@@ -30,9 +38,9 @@ export class EventManager {
             const handler = typeof hook === 'function' ? hook : entity[hook] ?? prototypeHook;
             return handler.bind(entity);
         }));
-        for (const listener of this.listeners[event] || []) {
+        for (const listener of this.listeners[event] ?? new Set()) {
             const entities = this.entities.get(listener);
-            if (entities.length === 0 || !entity || entities.includes(entity.constructor.name)) {
+            if (entities.size === 0 || !entity || entities.has(entity.constructor.name)) {
                 listeners.push(listener[event].bind(listener));
             }
         }
@@ -51,9 +59,9 @@ export class EventManager {
             this.cache.set(cacheKey, true);
             return true;
         }
-        for (const listener of this.listeners[event] ?? []) {
+        for (const listener of this.listeners[event] ?? new Set()) {
             const entities = this.entities.get(listener);
-            if (entities.length === 0 || entities.includes(meta.className)) {
+            if (entities.size === 0 || entities.has(meta.className)) {
                 this.cache.set(cacheKey, true);
                 return true;
             }
@@ -66,8 +74,8 @@ export class EventManager {
     }
     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/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,22 @@
 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;
     /**
      * @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;