@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.100

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,65 @@
+import { Utils } from '../utils/Utils.js';
+import { ValidationError } from '../errors.js';
+import { isRaw } 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)) {
+        throw new Error(`You cannot call 'EntityManager.findOne()' with empty 'where' parameter`);
+    }
+}

package/entity/wrap.d.ts

@@ -1,4 +1,4 @@
-import type { IWrappedEntity, IWrappedEntityInternal } from '../typings';
+import type { IWrappedEntity, IWrappedEntityInternal } from '../typings.js';
 /**
  * returns WrappedEntity instance associated with this entity. This includes all the internal properties like `__meta` or `__em`.
  */

package/entity/wrap.js

@@ -1,12 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrap = wrap;
-exports.helper = helper;
 /**
  * wraps entity type with WrappedEntity internal properties and helpers like init/isInitialized/populated/toJSON
  * use `preferHelper = true` to have access to the internal `__` properties like `__meta` or `__em`
  */
-function wrap(entity, preferHelper = false) {
+export function wrap(entity, preferHelper = false) {
     if (!entity) {
         return entity;
     }
@@ -20,6 +16,6 @@ function wrap(entity, preferHelper = false) {
  * use `preferHelper = true` to have access to the internal `__` properties like `__meta` or `__em`
  * @internal
  */
-function helper(entity) {
+export function helper(entity) {
     return entity.__helper;
 }

package/enums.d.ts

@@ -1,6 +1,6 @@
-import type { Dictionary, EntityKey, ExpandProperty } from './typings';
-import type { Transaction } from './connections';
-import type { LogContext } from './logging';
+import type { Dictionary, EntityKey, ExpandProperty } from './typings.js';
+import type { Transaction } from './connections/Connection.js';
+import type { LogContext } from './logging/Logger.js';
 export declare enum FlushMode {
     /** The `EntityManager` delays the flush until the current Transaction is committed. */
     COMMIT = "commit",
@@ -66,7 +66,7 @@ export declare enum QueryOrderNumeric {
     ASC = 1,
     DESC = -1
 }
-export type QueryOrderKeysFlat = QueryOrder | QueryOrderNumeric | keyof typeof QueryOrder;
+export type QueryOrderKeysFlat = QueryOrder | QueryOrderNumeric | `${QueryOrder}`;
 export type QueryOrderKeys<T> = QueryOrderKeysFlat | QueryOrderMap<T>;
 export type QueryOrderMap<T> = {
     [K in EntityKey<T>]?: QueryOrderKeys<ExpandProperty<T[K]>>;
@@ -85,9 +85,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 +110,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 +159,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 +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

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeferMode = exports.PlainObject = exports.EventTypeMap = exports.EventType = exports.IsolationLevel = exports.LockMode = exports.DataloaderType = exports.LoadStrategy = exports.Cascade = exports.ReferenceKind = exports.SCALAR_TYPES = exports.QueryFlag = exports.QueryOrderNumeric = exports.QueryOrder = exports.JSON_KEY_OPERATORS = exports.ARRAY_OPERATORS = exports.QueryOperator = exports.GroupOperator = exports.PopulatePath = exports.PopulateHint = exports.FlushMode = void 0;
-var FlushMode;
+export var FlushMode;
 (function (FlushMode) {
     /** The `EntityManager` delays the flush until the current Transaction is committed. */
     FlushMode["COMMIT"] = "commit";
@@ -9,23 +6,23 @@ var FlushMode;
     FlushMode["AUTO"] = "auto";
     /** Flushes the `EntityManager` before every query. */
     FlushMode["ALWAYS"] = "always";
-})(FlushMode || (exports.FlushMode = FlushMode = {}));
-var PopulateHint;
+})(FlushMode || (FlushMode = {}));
+export var PopulateHint;
 (function (PopulateHint) {
     PopulateHint["INFER"] = "infer";
     PopulateHint["ALL"] = "all";
-})(PopulateHint || (exports.PopulateHint = PopulateHint = {}));
-var PopulatePath;
+})(PopulateHint || (PopulateHint = {}));
+export var PopulatePath;
 (function (PopulatePath) {
     PopulatePath["INFER"] = "$infer";
     PopulatePath["ALL"] = "*";
-})(PopulatePath || (exports.PopulatePath = PopulatePath = {}));
-var GroupOperator;
+})(PopulatePath || (PopulatePath = {}));
+export var GroupOperator;
 (function (GroupOperator) {
     GroupOperator["$and"] = "and";
     GroupOperator["$or"] = "or";
-})(GroupOperator || (exports.GroupOperator = GroupOperator = {}));
-var QueryOperator;
+})(GroupOperator || (GroupOperator = {}));
+export var QueryOperator;
 (function (QueryOperator) {
     QueryOperator["$eq"] = "=";
     QueryOperator["$in"] = "in";
@@ -50,8 +47,8 @@ var QueryOperator;
     QueryOperator["$hasKey"] = "?";
     QueryOperator["$hasKeys"] = "?&";
     QueryOperator["$hasSomeKeys"] = "?|";
-})(QueryOperator || (exports.QueryOperator = QueryOperator = {}));
-exports.ARRAY_OPERATORS = [
+})(QueryOperator || (QueryOperator = {}));
+export const ARRAY_OPERATORS = [
     '$eq',
     '$gt',
     '$gte',
@@ -62,12 +59,12 @@ exports.ARRAY_OPERATORS = [
     '$contains',
     '$contained',
 ];
-exports.JSON_KEY_OPERATORS = [
+export const JSON_KEY_OPERATORS = [
     '$hasKey',
     '$hasKeys',
     '$hasSomeKeys',
 ];
-var QueryOrder;
+export var QueryOrder;
 (function (QueryOrder) {
     QueryOrder["ASC"] = "ASC";
     QueryOrder["ASC_NULLS_LAST"] = "ASC NULLS LAST";
@@ -81,13 +78,13 @@ var QueryOrder;
     QueryOrder["desc"] = "desc";
     QueryOrder["desc_nulls_last"] = "desc nulls last";
     QueryOrder["desc_nulls_first"] = "desc nulls first";
-})(QueryOrder || (exports.QueryOrder = QueryOrder = {}));
-var QueryOrderNumeric;
+})(QueryOrder || (QueryOrder = {}));
+export var QueryOrderNumeric;
 (function (QueryOrderNumeric) {
     QueryOrderNumeric[QueryOrderNumeric["ASC"] = 1] = "ASC";
     QueryOrderNumeric[QueryOrderNumeric["DESC"] = -1] = "DESC";
-})(QueryOrderNumeric || (exports.QueryOrderNumeric = QueryOrderNumeric = {}));
-var QueryFlag;
+})(QueryOrderNumeric || (QueryOrderNumeric = {}));
+export var QueryFlag;
 (function (QueryFlag) {
     QueryFlag["DISTINCT"] = "DISTINCT";
     QueryFlag["PAGINATE"] = "PAGINATE";
@@ -98,10 +95,12 @@ 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 || (exports.QueryFlag = QueryFlag = {}));
-exports.SCALAR_TYPES = ['string', 'number', 'boolean', 'bigint', 'Date', 'Buffer', 'RegExp'];
-var ReferenceKind;
+    QueryFlag["OUTPUT_TABLE"] = "OUTPUT_TABLE";
+})(QueryFlag || (QueryFlag = {}));
+export const SCALAR_TYPES = new Set(['string', 'number', 'boolean', 'bigint', 'Uint8Array', 'Date', 'Buffer', 'RegExp']);
+export var ReferenceKind;
 (function (ReferenceKind) {
     ReferenceKind["SCALAR"] = "scalar";
     ReferenceKind["ONE_TO_ONE"] = "1:1";
@@ -109,8 +108,8 @@ var ReferenceKind;
     ReferenceKind["MANY_TO_ONE"] = "m:1";
     ReferenceKind["MANY_TO_MANY"] = "m:n";
     ReferenceKind["EMBEDDED"] = "embedded";
-})(ReferenceKind || (exports.ReferenceKind = ReferenceKind = {}));
-var Cascade;
+})(ReferenceKind || (ReferenceKind = {}));
+export var Cascade;
 (function (Cascade) {
     Cascade["PERSIST"] = "persist";
     Cascade["MERGE"] = "merge";
@@ -120,20 +119,21 @@ var Cascade;
     Cascade["SCHEDULE_ORPHAN_REMOVAL"] = "schedule_orphan_removal";
     /** @internal */
     Cascade["CANCEL_ORPHAN_REMOVAL"] = "cancel_orphan_removal";
-})(Cascade || (exports.Cascade = Cascade = {}));
-var LoadStrategy;
+})(Cascade || (Cascade = {}));
+export var LoadStrategy;
 (function (LoadStrategy) {
     LoadStrategy["SELECT_IN"] = "select-in";
     LoadStrategy["JOINED"] = "joined";
-})(LoadStrategy || (exports.LoadStrategy = LoadStrategy = {}));
-var DataloaderType;
+    LoadStrategy["BALANCED"] = "balanced";
+})(LoadStrategy || (LoadStrategy = {}));
+export var DataloaderType;
 (function (DataloaderType) {
     DataloaderType[DataloaderType["NONE"] = 0] = "NONE";
     DataloaderType[DataloaderType["REFERENCE"] = 1] = "REFERENCE";
     DataloaderType[DataloaderType["COLLECTION"] = 2] = "COLLECTION";
     DataloaderType[DataloaderType["ALL"] = 3] = "ALL";
-})(DataloaderType || (exports.DataloaderType = DataloaderType = {}));
-var LockMode;
+})(DataloaderType || (DataloaderType = {}));
+export var LockMode;
 (function (LockMode) {
     LockMode[LockMode["NONE"] = 0] = "NONE";
     LockMode[LockMode["OPTIMISTIC"] = 1] = "OPTIMISTIC";
@@ -143,16 +143,16 @@ var LockMode;
     LockMode[LockMode["PESSIMISTIC_WRITE_OR_FAIL"] = 5] = "PESSIMISTIC_WRITE_OR_FAIL";
     LockMode[LockMode["PESSIMISTIC_PARTIAL_READ"] = 6] = "PESSIMISTIC_PARTIAL_READ";
     LockMode[LockMode["PESSIMISTIC_READ_OR_FAIL"] = 7] = "PESSIMISTIC_READ_OR_FAIL";
-})(LockMode || (exports.LockMode = LockMode = {}));
-var IsolationLevel;
+})(LockMode || (LockMode = {}));
+export var IsolationLevel;
 (function (IsolationLevel) {
     IsolationLevel["READ_UNCOMMITTED"] = "read uncommitted";
     IsolationLevel["READ_COMMITTED"] = "read committed";
     IsolationLevel["SNAPSHOT"] = "snapshot";
     IsolationLevel["REPEATABLE_READ"] = "repeatable read";
     IsolationLevel["SERIALIZABLE"] = "serializable";
-})(IsolationLevel || (exports.IsolationLevel = IsolationLevel = {}));
-var EventType;
+})(IsolationLevel || (IsolationLevel = {}));
+export var EventType;
 (function (EventType) {
     EventType["onInit"] = "onInit";
     EventType["onLoad"] = "onLoad";
@@ -173,16 +173,25 @@ var EventType;
     EventType["afterTransactionCommit"] = "afterTransactionCommit";
     EventType["beforeTransactionRollback"] = "beforeTransactionRollback";
     EventType["afterTransactionRollback"] = "afterTransactionRollback";
-})(EventType || (exports.EventType = EventType = {}));
-exports.EventTypeMap = Object.keys(EventType).reduce((a, b, i) => {
+})(EventType || (EventType = {}));
+export const EventTypeMap = Object.keys(EventType).reduce((a, b, i) => {
     a[b] = i;
     return a;
 }, {});
