@mikro-orm/core 7.1.0-dev.0 → 7.1.0-dev.10

package/typings.d.ts

@@ -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. */
@@ -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;
@@ -341,7 +391,7 @@ export interface IWrappedEntity<Entity extends object> {
     toObject<Ignored extends EntityKey<Entity>>(ignoreFields: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
     toJSON(...args: any[]): EntityDTO<Entity>;
     toPOJO(): EntityDTO<Entity>;
-    serialize<Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): SerializeDTO<Naked, Hint, Exclude>;
+    serialize<Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never, Fields extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude, Fields>): SerializeDTO<Naked, Hint, Exclude, never, ResolveSerializeFields<Fields, ExtractFieldsHint<Entity>>, SerializeFieldsKeepPK<Fields>>;
     setSerializationContext<Hint extends string = never, Fields extends string = never, Exclude extends string = never>(options: LoadHint<Entity, Hint, Fields, Exclude>): void;
     assign<Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(data: Data & IsSubset<EntityData<Naked, Convert>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
     getSchema(): string | undefined;
@@ -534,17 +584,32 @@ export type EntityDTOFlat<T, C extends TypeConfig = never> = {
 type SerializeTopHints<H extends string> = H extends `${infer Top}.${string}` ? Top : H;
 type SerializeSubHints<K extends string, H extends string> = H extends `${K}.${infer Rest}` ? Rest : never;
 type SerializeSubFields<K extends string, F extends string> = K extends F ? '*' : [F extends `${K & string}.${infer Rest}` ? Rest : never] extends [never] ? '*' : F extends `${K & string}.${infer Rest}` ? Rest : never;
-type SerializeFieldsFilter<T, K extends keyof T, F extends string> = K extends Prefix<T, F> | PrimaryProperty<T> ? K : never;
+type SerializeFieldsFilter<T, K extends keyof T, F extends string, KeepPK extends boolean = true> = K extends Prefix<T, F> | (KeepPK extends true ? PrimaryProperty<T> : never) ? K : never;
 type SerializePropValue<T, K extends keyof T, H extends string, C extends TypeConfig = never> = K & string extends SerializeTopHints<H> ? NonNullable<T[K]> extends CollectionShape<infer U> ? SerializeDTO<U & object, SerializeSubHints<K & string, H>, never, C>[] : SerializeDTO<ExpandProperty<T[K]>, SerializeSubHints<K & string, H>, never, C> | Extract<T[K], null | undefined> : EntityDTOProp<T, T[K], C>;
-type SerializePropValueWithFields<T, K extends keyof T, H extends string, C extends TypeConfig, F extends string> = K & string extends SerializeTopHints<H> ? NonNullable<T[K]> extends CollectionShape<infer U> ? SerializeDTO<U & object, SerializeSubHints<K & string, H>, never, C, SerializeSubFields<K & string, F>>[] : SerializeDTO<ExpandProperty<T[K]>, SerializeSubHints<K & string, H>, never, C, SerializeSubFields<K & string, F>> | Extract<T[K], null | undefined> : EntityDTOProp<T, T[K], C>;
+type SerializePropValueWithFields<T, K extends keyof T, H extends string, C extends TypeConfig, F extends string, KeepPK extends boolean = true> = K & string extends SerializeTopHints<H> ? NonNullable<T[K]> extends CollectionShape<infer U> ? SerializeDTO<U & object, SerializeSubHints<K & string, H>, never, C, SerializeSubFields<K & string, F>, KeepPK>[] : SerializeDTO<ExpandProperty<T[K]>, SerializeSubHints<K & string, H>, never, C, SerializeSubFields<K & string, F>, KeepPK> | Extract<T[K], null | undefined> : EntityDTOProp<T, T[K], C>;
+/**
+ * Resolves a user-provided `Fields` generic to the value passed to `SerializeDTO`'s `F` parameter:
+ * `never` (no `fields` option) falls back to `Default` (typically `'*'` or the entity's `ExtractFieldsHint`).
+ */
+export type ResolveSerializeFields<Fields extends string, Default extends string = '*'> = [Fields] extends [never] ? Default : Fields;
+/**
+ * Whether the explicit `serialize()` path should keep primary keys in the output. When the user does not provide
+ * a `fields` option (`Fields = never`), behave like `toObject()` and keep PKs; when they do, treat it as a strict
+ * whitelist so PKs are dropped unless listed.
+ */
+export type SerializeFieldsKeepPK<Fields extends string> = [Fields] extends [never] ? true : false;
 /**
  * Return type of `serialize()`. Combines Loaded + EntityDTO in a single pass for better performance.
  * Respects populate hints (`H`), exclude hints (`E`), and fields hints (`F`).
+ *
+ * `KeepPK` controls whether primary keys are auto-included when narrowing by `F`. The `toObject()` path keeps the
+ * default `true` (PKs always present); the explicit `serialize()` path passes `false` so the user-provided `fields`
+ * option is a strict whitelist that can drop PKs from the output.
  */
-export type SerializeDTO<T, H extends string = never, E extends string = never, C extends TypeConfig = never, F extends string = '*'> = string extends H ? EntityDTOFlat<T, C> : [F] extends ['*'] ? {
+export type SerializeDTO<T, H extends string = never, E extends string = never, C extends TypeConfig = never, F extends string = '*', KeepPK extends boolean = true> = string extends H ? EntityDTOFlat<T, C> : [F] extends ['*'] ? {
     [K in keyof T as ExcludeHidden<T, K> & CleanKeys<T, K> & (IsNever<E> extends true ? K : Exclude<K, E>)]: SerializePropValue<T, K, H, C> | Extract<T[K], null | undefined>;
 } : {
-    [K in keyof T as ExcludeHidden<T, K> & CleanKeys<T, K> & (IsNever<E> extends true ? K : Exclude<K, E>) & SerializeFieldsFilter<T, K, F>]: SerializePropValueWithFields<T, K, H, C, F> | Extract<T[K], null | undefined>;
+    [K in keyof T as ExcludeHidden<T, K> & CleanKeys<T, K> & (IsNever<E> extends true ? K : Exclude<K, E>) & SerializeFieldsFilter<T, K, F, KeepPK>]: SerializePropValueWithFields<T, K, H, C, F, KeepPK> | Extract<T[K], null | undefined>;
 };
 type TargetKeys<T> = T extends EntityClass<infer P> ? keyof P : keyof T;
 type PropertyName<T> = IsUnknown<T> extends false ? TargetKeys<T> : string;
@@ -591,6 +656,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. */
@@ -599,6 +666,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. */
@@ -818,6 +902,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: {
@@ -1045,6 +1130,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.
      */
@@ -1053,6 +1143,14 @@ export interface IMigrator {
      * Removes event handler.
      */
     off(event: MigratorEvent, listener: (event: MigrationInfo) => MaybePromise<void>): IMigrator;
+    /**
+     * Marks a migration as executed without actually running it.
+     */
+    logMigration(name: string): Promise<void>;
+    /**
+     * Removes a migration from the executed list without reverting it.
+     */
+    unlogMigration(name: string): Promise<void>;
     /**
      * @internal
      */
@@ -1119,11 +1217,23 @@ 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;
 type ExtractStringKeys<T> = {

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;

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,7 +70,25 @@ 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
+     */
+    logMigration(name: string): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    unlogMigration(name: string): Promise<void>;
     protected init(): Promise<void>;
     protected initPaths(): Promise<void>;
     protected initServices(): void;

package/utils/AbstractMigrator.js

@@ -63,6 +63,225 @@ 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
+     */
+    async logMigration(name) {
+        await this.init();
+        await this.storage.ensureTable?.();
+        await this.storage.logMigration({ name });
+    }
+    /**
+     * @inheritDoc
+     */
+    async unlogMigration(name) {
+        await this.init();
+        await this.storage.ensureTable?.();
+        await this.storage.unlogMigration({ name });
+    }
     async init() {
         if (this.initialized) {
             return;

package/utils/Configuration.d.ts

@@ -18,7 +18,7 @@ import type { MikroORM } from '../MikroORM.js';
 /** Holds and validates all ORM configuration options, providing access to drivers, loggers, cache adapters, and other services. */
 export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>> {
     #private;
-    constructor(options: Partial<Options>, validate?: boolean);
+    constructor(options: Partial<Options<any, any, any>>, validate?: boolean);
     /** Returns the database platform instance. */
     getPlatform(): ReturnType<D['getPlatform']>;
     /**
@@ -99,7 +99,7 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
 /**
  * Type helper to make it easier to use `mikro-orm.config.js`.
  */
-export declare function defineConfig<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<D> = EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Partial<Options<D, EM, Entities>>): Partial<Options<D, EM, Entities>>;
+export declare function defineConfig<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<D> = EntityManager<D>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Partial<Options<D, EM, Entities>>): Partial<Options<D, EM, Entities>>;
 /**
  * Connection configuration options for database connections.
  * @see https://mikro-orm.io/docs/configuration#connection
@@ -352,7 +352,7 @@ export interface MetadataDiscoveryOptions {
  * MikroORM configuration options.
  * @see https://mikro-orm.io/docs/configuration
  */
-export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<Driver> & Driver[typeof EntityManagerType] = EntityManager<Driver> & Driver[typeof EntityManagerType], Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends ConnectionOptions {
+export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<Driver> & Driver[typeof EntityManagerType] = EntityManager<Driver> & Driver[typeof EntityManagerType], Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends ConnectionOptions {
     /** Connection pool configuration. */
     pool: PoolConfig;
     /**
@@ -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>;
     }>>;