@mikro-orm/core 7.0.0-dev.99 → 7.0.0-rc.1

package/entity/defineEntity.d.ts

@@ -1,13 +1,14 @@
 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, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, IndexCallback } 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 } from '../typings.js';
+import type { Raw } from '../utils/RawQueryFragment.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, QueryOrderKeysFlat, 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';
@@ -120,7 +121,7 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
      * Specify default column value for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
      * This is a runtime value, assignable to the entity property. (SQL only)
      */
-    default<T extends string | string[] | number | number[] | boolean | null>(defaultValue: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'default'> & {
+    default<T extends string | string[] | number | number[] | boolean | null | Date | Raw>(defaultValue: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'default'> & {
         default: T;
     }, IncludeKeys>, IncludeKeys>;
     /**
@@ -139,7 +140,7 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
      *
      * @see https://mikro-orm.io/docs/defining-entities#formulas Formulas
      */
-    formula<T extends string | ((alias: string) => string)>(formula: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'formula'> & {
+    formula<T extends string | FormulaCallback<any>>(formula: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'formula'> & {
         formula: T;
     }, IncludeKeys>, IncludeKeys>;
     /**
@@ -311,6 +312,10 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     owner<T extends boolean = true>(owner?: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'owner'> & {
         owner: T;
     }, IncludeKeys>, IncludeKeys>;
+    /** For polymorphic relations. Specifies the property name that stores the entity type discriminator. Defaults to the property name. */
+    discriminator(discriminator: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
+    /** For polymorphic relations. Custom mapping of discriminator values to entity class names. */
+    discriminatorMap(discriminatorMap: Dictionary<string>): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** Point to the inverse side property name. */
     inversedBy(inversedBy: keyof Value | ((e: Value) => any)): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** Point to the owning side property name. */
@@ -326,7 +331,7 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     /** Override default name for pivot table (see {@doclink naming-strategy | Naming Strategy}). */
     pivotTable(pivotTable: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** Set pivot entity for this relation (see {@doclink collections#custom-pivot-table-entity | Custom pivot table entity}). */
-    pivotEntity(pivotEntity: string | (() => EntityName<any>)): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
+    pivotEntity(pivotEntity: () => EntityName): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
     joinColumn(joinColumn: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
@@ -339,6 +344,8 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     referenceColumnName(referenceColumnName: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
     referencedColumnNames(...referencedColumnNames: string[]): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
+    /** Specify the property name on the target entity that this FK references instead of the primary key. */
+    targetKey(targetKey: keyof Value): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** What to do when the target entity gets deleted. */
     deleteRule(deleteRule: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** What to do when the reference to the target entity gets updated. */
@@ -366,33 +373,36 @@ export declare class OneToManyOptionsBuilderOnlyMappedBy<Value extends object> e
     kind: '1:m';
 }, IncludeKeysForOneToManyOptions> {
     /** Point to the owning side property name. */
-    mappedBy(mappedBy: (AnyString & 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>;
 }
+type EntityTarget = {
+    '~entity': any;
+} | EntityClass;
 declare const propertyBuilders: {
     bigint: <Mode extends "bigint" | "number" | "string" = "bigint">(mode?: Mode) => UniversalPropertyOptionsBuilder<(Mode extends "bigint" ? bigint : Mode extends "number" ? number : string) & {}, EmptyOptions, IncludeKeysForProperty>;
     array: <T = string>(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string) => UniversalPropertyOptionsBuilder<T[], EmptyOptions, IncludeKeysForProperty>;
     decimal: <Mode extends "number" | "string" = "string">(mode?: Mode) => UniversalPropertyOptionsBuilder<NonNullable<Mode extends "number" ? number : string>, EmptyOptions, IncludeKeysForProperty>;
     json: <T>() => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
-    formula: <T>(formula: string | ((alias: string) => string)) => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
+    formula: <T>(formula: string | FormulaCallback<any>) => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
     datetime: (length?: number) => UniversalPropertyOptionsBuilder<Date, EmptyOptions, IncludeKeysForProperty>;
     time: (length?: number) => UniversalPropertyOptionsBuilder<any, EmptyOptions, IncludeKeysForProperty>;
     type: <T extends PropertyValueType>(type: T) => UniversalPropertyOptionsBuilder<InferPropertyValueType<T>, EmptyOptions, IncludeKeysForProperty>;
     enum: <const T extends (number | string)[] | (() => Dictionary)>(items?: T) => UniversalPropertyOptionsBuilder<T extends () => Dictionary ? ValueOf<ReturnType<T>> : T extends (infer Value)[] ? Value : T, EmptyOptions, IncludeKeysForEnumOptions>;
-    embedded: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any> | EntitySchemaWithMeta<any, any, any, any, any>[] | EntityClass<any>[]>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions, IncludeKeysForEmbeddedOptions>;
-    manyToMany: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any>>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
+    embedded: <Target extends EntityTarget | EntityTarget[]>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions, IncludeKeysForEmbeddedOptions>;
+    manyToMany: <Target extends EntityTarget>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
         kind: "m:n";
     }, IncludeKeysForManyToManyOptions>;
-    manyToOne: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any>>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
+    manyToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
         kind: "m:1";
     }, IncludeKeysForManyToOneOptions>;
-    oneToMany: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any>>(target: Target) => OneToManyOptionsBuilderOnlyMappedBy<InferEntity<Target>>;
-    oneToOne: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any>>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
+    oneToMany: <Target extends EntityTarget>(target: Target) => OneToManyOptionsBuilderOnlyMappedBy<InferEntity<Target>>;
+    oneToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
         kind: "1:1";
     }, IncludeKeysForOneToOneOptions>;
     date: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    blob: () => UniversalPropertyOptionsBuilder<NonNullable<Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike> | null>, EmptyOptions, IncludeKeysForProperty>;
+    blob: () => UniversalPropertyOptionsBuilder<NonNullable<Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | null>, EmptyOptions, IncludeKeysForProperty>;
     uint8array: () => UniversalPropertyOptionsBuilder<Uint8Array<ArrayBufferLike>, EmptyOptions, IncludeKeysForProperty>;
     enumArray: () => UniversalPropertyOptionsBuilder<(string | number)[], EmptyOptions, IncludeKeysForProperty>;
     integer: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
@@ -409,64 +419,76 @@ declare const propertyBuilders: {
     interval: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
     unknown: () => UniversalPropertyOptionsBuilder<{}, EmptyOptions, IncludeKeysForProperty>;
 };
-export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques'> {
+/** 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'> {
     name: TName;
     tableName?: TTableName;
-    extends?: EntityName<TBase>;
+    extends?: {
+        '~entity': TBase;
+    } | EntityCtor<TBase>;
     properties: TProperties | ((properties: typeof propertyBuilders) => TProperties);
     primaryKeys?: TPK & InferPrimaryKey<TProperties>[];
-    hooks?: DefineEntityHooks<InferEntityFromProperties<TProperties, TPK>>;
-    discriminatorColumn?: keyof TProperties;
-    versionProperty?: keyof TProperties;
-    concurrencyCheckKeys?: Set<keyof TProperties>;
-    serializedPrimaryKey?: keyof TProperties;
+    hooks?: DefineEntityHooks;
+    repository?: () => TRepository;
+    inheritance?: 'tpt';
+    orderBy?: {
+        [K in Extract<AllKeys<TProperties, TBase>, string>]?: QueryOrderKeysFlat;
+    } | {
+        [K in Extract<AllKeys<TProperties, TBase>, string>]?: QueryOrderKeysFlat;
+    }[];
+    discriminatorColumn?: string;
+    versionProperty?: AllKeys<TProperties, TBase>;
+    concurrencyCheckKeys?: Set<AllKeys<TProperties, TBase>>;
+    serializedPrimaryKey?: AllKeys<TProperties, TBase>;
     indexes?: {
         properties?: keyof TProperties | (keyof TProperties)[];
         name?: string;
         type?: string;
         options?: Dictionary;
-        expression?: string | IndexCallback<InferEntityFromProperties<TProperties, TPK>>;
+        expression?: string | IndexCallback<InferEntityFromProperties<TProperties, TPK, TBase>>;
     }[];
     uniques?: {
         properties?: keyof TProperties | (keyof TProperties)[];
         name?: string;
         options?: Dictionary;
-        expression?: string | IndexCallback<InferEntityFromProperties<TProperties, TPK>>;
+        expression?: string | IndexCallback<InferEntityFromProperties<TProperties, TPK, TBase>>;
         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>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase>): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK>, 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>(meta: Omit<Partial<EntityMetadata<TEntity>>, 'properties' | 'extends' | 'className' | 'tableName'> & {
-    class: EntityClass<TEntity>;
+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' | 'hooks'> & {
+    class: TClass;
     className?: TClassName;
     tableName?: TTableName;
-    extends?: EntityName<TBase>;
+    extends?: TBase;
     properties: TProperties | ((properties: typeof propertyBuilders) => TProperties);
-}): EntitySchemaWithMeta<TClassName, TTableName, TEntity, TBase, TProperties>;
+    hooks?: DefineEntityHooks<TEntity>;
+}): EntitySchemaWithMeta<TClassName, TTableName, TEntity, TBase, TProperties, TClass>;
 export declare namespace defineEntity {
     var properties: {
         bigint: <Mode extends "bigint" | "number" | "string" = "bigint">(mode?: Mode) => UniversalPropertyOptionsBuilder<(Mode extends "bigint" ? bigint : Mode extends "number" ? number : string) & {}, EmptyOptions, IncludeKeysForProperty>;
         array: <T = string>(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string) => UniversalPropertyOptionsBuilder<T[], EmptyOptions, IncludeKeysForProperty>;
         decimal: <Mode extends "number" | "string" = "string">(mode?: Mode) => UniversalPropertyOptionsBuilder<NonNullable<Mode extends "number" ? number : string>, EmptyOptions, IncludeKeysForProperty>;
         json: <T>() => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
-        formula: <T>(formula: string | ((alias: string) => string)) => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
+        formula: <T>(formula: string | FormulaCallback<any>) => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
         datetime: (length?: number) => UniversalPropertyOptionsBuilder<Date, EmptyOptions, IncludeKeysForProperty>;
         time: (length?: number) => UniversalPropertyOptionsBuilder<any, EmptyOptions, IncludeKeysForProperty>;
         type: <T extends PropertyValueType>(type: T) => UniversalPropertyOptionsBuilder<InferPropertyValueType<T>, EmptyOptions, IncludeKeysForProperty>;
         enum: <const T extends (number | string)[] | (() => Dictionary)>(items?: T) => UniversalPropertyOptionsBuilder<T extends () => Dictionary ? ValueOf<ReturnType<T>> : T extends (infer Value)[] ? Value : T, EmptyOptions, IncludeKeysForEnumOptions>;
-        embedded: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any> | EntitySchemaWithMeta<any, any, any, any, any>[] | EntityClass<any>[]>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions, IncludeKeysForEmbeddedOptions>;
-        manyToMany: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any>>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
+        embedded: <Target extends EntityTarget | EntityTarget[]>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions, IncludeKeysForEmbeddedOptions>;
+        manyToMany: <Target extends EntityTarget>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
             kind: "m:n";
         }, IncludeKeysForManyToManyOptions>;
-        manyToOne: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any>>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
+        manyToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
             kind: "m:1";
         }, IncludeKeysForManyToOneOptions>;
-        oneToMany: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any>>(target: Target) => OneToManyOptionsBuilderOnlyMappedBy<InferEntity<Target>>;
-        oneToOne: <Target extends EntitySchemaWithMeta<any, any, any, any, any> | EntityClass<any>>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
+        oneToMany: <Target extends EntityTarget>(target: Target) => OneToManyOptionsBuilderOnlyMappedBy<InferEntity<Target>>;
+        oneToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
             kind: "1:1";
         }, IncludeKeysForOneToOneOptions>;
         date: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        blob: () => UniversalPropertyOptionsBuilder<NonNullable<Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike> | null>, EmptyOptions, IncludeKeysForProperty>;
+        blob: () => UniversalPropertyOptionsBuilder<NonNullable<Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | null>, EmptyOptions, IncludeKeysForProperty>;
         uint8array: () => UniversalPropertyOptionsBuilder<Uint8Array<ArrayBufferLike>, EmptyOptions, IncludeKeysForProperty>;
         enumArray: () => UniversalPropertyOptionsBuilder<(string | number)[], EmptyOptions, IncludeKeysForProperty>;
         integer: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
@@ -485,21 +507,38 @@ 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>;
 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> = {
+export type InferEntityFromProperties<Properties extends Record<string, any>, PK extends (keyof Properties)[] | undefined = undefined, Base = never, Repository = never> = {
     -readonly [K in keyof Properties]: InferBuilderValue<MaybeReturnType<Properties[K]>>;
 } & {
-    [PrimaryKeyProp]?: PK extends undefined ? InferPrimaryKey<Properties> extends never ? never : IsUnion<InferPrimaryKey<Properties>> extends true ? InferPrimaryKey<Properties>[] : InferPrimaryKey<Properties> : PK;
-};
+    [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>);
+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;
 export type InferPrimaryKey<Properties extends Record<string, any>> = {
     [K in keyof Properties]: MaybeReturnType<Properties[K]> extends {
         '~options': {
@@ -548,18 +587,18 @@ type MaybeOpt<Value, Options> = Options extends {
     mapToPk: true;
 } ? Value extends Opt<infer OriginalValue> ? OriginalValue : Value : Options extends {
     autoincrement: true;
-} ? Opt<Value> : Options extends {
+} | {
     onCreate: Function;
-} ? Opt<Value> : Options extends {
-    default: string | string[] | number | number[] | boolean | null;
-} ? Opt<Value> : Options extends {
+} | {
+    default: string | string[] | number | number[] | boolean | null | Date | Raw;
+} | {
     defaultRaw: string;
-} ? Opt<Value> : Options extends {
+} | {
     persist: false;
-} ? Opt<Value> : Options extends {
+} | {
     version: true;
-} ? Opt<Value> : Options extends {
-    formula: string | (() => string);
+} | {
+    formula: string | ((...args: any[]) => any);
 } ? Opt<Value> : Value;
 type MaybeHidden<Value, Options> = Options extends {
     hidden: true;

package/entity/defineEntity.js

@@ -353,6 +353,14 @@ export class UniversalPropertyOptionsBuilder {
     owner(owner = true) {
         return this.assignOptions({ owner });
     }
+    /** For polymorphic relations. Specifies the property name that stores the entity type discriminator. Defaults to the property name. */
+    discriminator(discriminator) {
+        return this.assignOptions({ discriminator });
+    }
+    /** For polymorphic relations. Custom mapping of discriminator values to entity class names. */
+    discriminatorMap(discriminatorMap) {
+        return this.assignOptions({ discriminatorMap });
+    }
     /** Point to the inverse side property name. */
     inversedBy(inversedBy) {
         return this.assignOptions({ inversedBy });
@@ -409,6 +417,10 @@ export class UniversalPropertyOptionsBuilder {
     referencedColumnNames(...referencedColumnNames) {
         return this.assignOptions({ referencedColumnNames });
     }
+    /** Specify the property name on the target entity that this FK references instead of the primary key. */
+    targetKey(targetKey) {
+        return this.assignOptions({ targetKey });
+    }
     /** What to do when the target entity gets deleted. */
     deleteRule(deleteRule) {
         return this.assignOptions({ deleteRule });

package/entity/index.d.ts

@@ -1,5 +1,6 @@
 export * from './EntityRepository.js';
 export * from './EntityIdentifier.js';
+export * from './PolymorphicRef.js';
 export * from './EntityAssigner.js';
 export * from './EntityHelper.js';
 export * from './EntityFactory.js';

package/entity/index.js

@@ -1,5 +1,6 @@
 export * from './EntityRepository.js';
 export * from './EntityIdentifier.js';
+export * from './PolymorphicRef.js';
 export * from './EntityAssigner.js';
 export * from './EntityHelper.js';
 export * from './EntityFactory.js';

package/entity/utils.d.ts

@@ -1,4 +1,4 @@
-import type { EntityMetadata, PopulateOptions } from '../typings.js';
+import type { EntityMetadata, PopulateHintOptions, PopulateOptions } from '../typings.js';
 import { LoadStrategy, ReferenceKind } from '../enums.js';
 /**
  * @internal
@@ -10,3 +10,8 @@ export declare function expandDotPaths<Entity>(meta: EntityMetadata<Entity>, pop
  * @internal
  */
 export declare function getLoadingStrategy(strategy: LoadStrategy | `${LoadStrategy}`, kind: ReferenceKind): LoadStrategy.SELECT_IN | LoadStrategy.JOINED;
+/**
+ * Applies per-relation overrides from `populateHints` to the normalized populate tree.
+ * @internal
+ */
+export declare function applyPopulateHints<Entity>(populate: PopulateOptions<Entity>[], hints: Record<string, PopulateHintOptions>): void;

package/entity/utils.js

@@ -67,3 +67,36 @@ export function getLoadingStrategy(strategy, kind) {
     }
     return strategy;
 }
+/**
+ * Applies per-relation overrides from `populateHints` to the normalized populate tree.
+ * @internal
+ */
+export function applyPopulateHints(populate, hints) {
+    for (const [path, hint] of Object.entries(hints)) {
+        const entry = findPopulateEntry(populate, path.split('.'));
+        if (!entry) {
+            continue;
+        }
+        if (hint.strategy != null) {
+            entry.strategy = hint.strategy;
+        }
+        if (hint.joinType != null) {
+            entry.joinType = hint.joinType;
+        }
+    }
+}
+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

@@ -1,6 +1,6 @@
 import { Utils } from '../utils/Utils.js';
 import { ValidationError } from '../errors.js';
-import { isRaw } from '../utils/RawQueryFragment.js';
+import { isRaw, Raw } from '../utils/RawQueryFragment.js';
 import { SCALAR_TYPES } from '../enums.js';
 /** @internal */
 export function validateProperty(prop, givenValue, entity) {
@@ -59,7 +59,7 @@ export function validatePrimaryKey(entity, meta) {
 }
 /** @internal */
 export function validateEmptyWhere(where) {
-    if (Utils.isEmpty(where)) {
+    if (Utils.isEmpty(where) && !Raw.hasObjectFragments(where)) {
         throw new Error(`You cannot call 'EntityManager.findOne()' with empty 'where' parameter`);
     }
 }

package/enums.d.ts

@@ -1,4 +1,4 @@
-import type { Dictionary, EntityKey, ExpandProperty } from './typings.js';
+import type { EntityKey, ExpandProperty } from './typings.js';
 import type { Transaction } from './connections/Connection.js';
 import type { LogContext } from './logging/Logger.js';
 export declare enum FlushMode {
@@ -42,6 +42,7 @@ export declare enum QueryOperator {
     $none = "none",// collection operators, sql only
     $some = "some",// collection operators, sql only
     $every = "every",// collection operators, sql only
+    $size = "size",// collection operators, sql only
     $hasKey = "?",// postgres only, json
     $hasKeys = "?&",// postgres only, json
     $hasSomeKeys = "?|"
@@ -71,7 +72,6 @@ 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;
 }

package/enums.js

@@ -44,6 +44,7 @@ export var QueryOperator;
     QueryOperator["$none"] = "none";
     QueryOperator["$some"] = "some";
     QueryOperator["$every"] = "every";
+    QueryOperator["$size"] = "size";
     QueryOperator["$hasKey"] = "?";
     QueryOperator["$hasKeys"] = "?&";
     QueryOperator["$hasSomeKeys"] = "?|";

package/errors.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEntity, Constructor, Dictionary, EntityMetadata, EntityProperty, IPrimaryKey } from './typings.js';
+import type { AnyEntity, Constructor, Dictionary, EntityMetadata, EntityName, EntityProperty, IPrimaryKey } from './typings.js';
 export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Error {
     readonly entity?: T | undefined;
     constructor(message: string, entity?: T | undefined);
@@ -13,7 +13,7 @@ export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Er
     static entityNotManaged(entity: AnyEntity): ValidationError;
     static notEntity(owner: AnyEntity, prop: EntityProperty, data: any): ValidationError;
     static notDiscoveredEntity(data: any, meta?: EntityMetadata, action?: string): ValidationError;
-    static invalidPropertyName(entityName: string, invalid: string): ValidationError;
+    static invalidPropertyName(entityName: EntityName, invalid: string): ValidationError;
     static invalidCollectionValues(entityName: string, propName: string, invalid: unknown): ValidationError;
     static invalidEnumArrayItems(entityName: string, invalid: unknown): ValidationError;
     static invalidType(type: Constructor<any>, value: any, mode: string): ValidationError;
@@ -24,9 +24,9 @@ export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Er
     static invalidCompositeIdentifier(meta: EntityMetadata): ValidationError;
     static cannotCommit(): ValidationError;
     static cannotUseGlobalContext(): ValidationError;
-    static cannotUseOperatorsInsideEmbeddables(className: string, propName: string, payload: unknown): ValidationError;
-    static cannotUseGroupOperatorsInsideScalars(className: string, propName: string, payload: unknown): ValidationError;
-    static invalidEmbeddableQuery(className: string, propName: string, embeddableType: string): ValidationError;
+    static cannotUseOperatorsInsideEmbeddables(entityName: EntityName, propName: string, payload: unknown): ValidationError;
+    static cannotUseGroupOperatorsInsideScalars(entityName: EntityName, propName: string, payload: unknown): ValidationError;
+    static invalidEmbeddableQuery(entityName: EntityName, propName: string, embeddableType: string): ValidationError;
     static invalidQueryCondition(cond: unknown): ValidationError;
 }
 export declare class CursorError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {
@@ -49,11 +49,11 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static unknownIndexProperty(meta: EntityMetadata, prop: string, type: string): MetadataError;
     static multipleVersionFields(meta: EntityMetadata, fields: string[]): MetadataError;
     static invalidVersionFieldType(meta: EntityMetadata): MetadataError;
-    static fromUnknownEntity(className: string, source: string): MetadataError;
+    static fromUnknownEntity(entityName: string, source: string): MetadataError;
     static noEntityDiscovered(): MetadataError;
     static onlyAbstractEntitiesDiscovered(): MetadataError;
-    static duplicateEntityDiscovered(paths: string[], subject?: string): MetadataError;
-    static duplicateFieldName(className: string, names: [string, string][]): MetadataError;
+    static duplicateEntityDiscovered(paths: string[]): MetadataError;
+    static duplicateFieldName(entityName: EntityName, names: [string, string][]): MetadataError;
     static multipleDecorators(entityName: string, propertyName: string): MetadataError;
     static missingMetadata(entity: string): MetadataError;
     static invalidPrimaryKey(meta: EntityMetadata, prop: EntityProperty, requiredName: string): MetadataError<Partial<any>>;
@@ -62,6 +62,14 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static nonPersistentCompositeProp(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
     static propertyTargetsEntityType(meta: EntityMetadata, prop: EntityProperty, target: EntityMetadata): MetadataError<Partial<any>>;
     static fromMissingOption(meta: EntityMetadata, prop: EntityProperty, option: string): MetadataError<Partial<any>>;
+    static targetKeyOnManyToMany(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
+    static targetKeyNotUnique(meta: EntityMetadata, prop: EntityProperty, target?: EntityMetadata): MetadataError<Partial<any>>;
+    static targetKeyNotFound(meta: EntityMetadata, prop: EntityProperty, target?: EntityMetadata): MetadataError<Partial<any>>;
+    static incompatiblePolymorphicTargets(meta: EntityMetadata, prop: EntityProperty, target1: EntityMetadata, target2: EntityMetadata, reason: string): MetadataError<Partial<any>>;
+    static dangerousPropertyName(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
+    static viewEntityWithoutExpression(meta: EntityMetadata): MetadataError;
+    static mixedInheritanceStrategies(root: EntityMetadata, child: EntityMetadata): MetadataError;
+    static tptNotSupportedByDriver(meta: EntityMetadata): MetadataError;
     private static fromMessage;
 }
 export declare class NotFoundError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {

package/errors.js

@@ -1,4 +1,5 @@
 import { inspect } from './logging/inspect.js';
+import { Utils } from './utils/Utils.js';
 export class ValidationError extends Error {
     entity;
     constructor(message, entity) {
@@ -46,7 +47,7 @@ export class ValidationError extends Error {
         return new ValidationError(err);
     }
     static invalidPropertyName(entityName, invalid) {
-        return new ValidationError(`Entity '${entityName}' does not have property '${invalid}'`);
+        return new ValidationError(`Entity '${Utils.className(entityName)}' does not have property '${invalid}'`);
     }
     static invalidCollectionValues(entityName, propName, invalid) {
         return new ValidationError(`Invalid collection values provided for '${entityName}.${propName}' in ${entityName}.assign(): ${inspect(invalid)}`);
@@ -92,14 +93,14 @@ export class ValidationError extends Error {
     static cannotUseGlobalContext() {
         return new ValidationError('Using global EntityManager instance methods for context specific actions is disallowed. If you need to work with the global instance\'s identity map, use `allowGlobalContext` configuration option or `fork()` instead.');
     }
-    static cannotUseOperatorsInsideEmbeddables(className, propName, payload) {
-        return new ValidationError(`Using operators inside embeddables is not allowed, move the operator above. (property: ${className}.${propName}, payload: ${inspect(payload)})`);
+    static cannotUseOperatorsInsideEmbeddables(entityName, propName, payload) {
+        return new ValidationError(`Using operators inside embeddables is not allowed, move the operator above. (property: ${Utils.className(entityName)}.${propName}, payload: ${inspect(payload)})`);
     }
-    static 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 cannotUseGroupOperatorsInsideScalars(entityName, propName, payload) {
+        return new ValidationError(`Using group operators ($and/$or) inside scalar properties is not allowed, move the operator above. (property: ${Utils.className(entityName)}.${propName}, payload: ${inspect(payload)})`);
     }
-    static invalidEmbeddableQuery(className, propName, embeddableType) {
-        return new ValidationError(`Invalid query for entity '${className}', property '${propName}' does not exist in embeddable '${embeddableType}'`);
+    static invalidEmbeddableQuery(entityName, propName, embeddableType) {
+        return new ValidationError(`Invalid query for entity '${Utils.className(entityName)}', property '${propName}' does not exist in embeddable '${embeddableType}'`);
     }
     /* v8 ignore next */
     static invalidQueryCondition(cond) {
@@ -169,8 +170,8 @@ export class MetadataError extends ValidationError {
         const prop = meta.properties[meta.versionProperty];
         return new MetadataError(`Version property ${meta.className}.${prop.name} has unsupported type '${prop.type}'. Only 'number' and 'Date' are allowed.`);
     }
-    static fromUnknownEntity(className, source) {
-        return new MetadataError(`Entity '${className}' was not discovered, please make sure to provide it in 'entities' array when initializing the ORM (used in ${source})`);
+    static fromUnknownEntity(entityName, source) {
+        return new MetadataError(`Entity '${entityName}' was not discovered, please make sure to provide it in 'entities' array when initializing the ORM (used in ${source})`);
     }
     static noEntityDiscovered() {
         return new MetadataError('No entities were discovered');
@@ -178,11 +179,11 @@ export class MetadataError extends ValidationError {
     static onlyAbstractEntitiesDiscovered() {
         return new MetadataError('Only abstract entities were discovered, maybe you forgot to use @Entity() decorator? This can also happen when you have multiple `@mikro-orm/core` packages installed side by side.');
     }
-    static duplicateEntityDiscovered(paths, subject = 'entity names') {
-        return new MetadataError(`Duplicate ${subject} are not allowed: ${paths.join(', ')}`);
+    static duplicateEntityDiscovered(paths) {
+        return new MetadataError(`Duplicate table names are not allowed: ${paths.join(', ')}`);
     }
-    static duplicateFieldName(className, names) {
-        return new MetadataError(`Duplicate fieldNames are not allowed: ${names.map(n => `${className}.${n[0]} (fieldName: '${n[1]}')`).join(', ')}`);
+    static duplicateFieldName(entityName, names) {
+        return new MetadataError(`Duplicate fieldNames are not allowed: ${names.map(n => `${Utils.className(entityName)}.${n[0]} (fieldName: '${n[1]}')`).join(', ')}`);
     }
     static multipleDecorators(entityName, propertyName) {
         return new MetadataError(`Multiple property decorators used on '${entityName}.${propertyName}' property`);
@@ -212,6 +213,32 @@ export class MetadataError extends ValidationError {
     static fromMissingOption(meta, prop, option) {
         return this.fromMessage(meta, prop, `is missing '${option}' option`);
     }
+    static targetKeyOnManyToMany(meta, prop) {
+        return this.fromMessage(meta, prop, `uses 'targetKey' option which is not supported for ManyToMany relations`);
+    }
+    static targetKeyNotUnique(meta, prop, target) {
+        const targetName = target?.className ?? prop.type;
+        return this.fromMessage(meta, prop, `has 'targetKey' set to '${prop.targetKey}', but ${targetName}.${prop.targetKey} is not marked as unique`);
+    }
+    static targetKeyNotFound(meta, prop, target) {
+        const targetName = target?.className ?? prop.type;
+        return this.fromMessage(meta, prop, `has 'targetKey' set to '${prop.targetKey}', but ${targetName}.${prop.targetKey} does not exist`);
+    }
+    static incompatiblePolymorphicTargets(meta, prop, target1, target2, reason) {
+        return this.fromMessage(meta, prop, `has incompatible polymorphic targets ${target1.className} and ${target2.className}: ${reason}`);
+    }
+    static dangerousPropertyName(meta, prop) {
+        return this.fromMessage(meta, prop, `uses a dangerous property name '${prop.name}' which could lead to prototype pollution. Please use a different property name.`);
+    }
+    static viewEntityWithoutExpression(meta) {
+        return new MetadataError(`View entity ${meta.className} is missing 'expression'. View entities must have an expression defining the SQL query.`);
+    }
+    static mixedInheritanceStrategies(root, child) {
+        return new MetadataError(`Entity ${child.className} cannot mix STI (Single Table Inheritance) and TPT (Table-Per-Type) inheritance. Root entity ${root.className} uses STI (discriminatorColumn) but also has inheritance: 'tpt'. Choose one inheritance strategy per hierarchy.`);
+    }
+    static tptNotSupportedByDriver(meta) {
+        return new MetadataError(`Entity ${meta.className} uses TPT (Table-Per-Type) inheritance which is not supported by the current driver. TPT requires SQL JOINs and is only available with SQL drivers.`);
+    }
     static fromMessage(meta, prop, message) {
         return new MetadataError(`${meta.className}.${prop.name} ${message}`);
     }