@mikro-orm/core 7.1.0-dev.2 → 7.1.0-dev.20

package/typings.d.ts

@@ -11,7 +11,7 @@ import type { SerializationContext } from './serialization/SerializationContext.
 import type { SerializeOptions } from './serialization/EntitySerializer.js';
 import type { MetadataStorage } from './metadata/MetadataStorage.js';
 import type { EntitySchema } from './metadata/EntitySchema.js';
-import type { IndexColumnOptions } from './metadata/types.js';
+import type { EntityPartitionBy, IndexColumnOptions } from './metadata/types.js';
 import type { Type, types } from './types/index.js';
 import type { Platform } from './platforms/Platform.js';
 import type { Configuration } from './utils/Configuration.js';
@@ -47,7 +47,7 @@ export type AsyncFunction<R = any, T = Dictionary> = (args: T) => Promise<T>;
 export type Compute<T> = {
     [K in keyof T]: T[K];
 } & {};
-type InternalKeys = 'EntityRepositoryType' | 'PrimaryKeyProp' | 'OptionalProps' | 'EagerProps' | 'HiddenProps' | '__selectedType' | '__loadedType';
+type InternalKeys = 'EntityRepositoryType' | 'PrimaryKeyProp' | 'OptionalProps' | 'EagerProps' | 'HiddenProps' | 'IndexHints' | '__selectedType' | '__loadedType';
 /** Filters out function, symbol, and internal keys from an entity type. When `B = true`, also excludes scalar keys. */
 export type CleanKeys<T, K extends keyof T, B extends boolean = false> = T[K] & {} extends Function ? never : K extends symbol | InternalKeys ? never : B extends true ? T[K] & {} extends Scalar ? never : K : K;
 /** Extracts keys of `T` whose values are functions. */
