@mikro-orm/core 7.0.0-dev.200 → 7.0.0-dev.201

package/entity/defineEntity.d.ts

@@ -3,11 +3,11 @@ import type { ColumnType, PropertyOptions, ReferenceOptions, EnumOptions, Embedd
 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 { ScalarReference } from './Reference.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
-import type { Cascade, DeferMode, EmbeddedPrefixMode, EventType, LoadStrategy, QueryOrderMap } from '../enums.js';
+import type { Cascade, DeferMode, EmbeddedPrefixMode, LoadStrategy, QueryOrderMap } from '../enums.js';
+import type { EventSubscriber } from '../events/EventSubscriber.js';
 import type { IType, Type } from '../types/Type.js';
 import { types } from '../types/index.js';
 import type { Collection } from './Collection.js';
-import type { EventSubscriber } from '../events/EventSubscriber.js';
 import type { FilterOptions } from '../drivers/IDatabaseDriver.js';
 export type UniversalPropertyKeys = keyof PropertyOptions<any> | keyof EnumOptions<any> | keyof EmbeddedOptions<any, any> | keyof ReferenceOptions<any, any> | keyof ManyToOneOptions<any, any> | keyof OneToManyOptions<any, any> | keyof OneToOneOptions<any, any> | keyof ManyToManyOptions<any, any>;
 type BuilderExtraKeys = '~options' | '~type' | '$type';
@@ -422,7 +422,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     } | EntityCtor<TBase>;
     properties: TProperties | ((properties: typeof propertyBuilders) => TProperties);
     primaryKeys?: TPK & InferPrimaryKey<TProperties>[];
-    hooks?: DefineEntityHooks<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>;
+    hooks?: DefineEntityHooks;
     repository?: () => TRepository;
     discriminatorColumn?: keyof TProperties;
     versionProperty?: keyof TProperties;
@@ -444,12 +444,13 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     }[];
 }
 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 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'> & {
+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;
     tableName?: TTableName;
     extends?: TBase;
     properties: TProperties | ((properties: typeof propertyBuilders) => TProperties);
+    hooks?: DefineEntityHooks<TEntity>;
 }): EntitySchemaWithMeta<TClassName, TTableName, TEntity, TBase, TProperties, TClass>;
 export declare namespace defineEntity {
     var properties: {
@@ -493,11 +494,19 @@ export declare namespace defineEntity {
     };
 }
 export { propertyBuilders as p };
-export interface DefineEntityHooks<T> extends Partial<MapToArray<Pick<EventSubscriber<T>, keyof typeof EventType>>> {
+type EntityHookValue<T, K extends keyof EventSubscriber<T>> = (keyof T | NonNullable<EventSubscriber<T>[K]>)[];
+export interface DefineEntityHooks<T = any> {
+    onInit?: EntityHookValue<T, 'onInit'>;
+    onLoad?: EntityHookValue<T, 'onLoad'>;
+    beforeCreate?: EntityHookValue<T, 'beforeCreate'>;
+    afterCreate?: EntityHookValue<T, 'afterCreate'>;
+    beforeUpdate?: EntityHookValue<T, 'beforeUpdate'>;
+    afterUpdate?: EntityHookValue<T, 'afterUpdate'>;
+    beforeUpsert?: EntityHookValue<T, 'beforeUpsert'>;
+    afterUpsert?: EntityHookValue<T, 'afterUpsert'>;
+    beforeDelete?: EntityHookValue<T, 'beforeDelete'>;
+    afterDelete?: EntityHookValue<T, 'afterDelete'>;
 }
-type MapToArray<T extends Record<string, any>> = {
-    [K in keyof T]: NonNullable<T[K]>[];
-};
 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>;

package/metadata/EntitySchema.d.ts

@@ -1,5 +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 { ReferenceKind } from '../enums.js';
+import { type EventType, ReferenceKind } from '../enums.js';
+import type { EventSubscriber } 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>;
@@ -83,5 +84,23 @@ export declare class EntitySchema<Entity = any, Base = never, Class extends Enti
     private createProperty;
     private rename;
     private renameCompositeOptions;
+    /**
+     * Adds a lifecycle hook handler to the entity schema.
+     * This method allows registering hooks after the entity is defined,
+     * which can be useful for avoiding circular type references.
+     *
+     * @example
+     * ```ts
+     * export const Article = defineEntity({
+     *   name: 'Article',
+     *   properties: { ... },
+     * });
+     *
+     * Article.addHook('beforeCreate', async args => {
+     *   args.entity.slug = args.entity.title.toLowerCase();
+     * });
+     * ```
+     */
+    addHook<Event extends EventType | `${EventType}`>(event: Event, handler: NonNullable<EventSubscriber<Entity>[Event]>): this;
 }
 export {};

package/metadata/EntitySchema.js

@@ -320,4 +320,26 @@ export class EntitySchema {
         this.rename(options, 'referenceColumnName', 'referencedColumnNames');
         this.rename(options, 'columnType', 'columnTypes');
     }
+    /**
+     * Adds a lifecycle hook handler to the entity schema.
+     * This method allows registering hooks after the entity is defined,
+     * which can be useful for avoiding circular type references.
+     *
+     * @example
+     * ```ts
+     * export const Article = defineEntity({
+     *   name: 'Article',
+     *   properties: { ... },
+     * });
+     *
+     * Article.addHook('beforeCreate', async args => {
+     *   args.entity.slug = args.entity.title.toLowerCase();
+     * });
+     * ```
+     */
+    addHook(event, handler) {
+        this._meta.hooks[event] ??= [];
+        this._meta.hooks[event].push(handler);
+        return this;
+    }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.200",
+  "version": "7.0.0-dev.201",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "exports": {
     "./package.json": "./package.json",

package/utils/Utils.js

@@ -123,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.200';
+    static #ORM_VERSION = '7.0.0-dev.201';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */