@yandjin-mikro-orm/core 6.1.4-rc-sti-changes-1

package/enums.d.ts

@@ -0,0 +1,160 @@
+import type { Dictionary, EntityKey, ExpandProperty } from './typings';
+import type { Transaction } from './connections';
+import type { LogContext } from './logging';
+export declare enum FlushMode {
+    /** The `EntityManager` delays the flush until the current Transaction is committed. */
+    COMMIT = "commit",
+    /** This is the default mode, and it flushes the `EntityManager` only if necessary. */
+    AUTO = "auto",
+    /** Flushes the `EntityManager` before every query. */
+    ALWAYS = "always"
+}
+export declare enum PopulateHint {
+    INFER = "infer",
+    ALL = "all"
+}
+export declare enum GroupOperator {
+    $and = "and",
+    $or = "or"
+}
+export declare enum QueryOperator {
+    $eq = "=",
+    $in = "in",
+    $nin = "not in",
+    $gt = ">",
+    $gte = ">=",
+    $lt = "<",
+    $lte = "<=",
+    $ne = "!=",
+    $not = "not",
+    $like = "like",
+    $re = "regexp",
+    $fulltext = "fulltext",
+    $exists = "not null",
+    $ilike = "ilike",// postgres only
+    $overlap = "&&",// postgres only
+    $contains = "@>",// postgres only
+    $contained = "<@",// postgres only
+    $none = "none",// collection operators, sql only
+    $some = "some",// collection operators, sql only
+    $every = "every"
+}
+export declare const ARRAY_OPERATORS: string[];
+export declare enum QueryOrder {
+    ASC = "ASC",
+    ASC_NULLS_LAST = "ASC NULLS LAST",
+    ASC_NULLS_FIRST = "ASC NULLS FIRST",
+    DESC = "DESC",
+    DESC_NULLS_LAST = "DESC NULLS LAST",
+    DESC_NULLS_FIRST = "DESC NULLS FIRST",
+    asc = "asc",
+    asc_nulls_last = "asc nulls last",
+    asc_nulls_first = "asc nulls first",
+    desc = "desc",
+    desc_nulls_last = "desc nulls last",
+    desc_nulls_first = "desc nulls first"
+}
+export declare enum QueryOrderNumeric {
+    ASC = 1,
+    DESC = -1
+}
+export type QueryOrderKeysFlat = QueryOrder | QueryOrderNumeric | keyof typeof QueryOrder;
+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;
+}
+export declare enum QueryFlag {
+    DISTINCT = "DISTINCT",
+    PAGINATE = "PAGINATE",
+    DISABLE_PAGINATE = "DISABLE_PAGINATE",
+    UPDATE_SUB_QUERY = "UPDATE_SUB_QUERY",
+    DELETE_SUB_QUERY = "DELETE_SUB_QUERY",
+    CONVERT_CUSTOM_TYPES = "CONVERT_CUSTOM_TYPES",
+    INCLUDE_LAZY_FORMULAS = "INCLUDE_LAZY_FORMULAS",
+    AUTO_JOIN_ONE_TO_ONE_OWNER = "AUTO_JOIN_ONE_TO_ONE_OWNER",
+    INFER_POPULATE = "INFER_POPULATE"
+}
+export declare const SCALAR_TYPES: string[];
+export declare enum ReferenceKind {
+    SCALAR = "scalar",
+    ONE_TO_ONE = "1:1",
+    ONE_TO_MANY = "1:m",
+    MANY_TO_ONE = "m:1",
+    MANY_TO_MANY = "m:n",
+    EMBEDDED = "embedded"
+}
+export declare enum Cascade {
+    PERSIST = "persist",
+    MERGE = "merge",
+    REMOVE = "remove",
+    ALL = "all",
+    /** @internal */
+    SCHEDULE_ORPHAN_REMOVAL = "schedule_orphan_removal",
+    /** @internal */
+    CANCEL_ORPHAN_REMOVAL = "cancel_orphan_removal"
+}
+export declare enum LoadStrategy {
+    SELECT_IN = "select-in",
+    JOINED = "joined"
+}
+export declare enum DataloaderType {
+    NONE = 0,
+    REFERENCE = 1,
+    COLLECTION = 2,
+    ALL = 3
+}
+export declare enum LockMode {
+    NONE = 0,
+    OPTIMISTIC = 1,
+    PESSIMISTIC_READ = 2,
+    PESSIMISTIC_WRITE = 3,
+    PESSIMISTIC_PARTIAL_WRITE = 4,
+    PESSIMISTIC_WRITE_OR_FAIL = 5,
+    PESSIMISTIC_PARTIAL_READ = 6,
+    PESSIMISTIC_READ_OR_FAIL = 7
+}
+export declare enum IsolationLevel {
+    READ_UNCOMMITTED = "read uncommitted",
+    READ_COMMITTED = "read committed",
+    SNAPSHOT = "snapshot",
+    REPEATABLE_READ = "repeatable read",
+    SERIALIZABLE = "serializable"
+}
+export declare enum EventType {
+    onInit = "onInit",
+    onLoad = "onLoad",
+    beforeCreate = "beforeCreate",
+    afterCreate = "afterCreate",
+    beforeUpdate = "beforeUpdate",
+    afterUpdate = "afterUpdate",
+    beforeUpsert = "beforeUpsert",
+    afterUpsert = "afterUpsert",
+    beforeDelete = "beforeDelete",
+    afterDelete = "afterDelete",
+    beforeFlush = "beforeFlush",
+    onFlush = "onFlush",
+    afterFlush = "afterFlush",
+    beforeTransactionStart = "beforeTransactionStart",
+    afterTransactionStart = "afterTransactionStart",
+    beforeTransactionCommit = "beforeTransactionCommit",
+    afterTransactionCommit = "afterTransactionCommit",
+    beforeTransactionRollback = "beforeTransactionRollback",
+    afterTransactionRollback = "afterTransactionRollback"
+}
+export declare const EventTypeMap: Record<EventType, number>;
+export type TransactionEventType = EventType.beforeTransactionStart | EventType.afterTransactionStart | EventType.beforeTransactionCommit | EventType.afterTransactionCommit | EventType.beforeTransactionRollback | EventType.afterTransactionRollback;
+export interface TransactionOptions {
+    ctx?: Transaction;
+    isolationLevel?: IsolationLevel;
+    readOnly?: boolean;
+    clear?: boolean;
+    flushMode?: FlushMode;
+    ignoreNestedTransactions?: boolean;
+    loggerContext?: LogContext;
+}
+export declare abstract class PlainObject {
+}