-class PlainObject {
+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 {
 }
-exports.PlainObject = PlainObject;
-var DeferMode;
+export var DeferMode;
 (function (DeferMode) {
     DeferMode["INITIALLY_IMMEDIATE"] = "immediate";
     DeferMode["INITIALLY_DEFERRED"] = "deferred";
-})(DeferMode || (exports.DeferMode = DeferMode = {}));
+})(DeferMode || (DeferMode = {}));

package/errors.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEntity, Constructor, Dictionary, EntityMetadata, EntityProperty, IPrimaryKey } from './typings';
+import type { AnyEntity, Constructor, Dictionary, EntityMetadata, 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 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;
@@ -24,7 +25,9 @@ export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Er
     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 invalidQueryCondition(cond: unknown): ValidationError;
 }
 export declare class CursorError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {
     static entityNotPopulated(entity: AnyEntity, prop: string): ValidationError;
@@ -43,7 +46,6 @@ 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;
@@ -65,4 +67,10 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
 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,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotFoundError = exports.MetadataError = exports.OptimisticLockError = exports.CursorError = exports.ValidationError = void 0;
-const node_util_1 = require("node:util");
-class ValidationError extends Error {
+import { inspect } from './logging/inspect.js';
+export class ValidationError extends Error {
     entity;
     constructor(message, entity) {
         super(message);
@@ -19,18 +16,13 @@ class ValidationError extends Error {
     }
     static fromWrongPropertyType(entity, property, expectedType, givenType, givenValue) {
         const entityName = entity.constructor.name;
-        const msg = `Trying to set ${entityName}.${property} of type '${expectedType}' to ${(0, node_util_1.inspect)(givenValue)} of type '${givenType}'`;
+        const msg = `Trying to set ${entityName}.${property} of type '${expectedType}' to ${inspect(givenValue)} of type '${givenType}'`;
         return new ValidationError(msg);
     }
     static fromWrongRepositoryType(entityName, repoType, method) {
         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!`);
     }
@@ -42,13 +34,12 @@ class ValidationError extends Error {
     }
     static notEntity(owner, prop, data) {
         const type = Object.prototype.toString.call(data).match(/\[object (\w+)]/)[1].toLowerCase();
-        return new ValidationError(`Entity of type ${prop.type} expected for property ${owner.constructor.name}.${prop.name}, ${(0, node_util_1.inspect)(data)} of type ${type} given. If you are using Object.assign(entity, data), use em.assign(entity, data) instead.`);
+        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') {
-        /* istanbul ignore next */
+        /* v8 ignore next */
         const type = meta?.className ?? Object.prototype.toString.call(data).match(/\[object (\w+)]/)[1].toLowerCase();
         let err = `Trying to ${action} not discovered entity of type ${type}.`;
-        /* istanbul ignore else */
         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\`.`;
         }
@@ -57,6 +48,12 @@ class ValidationError extends Error {
     static invalidPropertyName(entityName, invalid) {
         return new ValidationError(`Entity '${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();
         if (value instanceof Date) {
@@ -66,7 +63,7 @@ class ValidationError extends Error {
     }
     static propertyRequired(entity, property) {
         const entityName = entity.__meta.className;
-        return new ValidationError(`Value for ${entityName}.${property.name} is required, '${entity[property.name]}' found\nentity: ${(0, node_util_1.inspect)(entity)}`, entity);
+        return new ValidationError(`Value for ${entityName}.${property.name} is required, '${entity[property.name]}' found\nentity: ${inspect(entity)}`, entity);
     }
     static cannotModifyInverseCollection(owner, property) {
         const inverseCollection = `${owner.constructor.name}.${property.name}`;
@@ -96,14 +93,20 @@ class ValidationError extends Error {
         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: ${(0, node_util_1.inspect)(payload)})`);
+        return new ValidationError(`Using operators inside embeddables is not allowed, move the operator above. (property: ${className}.${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(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 })}`);
+    }
 }
-exports.ValidationError = ValidationError;
-class CursorError extends ValidationError {
+export class CursorError extends ValidationError {
     static entityNotPopulated(entity, prop) {
         return new CursorError(`Cannot create cursor, value for '${entity.constructor.name}.${prop}' is missing.`);
     }
@@ -111,8 +114,7 @@ class CursorError extends ValidationError {
         return new CursorError(`Invalid cursor condition, value for '${entityName}.${prop}' is missing.`);
     }
 }
-exports.CursorError = CursorError;
-class OptimisticLockError extends ValidationError {
+export class OptimisticLockError extends ValidationError {
     static notVersioned(meta) {
         return new OptimisticLockError(`Cannot obtain optimistic lock on unversioned entity ${meta.className}`);
     }
@@ -127,8 +129,7 @@ class OptimisticLockError extends ValidationError {
         return new OptimisticLockError(`The optimistic lock failed, version ${expectedLockVersion} was expected, but is actually ${actualLockVersion}`, entity);
     }
 }
-exports.OptimisticLockError = OptimisticLockError;
-class MetadataError extends ValidationError {
+export class MetadataError extends ValidationError {
     static fromMissingPrimaryKey(meta) {
         return new MetadataError(`${meta.className} entity is missing @PrimaryKey()`);
     }
@@ -158,10 +159,6 @@ 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'.`);
     }
-    /* istanbul ignore next */
-    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.`);
     }
@@ -208,7 +205,7 @@ class MetadataError extends ValidationError {
         return this.fromMessage(meta, prop, `is non-persistent relation which targets composite primary key. This is not supported and will cause issues, 'persist: false' should be added to the properties representing single columns instead.`);
     }
     static propertyTargetsEntityType(meta, prop, target) {
-        /* istanbul ignore next */
+        /* v8 ignore next */
         const suggestion = target.embeddable ? 'Embedded' : 'ManyToOne';
         return this.fromMessage(meta, prop, `is defined as scalar @Property(), but its type is a discovered entity ${target.className}. Maybe you want to use @${suggestion}() decorator instead?`);
     }
@@ -219,13 +216,26 @@ class MetadataError extends ValidationError {
         return new MetadataError(`${meta.className}.${prop.name} ${message}`);
     }
 }
-exports.MetadataError = MetadataError;
-class NotFoundError extends ValidationError {
+export class NotFoundError extends ValidationError {
     static findOneFailed(name, where) {
-        return new NotFoundError(`${name} not found (${(0, node_util_1.inspect)(where)})`);
+        return new NotFoundError(`${name} not found (${inspect(where)})`);
     }
     static findExactlyOneFailed(name, where) {
-        return new NotFoundError(`Wrong number of ${name} entities found for query ${(0, node_util_1.inspect)(where)}, expected exactly one`);
+        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}`);
     }
 }
-exports.NotFoundError = NotFoundError;

package/events/EventManager.d.ts

@@ -1,13 +1,14 @@
-import type { EntityMetadata } from '../typings';
-import type { EventArgs, EventSubscriber, FlushEventArgs, TransactionEventArgs } from './EventSubscriber';
-import { EventType, type TransactionEventType } from '../enums';
+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;
-    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>;