@@ -113,7 +113,7 @@ type LoadedReferenceShape<T = any> = ReferenceShape & {
  * Using this instead of `Loadable<any>` in conditional type checks prevents
  * TypeScript from evaluating the full Collection/Reference interfaces.
  */
-type LoadableShape = CollectionShape | ReferenceShape | readonly any[];
+type LoadableShape = CollectionShape | ReferenceShape | LazyRef.Brand<any> | readonly any[];
 /** Gets all keys from all members of a union type (distributes over the union). */
 export type UnionKeys<T> = T extends any ? keyof T : never;
 /** Gets the type of a property from all union members that have it (distributes over the union). */
@@ -150,6 +150,44 @@ export declare const EntityName: unique symbol;
 export type InferEntityName<T> = T extends {
     [EntityName]?: infer Name;
 } ? (Name extends string ? Name : never) : never;
+/**
+ * Symbol used to declare index-to-column mappings on an entity type.
+ * For decorator entities, declare as a phantom property:
+ * ```typescript
+ * [IndexHints]?: { idx_email: 'email'; idx_name_age: 'name' | 'age' };
+ * ```
+ * For `defineEntity` entities, index hints are inferred automatically from
+ * named indexes (property-level `.index('name')` and entity-level `indexes`/`uniques`).
+ */
+export declare const IndexHints: unique symbol;
+/**
+ * Extracts the index hints map from an entity type. Returns `never` when no hints are declared.
+ * For decorator entities, `[IndexHints]` contains a pre-computed `{ idxName: 'prop' }` map.
+ * For `defineEntity` entities, `[IndexHints]` contains `[Properties]` (a tuple wrapping the
+ * raw property builders), which is lazily converted to the index map when first accessed.
+ */
+export type ExtractIndexHints<T> = T extends {
+    [IndexHints]?: infer H;
+} ? H extends [infer P extends Record<string, any>] ? InferPropertyIndexMap<P> : H : never;
+/**
+ * Extracts `{ indexName: propertyKey }` from property builder options.
+ * Checks `.index('name')` and `.unique('name')` on each property in a single pass.
+ */
+export type InferPropertyIndexMap<Properties extends Record<string, any>> = {
+    [K in keyof Properties as MaybeReturnType<Properties[K]> extends {
+        '~options': {
+            index: infer N extends string;
+        };
+    } ? N : MaybeReturnType<Properties[K]> extends {
+        '~options': {
+            unique: infer N extends string;
+        };
+    } ? N : never]: K & string;
+};
+/** Union of declared index names on an entity. Falls back to `string` when no `[IndexHints]` are declared. */
+export type IndexName<T> = [ExtractIndexHints<T>] extends [never] ? string : (keyof ExtractIndexHints<T> & string) | (string & {});
+/** Properties covered by the named index on entity T. Falls back to all entity keys when the index is unknown. */
+export type IndexColumns<T, Name extends string> = ExtractIndexHints<T> extends Record<Name, infer Cols> ? Cols & string : EntityKey<T>;
 /**
  * Branded type that marks a property as optional in `em.create()`.
  * Use as a property type wrapper: `createdAt: Opt<Date>` instead of listing in `[OptionalProps]`.
@@ -328,6 +366,18 @@ export type ObjectQuery<T> = OperatorMap<T> & FilterObject<T>;
  * Accepts an object query, a primary key value, entity props with operators, or an array of filters.
  */
 export type FilterQuery<T> = ObjectQuery<T> | NonNullable<ExpandScalar<Primary<T>>> | NonNullable<EntityProps<T> & OperatorMap<T>> | FilterQuery<T>[];
+/**
+ * `FilterQuery` restricted to only properties covered by the specified index(es).
+ * Used when `using` option is set in `FindOptions` to enforce type-safe index usage.
+ */
+export type IndexFilterQuery<T, Using extends string> = [Using] extends [never] ? FilterQuery<T> : (OperatorMap<T> & {
+    -readonly [K in Extract<EntityKey<T>, IndexColumns<T, Using>>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | ElemMatchFilter<FilterObjectProp<T, K>> | null;
+}) | NonNullable<ExpandScalar<Primary<T>>> | IndexFilterQuery<T, Using>[];
+/** Replaces `where` and `using` on an options type with index-aware variants when `Using` is specified. */
+export type WithUsingOptions<Opts, Entity, Using extends string> = Omit<Opts, 'where' | 'using'> & {
+    using?: Using | Using[];
+    where?: [Using] extends [never] ? FilterQuery<Entity> : IndexFilterQuery<Entity, Using>;
+};
 /** Public interface for the entity wrapper, accessible via `wrap(entity)`. Provides helper methods for entity state management. */
 export interface IWrappedEntity<Entity extends object> {
     isInitialized(): boolean;
@@ -417,12 +467,12 @@ type NonArrayObject = object & {
 export type EntityDataProp<T, C extends boolean> = T extends Date ? string | Date : T extends Scalar ? T : T extends ScalarReference<infer U> ? EntityDataProp<U, C> : T extends {
     __runtime?: infer Runtime;
     __raw?: infer Raw;
-} ? C extends true ? Raw : Runtime : T extends ReferenceShape<infer U> ? EntityDataNested<U, C> : T extends CollectionShape<infer U> ? U | U[] | EntityDataNested<U & object, C> | EntityDataNested<U & object, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : U[] | EntityDataNested<U, C>[] : EntityDataNested<T, C>;
+} ? C extends true ? Raw : Runtime : T extends LazyRef.Brand<infer U> ? EntityDataNested<U, C> : T extends ReferenceShape<infer U> ? EntityDataNested<U, C> : T extends CollectionShape<infer U> ? U | U[] | EntityDataNested<U & object, C> | EntityDataNested<U & object, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : U[] | EntityDataNested<U, C>[] : EntityDataNested<T, C>;
 /** Like `EntityDataProp` but used in `RequiredEntityData` context with required/optional key distinction. */
 export type RequiredEntityDataProp<T, O, C extends boolean> = T extends Date ? string | Date : Exclude<T, null> extends RequiredNullable.Brand ? T | null : T extends Scalar ? T : T extends ScalarReference<infer U> ? RequiredEntityDataProp<U, O, C> : T extends {
     __runtime?: infer Runtime;
     __raw?: infer Raw;
-} ? C extends true ? Raw : Runtime : T extends ReferenceShape<infer U> ? RequiredEntityDataNested<U, O, C> : T extends CollectionShape<infer U> ? U | U[] | RequiredEntityDataNested<U & object, O, C> | RequiredEntityDataNested<U & object, O, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : U[] | RequiredEntityDataNested<U, O, C>[] : RequiredEntityDataNested<T, O, C>;
+} ? C extends true ? Raw : Runtime : T extends LazyRef.Brand<infer U> ? RequiredEntityDataNested<U, O, C> : T extends ReferenceShape<infer U> ? RequiredEntityDataNested<U, O, C> : T extends CollectionShape<infer U> ? U | U[] | RequiredEntityDataNested<U & object, O, C> | RequiredEntityDataNested<U & object, O, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : U[] | RequiredEntityDataNested<U, O, C>[] : RequiredEntityDataNested<T, O, C>;
 /** Nested entity data shape for embedded or related entities within `EntityData`. */
 export type EntityDataNested<T, C extends boolean = false> = T extends undefined ? never : T extends any[] ? Readonly<T> : EntityData<T, C> | ExpandEntityProp<T, C>;
 type UnwrapScalarRef<T> = T extends ScalarReference<infer U> ? U : T;
@@ -471,6 +521,35 @@ type Relation<T> = {
 export type Rel<T> = T;
 /** Alias for `ScalarReference` (see {@apilink Ref}). */
 export type ScalarRef<T> = ScalarReference<T>;
+/**
+ * Type-level marker for a to-one relation that is **direct at runtime** (no `Reference` wrapper) but
+ * **restricted at compile time** until narrowed via `Loaded<>`.
+ *
+ * Use as the property type on a `@ManyToOne`/`@OneToOne` relation that does **not** have `ref: true`:
+ *
+ * ```ts
+ * @ManyToOne(() => User)
+ * author!: LazyRef<User>;
+ * ```
+ *
+ * Semantics:
+ * - **Runtime**: identical to a plain direct relation — `article.author` is a `User` instance (stub or hydrated),
+ *   `article.author instanceof User` is `true`, no `Reference` object is created.
+ * - **Type (unloaded view)**: only the primary key is accessible. Accessing other properties is a compile error.
+ * - **Type (loaded view)**: once the relation is in the populate hint of a `Loaded<Entity, 'author'>`, it narrows
+ *   back to the full entity — no `.$` or `.get()` indirection needed.
+ *
+ * Note: the safety is purely compile-time. JS code or `as any` casts bypass it.
+ */
+export type LazyRef<T extends object> = IsAny<T> extends true ? LazyRef.Brand<T> : {
+    [K in PrimaryProperty<T> & keyof T]: T[K];
+} & LazyRef.Brand<T>;
+export declare namespace LazyRef {
+    const __lazyRef: unique symbol;
+    interface Brand<T> {
+        [__lazyRef]?: (arg: T) => T;
+    }
+}
 /** Alias for `Reference<T> & { id: number }` (see {@apilink Ref}). */
 export type EntityRef<T extends object> = true extends IsUnknown<PrimaryProperty<T>> ? Reference<T> : IsAny<T> extends true ? Reference<T> : {
     [K in PrimaryProperty<T> & keyof T]: T[K];
@@ -606,6 +685,8 @@ export type IndexCallback<T> = (columns: Record<PropertyName<T>, string>, table:
 export type FormulaCallback<T> = (columns: FormulaColumns<T>, table: FormulaTable) => string | Raw;
 /** Callback for CHECK constraint expressions. Receives column mappings and table info. */
 export type CheckCallback<T> = (columns: Record<PropertyName<T>, string>, table: SchemaTable) => string | Raw;
+/** Callback for trigger body expressions. Receives column mappings and table info. */
+export type TriggerCallback<T> = (columns: Record<PropertyName<T>, string>, table: SchemaTable) => string | Raw;
 /** Callback for generated (computed) column expressions. Receives column mappings and table info. */
 export type GeneratedColumnCallback<T> = (columns: Record<PropertyName<T>, string>, table: SchemaTable) => string | Raw;
 /** Definition of a CHECK constraint on a table or property. */
@@ -614,6 +695,23 @@ export interface CheckConstraint<T = any> {
     property?: string;
     expression: string | Raw | CheckCallback<T>;
 }
+/** Definition of a database trigger on a table. */
+export interface TriggerDef<T = any> {
+    /** Trigger name. Auto-generated if omitted. */
+    name?: string;
+    /** When the trigger fires relative to the event. */
+    timing: 'before' | 'after' | 'instead of';
+    /** Which DML events activate the trigger. */
+    events: ('insert' | 'update' | 'delete' | 'truncate')[];
+    /** Whether the trigger fires once per row or per statement. Defaults to `'row'`. */
+    forEach?: 'row' | 'statement';
+    /** SQL body of the trigger. Can be a string, Raw query, or callback receiving column name mappings. */
+    body?: string | Raw | TriggerCallback<T>;
+    /** Optional SQL WHEN condition for the trigger. */
+    when?: string;
+    /** Raw DDL escape hatch — full CREATE TRIGGER statement. Mutually exclusive with `body`. */
+    expression?: string;
+}
 /** Branded string that accepts any string value while preserving autocompletion for known literals. */
 export type AnyString = string & {};
 /** Describes a single property (column, relation, or embedded) within an entity's metadata. */
@@ -776,6 +874,8 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
     materialized?: boolean;
     /** For materialized views, whether data is populated on creation. Defaults to true. */
     withData?: boolean;
+    /** PostgreSQL partitioning definition for this table. */
+    partitionBy?: EntityPartitionBy<Entity>;
     expression?: string | ((em: any, where: ObjectQuery<Entity>, options: FindOptions<Entity, any, any, any>, stream?: boolean) => MaybePromise<Raw | object | string>);
     discriminatorColumn?: EntityKey<Entity> | AnyString;
     discriminatorValue?: number | string;
@@ -814,6 +914,7 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
         type?: string;
         options?: Dictionary;
         expression?: string | IndexCallback<Entity>;
+        where?: string | FilterQuery<Entity>;
         columns?: IndexColumnOptions[];
         include?: EntityKey<Entity> | EntityKey<Entity>[];
         fillFactor?: number;
@@ -826,6 +927,7 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
         name?: string;
         options?: Dictionary;
         expression?: string | IndexCallback<Entity>;
+        where?: string | FilterQuery<Entity>;
         deferMode?: DeferMode | `${DeferMode}`;
         columns?: IndexColumnOptions[];
         include?: EntityKey<Entity> | EntityKey<Entity>[];
@@ -833,6 +935,7 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
         disabled?: boolean;
     }[];
     checks: CheckConstraint<Entity>[];
+    triggers: TriggerDef<Entity>[];
     repositoryClass?: string;
     repository: () => EntityClass<EntityRepository<any>>;
     hooks: {
@@ -853,6 +956,8 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
     polymorphicDiscriminatorMap?: Dictionary<EntityClass>;
     /** Inheritance type: 'sti' (Single Table Inheritance) or 'tpt' (Table-Per-Type). Only set on root entities. */
     inheritanceType?: 'sti' | 'tpt';
+    /** Legacy alias populated from `EntityOptions.inheritance`; mirrored to `inheritanceType` during discovery. */
+    inheritance?: 'tpt';
     /** For TPT: direct parent entity metadata (the entity this one extends). */
     tptParent?: EntityMetadata;
     /** For TPT: direct child entities (entities that extend this one). */
@@ -1060,6 +1165,11 @@ export interface IMigrator {
      * Executes down migrations to the given point. Without parameter it will migrate one version down.
      */
     down(options?: string | string[] | Omit<MigrateOptions, 'from'>): Promise<MigrationInfo[]>;
+    /**
+     * Combines multiple executed migrations into a single migration file.
+     * Concatenates source code without touching the database schema.
+     */
+    rollup(migrations?: string[]): Promise<MigrationResult>;
     /**
      * Registers event handler.
      */
@@ -1142,13 +1252,32 @@ export type PopulateOptions<T> = {
     children?: PopulateOptions<T[keyof T]>[];
     /** When true, ignores `mapToPk` on the property and returns full entity data instead of just PKs. */
     dataOnly?: boolean;
+    /** Limit the number of items loaded per parent entity. Collections will be marked as partial and readonly. */
+    limit?: number;
+    /** Offset for per-parent limiting (used with `limit`). */
+    offset?: number;
+    /** Order by clause for per-parent limiting. Takes precedence over nested `FindOptions.orderBy`. */
+    orderBy?: QueryOrderMap<T[keyof T]>;
 };
 /** Inline options that can be appended to populate hint strings (e.g., strategy, join type). */
 export type PopulateHintOptions = {
     strategy?: LoadStrategy.JOINED | LoadStrategy.SELECT_IN | 'joined' | 'select-in';
     joinType?: 'inner join' | 'left join';
+    /** Limit the number of items loaded per parent entity. Collections will be marked as partial and readonly. */
+    limit?: number;
+    /** Offset for per-parent limiting (used with `limit`). */
+    offset?: number;
+    /** Order by clause for per-parent limiting. Takes precedence over nested `FindOptions.orderBy`. */
+    orderBy?: QueryOrderMap<any>;
 };
 type ExtractType<T> = T extends CollectionShape<infer U> ? U : T extends ReferenceShape<infer U> ? U : T extends Ref<infer U> ? U : T extends readonly (infer U)[] ? U : T;
+/**
+ * Like {@link ExtractType} but also unwraps {@link LazyRef}. Kept separate so {@link ExtractType}'s
+ * hot path (used by `IsOptional`, `EntityData`, `RequiredEntityData`) doesn't pay the cost of the
+ * extra branch — those contexts handle `LazyRef` in their own earlier branches (see
+ * `EntityDataProp` / `RequiredEntityDataProp`) before delegating to `ExtractType`.
+ */
+type ExtractTypeWithLazyRef<T> = T extends LazyRef.Brand<infer U> ? U : ExtractType<T>;
 type ExtractStringKeys<T> = {
     [K in keyof T]-?: CleanKeys<T, K>;
 }[keyof T] & {};
@@ -1156,8 +1285,8 @@ type ExtractStringKeys<T> = {
  * Extracts string keys from an entity type, handling Collection/Reference wrappers.
  * Simplified to just check `T extends object` since ExtractType handles the unwrapping.
  */
-type StringKeys<T, E extends string = never> = T extends object ? ExtractStringKeys<ExtractType<T>> | E : never;
-type GetStringKey<T, K extends StringKeys<T, string>, E extends string> = K extends keyof T ? ExtractType<T[K]> : K extends E ? keyof T : never;
+type StringKeys<T, E extends string = never> = T extends object ? ExtractStringKeys<ExtractTypeWithLazyRef<T>> | E : never;
+type GetStringKey<T, K extends StringKeys<T, string>, E extends string> = K extends keyof T ? ExtractTypeWithLazyRef<T[K]> : K extends E ? keyof T : never;
 type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 type RelationKeys<T> = T extends object ? {
     [K in keyof T]-?: CleanKeys<T, K, true>;
@@ -1172,8 +1301,8 @@ export type UnboxArray<T> = T extends any[] ? ArrayElement<T> : T;
 /** Extracts the element type from an array type. */
 export type ArrayElement<ArrayType extends unknown[]> = ArrayType extends (infer ElementType)[] ? ElementType : never;
 /** Unwraps a property type from its wrapper (Reference, Collection, or array) to the inner entity type. */
-export type ExpandProperty<T> = T extends ReferenceShape<infer U> ? NonNullable<U> : T extends CollectionShape<infer U> ? NonNullable<U> : T extends (infer U)[] ? NonNullable<U> : NonNullable<T>;
-type LoadedLoadable<T, E extends object> = T extends CollectionShape ? LoadedCollection<E> : T extends ScalarReference<infer U> ? LoadedScalarReference<U> : T extends ReferenceShape ? T & LoadedReference<E> : T extends Scalar ? T : T extends (infer U)[] ? U extends Scalar ? T : E[] : E;
+export type ExpandProperty<T> = T extends LazyRef.Brand<infer U> ? NonNullable<U> : T extends ReferenceShape<infer U> ? NonNullable<U> : T extends CollectionShape<infer U> ? NonNullable<U> : T extends (infer U)[] ? NonNullable<U> : NonNullable<T>;
+type LoadedLoadable<T, E extends object> = T extends CollectionShape ? LoadedCollection<E> : T extends ScalarReference<infer U> ? LoadedScalarReference<U> : T extends LazyRef.Brand<any> ? E : T extends ReferenceShape ? T & LoadedReference<E> : T extends Scalar ? T : T extends (infer U)[] ? U extends Scalar ? T : E[] : E;
 type IsTrue<T> = IsNever<T> extends true ? false : T extends boolean ? (T extends true ? true : false) : false;
 type StringLiteral<T> = T extends string ? (string extends T ? never : T) : never;
 type Prefix<T, K> = K extends `${infer S}.${string}` ? S : K extends '*' ? keyof T : K;
@@ -1207,7 +1336,7 @@ export type MergeSelected<T, U, F extends string> = IsLoadedType<T> extends true
 export type MergeLoaded<T, U, P extends string, F extends string, E extends string, R extends boolean = false> = IsLoadedType<T> extends true ? T & Loaded<U, P, F, E> : Loaded<T, P, F, E>;
 /** Extracts the nullability modifiers (`null`, `undefined`, or both) from a type `T`. */
 export type AddOptional<T> = undefined | null extends T ? null | undefined : null extends T ? null : undefined extends T ? undefined : never;
-type LoadedProp<T, L extends string = never, F extends string = '*', E extends string = never> = LoadedLoadable<T, Loaded<ExtractType<T>, L, F, E>>;
+type LoadedProp<T, L extends string = never, F extends string = '*', E extends string = never> = LoadedLoadable<T, Loaded<ExtractTypeWithLazyRef<T>, L, F, E>>;
 /** Extracts the eager-loaded property names declared via `[EagerProps]` as a string union. */
 export type AddEager<T> = ExtractEagerProps<T> & string;
 /** Combines an explicit populate hint `L` with the entity's eagerly loaded properties. */

package/typings.js

@@ -4,7 +4,6 @@ import { EntityHelper } from './entity/EntityHelper.js';
 import { helper } from './entity/wrap.js';
 import { Utils } from './utils/Utils.js';
 import { EntityComparator } from './utils/EntityComparator.js';
-import { BaseEntity } from './entity/BaseEntity.js';
 /** Symbol used to declare a custom repository type on an entity class (e.g., `[EntityRepositoryType]?: BookRepository`). */
 export const EntityRepositoryType = Symbol('EntityRepositoryType');
 /** Symbol used to declare the primary key property name(s) on an entity (e.g., `[PrimaryKeyProp]?: 'id'`). */
@@ -22,6 +21,16 @@ export const Config = Symbol('Config');
 /** Symbol used to declare the entity name as a string literal type (used by `defineEntity`). */
 // eslint-disable-next-line @typescript-eslint/no-redeclare
 export const EntityName = Symbol('EntityName');
+/**
+ * Symbol used to declare index-to-column mappings on an entity type.
+ * For decorator entities, declare as a phantom property:
+ * ```typescript
+ * [IndexHints]?: { idx_email: 'email'; idx_name_age: 'name' | 'age' };
+ * ```
+ * For `defineEntity` entities, index hints are inferred automatically from
+ * named indexes (property-level `.index('name')` and entity-level `indexes`/`uniques`).
+ */
+export const IndexHints = Symbol('IndexHints');
 /**
  * Runtime metadata for an entity, holding its properties, relations, indexes, hooks, and more.
  * Created during metadata discovery and used throughout the ORM lifecycle.
@@ -39,12 +48,20 @@ export class EntityMetadata {
         this.indexes = [];
         this.uniques = [];
         this.checks = [];
+        this.triggers = [];
         this.referencingProperties = [];
         this.concurrencyCheckKeys = new Set();
         Object.assign(this, meta);
         const name = meta.className ?? meta.name;
         if (!this.class && name) {
-            const Class = this.extends === BaseEntity ? { [name]: class extends BaseEntity {
+            let Parent;
+            if (typeof this.extends === 'function') {
+                Parent = this.extends;
+            }
+            else if (this.extends != null && typeof this.extends.class === 'function') {
+                Parent = this.extends.class;
+            }
+            const Class = Parent ? { [name]: class extends Parent {
                 } }[name] : { [name]: class {
                 } }[name];
             this.class = Class;
@@ -244,8 +261,8 @@ export class EntityMetadata {
         }, { __gettersDefined: { value: true, enumerable: false } });
     }
     initIndexes(prop) {
-        const simpleIndex = this.indexes.find(index => index.properties === prop.name && !index.options && !index.type && !index.expression);
-        const simpleUnique = this.uniques.find(index => index.properties === prop.name && !index.options);
+        const simpleIndex = this.indexes.find(index => index.properties === prop.name && !index.options && !index.type && !index.expression && index.where == null);
+        const simpleUnique = this.uniques.find(index => index.properties === prop.name && !index.options && !index.expression && index.where == null);
         const owner = prop.kind === ReferenceKind.MANY_TO_ONE;
         if (!prop.index && simpleIndex) {
             Utils.defaultValue(simpleIndex, 'name', true);

package/utils/AbstractMigrator.d.ts

@@ -1,4 +1,4 @@
-import type { Constructor, IMigrationGenerator, IMigrationRunner, IMigrator, IMigratorStorage, MaybePromise, Migration, MigrationInfo, MigrationRow, MigratorEvent } from '../typings.js';
+import type { Constructor, IMigrationGenerator, IMigrationRunner, IMigrator, IMigratorStorage, MaybePromise, Migration, MigrationInfo, MigrationResult, MigrationRow, MigratorEvent } from '../typings.js';
 import type { Transaction } from '../connections/Connection.js';
 import type { Configuration, MigrationsOptions } from './Configuration.js';
 import type { EntityManagerType, IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
@@ -70,6 +70,16 @@ export declare abstract class AbstractMigrator<D extends IDatabaseDriver> implem
      * @inheritDoc
      */
     down(options?: string | string[] | Omit<MigrateOptions, 'from'>): Promise<MigrationInfo[]>;
+    /**
+     * @inheritDoc
+     */
+    rollup(migrations?: string[]): Promise<MigrationResult>;
+    /**
+     * Extracts the body of a method from migration source code using brace counting.
+     * Returns the raw lines between the opening and closing braces, or empty string if not found.
+     * @internal
+     */
+    private extractMethodBody;
     abstract getStorage(): IMigratorStorage;
     /**
      * @inheritDoc

package/utils/AbstractMigrator.js

@@ -63,6 +63,209 @@ export class AbstractMigrator {
     async down(options) {
         return this.runMigrations('down', options);
     }
+    /**
+     * @inheritDoc
+     */
+    async rollup(migrations) {
+        await this.init();
+        const { fs } = await import('@mikro-orm/core/fs-utils');
+        const all = await this.discoverMigrations();
+        const executedSet = new Set(await this.storage.executed());
+        let toRollup;
+        if (migrations && migrations.length > 0) {
+            const requested = new Set(migrations.map(m => this.getMigrationFilename(m)));
+            toRollup = all.filter(m => requested.has(m.name));
+            const found = new Set(toRollup.map(m => m.name));
+            const notFound = [...requested].filter(name => !found.has(name));
+            if (notFound.length > 0) {
+                throw new Error(`Migrations not found: ${notFound.join(', ')}`);
+            }
+            const notExecuted = toRollup.filter(m => !executedSet.has(m.name));
+            if (notExecuted.length > 0) {
+                throw new Error(`Cannot roll up migrations that have not been executed: ${notExecuted.map(m => m.name).join(', ')}`);
+            }
+        }
+        else {
+            toRollup = all.filter(m => executedSet.has(m.name));
+        }
+        if (toRollup.length < 2) {
+            throw new Error('At least 2 executed migrations are required for rollup');
+        }
+        const withoutPath = toRollup.filter(m => !m.path);
+        if (withoutPath.length > 0) {
+            throw new Error(`Cannot roll up migrations without file paths (class-based migrations): ${withoutPath.map(m => m.name).join(', ')}`);
+        }
+        const upBodies = [];
+        const downBodies = [];
+        const placeholder = `__mikro_orm_rollup_${Date.now()}__`;
+        for (const migration of toRollup) {
+            const source = await fs.readFile(migration.path);
+            const upBody = this.extractMethodBody(source, 'up');
+            const downBody = this.extractMethodBody(source, 'down');
+            if (upBody) {
+                upBodies.push(`    // --- merged from ${migration.name} ---\n${upBody}`);
+            }
+            if (downBody) {
+                downBodies.unshift(`    // --- merged from ${migration.name} ---\n${downBody}`);
+            }
+        }
+        const diff = {
+            up: [placeholder],
+            down: downBodies.length > 0 ? [placeholder] : [],
+        };
+        const [templateCode, fileName] = await this.generator.generate(diff);
+        const placeholderRe = new RegExp(`^.*${placeholder}.*$`, 'm');
+        let code = templateCode.replace(placeholderRe, upBodies.join('\n'));
+        if (downBodies.length > 0) {
+            code = code.replace(placeholderRe, downBodies.join('\n'));
+        }
+        await fs.writeFile(fs.normalizePath(this.absolutePath, fileName), code, { flush: true });
+        const updateStorage = async () => {
+            for (const migration of toRollup) {
+                await this.storage.unlogMigration({ name: migration.name });
+            }
+            await this.storage.logMigration({ name: fileName.replace(/\.[jt]s$/, '') });
+        };
+        if (this.options.transactional) {
+            await this.driver.getConnection().transactional(async (trx) => {
+                this.storage.setMasterMigration(trx);
+                try {
+                    await updateStorage();
+                }
+                finally {
+                    this.storage.unsetMasterMigration();
+                }
+            });
+        }
+        else {
+            await updateStorage();
+        }
+        await Promise.all(toRollup.map(migration => fs.unlink(migration.path)));
+        return { fileName, code, diff: { up: [], down: [] } };
+    }
+    /**
+     * Extracts the body of a method from migration source code using brace counting.
+     * Returns the raw lines between the opening and closing braces, or empty string if not found.
+     * @internal
+     */
+    extractMethodBody(source, methodName) {
+        const lines = source.split('\n');
+        // match method declarations, not occurrences in comments/strings — require preceding whitespace or keyword
+        const methodPattern = new RegExp(`^\\s+(?:override\\s+|async\\s+)*${methodName}\\s*\\(`);
+        let methodLine = -1;
+        for (let i = 0; i < lines.length; i++) {
+            if (methodPattern.test(lines[i])) {
+                methodLine = i;
+                break;
+            }
+        }
+        if (methodLine === -1) {
+            return '';
+        }
+        let braceCount = 0;
+        let bodyStart = -1;
+        let bodyEnd = -1;
+        let bodyStartCol = -1;
+        let bodyEndCol = -1;
+        let inBacktick = false;
+        let inBlockComment = false;
+        // stack tracks brace depth at which each template expression `${...}` was entered
+        const templateExprStack = [];
+        for (let i = methodLine; i < lines.length; i++) {
+            const line = lines[i];
+            for (let j = 0; j < line.length; j++) {
+                // handle multi-line block comments
+                if (inBlockComment) {
+                    if (line[j] === '*' && j + 1 < line.length && line[j + 1] === '/') {
+                        inBlockComment = false;
+                        j++;
+                    }
+                    continue;
+                }
+                // handle multi-line template literals
+                if (inBacktick) {
+                    if (line[j] === '\\') {
+                        j++;
+                    }
+                    else if (line[j] === '`') {
+                        inBacktick = false;
+                    }
+                    else if (line[j] === '$' && j + 1 < line.length && line[j + 1] === '{') {
+                        // entering template expression — resume brace counting
+                        templateExprStack.push(braceCount);
+                        inBacktick = false;
+                        j++; // skip the {
+                        braceCount++;
+                    }
+                    continue;
+                }
+                const ch = line[j];
+                // single/double quoted strings (single-line only)
+                if (ch === "'" || ch === '"') {
+                    const quote = ch;
+                    j++;
+                    while (j < line.length) {
+                        if (line[j] === '\\') {
+                            j++;
+                        }
+                        else if (line[j] === quote) {
+                            break;
+                        }
+                        j++;
+                    }
+                    continue;
+                }
+                // template literal start
+                if (ch === '`') {
+                    inBacktick = true;
+                    continue;
+                }
+                // single-line comment
+                if (ch === '/' && j + 1 < line.length && line[j + 1] === '/') {
+                    break;
+                }
+                // block comment start
+                if (ch === '/' && j + 1 < line.length && line[j + 1] === '*') {
+                    inBlockComment = true;
+                    j++;
+                    continue;
+                }
+                if (ch === '{') {
+                    if (braceCount === 0) {
+                        bodyStart = i;
+                        bodyStartCol = j + 1;
+                    }
+                    braceCount++;
+                }
+                else if (ch === '}') {
+                    braceCount--;
+                    // closing a template expression — re-enter backtick mode
+                    if (templateExprStack.length > 0 && braceCount === templateExprStack[templateExprStack.length - 1]) {
+                        templateExprStack.pop();
+                        inBacktick = true;
+                        continue;
+                    }
+                    if (braceCount === 0) {
+                        bodyEnd = i;
+                        bodyEndCol = j;
+                        break;
+                    }
+                }
+            }
+            if (bodyEnd !== -1) {
+                break;
+            }
+        }
+        if (bodyStart === -1 || bodyEnd === -1) {
+            return '';
+        }
+        // single-line method body: extract content between braces on the same line
+        if (bodyStart === bodyEnd) {
+            const content = lines[bodyStart].slice(bodyStartCol, bodyEndCol).trim();
+            return content ? `    ${content}` : '';
+        }
+        return lines.slice(bodyStart + 1, bodyEnd).join('\n');
+    }
     /**
      * @inheritDoc
      */

package/utils/Configuration.d.ts

@@ -529,6 +529,13 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * @default false
      */
     forceUndefined: boolean;
+    /**
+     * Initialize nullable properties to `null` (or `undefined` when `forceUndefined` is set)
+     * during `em.create()` when they are not provided in the data. Without this option,
+     * nullable properties remain `undefined` until the entity is loaded from the database.
+     * @default false
+     */
+    initNullableProperties: boolean;
     /**
      * Property `onCreate` hooks are normally executed during `flush` operation.
      * With this option, they will be processed early inside `em.create()` method.

package/utils/Configuration.js

@@ -62,6 +62,7 @@ const DEFAULTS = {
     upsertManaged: true,
     forceEntityConstructor: false,
     forceUndefined: false,
+    initNullableProperties: false,
     forceUtcTimezone: true,
     processOnCreateHooksEarly: true,
     ensureDatabase: true,

package/utils/DataloaderUtils.d.ts

@@ -1,5 +1,5 @@
 import type { Constructor, Primary, Ref } from '../typings.js';
-import { Collection, type InitCollectionOptions } from '../entity/Collection.js';
+import { Collection, type InitCollectionOptions, type LoadCountOptions } from '../entity/Collection.js';
 import { type EntityManager } from '../EntityManager.js';
 import { type LoadReferenceOptions } from '../entity/Reference.js';
 type BatchLoadFn<K, V> = (keys: readonly K[]) => PromiseLike<ArrayLike<V | Error>>;
@@ -44,6 +44,15 @@ export declare class DataloaderUtils {
      * makes one query per entity and maps each input collection to the corresponding result.
      */
     static getManyToManyColBatchLoadFn(em: EntityManager): BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
+    /**
+     * Returns the count dataloader batchLoadFn, which aggregates `Collection.loadCount()` calls
+     * by entity and relation, issues a single grouped count query per entity+options combination
+     * via `em.countBy()`, and maps each input collection to the corresponding count.
+     *
+     * For 1:M relations, groups by the FK property on the target entity.
+     * For M:N relations, groups by the owner FK on the pivot entity.
+     */
+    static getCountBatchLoadFn(em: EntityManager): BatchLoadFn<[Collection<any>, Omit<LoadCountOptions<any>, 'dataloader' | 'refresh'>?], number>;
     static getDataLoader(): Promise<Constructor<{
         load: (...args: unknown[]) => Promise<unknown>;
     }>>;