package/enums.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.ARRAY_OPERATORS = exports.QueryOperator = exports.GroupOperator = exports.PopulateHint = exports.FlushMode = void 0;
+var FlushMode;
+(function (FlushMode) {
+    /** The `EntityManager` delays the flush until the current Transaction is committed. */
+    FlushMode["COMMIT"] = "commit";
+    /** This is the default mode, and it flushes the `EntityManager` only if necessary. */
+    FlushMode["AUTO"] = "auto";
+    /** Flushes the `EntityManager` before every query. */
+    FlushMode["ALWAYS"] = "always";
+})(FlushMode || (exports.FlushMode = FlushMode = {}));
+var PopulateHint;
+(function (PopulateHint) {
+    PopulateHint["INFER"] = "infer";
+    PopulateHint["ALL"] = "all";
+})(PopulateHint || (exports.PopulateHint = PopulateHint = {}));
+var GroupOperator;
+(function (GroupOperator) {
+    GroupOperator["$and"] = "and";
+    GroupOperator["$or"] = "or";
+})(GroupOperator || (exports.GroupOperator = GroupOperator = {}));
+var QueryOperator;
+(function (QueryOperator) {
+    QueryOperator["$eq"] = "=";
+    QueryOperator["$in"] = "in";
+    QueryOperator["$nin"] = "not in";
+    QueryOperator["$gt"] = ">";
+    QueryOperator["$gte"] = ">=";
+    QueryOperator["$lt"] = "<";
+    QueryOperator["$lte"] = "<=";
+    QueryOperator["$ne"] = "!=";
+    QueryOperator["$not"] = "not";
+    QueryOperator["$like"] = "like";
+    QueryOperator["$re"] = "regexp";
+    QueryOperator["$fulltext"] = "fulltext";
+    QueryOperator["$exists"] = "not null";
+    QueryOperator["$ilike"] = "ilike";
+    QueryOperator["$overlap"] = "&&";
+    QueryOperator["$contains"] = "@>";
+    QueryOperator["$contained"] = "<@";
+    QueryOperator["$none"] = "none";
+    QueryOperator["$some"] = "some";
+    QueryOperator["$every"] = "every";
+})(QueryOperator || (exports.QueryOperator = QueryOperator = {}));
+exports.ARRAY_OPERATORS = [
+    '$eq',
+    '$gt',
+    '$gte',
+    '$lt',
+    '$lte',
+    '$ne',
+    '$overlap',
+    '$contains',
+    '$contained',
+];
+var QueryOrder;
+(function (QueryOrder) {
+    QueryOrder["ASC"] = "ASC";
+    QueryOrder["ASC_NULLS_LAST"] = "ASC NULLS LAST";
+    QueryOrder["ASC_NULLS_FIRST"] = "ASC NULLS FIRST";
+    QueryOrder["DESC"] = "DESC";
+    QueryOrder["DESC_NULLS_LAST"] = "DESC NULLS LAST";
+    QueryOrder["DESC_NULLS_FIRST"] = "DESC NULLS FIRST";
+    QueryOrder["asc"] = "asc";
+    QueryOrder["asc_nulls_last"] = "asc nulls last";
+    QueryOrder["asc_nulls_first"] = "asc nulls first";
+    QueryOrder["desc"] = "desc";
+    QueryOrder["desc_nulls_last"] = "desc nulls last";
+    QueryOrder["desc_nulls_first"] = "desc nulls first";
+})(QueryOrder || (exports.QueryOrder = QueryOrder = {}));
+var QueryOrderNumeric;
+(function (QueryOrderNumeric) {
+    QueryOrderNumeric[QueryOrderNumeric["ASC"] = 1] = "ASC";
+    QueryOrderNumeric[QueryOrderNumeric["DESC"] = -1] = "DESC";
+})(QueryOrderNumeric || (exports.QueryOrderNumeric = QueryOrderNumeric = {}));
+var QueryFlag;
+(function (QueryFlag) {
+    QueryFlag["DISTINCT"] = "DISTINCT";
+    QueryFlag["PAGINATE"] = "PAGINATE";
+    QueryFlag["DISABLE_PAGINATE"] = "DISABLE_PAGINATE";
+    QueryFlag["UPDATE_SUB_QUERY"] = "UPDATE_SUB_QUERY";
+    QueryFlag["DELETE_SUB_QUERY"] = "DELETE_SUB_QUERY";
+    QueryFlag["CONVERT_CUSTOM_TYPES"] = "CONVERT_CUSTOM_TYPES";
+    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 || (exports.QueryFlag = QueryFlag = {}));
+exports.SCALAR_TYPES = ['string', 'number', 'boolean', 'Date', 'Buffer', 'RegExp'];
+var ReferenceKind;
+(function (ReferenceKind) {
+    ReferenceKind["SCALAR"] = "scalar";
+    ReferenceKind["ONE_TO_ONE"] = "1:1";
+    ReferenceKind["ONE_TO_MANY"] = "1:m";
+    ReferenceKind["MANY_TO_ONE"] = "m:1";
+    ReferenceKind["MANY_TO_MANY"] = "m:n";
+    ReferenceKind["EMBEDDED"] = "embedded";
+})(ReferenceKind || (exports.ReferenceKind = ReferenceKind = {}));
+var Cascade;
+(function (Cascade) {
+    Cascade["PERSIST"] = "persist";
+    Cascade["MERGE"] = "merge";
+    Cascade["REMOVE"] = "remove";
+    Cascade["ALL"] = "all";
+    /** @internal */
+    Cascade["SCHEDULE_ORPHAN_REMOVAL"] = "schedule_orphan_removal";
+    /** @internal */
+    Cascade["CANCEL_ORPHAN_REMOVAL"] = "cancel_orphan_removal";
+})(Cascade || (exports.Cascade = Cascade = {}));
+var LoadStrategy;
+(function (LoadStrategy) {
+    LoadStrategy["SELECT_IN"] = "select-in";
+    LoadStrategy["JOINED"] = "joined";
+})(LoadStrategy || (exports.LoadStrategy = LoadStrategy = {}));
+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;
+(function (LockMode) {
+    LockMode[LockMode["NONE"] = 0] = "NONE";
+    LockMode[LockMode["OPTIMISTIC"] = 1] = "OPTIMISTIC";
+    LockMode[LockMode["PESSIMISTIC_READ"] = 2] = "PESSIMISTIC_READ";
+    LockMode[LockMode["PESSIMISTIC_WRITE"] = 3] = "PESSIMISTIC_WRITE";
+    LockMode[LockMode["PESSIMISTIC_PARTIAL_WRITE"] = 4] = "PESSIMISTIC_PARTIAL_WRITE";
+    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;
+(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;
+(function (EventType) {
+    EventType["onInit"] = "onInit";
+    EventType["onLoad"] = "onLoad";
+    EventType["beforeCreate"] = "beforeCreate";
+    EventType["afterCreate"] = "afterCreate";
+    EventType["beforeUpdate"] = "beforeUpdate";
+    EventType["afterUpdate"] = "afterUpdate";
+    EventType["beforeUpsert"] = "beforeUpsert";
+    EventType["afterUpsert"] = "afterUpsert";
+    EventType["beforeDelete"] = "beforeDelete";
+    EventType["afterDelete"] = "afterDelete";
+    EventType["beforeFlush"] = "beforeFlush";
+    EventType["onFlush"] = "onFlush";
+    EventType["afterFlush"] = "afterFlush";
+    EventType["beforeTransactionStart"] = "beforeTransactionStart";
+    EventType["afterTransactionStart"] = "afterTransactionStart";
+    EventType["beforeTransactionCommit"] = "beforeTransactionCommit";
+    EventType["afterTransactionCommit"] = "afterTransactionCommit";
+    EventType["beforeTransactionRollback"] = "beforeTransactionRollback";
+    EventType["afterTransactionRollback"] = "afterTransactionRollback";
+})(EventType || (exports.EventType = EventType = {}));
+exports.EventTypeMap = Object.keys(EventType).reduce((a, b, i) => {
+    a[b] = i;
+    return a;
+}, {});
+class PlainObject {
+}
+exports.PlainObject = PlainObject;

package/errors.d.ts

@@ -0,0 +1,65 @@
+import type { AnyEntity, Constructor, Dictionary, EntityMetadata, EntityProperty, IPrimaryKey } from './typings';
+export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Error {
+    readonly entity?: T | undefined;
+    constructor(message: string, entity?: T | undefined);
+    /**
+     * Gets instance of entity that caused this error.
+     */
+    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 invalidType(type: Constructor<any>, value: any, mode: string): ValidationError;
+    static propertyRequired(entity: AnyEntity, property: EntityProperty): ValidationError;
+    static cannotModifyInverseCollection(owner: AnyEntity, property: EntityProperty): ValidationError;
+    static cannotModifyReadonlyCollection(owner: AnyEntity, property: EntityProperty): ValidationError;
+    static cannotRemoveFromCollectionWithoutOrphanRemoval(owner: AnyEntity, property: EntityProperty): ValidationError;
+    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;
+}
+export declare class CursorError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {
+    static entityNotPopulated(entity: AnyEntity, prop: string): ValidationError;
+}
+export declare class OptimisticLockError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {
+    static notVersioned(meta: EntityMetadata): OptimisticLockError;
+    static lockFailed(entityOrName: AnyEntity | string): OptimisticLockError;
+    static lockFailedVersionMismatch(entity: AnyEntity, expectedLockVersion: number | Date, actualLockVersion: number | Date): OptimisticLockError;
+}
+export declare class MetadataError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {
+    static fromMissingPrimaryKey(meta: EntityMetadata): MetadataError;
+    static fromWrongReference(meta: EntityMetadata, prop: EntityProperty, key: 'inversedBy' | 'mappedBy', owner?: EntityProperty): MetadataError;
+    static fromWrongTypeDefinition(meta: EntityMetadata, prop: EntityProperty): MetadataError;
+    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 noEntityDiscovered(): MetadataError;
+    static onlyAbstractEntitiesDiscovered(): MetadataError;
+    static duplicateEntityDiscovered(paths: string[], subject?: string): MetadataError;
+    static duplicateFieldName(className: string, names: [string, string][]): MetadataError;
+    static multipleDecorators(entityName: string, propertyName: string): MetadataError;
+    static missingMetadata(entity: string): MetadataError;
+    static invalidPrimaryKey(meta: EntityMetadata, prop: EntityProperty, requiredName: string): MetadataError<Partial<any>>;
+    static invalidManyToManyWithPivotEntity(meta1: EntityMetadata, prop1: EntityProperty, meta2: EntityMetadata, prop2: EntityProperty): MetadataError<Partial<any>>;
+    static targetIsAbstract(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
+    static propertyTargetsEntityType(meta: EntityMetadata, prop: EntityProperty, target: EntityMetadata): MetadataError<Partial<any>>;
+    static fromMissingOption(meta: EntityMetadata, prop: EntityProperty, option: string): MetadataError<Partial<any>>;
+    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;
+}

package/errors.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = exports.MetadataError = exports.OptimisticLockError = exports.CursorError = exports.ValidationError = void 0;
+const util_1 = require("util");
+class ValidationError extends Error {
+    entity;
+    constructor(message, entity) {
+        super(message);
+        this.entity = entity;
+        Error.captureStackTrace(this, this.constructor);
+        this.name = this.constructor.name;
+        this.message = message;
+    }
+    /**
+     * Gets instance of entity that caused this error.
+     */
+    getEntity() {
+        return this.entity;
+    }
+    static fromWrongPropertyType(entity, property, expectedType, givenType, givenValue) {
+        const entityName = entity.constructor.name;
+        const msg = `Trying to set ${entityName}.${property} of type '${expectedType}' to '${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!`);
+    }
+    static transactionRequired() {
+        return new ValidationError('An open transaction is required for this operation');
+    }
+    static entityNotManaged(entity) {
+        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();
+        return new ValidationError(`Entity of type ${prop.type} expected for property ${owner.constructor.name}.${prop.name}, ${(0, util_1.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 */
+        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\`.`;
+        }
+        return new ValidationError(err);
+    }
+    static invalidPropertyName(entityName, invalid) {
+        return new ValidationError(`Entity '${entityName}' does not have property '${invalid}'`);
+    }
+    static invalidType(type, value, mode) {
+        const valueType = Object.prototype.toString.call(value).match(/\[object (\w+)]/)[1].toLowerCase();
+        if (value instanceof Date) {
+            value = value.toISOString();
+        }
+        return new ValidationError(`Could not convert ${mode} value '${value}' of type '${valueType}' to type ${type.name}`);
+    }
+    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, util_1.inspect)(entity)}`, entity);
+    }
+    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}).`;
+        return new ValidationError(error, owner);
+    }
+    static cannotModifyReadonlyCollection(owner, property) {
+        return new ValidationError(`You cannot modify collection ${owner.constructor.name}.${property.name} as it is marked as readonly.`, owner);
+    }
+    static cannotRemoveFromCollectionWithoutOrphanRemoval(owner, property) {
+        const options = [
+            ' - add `orphanRemoval: true` to the collection 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);
+    }
+    static invalidCompositeIdentifier(meta) {
+        return new ValidationError(`Composite key required for entity ${meta.className}.`);
+    }
+    static cannotCommit() {
+        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.');
+    }
+    static cannotUseOperatorsInsideEmbeddables(className, propName, payload) {
+        return new ValidationError(`Using operators inside embeddables is not allowed, move the operator above. (property: ${className}.${propName}, payload: ${(0, util_1.inspect)(payload)})`);
+    }
+    static invalidEmbeddableQuery(className, propName, embeddableType) {
+        return new ValidationError(`Invalid query for entity '${className}', property '${propName}' does not exist in embeddable '${embeddableType}'`);
+    }
+}
+exports.ValidationError = ValidationError;
+class CursorError extends ValidationError {
+    static entityNotPopulated(entity, prop) {
+        return new CursorError(`Cannot create cursor, value for '${entity.constructor.name}.${prop}' is missing.`);
+    }
+}
+exports.CursorError = CursorError;
+class OptimisticLockError extends ValidationError {
+    static notVersioned(meta) {
+        return new OptimisticLockError(`Cannot obtain optimistic lock on unversioned entity ${meta.className}`);
+    }
+    static lockFailed(entityOrName) {
+        const name = typeof entityOrName === 'string' ? entityOrName : entityOrName.constructor.name;
+        const entity = typeof entityOrName === 'string' ? undefined : entityOrName;
+        return new OptimisticLockError(`The optimistic lock on entity ${name} failed`, entity);
+    }
+    static lockFailedVersionMismatch(entity, expectedLockVersion, actualLockVersion) {
+        expectedLockVersion = expectedLockVersion instanceof Date ? expectedLockVersion.getTime() : expectedLockVersion;
+        actualLockVersion = actualLockVersion instanceof Date ? actualLockVersion.getTime() : actualLockVersion;
+        return new OptimisticLockError(`The optimistic lock failed, version ${expectedLockVersion} was expected, but is actually ${actualLockVersion}`, entity);
+    }
+}
+exports.OptimisticLockError = OptimisticLockError;
+class MetadataError extends ValidationError {
+    static fromMissingPrimaryKey(meta) {
+        return new MetadataError(`${meta.className} entity is missing @PrimaryKey()`);
+    }
+    static fromWrongReference(meta, prop, key, owner) {
+        if (owner) {
+            return MetadataError.fromMessage(meta, prop, `has wrong '${key}' reference type: ${owner.type} instead of ${meta.className}`);
+        }
+        return MetadataError.fromMessage(meta, prop, `has unknown '${key}' reference: ${prop.type}.${prop[key]}`);
+    }
+    static fromWrongTypeDefinition(meta, prop) {
+        if (!prop.type) {
+            return MetadataError.fromMessage(meta, prop, `is missing type definition`);
+        }
+        return MetadataError.fromMessage(meta, prop, `has unknown type: ${prop.type}`);
+    }
+    static fromWrongOwnership(meta, prop, key) {
+        const type = key === 'inversedBy' ? 'owning' : 'inverse';
+        const other = key === 'inversedBy' ? 'mappedBy' : 'inversedBy';
+        return new MetadataError(`Both ${meta.className}.${prop.name} and ${prop.type}.${prop[key]} are defined as ${type} sides, use '${other}' on one of them`);
+    }
+    static fromWrongReferenceKind(meta, owner, prop) {
+        return new MetadataError(`${meta.className}.${prop.name} is of type ${prop.kind} which is incompatible with its owning side ${prop.type}.${owner.name} of type ${owner.kind}`);
+    }
+    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.`);
+    }
+    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.`);
+    }
+    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 noEntityDiscovered() {
+        return new MetadataError('No entities were discovered');
+    }
+    static onlyAbstractEntitiesDiscovered() {
+        return new MetadataError('Only abstract entities were discovered, maybe you forgot to use @Entity() decorator?');
+    }
+    static duplicateEntityDiscovered(paths, subject = 'entity names') {
+        return new MetadataError(`Duplicate ${subject} 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 multipleDecorators(entityName, propertyName) {
+        return new MetadataError(`Multiple property decorators used on '${entityName}.${propertyName}' property`);
+    }
+    static missingMetadata(entity) {
+        return new MetadataError(`Metadata for entity ${entity} not found`);
+    }
+    static invalidPrimaryKey(meta, prop, requiredName) {
+        return this.fromMessage(meta, prop, `has wrong field name, '${requiredName}' is required in current driver`);
+    }
+    static invalidManyToManyWithPivotEntity(meta1, prop1, meta2, prop2) {
+        const p1 = `${meta1.className}.${prop1.name}`;
+        const p2 = `${meta2.className}.${prop2.name}`;
+        return new MetadataError(`${p1} and ${p2} use the same 'pivotEntity', but don't form a bidirectional relation. Specify 'inversedBy' or 'mappedBy' to link them.`);
+    }
+    static targetIsAbstract(meta, prop) {
+        return this.fromMessage(meta, prop, `targets abstract entity ${prop.type}. Maybe you forgot to put @Entity() decorator on the ${prop.type} class?`);
+    }
+    static propertyTargetsEntityType(meta, prop, target) {
+        /* istanbul 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?`);
+    }
+    static fromMissingOption(meta, prop, option) {
+        return this.fromMessage(meta, prop, `is missing '${option}' option`);
+    }
+    static fromMessage(meta, prop, message) {
+        return new MetadataError(`${meta.className}.${prop.name} ${message}`);
+    }
+}
+exports.MetadataError = MetadataError;
+class NotFoundError extends ValidationError {
+    static findOneFailed(name, where) {
+        return new NotFoundError(`${name} not found (${(0, util_1.inspect)(where)})`);
+    }
+    static findExactlyOneFailed(name, where) {
+        return new NotFoundError(`Wrong number of ${name} entities found for query ${(0, util_1.inspect)(where)}, expected exactly one`);
+    }
+}
+exports.NotFoundError = NotFoundError;

package/events/EventManager.d.ts

@@ -0,0 +1,17 @@
+import type { EntityMetadata } from '../typings';
+import type { EventArgs, EventSubscriber, FlushEventArgs, TransactionEventArgs } from './EventSubscriber';
+import { EventType, type TransactionEventType } from '../enums';
+export declare class EventManager {
+    private readonly listeners;
+    private readonly entities;
+    private readonly cache;
+    private readonly subscribers;
+    constructor(subscribers: EventSubscriber[]);
+    registerSubscriber(subscriber: EventSubscriber): void;
+    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>;
+    hasListeners<T>(event: EventType, meta: EntityMetadata<T>): boolean;
+    clone(): EventManager;
+    private getSubscribedEntities;
+}