@mikro-orm/core 7.1.0-dev.8 → 7.1.0

package/entity/EntityLoader.js

@@ -177,8 +177,9 @@ export class EntityLoader {
             Utils.isObject(orderBy[prop.name]))
             .flatMap(orderBy => orderBy[prop.name]);
         const where = await this.extractChildCondition(options, prop);
+        const mergedOrderBy = populate.orderBy ? Utils.asArray(populate.orderBy) : innerOrderBy;
         if (prop.kind === ReferenceKind.MANY_TO_MANY && this.#driver.getPlatform().usesPivotTable()) {
-            const pivotOrderBy = QueryHelper.mergeOrderBy(innerOrderBy, prop.orderBy, prop.targetMeta?.orderBy);
+            const pivotOrderBy = QueryHelper.mergeOrderBy(mergedOrderBy, prop.orderBy, prop.targetMeta?.orderBy);
             const res = await this.findChildrenFromPivotTable(filtered, prop, options, pivotOrderBy, populate, !!ref);
             return Utils.flatten(res);
         }
@@ -188,10 +189,12 @@ export class EntityLoader {
         const { items, partial } = await this.findChildren(options.filtered ?? entities, prop, populate, {
             ...options,
             where,
-            orderBy: innerOrderBy,
+            orderBy: mergedOrderBy,
         }, !!(ref || prop.mapToPk));
-        const customOrder = innerOrderBy.length > 0 || !!prop.orderBy || !!prop.targetMeta?.orderBy;
-        this.initializeCollections(filtered, prop, field, items, customOrder, partial);
+        const hasLimit = populate.limit != null;
+        const isPartial = partial || hasLimit;
+        const customOrder = mergedOrderBy.length > 0 || !!prop.orderBy || !!prop.targetMeta?.orderBy;
+        this.initializeCollections(filtered, prop, field, items, customOrder, isPartial, hasLimit);
         return items;
     }
     async populateScalar(meta, filtered, options) {
@@ -269,15 +272,15 @@ export class EntityLoader {
         }));
         return allItems;
     }
