@mikro-orm/core 7.0.0-rc.2 → 7.0.0-rc.3

package/entity/Reference.js

@@ -93,7 +93,8 @@ export class Reference {
             await wrapped.__em.populate(this.entity, options.populate, options);
         }
         if (!this.isInitialized() || options.refresh) {
-            if (options.dataloader ?? [DataloaderType.ALL, DataloaderType.REFERENCE].includes(wrapped.__em.config.getDataloaderType())) {
+            if (options.dataloader ??
+                [DataloaderType.ALL, DataloaderType.REFERENCE].includes(wrapped.__em.config.getDataloaderType())) {
                 const dataLoader = await wrapped.__em.getDataLoader('ref');
                 return dataLoader.load([this, options]);
             }
@@ -219,16 +220,44 @@ export class ScalarReference {
 }
 Object.defineProperties(Reference.prototype, {
     __reference: { value: true, enumerable: false },
-    __meta: { get() { return this.entity.__meta; } },
-    __platform: { get() { return this.entity.__platform; } },
-    __helper: { get() { return this.entity.__helper; } },
-    $: { get() { return this.entity; } },
-    get: { get() { return () => this.entity; } },
+    __meta: {
+        get() {
+            return this.entity.__meta;
+        },
+    },
+    __platform: {
+        get() {
+            return this.entity.__platform;
+        },
+    },
+    __helper: {
+        get() {
+            return this.entity.__helper;
+        },
+    },
+    $: {
+        get() {
+            return this.entity;
+        },
+    },
+    get: {
+        get() {
+            return () => this.entity;
+        },
+    },
 });
 Object.defineProperties(ScalarReference.prototype, {
     __scalarReference: { value: true, enumerable: false },
-    $: { get() { return this.value; } },
-    get: { get() { return () => this.value; } },
+    $: {
+        get() {
+            return this.value;
+        },
+    },
+    get: {
+        get() {
+            return () => this.value;
+        },
+    },
 });
 /**
  * shortcut for `wrap(entity).toReference()`

package/entity/WrappedEntity.js

@@ -71,7 +71,11 @@ export class WrappedEntity {
         if (!this.__em) {
             throw ValidationError.entityNotManaged(this.entity);
         }
-        return this.__em.findOne(this.entity.constructor, this.entity, { ...options, refresh: true, schema: this.__schema });
+        return this.__em.findOne(this.entity.constructor, this.entity, {
+            ...options,
+            refresh: true,
+            schema: this.__schema,
+        });
     }
     async populate(populate, options = {}) {
         if (!this.__em) {

package/entity/defineEntity.d.ts

@@ -1,6 +1,6 @@
 import type { EntityManager } from '../EntityManager.js';
 import type { ColumnType, PropertyOptions, ReferenceOptions, EnumOptions, EmbeddedOptions, ManyToOneOptions, OneToManyOptions, OneToOneOptions, ManyToManyOptions } from '../metadata/types.js';
-import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, EntityRepositoryType, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, IndexCallback, FormulaCallback, EntityCtor, IsNever } from '../typings.js';
+import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, EntityRepositoryType, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, IndexCallback, FormulaCallback, EntityCtor, IsNever, IWrappedEntity, DefineConfig, Config } from '../typings.js';
 import type { Raw } from '../utils/RawQueryFragment.js';
 import type { ScalarReference } from './Reference.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
@@ -96,7 +96,7 @@ export interface PropertyChain<Value, Options> {
     serializer(serializer: (value: Value, options?: SerializeOptions<any>) => any): PropertyChain<Value, Options>;
     serializedName(serializedName: string): PropertyChain<Value, Options>;
     groups(...groups: string[]): PropertyChain<Value, Options>;
-    customOrder(...customOrder: (string[] | number[] | boolean[])): PropertyChain<Value, Options>;
+    customOrder(...customOrder: string[] | number[] | boolean[]): PropertyChain<Value, Options>;
     extra(extra: string): PropertyChain<Value, Options>;
     ignoreSchemaChanges(...ignoreSchemaChanges: ('type' | 'extra' | 'default')[]): PropertyChain<Value, Options>;
     index(index?: boolean | string): PropertyChain<Value, Options>;
@@ -409,7 +409,7 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     /**
      * Specify a custom order based on the values. (SQL only)
      */
-    customOrder(...customOrder: (string[] | number[] | boolean[])): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
+    customOrder(...customOrder: string[] | number[] | boolean[]): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /**
      * Specify comment of column for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
      */
@@ -501,7 +501,7 @@ export declare class OneToManyOptionsBuilderOnlyMappedBy<Value extends object> e
     kind: '1:m';
 }, IncludeKeysForOneToManyOptions> {
     /** Point to the owning side property name. */
-    mappedBy(mappedBy: (keyof Value) | ((e: Value) => any)): Pick<UniversalPropertyOptionsBuilder<Value, EmptyOptions & {
+    mappedBy(mappedBy: keyof Value | ((e: Value) => any)): Pick<UniversalPropertyOptionsBuilder<Value, EmptyOptions & {
         kind: '1:m';
     }, IncludeKeysForOneToManyOptions>, IncludeKeysForOneToManyOptions>;
 }
@@ -553,7 +553,7 @@ declare const propertyBuilders: {
 };
 /** Own keys + base entity keys (when TBase is not `never`). Guards against `keyof never = string | number | symbol`. */
 type AllKeys<TProperties, TBase> = keyof TProperties | (IsNever<TBase> extends true ? never : keyof TBase);
-export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'repository' | 'orderBy'> {
+export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never, TForceObject extends boolean = false> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'repository' | 'orderBy'> {
     name: TName;
     tableName?: TTableName;
     extends?: {
@@ -563,6 +563,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     primaryKeys?: TPK & InferPrimaryKey<TProperties>[];
     hooks?: DefineEntityHooks;
     repository?: () => TRepository;
+    forceObject?: TForceObject;
     inheritance?: 'tpt';
     orderBy?: {
         [K in Extract<AllKeys<TProperties, TBase>, string>]?: QueryOrderKeysFlat;
@@ -588,7 +589,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
         deferMode?: DeferMode | `${DeferMode}`;
     }[];
 }
-export declare function defineEntity<const TName extends string, const TTableName extends string, const TProperties extends Record<string, any>, const TPK extends (keyof TProperties)[] | undefined = undefined, const TBase = never, const TRepository = never>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase, TRepository>): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK, TBase, TRepository>, TBase, TProperties>;
+export declare function defineEntity<const TName extends string, const TTableName extends string, const TProperties extends Record<string, any>, const TPK extends (keyof TProperties)[] | undefined = undefined, const TBase = never, const TRepository = never, const TForceObject extends boolean = false>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase, TRepository, TForceObject>): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject>, TBase, TProperties>;
 export declare function defineEntity<const TEntity = any, const TProperties extends Record<string, any> = Record<string, any>, const TClassName extends string = string, const TTableName extends string = string, const TBase = never, const TClass extends EntityCtor = EntityCtor<TEntity>>(meta: Omit<Partial<EntityMetadata<TEntity>>, 'properties' | 'extends' | 'className' | 'tableName' | 'hooks'> & {
     class: TClass;
     className?: TClassName;
@@ -658,23 +659,34 @@ export interface DefineEntityHooks<T = any> {
 }
 type PropertyValueType = PropertyOptions<any>['type'];
 type InferPropertyValueType<T extends PropertyValueType> = T extends string ? InferTypeByString<T> : T extends NumberConstructor ? number : T extends StringConstructor ? string : T extends BooleanConstructor ? boolean : T extends DateConstructor ? Date : T extends ArrayConstructor ? string[] : T extends Constructor<infer TType> ? TType extends Type<infer TValue, any> ? NonNullable<TValue> : TType : T extends Type<infer TValue, any> ? NonNullable<TValue> : any;
-type InferTypeByString<T extends string> = T extends keyof typeof types ? InferJSType<typeof types[T]> : InferColumnType<T>;
+type InferTypeByString<T extends string> = T extends keyof typeof types ? InferJSType<(typeof types)[T]> : InferColumnType<T>;
 type InferJSType<T> = T extends typeof Type<infer TValue, any> ? NonNullable<TValue> : never;
 type InferColumnType<T extends string> = T extends 'int' | 'int4' | 'integer' | 'bigint' | 'int8' | 'int2' | 'tinyint' | 'smallint' | 'mediumint' ? number : T extends 'double' | 'double precision' | 'real' | 'float8' | 'decimal' | 'numeric' | 'float' | 'float4' ? number : T extends 'datetime' | 'time' | 'time with time zone' | 'timestamp' | 'timestamp with time zone' | 'timetz' | 'timestamptz' | 'date' | 'interval' ? Date : T extends 'ObjectId' | 'objectId' | 'character varying' | 'varchar' | 'char' | 'character' | 'uuid' | 'text' | 'tinytext' | 'mediumtext' | 'longtext' | 'enum' ? string : T extends 'boolean' | 'bool' | 'bit' ? boolean : T extends 'blob' | 'tinyblob' | 'mediumblob' | 'longblob' | 'bytea' ? Buffer : T extends 'point' | 'line' | 'lseg' | 'box' | 'circle' | 'path' | 'polygon' | 'geometry' ? number[] : T extends 'tsvector' | 'tsquery' ? string[] : T extends 'json' | 'jsonb' ? any : any;
-export type InferEntityFromProperties<Properties extends Record<string, any>, PK extends (keyof Properties)[] | undefined = undefined, Base = never, Repository = never> = {
+type BaseEntityMethodKeys = 'toObject' | 'toPOJO' | 'serialize' | 'assign' | 'populate' | 'init' | 'toReference';
+export type InferEntityFromProperties<Properties extends Record<string, any>, PK extends (keyof Properties)[] | undefined = undefined, Base = never, Repository = never, ForceObject extends boolean = false> = (IsNever<Base> extends true ? {} : Base extends {
+    toObject(...args: any[]): any;
+} ? Pick<IWrappedEntity<{
     -readonly [K in keyof Properties]: InferBuilderValue<MaybeReturnType<Properties[K]>>;
 } & {
     [PrimaryKeyProp]?: InferCombinedPrimaryKey<Properties, PK, Base>;
 } & (IsNever<Repository> extends true ? {} : {
     [EntityRepositoryType]?: Repository extends Constructor<infer R> ? R : Repository;
-}) & (IsNever<Base> extends true ? {} : Omit<Base, typeof PrimaryKeyProp>);
+}) & Omit<Base, typeof PrimaryKeyProp>>, BaseEntityMethodKeys> : {}) & {
+    -readonly [K in keyof Properties]: InferBuilderValue<MaybeReturnType<Properties[K]>>;
+} & {
+    [PrimaryKeyProp]?: InferCombinedPrimaryKey<Properties, PK, Base>;
+} & (IsNever<Repository> extends true ? {} : {
+    [EntityRepositoryType]?: Repository extends Constructor<infer R> ? R : Repository;
+}) & (IsNever<Base> extends true ? {} : Omit<Base, typeof PrimaryKeyProp>) & (ForceObject extends true ? {
+    [Config]?: DefineConfig<{
+        forceObject: true;
+    }>;
+} : {});
 type InferCombinedPrimaryKey<Properties extends Record<string, any>, PK, Base> = PK extends undefined ? CombinePrimaryKeys<InferPrimaryKey<Properties>, ExtractBasePrimaryKey<Base>> : PK;
 type ExtractBasePrimaryKey<Base> = Base extends {
     [PrimaryKeyProp]?: infer BasePK;
 } ? BasePK : never;
-type CombinePrimaryKeys<ChildPK, BasePK> = [
-    ChildPK
-] extends [never] ? BasePK : [BasePK] extends [never] ? IsUnion<ChildPK> extends true ? ChildPK[] : ChildPK : ChildPK | BasePK;
+type CombinePrimaryKeys<ChildPK, BasePK> = [ChildPK] extends [never] ? BasePK : [BasePK] extends [never] ? IsUnion<ChildPK> extends true ? ChildPK[] : ChildPK : ChildPK | BasePK;
 export type InferPrimaryKey<Properties extends Record<string, any>> = {
     [K in keyof Properties]: MaybeReturnType<Properties[K]> extends {
         '~options': {

package/entity/utils.js

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

package/entity/validators.js

@@ -52,7 +52,8 @@ export function validateParams(params, type = 'search condition', field) {
 }
 /** @internal */
 export function validatePrimaryKey(entity, meta) {
-    const pkExists = meta.primaryKeys.every(pk => entity[pk] != null) || (meta.serializedPrimaryKey && entity[meta.serializedPrimaryKey] != null);
+    const pkExists = meta.primaryKeys.every(pk => entity[pk] != null) ||
+        (meta.serializedPrimaryKey && entity[meta.serializedPrimaryKey] != null);
     if (!entity || !pkExists) {
         throw ValidationError.fromMergeWithoutPK(meta);
     }

package/enums.js

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

package/errors.js

@@ -34,12 +34,19 @@ export class ValidationError extends Error {
         return new ValidationError(`Entity ${entity.constructor.name} is not managed. An entity is managed if its fetched from the database or registered as new through EntityManager.persist()`);
     }
     static notEntity(owner, prop, data) {
-        const type = Object.prototype.toString.call(data).match(/\[object (\w+)]/)[1].toLowerCase();
+        const type = Object.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}, ${inspect(data)} of type ${type} given. If you are using Object.assign(entity, data), use em.assign(entity, data) instead.`);
     }
     static notDiscoveredEntity(data, meta, action = 'persist') {
         /* v8 ignore next */
-        const type = meta?.className ?? Object.prototype.toString.call(data).match(/\[object (\w+)]/)[1].toLowerCase();
+        const type = meta?.className ??
+            Object.prototype.toString
+                .call(data)
+                .match(/\[object (\w+)]/)[1]
+                .toLowerCase();
         let err = `Trying to ${action} not discovered entity of type ${type}.`;
         if (meta) {
             err += ` Entity with this name was discovered, but not the prototype you are passing to the ORM. If using EntitySchema, be sure to point to the implementation via \`class\`.`;
@@ -56,7 +63,10 @@ export class ValidationError extends Error {
         return new ValidationError(`Invalid enum array items provided in ${entityName}: ${inspect(invalid)}`);
     }
     static invalidType(type, value, mode) {
-        const valueType = Object.prototype.toString.call(value).match(/\[object (\w+)]/)[1].toLowerCase();
+        const valueType = Object.prototype.toString
+            .call(value)
+            .match(/\[object (\w+)]/)[1]
+            .toLowerCase();
         if (value instanceof Date) {
             value = value.toISOString();
         }
@@ -69,8 +79,8 @@ export class ValidationError extends Error {
     static cannotModifyInverseCollection(owner, property) {
         const inverseCollection = `${owner.constructor.name}.${property.name}`;
         const ownerCollection = `${property.type}.${property.mappedBy}`;
-        const error = `You cannot modify inverse side of M:N collection ${inverseCollection} when the owning side is not initialized. `
-            + `Consider working with the owning side instead (${ownerCollection}).`;
+        const error = `You cannot modify inverse side of M:N collection ${inverseCollection} when the owning side is not initialized. ` +
+            `Consider working with the owning side instead (${ownerCollection}).`;
         return new ValidationError(error, owner);
     }
     static cannotModifyReadonlyCollection(owner, property) {
@@ -79,7 +89,7 @@ export class ValidationError extends Error {
     static cannotRemoveFromCollectionWithoutOrphanRemoval(owner, property) {
         const options = [
             ' - add `orphanRemoval: true` to the collection options',
-            ' - add `deleteRule: \'cascade\'` to the owning side options',
+            " - add `deleteRule: 'cascade'` to the owning side options",
             ' - add `nullable: true` to the owning side options',
         ].join('\n');
         return new ValidationError(`Removing items from collection ${owner.constructor.name}.${property.name} without \`orphanRemoval: true\` would break non-null constraint on the owning side. You have several options: \n${options}`, owner);
@@ -91,7 +101,7 @@ export class ValidationError extends Error {
         return new ValidationError('You cannot call em.flush() from inside lifecycle hook handlers');
     }
     static cannotUseGlobalContext() {
-        return new ValidationError('Using global EntityManager instance methods for context specific actions is disallowed. If you need to work with the global instance\'s identity map, use `allowGlobalContext` configuration option or `fork()` instead.');
+        return new ValidationError("Using global EntityManager instance methods for context specific actions is disallowed. If you need to work with the global instance's identity map, use `allowGlobalContext` configuration option or `fork()` instead.");
     }
     static cannotUseOperatorsInsideEmbeddables(entityName, propName, payload) {
         return new ValidationError(`Using operators inside embeddables is not allowed, move the operator above. (property: ${Utils.className(entityName)}.${propName}, payload: ${inspect(payload)})`);
@@ -164,7 +174,7 @@ export class MetadataError extends ValidationError {
         return new MetadataError(`Entity ${meta.className} has wrong ${type} definition: '${prop}' does not exist. You need to use property name, not column name.`);
     }
     static multipleVersionFields(meta, fields) {
-        return new MetadataError(`Entity ${meta.className} has multiple version properties defined: '${fields.join('\', \'')}'. Only one version property is allowed per entity.`);
+        return new MetadataError(`Entity ${meta.className} has multiple version properties defined: '${fields.join("', '")}'. Only one version property is allowed per entity.`);
     }
     static invalidVersionFieldType(meta) {
         const prop = meta.properties[meta.versionProperty];

package/events/EventManager.js

@@ -35,7 +35,7 @@ export class EventManager {
         const hooks = (meta?.hooks[event] || []);
         listeners.push(...hooks.map(hook => {
             const prototypeHook = meta?.prototype[hook];
-            const handler = typeof hook === 'function' ? hook : entity[hook] ?? prototypeHook;
+            const handler = typeof hook === 'function' ? hook : (entity[hook] ?? prototypeHook);
             return handler.bind(entity);
         }));
         for (const listener of this.listeners[event] ?? new Set()) {

package/exceptions.js

@@ -9,10 +9,15 @@ export class DriverException extends Error {
     errmsg;
     constructor(previous) {
         super(previous.message);
-        Object.getOwnPropertyNames(previous).forEach(k => this[k] = previous[k]);
+        Object.getOwnPropertyNames(previous).forEach(k => (this[k] = previous[k]));
         this.name = this.constructor.name;
         Error.captureStackTrace(this, this.constructor);
-        this.stack += '\n\n' + previous.stack.split('\n').filter(l => l.trim().startsWith('at ')).join('\n');
+        this.stack +=
+            '\n\n' +
+                previous
+                    .stack.split('\n')
+                    .filter(l => l.trim().startsWith('at '))
+                    .join('\n');
     }
 }
 /**

package/hydration/ObjectHydrator.js

@@ -66,7 +66,10 @@ export class ObjectHydrator extends Hydrator {
         const hydrateScalar = (prop, path, dataKey) => {
             const entityKey = path.map(k => this.wrap(k)).join('');
             const tz = this.platform.getTimezone();
-            const convertorKey = path.filter(k => !k.match(/\[idx_\d+]/)).map(k => this.safeKey(k)).join('_');
+            const convertorKey = path
+                .filter(k => !k.match(/\[idx_\d+]/))
+                .map(k => this.safeKey(k))
+                .join('_');
             const ret = [];
             const idx = this.tmpIndex++;
             const nullVal = this.config.get('forceUndefined') ? 'undefined' : 'null';
@@ -139,7 +142,9 @@ export class ObjectHydrator extends Hydrator {
             ret.push(`  if (data${dataKey} === null) {\n    entity${entityKey} = ${nullVal};`);
             ret.push(`  } else if (typeof data${dataKey} !== 'undefined') {`);
             // For polymorphic: instanceof check; for regular: isPrimaryKey() check
-            const pkCheck = prop.polymorphic ? `data${dataKey} instanceof PolymorphicRef` : `isPrimaryKey(data${dataKey}, true)`;
+            const pkCheck = prop.polymorphic
+                ? `data${dataKey} instanceof PolymorphicRef`
+                : `isPrimaryKey(data${dataKey}, true)`;
             ret.push(`    if (${pkCheck}) {`);
             // When targetKey is set, pass the key option to createReference so it uses the alternate key
             const keyOption = prop.targetKey ? `, key: '${prop.targetKey}'` : '';
@@ -232,7 +237,10 @@ export class ObjectHydrator extends Hydrator {
             return ret;
         };
         const registerEmbeddedPrototype = (prop, path) => {
-            const convertorKey = path.filter(k => !k.match(/\[idx_\d+]/)).map(k => this.safeKey(k)).join('_');
+            const convertorKey = path
+                .filter(k => !k.match(/\[idx_\d+]/))
+                .map(k => this.safeKey(k))
+                .join('_');
             if (prop.targetMeta?.polymorphs) {
                 prop.targetMeta.polymorphs.forEach(meta => {
                     context.set(`prototype_${convertorKey}_${meta.className}`, meta.prototype);
@@ -297,7 +305,9 @@ export class ObjectHydrator extends Hydrator {
                     meta.props
                         .filter(p => p.embedded?.[0] === prop.name)
                         .forEach(childProp => {
-                        const childDataKey = prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
+                        const childDataKey = prop.object
+                            ? dataKey + this.wrap(childProp.embedded[1])
+                            : this.wrap(childProp.name);
                         const prop2 = childMeta.properties[childProp.embedded[1]];
                         const prop3 = {
                             ...prop2,
@@ -305,8 +315,9 @@ export class ObjectHydrator extends Hydrator {
                             embedded: childProp.embedded,
                             embeddedProps: childProp.embeddedProps,
                         };
-                        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                        ret.push(...hydrateProperty(prop3, childProp.object, [...path, childProp.embedded[1]], childDataKey).map(l => '    ' + l));
+                        ret.push(
+                        // eslint-disable-next-line @typescript-eslint/no-use-before-define, no-use-before-define
+                        ...hydrateProperty(prop3, childProp.object, [...path, childProp.embedded[1]], childDataKey).map(l => '    ' + l));
                     });
                     ret.push(`    }`);
                 });
@@ -321,8 +332,9 @@ export class ObjectHydrator extends Hydrator {
                     .filter(p => p.embedded?.[0] === prop.name)
                     .forEach(childProp => {
                     const childDataKey = prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
-                    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                    ret.push(...hydrateProperty(childProp, prop.object, [...path, childProp.embedded[1]], childDataKey).map(l => '  ' + l));
+                    ret.push(
+                    // eslint-disable-next-line @typescript-eslint/no-use-before-define, no-use-before-define
+                    ...hydrateProperty(childProp, prop.object, [...path, childProp.embedded[1]], childDataKey).map(l => '  ' + l));
                 });
             }
             /* v8 ignore next */
@@ -353,7 +365,8 @@ export class ObjectHydrator extends Hydrator {
         };
         const hydrateProperty = (prop, object = prop.object, path = [prop.name], dataKey) => {
             const entityKey = path.map(k => this.wrap(k)).join('');
-            dataKey = dataKey ?? (object ? entityKey : this.wrap(normalizeAccessors ? (prop.accessor ?? prop.name) : prop.name));
+            dataKey =
+                dataKey ?? (object ? entityKey : this.wrap(normalizeAccessors ? (prop.accessor ?? prop.name) : prop.name));
             const ret = [];
             if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.mapToPk) {
                 ret.push(...hydrateToOne(prop, dataKey, entityKey));
@@ -372,7 +385,8 @@ export class ObjectHydrator extends Hydrator {
                     }
                 }
             }
-            else { // ReferenceKind.SCALAR
+            else {
+                // ReferenceKind.SCALAR
                 ret.push(...hydrateScalar(prop, path, dataKey));
             }
             if (this.config.get('forceUndefined')) {
@@ -383,9 +397,9 @@ export class ObjectHydrator extends Hydrator {
         for (const prop of props) {
             lines.push(...hydrateProperty(prop));
         }
-        const code = `// compiled hydrator for entity ${meta.className} (${type + normalizeAccessors ? ' normalized' : ''})\n`
-            + `return function(entity, data, factory, newEntity, convertCustomTypes, schema, parentSchema, normalizeAccessors) {\n`
-            + `${lines.join('\n')}\n}`;
+        const code = `// compiled hydrator for entity ${meta.className} (${type + normalizeAccessors ? ' normalized' : ''})\n` +
+            `return function(entity, data, factory, newEntity, convertCustomTypes, schema, parentSchema, normalizeAccessors) {\n` +
+            `${lines.join('\n')}\n}`;
         const fnKey = `hydrator-${meta.uniqueName}-${type}-${normalizeAccessors}`;
         const hydrator = Utils.createFunction(context, code, this.config.get('compiledFunctions'), fnKey);
         this.hydrators[key].set(meta.class, hydrator);

package/index.d.ts

@@ -2,7 +2,7 @@
  * @packageDocumentation
  * @module core
  */
-export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, EntityName } from './typings.js';
+export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, EntityName, } from './typings.js';
 export type { CompiledFunctions, Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, InferEntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, EntityDTOFlat, EntityDTOProp, SerializeDTO, MigrationDiff, GenerateOptions, FilterObject, IMigrationRunner, IEntityGenerator, ISeedManager, SeederObject, IMigratorStorage, RequiredEntityData, CheckCallback, IndexCallback, FormulaCallback, FormulaTable, SchemaTable, SchemaColumns, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, MigrationInfo, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, TypeConfig, AnyString, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, RequiredNullable, DefineConfig, Opt, Hidden, EntitySchemaWithMeta, InferEntity, CheckConstraint, GeneratedColumnCallback, FilterDef, EntityCtor, Subquery, PopulateHintOptions, Prefixes, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';

package/index.js

@@ -2,7 +2,7 @@
  * @packageDocumentation
  * @module core
  */
-export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, EntityName } from './typings.js';
+export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, EntityName, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/logging/DefaultLogger.js

@@ -29,9 +29,7 @@ export class DefaultLogger {
         if (context?.level === 'warning') {
             message = colors.yellow(message);
         }
-        const label = context?.label
-            ? colors.cyan(`(${context.label}) `)
-            : '';
+        const label = context?.label ? colors.cyan(`(${context.label}) `) : '';
         this.writer(colors.grey(`[${namespace}] `) + label + message);
     }
     /**
@@ -60,8 +58,8 @@ export class DefaultLogger {
         if (namespace === 'deprecated') {
             const { ignoreDeprecations = false } = this.options;
             return Array.isArray(ignoreDeprecations)
-                /* v8 ignore next */
-                ? !ignoreDeprecations.includes(context?.label ?? '')
+                ? /* v8 ignore next */
+                    !ignoreDeprecations.includes(context?.label ?? '')
                 : !ignoreDeprecations;
         }
         return !!debugMode && (!Array.isArray(debugMode) || debugMode.includes(namespace));

package/logging/colors.js

@@ -1,11 +1,8 @@
 import { getEnv } from '../utils/env-vars.js';
 const bool = (k) => ['true', 't', '1'].includes(getEnv(k)?.toLowerCase() ?? '');
-const boolIfDefined = (k) => getEnv(k) != null ? bool(k) : true;
-const enabled = () => !bool('NO_COLOR')
-    && !bool('MIKRO_ORM_NO_COLOR')
-    && boolIfDefined('FORCE_COLOR')
-    && boolIfDefined('MIKRO_ORM_COLORS');
-const wrap = (fn) => (text) => enabled() ? fn(text) : text;
+const boolIfDefined = (k) => (getEnv(k) != null ? bool(k) : true);
+const enabled = () => !bool('NO_COLOR') && !bool('MIKRO_ORM_NO_COLOR') && boolIfDefined('FORCE_COLOR') && boolIfDefined('MIKRO_ORM_COLORS');
+const wrap = (fn) => (text) => (enabled() ? fn(text) : text);
 /** @internal */
 export const colors = {
     red: wrap((text) => `\x1B[31m${text}\x1B[39m`),

package/metadata/EntitySchema.d.ts

@@ -1,6 +1,6 @@
 import { EntityMetadata, type AnyEntity, type EntityKey, type Constructor, type DeepPartial, type EntityName, type EntityProperty, type CleanKeys, type ExpandProperty, type IsNever, type EntityCtor } from '../typings.js';
 import { type EventType, ReferenceKind } from '../enums.js';
-import type { EventSubscriber } from '../events/EventSubscriber.js';
+import type { EventArgs } from '../events/EventSubscriber.js';
 import { Type } from '../types/Type.js';
 import type { PropertyOptions, ManyToOneOptions, OneToOneOptions, OneToManyOptions, ManyToManyOptions, EmbeddedOptions, EnumOptions, PrimaryKeyOptions, SerializedPrimaryKeyOptions, IndexOptions, UniqueOptions } from './types.js';
 type TypeType = string | NumberConstructor | StringConstructor | BooleanConstructor | DateConstructor | ArrayConstructor | Constructor<Type<any>> | Type<any>;
@@ -108,6 +108,6 @@ export declare class EntitySchema<Entity = any, Base = never, Class extends Enti
      * });
      * ```
      */
-    addHook<Event extends EventType | `${EventType}`, T extends Entity = Entity>(event: Event, handler: NonNullable<EventSubscriber<T>[Event]>): this;
+    addHook<T extends Entity = Entity>(event: EventType | `${EventType}`, handler: (args: EventArgs<T>) => void | Promise<void>): this;
 }
 export {};

package/metadata/EntitySchema.js

@@ -34,7 +34,12 @@ export class EntitySchema {
     }
     addProperty(name, type, options = {}) {
         this.renameCompositeOptions(name, options);
-        const prop = { name, kind: ReferenceKind.SCALAR, ...options, ...this.normalizeType(options, type) };
+        const prop = {
+            name,
+            kind: ReferenceKind.SCALAR,
+            ...options,
+            ...this.normalizeType(options, type),
+        };
         if (type && Type.isMappedType(type.prototype)) {
             prop.type = type;
         }
@@ -299,7 +304,12 @@ export class EntitySchema {
             }
             else if (options.entity) {
                 const tmp = options.entity();
-                type = options.type = Array.isArray(tmp) ? tmp.map(t => Utils.className(t)).sort().join(' | ') : Utils.className(tmp);
+                type = options.type = Array.isArray(tmp)
+                    ? tmp
+                        .map(t => Utils.className(t))
+                        .sort()
+                        .join(' | ')
+                    : Utils.className(tmp);
                 const target = tmp instanceof EntitySchema ? tmp.meta.class : tmp;
                 return { type, target };
             }