@mikro-orm/core 7.1.0-dev.1 → 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.
      */
@@ -1127,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,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>;
     }>>;

package/utils/DataloaderUtils.js

@@ -1,6 +1,7 @@
 import { Collection } from '../entity/Collection.js';
 import { helper } from '../entity/wrap.js';
 import { Reference } from '../entity/Reference.js';
+import { ReferenceKind } from '../enums.js';
 import { Utils } from './Utils.js';
 export class DataloaderUtils {
     static DataLoader;
@@ -216,6 +217,83 @@ export class DataloaderUtils {
             return ret;
         };
     }
+    /**
+     * 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) {
+        return async (collsWithOpts) => {
+            const groups = new Map();
+            const keys = [];
+            for (const [col, opts] of collsWithOpts) {
+                const prop = col.property;
+                let fkProp;
+                let countByClass;
+                let targetFilterProp;
+                if (prop.kind === ReferenceKind.ONE_TO_MANY) {
+                    fkProp = prop.mappedBy;
+                    countByClass = prop.targetMeta.class;
+                }
+                else {
+                    // M:N: group by the owner FK on the pivot entity
+                    const pivotMeta = em.getMetadata().get(prop.pivotEntity);
+                    const ownerPivotProp = pivotMeta.relations[prop.owner ? 0 : 1];
+                    const targetPivotProp = pivotMeta.relations[prop.owner ? 1 : 0];
+                    fkProp = ownerPivotProp.name;
+                    countByClass = pivotMeta.class;
+                    targetFilterProp = targetPivotProp.name;
+                }
+                // Include the owner-side uniqueName in the key so that two distinct owner entity types
+                // sharing a relation with the same property name (e.g. `Author.books` and `Publisher.books`)
+                // don't collide into a single batch that would use one owner's FK mapping for the other.
+                const ownerUniqueName = helper(col.owner).__meta.uniqueName;
+                const key = `${ownerUniqueName}.${prop.name}|${JSON.stringify(opts ?? {})}`;
+                keys.push(key);
+                let group = groups.get(key);
+                if (!group) {
+                    group = { fkProp, countByClass, targetFilterProp, ownerPKs: new Map(), opts: opts ?? {} };
+                    groups.set(key, group);
+                }
+                const pk = helper(col.owner).getPrimaryKey();
+                group.ownerPKs.set(JSON.stringify(pk), pk);
+            }
+            const promises = Array.from(groups.entries()).map(async ([key, group]) => {
+                const allPKs = Array.from(group.ownerPKs.values());
+                const { where, ...countOpts } = group.opts;
+                const conditions = [{ [group.fkProp]: { $in: allPKs } }];
+                if (where) {
+                    conditions.push(where);
+                }
+                // For M:N, apply the target entity's filters through the pivot's target relation
+                if (group.targetFilterProp) {
+                    const targetMeta = em.getMetadata().find(group.countByClass);
+                    const targetRelMeta = targetMeta.properties[group.targetFilterProp]?.targetMeta;
+                    if (targetRelMeta) {
+                        const filterCond = await em.applyFilters(targetRelMeta.class, {}, countOpts.filters, 'read');
+                        if (filterCond && Object.keys(filterCond).length > 0) {
+                            conditions.push({ [group.targetFilterProp]: filterCond });
+                        }
+                    }
+                }
+                const fkWhere = conditions.length === 1 ? conditions[0] : { $and: conditions };
+                const counts = await em.countBy(group.countByClass, group.fkProp, {
+                    where: fkWhere,
+                    ...countOpts,
+                });
+                return [key, counts];
+            });
+            const resultsMap = new Map(await Promise.all(promises));
+            return collsWithOpts.map(([col], i) => {
+                const pk = helper(col.owner).getPrimaryKey();
+                const counts = resultsMap.get(keys[i]);
+                return counts?.[String(pk)] ?? 0;
+            });
+        };
+    }
     static async getDataLoader() {
         if (this.DataLoader) {
             return this.DataLoader;

package/utils/QueryHelper.d.ts

@@ -6,6 +6,22 @@ import type { FilterOptions } from '../drivers/IDatabaseDriver.js';
 /** @internal */
 export declare class QueryHelper {
     static readonly SUPPORTED_OPERATORS: string[];
+    /**
+     * True when the property has multiple polymorph target types. Covers two structurally-equivalent
+     * shapes routed through the same loading path:
+     *   1. Union-target owner side — `Post.attachments: Collection<Image | Video>` (one owner, many
+     *      target types, shared pivot with target-side discriminator).
+     *   2. Merged inverse of Rails-style polymorphic M:N — `Tag.owners: Collection<Post | Video>`
+     *      (many owner types pointing at one target, viewed from the target where "owners" looks
+     *      like a union of multiple types).
+     *
+     * Both cases are loaded via `loadFromUnionTargetPolymorphicPivotTable`, which buckets pivot rows
+     * by discriminator and hydrates each target class separately.
+     */
+    static isUnionTargetPolymorphic(prop: {
+        polymorphic?: boolean;
+        polymorphTargets?: readonly unknown[];
+    }): boolean;
     /**
      * Finds the discriminator value (key) for a given entity class in a discriminator map.
      * Walks up the prototype chain so TPT subclasses resolve to their root's key.