-    initializeCollections(filtered, prop, field, children, customOrder, partial) {
+    initializeCollections(filtered, prop, field, children, customOrder, partial, readonly) {
         if (prop.kind === ReferenceKind.ONE_TO_MANY) {
-            this.initializeOneToMany(filtered, children, prop, field, partial);
+            this.initializeOneToMany(filtered, children, prop, field, partial, readonly);
         }
         if (prop.kind === ReferenceKind.MANY_TO_MANY && !this.#driver.getPlatform().usesPivotTable()) {
-            this.initializeManyToMany(filtered, children, prop, field, customOrder, partial);
+            this.initializeManyToMany(filtered, children, prop, field, customOrder, partial, readonly);
         }
     }
-    initializeOneToMany(filtered, children, prop, field, partial) {
+    initializeOneToMany(filtered, children, prop, field, partial, readonly) {
         const mapToPk = prop.targetMeta.properties[prop.mappedBy].mapToPk;
         const map = {};
         for (const entity of filtered) {
@@ -293,14 +296,14 @@ export class EntityLoader {
         }
         for (const entity of filtered) {
             const key = helper(entity).getSerializedPrimaryKey();
-            entity[field].hydrate(map[key], undefined, partial);
+            entity[field].hydrate(map[key], undefined, partial, readonly);
         }
     }
-    initializeManyToMany(filtered, children, prop, field, customOrder, partial) {
+    initializeManyToMany(filtered, children, prop, field, customOrder, partial, readonly) {
         if (prop.mappedBy) {
             for (const entity of filtered) {
                 const items = children.filter(child => child[prop.mappedBy].contains(entity, false));
-                entity[field].hydrate(items, true, partial);
+                entity[field].hydrate(items, true, partial, readonly);
             }
         }
         else {
@@ -311,12 +314,12 @@ export class EntityLoader {
                 if (!customOrder) {
                     items.sort((a, b) => order.indexOf(a) - order.indexOf(b));
                 }
-                entity[field].hydrate(items, true, partial);
+                entity[field].hydrate(items, true, partial, readonly);
             }
         }
     }
     async findChildren(entities, prop, populate, options, ref) {
-        const children = Utils.unique(this.getChildReferences(entities, prop, options, ref));
+        const children = Utils.unique(this.getChildReferences(entities, prop, options, ref, populate));
         const meta = prop.targetMeta;
         // When targetKey is set, use it for FK lookup instead of the PK
         let fk = prop.targetKey ?? Utils.getPrimaryKeyHash(meta.primaryKeys);
@@ -334,10 +337,10 @@ export class EntityLoader {
                 fk = ownerProp.name;
             }
         }
-        if (prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner && !ref) {
+        if (prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner && (!ref || (!prop.mapToPk && !populate.filter))) {
             children.length = 0;
             fk = meta.properties[prop.mappedBy].name;
-            children.push(...this.filterByReferences(entities, prop.name, options.refresh));
+            children.push(...this.filterByReferences(entities, prop, options, ref));
         }
         if (children.length === 0) {
             return { items: [], partial };
@@ -366,8 +369,11 @@ export class EntityLoader {
         }
         const fields = this.buildFields(options.fields, prop, ref);
         /* eslint-disable prefer-const */
-        let { refresh, filters, convertCustomTypes, lockMode, strategy, populateWhere = 'infer', connectionType, logging, } = options;
+        let { refresh, filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging } = options;
         /* eslint-enable prefer-const */
+        // `populateWhere` is typed as required via `Required<EntityLoaderOptions>`, but `em.populate(...)`
+        // forwards user-supplied options without filling it in — keep the runtime default.
+        populateWhere ??= 'infer';
         if (typeof populateWhere === 'object') {
             populateWhere = await this.extractChildCondition({ where: populateWhere }, prop);
         }
@@ -375,7 +381,7 @@ export class EntityLoader {
             where = { $and: [where, prop.where] };
         }
         const orderBy = QueryHelper.mergeOrderBy(options.orderBy, prop.orderBy);
-        const items = await this.#em.find(meta.class, where, {
+        const findOptions = {
             filters,
             convertCustomTypes,
             lockMode,
@@ -390,11 +396,21 @@ export class EntityLoader {
             fields,
             schema,
             connectionType,
+            signal: options.signal,
+            inflightQueryAbortStrategy: options.inflightQueryAbortStrategy,
             // @ts-ignore not a public option, will be propagated to the populate call
             refresh: refresh && !children.every(item => options.visited.has(item)),
             // @ts-ignore not a public option, will be propagated to the populate call
             visited: options.visited,
-        });
+        };
+        if (populate.limit != null) {
+            findOptions._partitionLimit = {
+                partitionBy: fk,
+                limit: populate.limit,
+                offset: populate.offset,
+            };
+        }
+        const items = await this.#em.find(meta.class, where, findOptions);
         // For targetKey relations, wire up loaded entities to parent references
         // This is needed because the references were created under alternate key,
         // but loaded entities are stored under PK, so they don't automatically merge
@@ -582,6 +598,12 @@ export class EntityLoader {
         const options2 = { ...options, fields, exclude, populateFilter };
         ['limit', 'offset', 'first', 'last', 'before', 'after', 'overfetch'].forEach(prop => delete options2[prop]);
         options2.populate = populate?.children ?? [];
+        if (populate?.limit != null) {
+            options2._partitionLimit = {
+                limit: populate.limit,
+                offset: populate.offset,
+            };
+        }
         if (!Utils.isEmpty(prop.where)) {
             where = { $and: [where, prop.where] };
         }
@@ -609,7 +631,8 @@ export class EntityLoader {
                 });
                 return this.#em.getUnitOfWork().register(entity, item, { refresh, loaded: true });
             });
-            entity[prop.name].hydrate(items, true);
+            const hasLimit = populate?.limit != null;
+            entity[prop.name].hydrate(items, true, hasLimit, hasLimit);
             children.push(items);
         }
         return children;
@@ -670,8 +693,11 @@ export class EntityLoader {
             }
             return ret;
         }, []);
-        // we need to automatically select the FKs too, e.g. for 1:m relations to be able to wire them with the items
-        if (prop.kind === ReferenceKind.ONE_TO_MANY || prop.kind === ReferenceKind.MANY_TO_MANY) {
+        // we need to automatically select the FKs too, e.g. for 1:m and inverse 1:1 relations
+        // to be able to wire them with the items
+        if (prop.kind === ReferenceKind.ONE_TO_MANY ||
+            prop.kind === ReferenceKind.MANY_TO_MANY ||
+            (prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner)) {
             const owner = prop.targetMeta.properties[prop.mappedBy];
             // when the owning FK is lazy, we need to explicitly select it even without user-provided fields,
             // otherwise the driver will exclude it and we won't be able to map children to their parent collections
@@ -684,7 +710,7 @@ export class EntityLoader {
         }
         return ret;
     }
-    getChildReferences(entities, prop, options, ref) {
+    getChildReferences(entities, prop, options, ref, populate) {
         const filtered = this.filterCollections(entities, prop.name, options, ref);
         if (prop.kind === ReferenceKind.ONE_TO_MANY) {
             return filtered.map(e => e[prop.name].owner);
@@ -700,7 +726,7 @@ export class EntityLoader {
             return filtered;
         }
         // MANY_TO_ONE or ONE_TO_ONE
-        return this.filterReferences(entities, prop.name, options, ref);
+        return this.filterReferences(entities, prop.name, options, ref, populate);
     }
     filterCollections(entities, field, options, ref) {
         if (options.refresh) {
@@ -714,7 +740,16 @@ export class EntityLoader {
         }
         const wrapped = helper(entity);
         if (!field.includes('.')) {
-            return wrapped.__loadedProperties.has(field);
+            if (wrapped.__loadedProperties.has(field)) {
+                return true;
+            }
+            // Inlined embeddables track each leaf child separately, not the parent property,
+            // so we need to recurse for nested inline embeddables.
+            const prop = wrapped.__meta.properties[field];
+            if (prop?.kind === ReferenceKind.EMBEDDED && !prop.object) {
+                return Object.values(prop.embeddedProps).every(child => this.isPropertyLoaded(entity, child.name));
+            }
+            return false;
         }
         const [f, ...r] = field.split('.');
         /* v8 ignore next */
@@ -726,7 +761,7 @@ export class EntityLoader {
         }
         return this.isPropertyLoaded(entity[f], r.join('.'));
     }
-    filterReferences(entities, field, options, ref) {
+    filterReferences(entities, field, options, ref, populate) {
         if (ref) {
             return [];
         }
@@ -735,13 +770,19 @@ export class EntityLoader {
             return children.map(e => Reference.unwrapReference(e[field]));
         }
         if (options.fields) {
+            // `:ref` populate children are satisfied by FK/PK and will be loaded lazily — they don't force a parent reload
+            const refChildren = new Set((populate?.children ?? [])
+                .map(c => c.field.split(':'))
+                .filter(parts => parts[1] === 'ref')
+                .map(parts => parts[0]));
             return children
                 .map(e => Reference.unwrapReference(e[field]))
                 .filter(target => {
                 const wrapped = helper(target);
                 const childFields = options.fields
                     .filter(f => f.startsWith(`${field}.`))
-                    .map(f => f.substring(field.length + 1));
+                    .map(f => f.substring(field.length + 1))
+                    .filter(cf => !refChildren.has(cf.split('.')[0]));
                 return !wrapped.__initialized || !childFields.every(cf => this.isPropertyLoaded(target, cf));
             });
         }
@@ -749,12 +790,39 @@ export class EntityLoader {
             .filter(e => !e[field].__helper.__initialized)
             .map(e => Reference.unwrapReference(e[field]));
     }
-    filterByReferences(entities, field, refresh) {
+    filterByReferences(entities, prop, options, ref) {
         /* v8 ignore next */
-        if (refresh) {
+        if (options.refresh) {
             return entities;
         }
-        return entities.filter(e => e[field] !== null && !e[field]?.__helper?.__initialized);
+        const field = prop.name;
+        return entities.filter(e => {
+            const value = e[field];
+            if (value === null) {
+                return false;
+            }
+            if (value === undefined || !Utils.isEntity(value, true)) {
+                return true;
+            }
+            const target = Reference.unwrapReference(value);
+            const wrapped = helper(target);
+            if (!wrapped.__initialized) {
+                return true;
+            }
+            if (ref) {
+                return false;
+            }
+            if (options.fields) {
+                const childFields = options.fields
+                    .filter(f => f.startsWith(`${prop.name}.`))
+                    .map(f => f.substring(prop.name.length + 1));
+                return childFields.length > 0 && !childFields.every(f => this.isPropertyLoaded(target, f));
+            }
+            return prop.targetMeta.comparableProps.some(targetProp => {
+                const inlineEmbedded = targetProp.kind === ReferenceKind.EMBEDDED && !targetProp.object;
+                return !inlineEmbedded && !targetProp.lazy && !wrapped.__loadedProperties.has(targetProp.name);
+            });
+        });
     }
     lookupAllRelationships(entityName) {
         const ret = [];

package/entity/EntityRepository.d.ts

@@ -1,8 +1,8 @@
 import type { PopulatePath } from '../enums.js';
 import type { CreateOptions, EntityManager, MergeOptions } from '../EntityManager.js';
 import type { AssignOptions } from './EntityAssigner.js';
-import type { EntityData, EntityName, Primary, Loaded, FilterQuery, EntityDictionary, AutoPath, RequiredEntityData, Ref, EntityType, EntityDTO, MergeSelected, FromEntityType, IsSubset, MergeLoaded, ArrayElement, IndexFilterQuery, WithUsingOptions } from '../typings.js';
-import type { CountOptions, DeleteOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, NativeInsertUpdateOptions, StreamOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from '../drivers/IDatabaseDriver.js';
+import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityName, FilterQuery, Loaded, Primary, AutoPath, RequiredEntityData, Ref, EntityType, EntityDTO, MergeSelected, FromEntityType, IsSubset, MergeLoaded, ArrayElement, IndexFilterQuery, WithUsingOptions } from '../typings.js';
+import type { CountByOptions, CountOptions, DeleteOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, NativeInsertUpdateOptions, StreamOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from '../drivers/IDatabaseDriver.js';
 import type { EntityLoaderOptions } from './EntityLoader.js';
 import type { Cursor } from '../utils/Cursor.js';
 /** Repository class providing a type-safe API for querying and persisting a specific entity type. */
@@ -207,6 +207,16 @@ export declare class EntityRepository<Entity extends object> {
      * Returns total number of entities matching your `where` query.
      */
     count<Hint extends string = never>(where?: FilterQuery<Entity>, options?: CountOptions<Entity, Hint>): Promise<number>;
+    /**
+     * Counts entities grouped by one or more properties.
+     *
+     * @example
+     * ```ts
+     * const counts = await repo.countBy('status');
+     * // { 'active': 5, 'inactive': 2 }
+     * ```
+     */
+    countBy(groupBy: EntityKey<Entity> | readonly EntityKey<Entity>[], options?: CountByOptions<Entity>): Promise<Dictionary<number>>;
     /** Returns the entity class name associated with this repository. */
     getEntityName(): string;
     /**

package/entity/EntityRepository.js

@@ -194,6 +194,18 @@ export class EntityRepository {
     async count(where = {}, options = {}) {
         return this.getEntityManager().count(this.entityName, where, options);
     }
+    /**
+     * Counts entities grouped by one or more properties.
+     *
+     * @example
+     * ```ts
+     * const counts = await repo.countBy('status');
+     * // { 'active': 5, 'inactive': 2 }
+     * ```
+     */
+    async countBy(groupBy, options) {
+        return this.getEntityManager().countBy(this.entityName, groupBy, options);
+    }
     /** Returns the entity class name associated with this repository. */
     getEntityName() {
         return Utils.className(this.entityName);

package/entity/Reference.d.ts

@@ -1,4 +1,4 @@
-import type { AddEager, AddOptional, Dictionary, EntityClass, EntityKey, EntityProperty, Loaded, LoadedReference, Primary, Ref } from '../typings.js';
+import type { AddEager, AddOptional, Dictionary, EntityClass, EntityKey, EntityProperty, LazyRef, Loaded, LoadedReference, Primary, Ref } from '../typings.js';
 import type { FindOneOptions, FindOneOrFailOptions } from '../drivers/IDatabaseDriver.js';
 /** Wrapper around an entity that provides lazy loading capabilities and identity-preserving reference semantics. */
 export declare class Reference<T extends object> {
@@ -98,6 +98,47 @@ export declare function ref<I extends unknown | Ref<unknown> | undefined | null,
  * shortcut for `Reference.createFromPK(entityType, pk)`
  */
 export declare function ref<I extends unknown | undefined | null, T, PKV extends Primary<T> = Primary<T>>(entityType: EntityClass<T>, pk: I): Ref<T> | AddOptional<typeof pk>;
+/**
+ * Unwraps a reference to its underlying value, returning the entity or scalar. Works on any of:
+ *
+ * - `Ref<T>` / `Reference<T>` (entity) — calls `.unwrap()` to extract the wrapped entity, returns `T`.
+ * - `LazyRef<T>` — type-only marker; runtime value is already `T`, so returned as-is.
+ * - plain entity `T` — returned as-is.
+ * - `ScalarReference<V>` / `ScalarRef<V>` — calls `.unwrap()` to extract the scalar value, returns `V | undefined`
+ *   (a scalar reference may be bound without an initial value).
+ *
+ * Inverse of the {@link ref} helper. Use as a typed escape hatch when you know a relation is populated
+ * but don't want to (or can't) thread `Loaded<T, 'relation'>` through a function signature.
+ *
+ * ```ts
+ * function logAuthor(book: Book) {
+ *   // `book.author` is typed as `LazyRef<Author>`, so `.name` is not directly accessible
+ *   console.log(unref(book.author).name);
+ * }
+ *
+ * // Scalar reference:
+ * const scalar = ref('hello');
+ * unref(scalar); // 'hello' (type: string | undefined)
+ * ```
+ *
+ * Note: `unref` is a compile-time narrowing only for entity refs. On a `LazyRef<T>` or plain entity
+ * relation that is a stub (PK only, never populated), reads of non-PK properties will still return
+ * `undefined` at runtime — same footgun as a plain non-`Ref` relation.
+ */
+export declare function unref<V>(value: ScalarReference<V>): V | undefined;
+export declare function unref<T extends object>(value: Ref<T> | LazyRef<T> | T): T;
+/**
+ * Unwraps a reference to its underlying value. Nullable variant — returns `null` unchanged.
+ */
+export declare function unref<T extends object>(value: Ref<T> | LazyRef<T> | T | null): T | null;
+/**
+ * Unwraps a reference to its underlying value. Optional variant — returns `undefined` unchanged.
+ */
+export declare function unref<T extends object>(value: Ref<T> | LazyRef<T> | T | undefined): T | undefined;
+/**
+ * Unwraps a reference to its underlying value. Nullable variant — returns `null`/`undefined` unchanged.
+ */
+export declare function unref<T extends object>(value: Ref<T> | LazyRef<T> | T | null | undefined): T | null | undefined;
 /**
  * shortcut for `Reference.createNakedFromPK(entityType, pk)`
  */

package/entity/Reference.js

@@ -303,6 +303,15 @@ export function ref(entityOrType, pk) {
     }
     return Reference.createFromPK(entityOrType, pk);
 }
+export function unref(value) {
+    if (value == null) {
+        return value;
+    }
+    if (ScalarReference.isScalarReference(value)) {
+        return value.unwrap();
+    }
+    return Reference.unwrapReference(value);
+}
 /**
  * shortcut for `Reference.createNakedFromPK(entityType, pk)`
  */

package/entity/defineEntity.d.ts

@@ -1,6 +1,6 @@
 import type { EntityManager } from '../EntityManager.js';
 import type { ColumnType, PropertyOptions, ReferenceOptions, EnumOptions, EmbeddedOptions, ManyToOneOptions, OneToManyOptions, OneToOneOptions, ManyToManyOptions, IndexColumnOptions } from '../metadata/types.js';
-import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, EntityRepositoryType, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, IndexCallback, TriggerCallback, FormulaCallback, EntityCtor, IsNever, IWrappedEntity, DefineConfig, Config, MaybePromise, IndexHints } from '../typings.js';
+import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, EntityRepositoryType, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, LazyRef, IndexCallback, TriggerCallback, FormulaCallback, EntityCtor, IsNever, IWrappedEntity, DefineConfig, Config, MaybePromise, IndexHints } from '../typings.js';
 import type { Raw } from '../utils/RawQueryFragment.js';
 import type { ScalarReference } from './Reference.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
@@ -12,7 +12,7 @@ import type { Collection } from './Collection.js';
 import type { FilterOptions, FindOptions, FindOneOptions } from '../drivers/IDatabaseDriver.js';
 /** Union of all option keys supported across all property definition types (scalar, enum, embedded, relations). */
 export type UniversalPropertyKeys = keyof PropertyOptions<any> | keyof EnumOptions<any> | keyof EmbeddedOptions<any, any> | keyof ReferenceOptions<any, any> | keyof ManyToOneOptions<any, any> | keyof OneToManyOptions<any, any> | keyof OneToOneOptions<any, any> | keyof ManyToManyOptions<any, any>;
-type BuilderExtraKeys = '~options' | '~type' | '$type' | 'strictNullable';
+type BuilderExtraKeys = '~options' | '~type' | '$type' | 'strictNullable' | 'lazyRef';
 type ExcludeKeys = 'entity' | 'items';
 type BuilderKeys = Exclude<UniversalPropertyKeys, ExcludeKeys> | BuilderExtraKeys;
 type IncludeKeysForProperty = Exclude<keyof PropertyOptions<any>, ExcludeKeys> | BuilderExtraKeys;
@@ -36,9 +36,23 @@ export interface PropertyChain<Value, Options> {
         nullable: true;
         strictNullable: true;
     }>;
-    ref(): PropertyChain<Value, Omit<Options, 'ref'> & {
+    ref(): Options extends {
+        lazyRef: true;
+    } ? never : PropertyChain<Value, Omit<Options, 'ref'> & {
         ref: true;
     }>;
+    /**
+     * Mark a to-one relation (`m:1`/`1:1`) as a {@apilink LazyRef} — direct entity at runtime, type-restricted
+     * until `Loaded<>` narrows it. Type-level only, no `ref: true` wrapping. Not compatible with `.ref()` or
+     * `.mapToPk()` — those chains are rejected in both directions at compile time.
+     */
+    lazyRef(): HasKind<Options, 'm:1' | '1:1'> extends true ? Options extends {
+        ref: true;
+    } | {
+        mapToPk: true;
+    } ? never : PropertyChain<Value, Omit<Options, 'lazyRef'> & {
+        lazyRef: true;
+    }> : never;
     primary(): PropertyChain<Value, Omit<Options, 'primary'> & {
         primary: true;
     }>;
@@ -103,7 +117,7 @@ export interface PropertyChain<Value, Options> {
     groups(...groups: string[]): PropertyChain<Value, Options>;
     customOrder(...customOrder: string[] | number[] | boolean[]): PropertyChain<Value, Options>;
     extra(extra: string): PropertyChain<Value, Options>;
-    ignoreSchemaChanges(...ignoreSchemaChanges: ('type' | 'extra' | 'default')[]): PropertyChain<Value, Options>;
+    ignoreSchemaChanges(...ignoreSchemaChanges: ('type' | 'extra' | 'default' | 'collation')[]): PropertyChain<Value, Options>;
     /** Explicitly specify index on a property. When a string name is passed, it enables type-safe `using` in `FindOptions`. */
     index<N extends string>(name: N): PropertyChain<Value, Omit<Options, 'index'> & {
         index: N;
@@ -115,6 +129,7 @@ export interface PropertyChain<Value, Options> {
     }>;
     unique(unique?: boolean): PropertyChain<Value, Options>;
     comment(comment: string): PropertyChain<Value, Options>;
+    collation(collation: string): PropertyChain<Value, Options>;
     accessor(accessor?: string | boolean): PropertyChain<Value, Options>;
     eager(eager?: boolean): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
     cascade(...cascade: Cascade[]): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
@@ -125,7 +140,9 @@ export interface PropertyChain<Value, Options> {
     owner(): HasKind<Options, '1:1' | 'm:n'> extends true ? PropertyChain<Value, Omit<Options, 'owner'> & {
         owner: true;
     }> : never;
-    mapToPk(): HasKind<Options, 'm:1' | '1:1'> extends true ? PropertyChain<Value, Omit<Options, 'mapToPk'> & {
+    mapToPk(): HasKind<Options, 'm:1' | '1:1'> extends true ? Options extends {
+        lazyRef: true;
+    } ? never : PropertyChain<Value, Omit<Options, 'mapToPk'> & {
         mapToPk: true;
     }> : never;
     orphanRemoval(orphanRemoval?: boolean): HasKind<Options, '1:m' | '1:1'> extends true ? PropertyChain<Value, Options> : never;
@@ -325,9 +342,24 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     /**
      * Enable `ScalarReference` wrapper for lazy values. Use this in combination with `lazy: true` to have a type-safe accessor object in place of the value.
      */
-    ref(): UniversalPropertyOptionsBuilder<Value, Omit<Options, 'ref'> & {
+    ref(): Options extends {
+        lazyRef: true;
+    } ? never : UniversalPropertyOptionsBuilder<Value, Omit<Options, 'ref'> & {
         ref: true;
     }, IncludeKeys>;
+    /**
+     * Mark a to-one relation (`m:1`/`1:1`) as a {@apilink LazyRef} — the runtime value stays a plain entity
+     * (no `Reference` wrapper) but the TypeScript type restricts access to the primary key until `Loaded<>`
+     * narrows it. Type-level only; does not set `ref: true`. Not compatible with `.ref()` or `.mapToPk()` —
+     * those chains are rejected in both directions at compile time.
+     */
+    lazyRef(): HasKind<Options, 'm:1' | '1:1'> extends true ? Options extends {
+        ref: true;
+    } | {
+        mapToPk: true;
+    } ? never : UniversalPropertyOptionsBuilder<Value, Omit<Options, 'lazyRef'> & {
+        lazyRef: true;
+    }, IncludeKeys> : never;
     /**
      * Set to true to omit the property when {@link https://mikro-orm.io/docs/serializing Serializing}.
      */
@@ -447,6 +479,11 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
      * Specify comment of column for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
      */
     comment(comment: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
+    /**
+     * Specify column-level collation for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     * Emits a `COLLATE` clause on the column definition; the accepted collation names are dialect-specific.
+     */
+    collation(collation: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** mysql only */
     extra(extra: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /**
@@ -454,7 +491,7 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
      *
      * @see https://mikro-orm.io/docs/defining-entities#sql-generated-columns
      */
-    ignoreSchemaChanges(...ignoreSchemaChanges: ('type' | 'extra' | 'default')[]): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
+    ignoreSchemaChanges(...ignoreSchemaChanges: ('type' | 'extra' | 'default' | 'collation')[]): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     array(): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'array'> & {
         array: true;
     }, IncludeKeys>, IncludeKeys>;
@@ -512,7 +549,9 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     /** What to do when the reference to the target entity gets updated. */
     updateRule(updateRule: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** Map this relation to the primary key value instead of an entity. */
-    mapToPk(): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'mapToPk'> & {
+    mapToPk(): Options extends {
+        lazyRef: true;
+    } ? never : Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'mapToPk'> & {
         mapToPk: true;
     }, IncludeKeys>, IncludeKeys>;
     /** Set the constraint type. Immediate constraints are checked for each statement, while deferred ones are only checked at the end of the transaction. Only for postgres unique constraints. */
@@ -556,7 +595,7 @@ export type PropertyBuilders = {
     datetime: (length?: number) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.datetime>, EmptyOptions, IncludeKeysForProperty>;
     time: (length?: number) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.time>, EmptyOptions, IncludeKeysForProperty>;
     type: <T extends PropertyValueType>(type: T) => UniversalPropertyOptionsBuilder<InferPropertyValueType<T>, EmptyOptions, IncludeKeysForProperty>;
-    enum: <const T extends readonly (number | string)[] | (() => Dictionary)>(items?: T) => UniversalPropertyOptionsBuilder<T extends () => Dictionary ? ValueOf<ReturnType<T>> : T extends readonly (infer Value)[] ? Value : T, EmptyOptions, IncludeKeysForEnumOptions>;
+    enum: <const T extends readonly (number | string)[] | Dictionary | (() => Dictionary)>(items?: T) => UniversalPropertyOptionsBuilder<T extends () => Dictionary ? ValueOf<ReturnType<T>> : T extends readonly (infer Value)[] ? Value : T extends Dictionary ? ValueOf<T> : T, EmptyOptions, IncludeKeysForEnumOptions>;
     embedded: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
         kind: 'embedded';
     }>;
@@ -576,12 +615,15 @@ export type PropertyBuilders = {
 /** Own keys + base entity keys (when TBase is not `never`). Guards against `keyof never = string | number | symbol`. */
 type AllKeys<TProperties, TBase> = keyof TProperties | (IsNever<TBase> extends true ? never : keyof TBase);
 /** Metadata descriptor for `defineEntity()`, combining entity options with property definitions. */
-export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never, TForceObject extends boolean = false> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'triggers' | 'repository' | 'filters' | 'orderBy'> {
+export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never, TForceObject extends boolean = false, TDiscriminatorColumn extends string | undefined = undefined, TDiscriminatorValue extends string | number | undefined = undefined, TBaseDiscriminatorColumn extends string | undefined = undefined> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminator' | 'discriminatorColumn' | 'discriminatorValue' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'triggers' | 'repository' | 'filters' | 'orderBy'> {
     name: TName;
     tableName?: TTableName;
     extends?: {
         '~entity': TBase;
-    } | EntityCtor<TBase>;
+        '~discriminatorColumn'?: TBaseDiscriminatorColumn;
+    } | (EntityCtor<TBase> & {
+        '~discriminatorColumn'?: TBaseDiscriminatorColumn;
+    });
     properties: TProperties | ((properties: PropertyBuilders) => TProperties);
     primaryKeys?: TPK & InferPrimaryKeyConstraint<TProperties>[];
     hooks?: DefineEntityHooks;
@@ -601,7 +643,10 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     } | {
         [K in Extract<AllKeys<TProperties, TBase>, string>]?: QueryOrderKeysFlat;
     }[];
-    discriminatorColumn?: string;
+    discriminator?: TDiscriminatorColumn;
+    /** Alias for `discriminator`. */
+    discriminatorColumn?: TDiscriminatorColumn;
+    discriminatorValue?: TDiscriminatorValue;
     versionProperty?: AllKeys<TProperties, TBase>;
     concurrencyCheckKeys?: Set<AllKeys<TProperties, TBase>>;
     serializedPrimaryKey?: AllKeys<TProperties, TBase>;
@@ -611,6 +656,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
         type?: string;
         options?: Dictionary;
         expression?: string | IndexCallback<InferEntityFromProperties<TProperties, TPK, TBase>>;
+        where?: string | FilterQuery<InferEntityFromProperties<TProperties, TPK, TBase>>;
         columns?: IndexColumnOptions[];
         include?: NoInfer<AllKeys<TProperties, TBase>> | NoInfer<AllKeys<TProperties, TBase>>[];
         fillFactor?: number;
@@ -623,6 +669,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
         name?: string;
         options?: Dictionary;
         expression?: string | IndexCallback<InferEntityFromProperties<TProperties, TPK, TBase>>;
+        where?: string | FilterQuery<InferEntityFromProperties<TProperties, TPK, TBase>>;
         deferMode?: DeferMode | `${DeferMode}`;
         columns?: IndexColumnOptions[];
         include?: NoInfer<AllKeys<TProperties, TBase>> | NoInfer<AllKeys<TProperties, TBase>>[];
@@ -640,7 +687,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     }[];
 }
 /** Defines an entity schema using property builders, with full type inference from the property definitions. */
-export declare function defineEntity<const TName extends string, const TTableName extends string, const TProperties extends Record<string, any>, const TPK extends (keyof TProperties)[] | undefined = undefined, const TBase = never, const TRepository = never, const TForceObject extends boolean = false>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase, TRepository, TForceObject>): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject>, TBase, TProperties>;
+export declare function defineEntity<const TName extends string, const TTableName extends string, const TProperties extends Record<string, any>, const TPK extends (keyof TProperties)[] | undefined = undefined, const TBase = never, const TRepository = never, const TForceObject extends boolean = false, const TDiscriminatorColumn extends string | undefined = undefined, const TDiscriminatorValue extends string | number | undefined = undefined, const TBaseDiscriminatorColumn extends string | undefined = undefined>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase, TRepository, TForceObject, TDiscriminatorColumn, TDiscriminatorValue, TBaseDiscriminatorColumn>): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject, TBaseDiscriminatorColumn, TDiscriminatorValue>, TBase, TProperties, EntityCtor<InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject, TBaseDiscriminatorColumn, TDiscriminatorValue>>, TDiscriminatorColumn>;
 /** Defines an entity schema for an existing class, combining the class with property builders. */
 export declare function defineEntity<const TEntity = any, const TProperties extends Record<string, any> = Record<string, any>, const TClassName extends string = string, const TTableName extends string = string, const TBase = never, const TClass extends EntityCtor = EntityCtor<TEntity>>(meta: Omit<Partial<EntityMetadata<TEntity>>, 'properties' | 'extends' | 'className' | 'tableName' | 'hooks'> & {
     class: TClass;
@@ -676,7 +723,7 @@ type InferJSType<T> = T extends typeof Type<infer TValue, any> ? NonNullable<TVa
 type InferColumnType<T extends string> = T extends 'int' | 'int4' | 'integer' | 'bigint' | 'int8' | 'int2' | 'tinyint' | 'smallint' | 'mediumint' ? number : T extends 'double' | 'double precision' | 'real' | 'float8' | 'decimal' | 'numeric' | 'float' | 'float4' ? number : T extends 'datetime' | 'time' | 'time with time zone' | 'timestamp' | 'timestamp with time zone' | 'timetz' | 'timestamptz' | 'date' | 'interval' ? Date : T extends 'ObjectId' | 'objectId' | 'character varying' | 'varchar' | 'char' | 'character' | 'uuid' | 'text' | 'tinytext' | 'mediumtext' | 'longtext' | 'enum' ? string : T extends 'boolean' | 'bool' | 'bit' ? boolean : T extends 'blob' | 'tinyblob' | 'mediumblob' | 'longblob' | 'bytea' ? Buffer : T extends 'point' | 'line' | 'lseg' | 'box' | 'circle' | 'path' | 'polygon' | 'geometry' ? number[] : T extends 'tsvector' | 'tsquery' ? string[] : T extends 'json' | 'jsonb' ? any : any;
 type BaseEntityMethodKeys = 'toObject' | 'toPOJO' | 'serialize' | 'assign' | 'populate' | 'init' | 'toReference';
 /** Infers the entity type from a `defineEntity()` properties map, resolving builders, base classes, and primary keys. */
-export type InferEntityFromProperties<Properties extends Record<string, any>, PK extends (keyof Properties)[] | undefined = undefined, Base = never, Repository = never, ForceObject extends boolean = false> = (IsNever<Base> extends true ? {} : Base extends {
+export type InferEntityFromProperties<Properties extends Record<string, any>, PK extends (keyof Properties)[] | undefined = undefined, Base = never, Repository = never, ForceObject extends boolean = false, BaseDiscriminatorColumn extends string | undefined = undefined, DiscriminatorValue extends string | number | undefined = undefined> = (IsNever<Base> extends true ? {} : Base extends {
     toObject(...args: any[]): any;
 } ? Pick<IWrappedEntity<{
     -readonly [K in keyof Properties]: InferBuilderValue<MaybeReturnType<Properties[K]>>;
@@ -684,19 +731,22 @@ export type InferEntityFromProperties<Properties extends Record<string, any>, PK
     [PrimaryKeyProp]?: InferCombinedPrimaryKey<Properties, PK, Base>;
 } & (IsNever<Repository> extends true ? {} : {
     [EntityRepositoryType]?: Repository extends Constructor<infer R> ? R : Repository;
-}) & Omit<Base, typeof PrimaryKeyProp>>, BaseEntityMethodKeys> : {}) & {
+}) & NarrowDiscriminator<Omit<Base, typeof PrimaryKeyProp>, BaseDiscriminatorColumn, DiscriminatorValue>>, BaseEntityMethodKeys> : {}) & {
     -readonly [K in keyof Properties]: InferBuilderValue<MaybeReturnType<Properties[K]>>;
 } & {
     [PrimaryKeyProp]?: InferCombinedPrimaryKey<Properties, PK, Base>;
 } & (IsNever<Repository> extends true ? {} : {
     [EntityRepositoryType]?: Repository extends Constructor<infer R> ? R : Repository;
-}) & (IsNever<Base> extends true ? {} : Omit<Base, typeof PrimaryKeyProp>) & (ForceObject extends true ? {
+}) & (IsNever<Base> extends true ? {} : NarrowDiscriminator<Omit<Base, typeof PrimaryKeyProp>, BaseDiscriminatorColumn, DiscriminatorValue>) & (ForceObject extends true ? {
     [Config]?: DefineConfig<{
         forceObject: true;
     }>;
 } : {}) & {
     [IndexHints]?: [Properties];
 };
+type NarrowDiscriminator<Base, DiscColumn extends string | undefined, DiscValue> = DiscColumn extends string ? DiscColumn extends keyof Base ? DiscValue extends string | number ? Omit<Base, DiscColumn> & {
+    [K in DiscColumn]: DiscValue;
+} : Base : Base : Base;
 type InferCombinedPrimaryKey<Properties extends Record<string, any>, PK, Base> = PK extends undefined ? CombinePrimaryKeys<InferPrimaryKey<Properties>, ExtractBasePrimaryKey<Base>> : PK;
 type ExtractBasePrimaryKey<Base> = Base extends {
     [PrimaryKeyProp]?: infer BasePK;
@@ -738,6 +788,9 @@ type MaybeNullable<Value, Options> = Options extends {
 type MaybeRelationRef<Value, Options> = Options extends {
     mapToPk: true;
 } ? Value : Options extends {
+    lazyRef: true;
+    kind: '1:1' | 'm:1';
+} ? Value extends object ? LazyRef<Value> : never : Options extends {
     ref: true;
     kind: '1:1';
 } ? Value extends object ? Ref<Value> : never : Options extends {