@mikro-orm/core 7.1.0-dev.4 → 7.1.0-dev.40

package/typings.d.ts

@@ -11,7 +11,7 @@ import type { SerializationContext } from './serialization/SerializationContext.
 import type { SerializeOptions } from './serialization/EntitySerializer.js';
 import type { MetadataStorage } from './metadata/MetadataStorage.js';
 import type { EntitySchema } from './metadata/EntitySchema.js';
-import type { IndexColumnOptions } from './metadata/types.js';
+import type { EntityPartitionBy, IndexColumnOptions } from './metadata/types.js';
 import type { Type, types } from './types/index.js';
 import type { Platform } from './platforms/Platform.js';
 import type { Configuration } from './utils/Configuration.js';
@@ -47,7 +47,7 @@ export type AsyncFunction<R = any, T = Dictionary> = (args: T) => Promise<T>;
 export type Compute<T> = {
     [K in keyof T]: T[K];
 } & {};
-type InternalKeys = 'EntityRepositoryType' | 'PrimaryKeyProp' | 'OptionalProps' | 'EagerProps' | 'HiddenProps' | '__selectedType' | '__loadedType';
+type InternalKeys = 'EntityRepositoryType' | 'PrimaryKeyProp' | 'OptionalProps' | 'EagerProps' | 'HiddenProps' | 'IndexHints' | '__selectedType' | '__loadedType';
 /** Filters out function, symbol, and internal keys from an entity type. When `B = true`, also excludes scalar keys. */
 export type CleanKeys<T, K extends keyof T, B extends boolean = false> = T[K] & {} extends Function ? never : K extends symbol | InternalKeys ? never : B extends true ? T[K] & {} extends Scalar ? never : K : K;
 /** Extracts keys of `T` whose values are functions. */
@@ -113,7 +113,7 @@ type LoadedReferenceShape<T = any> = ReferenceShape & {
  * Using this instead of `Loadable<any>` in conditional type checks prevents
  * TypeScript from evaluating the full Collection/Reference interfaces.
  */
-type LoadableShape = CollectionShape | ReferenceShape | readonly any[];
+type LoadableShape = CollectionShape | ReferenceShape | LazyRef.Brand<any> | readonly any[];
 /** Gets all keys from all members of a union type (distributes over the union). */
 export type UnionKeys<T> = T extends any ? keyof T : never;
 /** Gets the type of a property from all union members that have it (distributes over the union). */
@@ -150,6 +150,44 @@ export declare const EntityName: unique symbol;
 export type InferEntityName<T> = T extends {
     [EntityName]?: infer Name;
 } ? (Name extends string ? Name : never) : never;
+/**
+ * Symbol used to declare index-to-column mappings on an entity type.
+ * For decorator entities, declare as a phantom property:
+ * ```typescript
+ * [IndexHints]?: { idx_email: 'email'; idx_name_age: 'name' | 'age' };
+ * ```
+ * For `defineEntity` entities, index hints are inferred automatically from
+ * named indexes (property-level `.index('name')` and entity-level `indexes`/`uniques`).
+ */
+export declare const IndexHints: unique symbol;
+/**
+ * Extracts the index hints map from an entity type. Returns `never` when no hints are declared.
+ * For decorator entities, `[IndexHints]` contains a pre-computed `{ idxName: 'prop' }` map.
+ * For `defineEntity` entities, `[IndexHints]` contains `[Properties]` (a tuple wrapping the
+ * raw property builders), which is lazily converted to the index map when first accessed.
+ */
+export type ExtractIndexHints<T> = T extends {
+    [IndexHints]?: infer H;
+} ? H extends [infer P extends Record<string, any>] ? InferPropertyIndexMap<P> : H : never;
+/**
+ * Extracts `{ indexName: propertyKey }` from property builder options.
+ * Checks `.index('name')` and `.unique('name')` on each property in a single pass.
+ */
+export type InferPropertyIndexMap<Properties extends Record<string, any>> = {
+    [K in keyof Properties as MaybeReturnType<Properties[K]> extends {
+        '~options': {
+            index: infer N extends string;
+        };
+    } ? N : MaybeReturnType<Properties[K]> extends {
+        '~options': {
+            unique: infer N extends string;
+        };
+    } ? N : never]: K & string;
+};
+/** Union of declared index names on an entity. Falls back to `string` when no `[IndexHints]` are declared. */
+export type IndexName<T> = [ExtractIndexHints<T>] extends [never] ? string : (keyof ExtractIndexHints<T> & string) | (string & {});
+/** Properties covered by the named index on entity T. Falls back to all entity keys when the index is unknown. */
+export type IndexColumns<T, Name extends string> = ExtractIndexHints<T> extends Record<Name, infer Cols> ? Cols & string : EntityKey<T>;
 /**
  * Branded type that marks a property as optional in `em.create()`.
  * Use as a property type wrapper: `createdAt: Opt<Date>` instead of listing in `[OptionalProps]`.
@@ -328,6 +366,18 @@ export type ObjectQuery<T> = OperatorMap<T> & FilterObject<T>;
  * Accepts an object query, a primary key value, entity props with operators, or an array of filters.
  */
 export type FilterQuery<T> = ObjectQuery<T> | NonNullable<ExpandScalar<Primary<T>>> | NonNullable<EntityProps<T> & OperatorMap<T>> | FilterQuery<T>[];
+/**
+ * `FilterQuery` restricted to only properties covered by the specified index(es).
+ * Used when `using` option is set in `FindOptions` to enforce type-safe index usage.
+ */
+export type IndexFilterQuery<T, Using extends string> = [Using] extends [never] ? FilterQuery<T> : (OperatorMap<T> & {
+    -readonly [K in Extract<EntityKey<T>, IndexColumns<T, Using>>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | ElemMatchFilter<FilterObjectProp<T, K>> | null;
+}) | NonNullable<ExpandScalar<Primary<T>>> | IndexFilterQuery<T, Using>[];
+/** Replaces `where` and `using` on an options type with index-aware variants when `Using` is specified. */
+export type WithUsingOptions<Opts, Entity, Using extends string> = Omit<Opts, 'where' | 'using'> & {
+    using?: Using | Using[];
+    where?: [Using] extends [never] ? FilterQuery<Entity> : IndexFilterQuery<Entity, Using>;
+};
 /** Public interface for the entity wrapper, accessible via `wrap(entity)`. Provides helper methods for entity state management. */
 export interface IWrappedEntity<Entity extends object> {
     isInitialized(): boolean;
@@ -417,12 +467,12 @@ type NonArrayObject = object & {
 export type EntityDataProp<T, C extends boolean> = T extends Date ? string | Date : T extends Scalar ? T : T extends ScalarReference<infer U> ? EntityDataProp<U, C> : T extends {
     __runtime?: infer Runtime;
     __raw?: infer Raw;
-} ? C extends true ? Raw : Runtime : T extends ReferenceShape<infer U> ? EntityDataNested<U, C> : T extends CollectionShape<infer U> ? U | U[] | EntityDataNested<U & object, C> | EntityDataNested<U & object, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : U[] | EntityDataNested<U, C>[] : EntityDataNested<T, C>;
+} ? C extends true ? Raw : Runtime : T extends LazyRef.Brand<infer U> ? EntityDataNested<U, C> : T extends ReferenceShape<infer U> ? EntityDataNested<U, C> : T extends CollectionShape<infer U> ? U | U[] | EntityDataNested<U & object, C> | EntityDataNested<U & object, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : U[] | EntityDataNested<U, C>[] : EntityDataNested<T, C>;
 /** Like `EntityDataProp` but used in `RequiredEntityData` context with required/optional key distinction. */
 export type RequiredEntityDataProp<T, O, C extends boolean> = T extends Date ? string | Date : Exclude<T, null> extends RequiredNullable.Brand ? T | null : T extends Scalar ? T : T extends ScalarReference<infer U> ? RequiredEntityDataProp<U, O, C> : T extends {
     __runtime?: infer Runtime;
     __raw?: infer Raw;
-} ? C extends true ? Raw : Runtime : T extends ReferenceShape<infer U> ? RequiredEntityDataNested<U, O, C> : T extends CollectionShape<infer U> ? U | U[] | RequiredEntityDataNested<U & object, O, C> | RequiredEntityDataNested<U & object, O, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : U[] | RequiredEntityDataNested<U, O, C>[] : RequiredEntityDataNested<T, O, C>;
+} ? C extends true ? Raw : Runtime : T extends LazyRef.Brand<infer U> ? RequiredEntityDataNested<U, O, C> : T extends ReferenceShape<infer U> ? RequiredEntityDataNested<U, O, C> : T extends CollectionShape<infer U> ? U | U[] | RequiredEntityDataNested<U & object, O, C> | RequiredEntityDataNested<U & object, O, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : U[] | RequiredEntityDataNested<U, O, C>[] : RequiredEntityDataNested<T, O, C>;
 /** Nested entity data shape for embedded or related entities within `EntityData`. */
 export type EntityDataNested<T, C extends boolean = false> = T extends undefined ? never : T extends any[] ? Readonly<T> : EntityData<T, C> | ExpandEntityProp<T, C>;
 type UnwrapScalarRef<T> = T extends ScalarReference<infer U> ? U : T;
@@ -471,6 +521,35 @@ type Relation<T> = {
 export type Rel<T> = T;
 /** Alias for `ScalarReference` (see {@apilink Ref}). */
 export type ScalarRef<T> = ScalarReference<T>;
+/**
+ * Type-level marker for a to-one relation that is **direct at runtime** (no `Reference` wrapper) but
+ * **restricted at compile time** until narrowed via `Loaded<>`.
+ *
+ * Use as the property type on a `@ManyToOne`/`@OneToOne` relation that does **not** have `ref: true`:
+ *
+ * ```ts
+ * @ManyToOne(() => User)
+ * author!: LazyRef<User>;
+ * ```
+ *
+ * Semantics:
+ * - **Runtime**: identical to a plain direct relation — `article.author` is a `User` instance (stub or hydrated),
+ *   `article.author instanceof User` is `true`, no `Reference` object is created.
+ * - **Type (unloaded view)**: only the primary key is accessible. Accessing other properties is a compile error.
+ * - **Type (loaded view)**: once the relation is in the populate hint of a `Loaded<Entity, 'author'>`, it narrows
+ *   back to the full entity — no `.$` or `.get()` indirection needed.
+ *
+ * Note: the safety is purely compile-time. JS code or `as any` casts bypass it.
+ */
+export type LazyRef<T extends object> = IsAny<T> extends true ? LazyRef.Brand<T> : {
+    [K in PrimaryProperty<T> & keyof T]: T[K];
+} & LazyRef.Brand<T>;
+export declare namespace LazyRef {
+    const __lazyRef: unique symbol;
+    interface Brand<T> {
+        [__lazyRef]?: (arg: T) => T;
+    }
+}
 /** Alias for `Reference<T> & { id: number }` (see {@apilink Ref}). */
 export type EntityRef<T extends object> = true extends IsUnknown<PrimaryProperty<T>> ? Reference<T> : IsAny<T> extends true ? Reference<T> : {
     [K in PrimaryProperty<T> & keyof T]: T[K];
@@ -594,19 +673,39 @@ export type SchemaTable = {
 export type FormulaColumns<T> = Record<PropertyName<T>, string> & {
     toString(): string;
 };
+/**
+ * Column reference for schema callbacks. Behaves like a string (coercible via `toString()`),
+ * with arbitrary nested property access for embedded sub-columns (e.g. `cols.address.city`).
+ */
+export type SchemaColumnRef = string & {
+    readonly [key: string]: SchemaColumnRef;
+};
 /**
  * Column mapping for schema callbacks (indexes, checks, generated columns).
  * Maps property names to field names. For TPT entities, only includes properties
  * that belong to the current table (not inherited properties from parent tables).
+ * Embedded properties expose their sub-columns via nested access (e.g. `cols.address.city`),
+ * while coercing to the embedded property's own column name via `toString()` (matches the
+ * pre-7712 behaviour, regardless of any custom `prefix`).
+ */
+export type SchemaColumns<T> = Record<PropertyName<T>, SchemaColumnRef>;
+/**
+ * Callback for custom index expressions. Receives column mappings, table info, and the index name.
+ * The runtime `columns` object includes nested entries for embedded properties (see `SchemaColumnRef`);
+ * cast to `SchemaColumns<T>` if you need typed nested access.
  */
-export type SchemaColumns<T> = Record<PropertyName<T>, string>;
-/** Callback for custom index expressions. Receives column mappings, table info, and the index name. */
 export type IndexCallback<T> = (columns: Record<PropertyName<T>, string>, table: SchemaTable, indexName: string) => string | Raw;
 /** Callback for computed (formula) properties. Receives column mappings and table info, returns a SQL expression. */
 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 generated (computed) column expressions. Receives column mappings and table info. */
+export type CheckCallback<T> = (columns: SchemaColumns<T>, 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.
+ * The runtime `columns` object includes nested entries for embedded properties (see `SchemaColumnRef`);
+ * cast to `SchemaColumns<T>` if you need typed nested access.
+ */
 export type GeneratedColumnCallback<T> = (columns: Record<PropertyName<T>, string>, table: SchemaTable) => string | Raw;
 /** Definition of a CHECK constraint on a table or property. */
 export interface CheckConstraint<T = any> {
@@ -614,6 +713,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. */
@@ -711,11 +827,12 @@ export interface EntityProperty<Owner = any, Target = any> {
     serializer?: (value: any, options?: SerializeOptions<any>) => any;
     serializedName?: string;
     comment?: string;
+    collation?: string;
     /** mysql only */
     extra?: string;
     userDefined?: boolean;
     optional?: boolean;
-    ignoreSchemaChanges?: ('type' | 'extra' | 'default')[];
+    ignoreSchemaChanges?: ('type' | 'extra' | 'default' | 'collation')[];
     deferMode?: DeferMode;
     createForeignKeyConstraint: boolean;
     foreignKeyName?: string;
@@ -743,8 +860,12 @@ export declare class EntityMetadata<Entity = any, Class extends EntityCtor<Entit
     /**
      * Creates a column mapping for schema callbacks (indexes, checks, generated columns).
      * For TPT entities, only includes properties that belong to the current table (ownProps).
+     * Embedded properties expose their sub-columns via nested access (e.g. `cols.address.city`),
+     * while still coercing to the embedded column prefix when used as a string (GH #7712).
      */
     createSchemaColumnMappingObject(): SchemaColumns<Entity>;
+    /** @internal Recursively builds a column mapping for an embedded property's sub-columns. */
+    private static buildEmbeddedColumnMapping;
     get tableName(): string;
     set tableName(name: string);
     get uniqueName(): string;
@@ -763,7 +884,6 @@ export type EntityCtor<T = any> = abstract new (...args: any[]) => T;
 export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> = EntityCtor<Entity>> {
     name?: string;
     className: string;
-    tableName: string;
     schema?: string;
     pivotTable?: boolean;
     virtual?: boolean;
@@ -776,6 +896,8 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
     materialized?: boolean;
     /** For materialized views, whether data is populated on creation. Defaults to true. */
     withData?: boolean;
+    /** PostgreSQL partitioning definition for this table. */
+    partitionBy?: EntityPartitionBy<Entity>;
     expression?: string | ((em: any, where: ObjectQuery<Entity>, options: FindOptions<Entity, any, any, any>, stream?: boolean) => MaybePromise<Raw | object | string>);
     discriminatorColumn?: EntityKey<Entity> | AnyString;
     discriminatorValue?: number | string;
@@ -814,6 +936,7 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
         type?: string;
         options?: Dictionary;
         expression?: string | IndexCallback<Entity>;
+        where?: string | FilterQuery<Entity>;
         columns?: IndexColumnOptions[];
         include?: EntityKey<Entity> | EntityKey<Entity>[];
         fillFactor?: number;
@@ -826,6 +949,7 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
         name?: string;
         options?: Dictionary;
         expression?: string | IndexCallback<Entity>;
+        where?: string | FilterQuery<Entity>;
         deferMode?: DeferMode | `${DeferMode}`;
         columns?: IndexColumnOptions[];
         include?: EntityKey<Entity> | EntityKey<Entity>[];
@@ -833,6 +957,7 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
         disabled?: boolean;
     }[];
     checks: CheckConstraint<Entity>[];
+    triggers: TriggerDef<Entity>[];
     repositoryClass?: string;
     repository: () => EntityClass<EntityRepository<any>>;
     hooks: {
@@ -853,6 +978,8 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
     polymorphicDiscriminatorMap?: Dictionary<EntityClass>;
     /** Inheritance type: 'sti' (Single Table Inheritance) or 'tpt' (Table-Per-Type). Only set on root entities. */
     inheritanceType?: 'sti' | 'tpt';
+    /** Legacy alias populated from `EntityOptions.inheritance`; mirrored to `inheritanceType` during discovery. */
+    inheritance?: 'tpt';
     /** For TPT: direct parent entity metadata (the entity this one extends). */
     tptParent?: EntityMetadata;
     /** For TPT: direct child entities (entities that extend this one). */
@@ -880,6 +1007,11 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
 export interface CreateSchemaOptions {
     wrap?: boolean;
     schema?: string;
+    /**
+     * When true, entities with a wildcard schema (`schema: '*'`) are included in the generated DDL.
+     * Without this, wildcard tables are skipped.
+     */
+    includeWildcardSchema?: boolean;
 }
 /** Options for `ISchemaGenerator.clear()` to truncate/clear database tables. */
 export interface ClearDatabaseOptions {
@@ -909,6 +1041,13 @@ export interface UpdateSchemaOptions<DatabaseSchema = unknown> {
     dropTables?: boolean;
     schema?: string;
     fromSchema?: DatabaseSchema;
+    /**
+     * When true, entities with a wildcard schema (`schema: '*'`) are included in the diff so migrations
+     * can be generated for them. The emitted SQL is unqualified — and therefore safe to apply against
+     * any schema at runtime — only when neither `options.schema` nor `config.schema` is set; otherwise
+     * wildcard tables inherit that schema qualifier.
+     */
+    includeWildcardSchema?: boolean;
 }
 /** Options for `ISchemaGenerator.refresh()` which drops and recreates the schema. */
 export interface RefreshDatabaseOptions extends CreateSchemaOptions {
@@ -989,6 +1128,12 @@ export type MigrateOptions = {
     to?: string | number;
     migrations?: string[];
     transaction?: Transaction;
+    /**
+     * Target schema to run migrations against. Issues a driver-specific "set current schema"
+     * statement (e.g. `SET search_path` on PostgreSQL) before each migration, and places the
+     * tracking table in this schema. Overrides `migrations.schema` from config. Not supported on MSSQL.
+     */
+    schema?: string;
 };
 /** Result of creating a new migration file, including the generated code and schema diff. */
 export type MigrationResult = {
@@ -1006,21 +1151,25 @@ export type MigrationRow = {
  * @internal
  */
 export interface IMigrationRunner {
-    run(migration: Migration, method: 'up' | 'down'): Promise<void>;
+    run(migration: Migration, method: 'up' | 'down', afterRun?: (tx?: Transaction) => Promise<void>): Promise<void>;
     setMasterMigration(trx: Transaction): void;
     unsetMasterMigration(): void;
+    setRunSchema?(schema?: string): void;
+    unsetRunSchema?(): void;
 }
 /**
  * @internal
  */
 export interface IMigratorStorage {
     executed(): Promise<string[]>;
-    logMigration(params: Dictionary): Promise<void>;
-    unlogMigration(params: Dictionary): Promise<void>;
+    logMigration(params: Dictionary, tx?: Transaction): Promise<void>;
+    unlogMigration(params: Dictionary, tx?: Transaction): Promise<void>;
     getExecutedMigrations(): Promise<MigrationRow[]>;
     ensureTable?(): Promise<void>;
     setMasterMigration(trx: Transaction): void;
     unsetMasterMigration(): void;
+    setRunSchema?(schema?: string): void;
+    unsetRunSchema?(): void;
     getMigrationName(name: string): string;
     getTableName?(): {
         schemaName?: string;
@@ -1047,11 +1196,15 @@ export interface IMigrator {
     /**
      * Returns list of already executed migrations.
      */
-    getExecuted(): Promise<MigrationRow[]>;
+    getExecuted(options?: {
+        schema?: string;
+    }): Promise<MigrationRow[]>;
     /**
      * Returns list of pending (not yet executed) migrations found in the migration directory.
      */
-    getPending(): Promise<MigrationInfo[]>;
+    getPending(options?: {
+        schema?: string;
+    }): Promise<MigrationInfo[]>;
     /**
      * Executes specified migrations. Without parameter it will migrate up to the latest version.
      */
@@ -1060,6 +1213,11 @@ export interface IMigrator {
      * Executes down migrations to the given point. Without parameter it will migrate one version down.
      */
     down(options?: string | string[] | Omit<MigrateOptions, 'from'>): Promise<MigrationInfo[]>;
+    /**
+     * Combines multiple executed migrations into a single migration file.
+     * Concatenates source code without touching the database schema.
+     */
+    rollup(migrations?: string[]): Promise<MigrationResult>;
     /**
      * Registers event handler.
      */
@@ -1142,13 +1300,32 @@ export type PopulateOptions<T> = {
     children?: PopulateOptions<T[keyof T]>[];
     /** When true, ignores `mapToPk` on the property and returns full entity data instead of just PKs. */
     dataOnly?: boolean;
+    /** Limit the number of items loaded per parent entity. Collections will be marked as partial and readonly. */
+    limit?: number;
+    /** Offset for per-parent limiting (used with `limit`). */
+    offset?: number;
+    /** Order by clause for per-parent limiting. Takes precedence over nested `FindOptions.orderBy`. */
+    orderBy?: QueryOrderMap<T[keyof T]>;
 };
 /** Inline options that can be appended to populate hint strings (e.g., strategy, join type). */
 export type PopulateHintOptions = {
     strategy?: LoadStrategy.JOINED | LoadStrategy.SELECT_IN | 'joined' | 'select-in';
     joinType?: 'inner join' | 'left join';
+    /** Limit the number of items loaded per parent entity. Collections will be marked as partial and readonly. */
+    limit?: number;
+    /** Offset for per-parent limiting (used with `limit`). */
+    offset?: number;
+    /** Order by clause for per-parent limiting. Takes precedence over nested `FindOptions.orderBy`. */
+    orderBy?: QueryOrderMap<any>;
 };
 type ExtractType<T> = T extends CollectionShape<infer U> ? U : T extends ReferenceShape<infer U> ? U : T extends Ref<infer U> ? U : T extends readonly (infer U)[] ? U : T;
+/**
+ * Like {@link ExtractType} but also unwraps {@link LazyRef}. Kept separate so {@link ExtractType}'s
+ * hot path (used by `IsOptional`, `EntityData`, `RequiredEntityData`) doesn't pay the cost of the
+ * extra branch — those contexts handle `LazyRef` in their own earlier branches (see
+ * `EntityDataProp` / `RequiredEntityDataProp`) before delegating to `ExtractType`.
+ */
+type ExtractTypeWithLazyRef<T> = T extends LazyRef.Brand<infer U> ? U : ExtractType<T>;
 type ExtractStringKeys<T> = {
     [K in keyof T]-?: CleanKeys<T, K>;
 }[keyof T] & {};
@@ -1156,8 +1333,8 @@ type ExtractStringKeys<T> = {
  * Extracts string keys from an entity type, handling Collection/Reference wrappers.
  * Simplified to just check `T extends object` since ExtractType handles the unwrapping.
  */
-type StringKeys<T, E extends string = never> = T extends object ? ExtractStringKeys<ExtractType<T>> | E : never;
-type GetStringKey<T, K extends StringKeys<T, string>, E extends string> = K extends keyof T ? ExtractType<T[K]> : K extends E ? keyof T : never;
+type StringKeys<T, E extends string = never> = T extends object ? ExtractStringKeys<ExtractTypeWithLazyRef<T>> | E : never;
+type GetStringKey<T, K extends StringKeys<T, string>, E extends string> = K extends keyof T ? ExtractTypeWithLazyRef<T[K]> : K extends E ? keyof T : never;
 type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 type RelationKeys<T> = T extends object ? {
     [K in keyof T]-?: CleanKeys<T, K, true>;
@@ -1172,8 +1349,8 @@ export type UnboxArray<T> = T extends any[] ? ArrayElement<T> : T;
 /** Extracts the element type from an array type. */
 export type ArrayElement<ArrayType extends unknown[]> = ArrayType extends (infer ElementType)[] ? ElementType : never;
 /** Unwraps a property type from its wrapper (Reference, Collection, or array) to the inner entity type. */
-export type ExpandProperty<T> = T extends ReferenceShape<infer U> ? NonNullable<U> : T extends CollectionShape<infer U> ? NonNullable<U> : T extends (infer U)[] ? NonNullable<U> : NonNullable<T>;
-type LoadedLoadable<T, E extends object> = T extends CollectionShape ? LoadedCollection<E> : T extends ScalarReference<infer U> ? LoadedScalarReference<U> : T extends ReferenceShape ? T & LoadedReference<E> : T extends Scalar ? T : T extends (infer U)[] ? U extends Scalar ? T : E[] : E;
+export type ExpandProperty<T> = T extends LazyRef.Brand<infer U> ? NonNullable<U> : T extends ReferenceShape<infer U> ? NonNullable<U> : T extends CollectionShape<infer U> ? NonNullable<U> : T extends (infer U)[] ? NonNullable<U> : NonNullable<T>;
+type LoadedLoadable<T, E extends object> = T extends CollectionShape ? LoadedCollection<E> : T extends ScalarReference<infer U> ? LoadedScalarReference<U> : T extends LazyRef.Brand<any> ? E : T extends ReferenceShape ? T & LoadedReference<E> : T extends Scalar ? T : T extends (infer U)[] ? U extends Scalar ? T : E[] : E;
 type IsTrue<T> = IsNever<T> extends true ? false : T extends boolean ? (T extends true ? true : false) : false;
 type StringLiteral<T> = T extends string ? (string extends T ? never : T) : never;
 type Prefix<T, K> = K extends `${infer S}.${string}` ? S : K extends '*' ? keyof T : K;
@@ -1207,7 +1384,7 @@ export type MergeSelected<T, U, F extends string> = IsLoadedType<T> extends true
 export type MergeLoaded<T, U, P extends string, F extends string, E extends string, R extends boolean = false> = IsLoadedType<T> extends true ? T & Loaded<U, P, F, E> : Loaded<T, P, F, E>;
 /** Extracts the nullability modifiers (`null`, `undefined`, or both) from a type `T`. */
 export type AddOptional<T> = undefined | null extends T ? null | undefined : null extends T ? null : undefined extends T ? undefined : never;
-type LoadedProp<T, L extends string = never, F extends string = '*', E extends string = never> = LoadedLoadable<T, Loaded<ExtractType<T>, L, F, E>>;
+type LoadedProp<T, L extends string = never, F extends string = '*', E extends string = never> = LoadedLoadable<T, Loaded<ExtractTypeWithLazyRef<T>, L, F, E>>;
 /** Extracts the eager-loaded property names declared via `[EagerProps]` as a string union. */
 export type AddEager<T> = ExtractEagerProps<T> & string;
 /** Combines an explicit populate hint `L` with the entity's eagerly loaded properties. */
@@ -1322,15 +1499,18 @@ export type MaybeReturnType<T> = T extends (...args: any[]) => infer R ? R : T;
  * Extended `EntitySchema` interface that carries additional type-level metadata (entity name, properties, table name).
  * Returned by `defineEntity()` to provide strong type inference without explicit generics.
  */
-export interface EntitySchemaWithMeta<TName extends string = string, TTableName extends string = string, TEntity = any, TBase = never, TProperties extends Record<string, any> = Record<string, any>, TClass extends EntityCtor = EntityCtor<TEntity>> extends EntitySchema<TEntity, TBase, TClass> {
+export interface EntitySchemaWithMeta<TName extends string = string, TTableName extends string = string, TEntity = any, TBase = never, TProperties extends Record<string, any> = Record<string, any>, TClass extends EntityCtor = EntityCtor<TEntity>, TDiscriminatorColumn extends string | undefined = undefined> extends EntitySchema<TEntity, TBase, TClass> {
     readonly name: TName;
     readonly properties: TProperties;
     readonly tableName: TTableName;
     /** @internal Direct entity type access - avoids expensive pattern matching */
     readonly '~entity': TEntity;
+    /** @internal Type-level marker carrying the discriminator column name, used by `defineEntity()` to narrow inherited discriminator properties to the literal `discriminatorValue` of each child schema. */
+    readonly '~discriminatorColumn'?: TDiscriminatorColumn;
     /** @internal */
     readonly class: TClass & {
         '~entityName'?: TName;
+        '~discriminatorColumn'?: TDiscriminatorColumn;
     };
 }
 /**

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;
@@ -116,16 +133,37 @@ export class EntityMetadata {
     /**
      * Creates a column mapping for schema callbacks (indexes, checks, generated columns).
      * For TPT entities, only includes properties that belong to the current table (ownProps).
+     * Embedded properties expose their sub-columns via nested access (e.g. `cols.address.city`),
+     * while still coercing to the embedded column prefix when used as a string (GH #7712).
      */
     createSchemaColumnMappingObject() {
         // For TPT entities, only include properties that belong to this entity's table
         const props = this.inheritanceType === 'tpt' && this.ownProps ? this.ownProps : Object.values(this.properties);
-        return props.reduce((o, prop) => {
-            if (prop.fieldNames) {
-                o[prop.name] = prop.fieldNames[0];
+        const result = {};
+        for (const prop of props) {
+            if (!prop.fieldNames) {
+                continue;
             }
-            return o;
-        }, {});
+            if (prop.kind === ReferenceKind.EMBEDDED && prop.embeddedProps) {
+                result[prop.name] = EntityMetadata.buildEmbeddedColumnMapping(prop);
+                continue;
+            }
+            result[prop.name] = prop.fieldNames[0];
+        }
+        return result;
+    }
+    /** @internal Recursively builds a column mapping for an embedded property's sub-columns. */
+    static buildEmbeddedColumnMapping(embeddedProp) {
+        const result = {};
+        for (const [name, sub] of Object.entries(embeddedProp.embeddedProps)) {
+            result[name] =
+                sub.kind === ReferenceKind.EMBEDDED && sub.embeddedProps
+                    ? EntityMetadata.buildEmbeddedColumnMapping(sub)
+                    : sub.fieldNames[0];
+        }
+        const prefix = embeddedProp.fieldNames[0];
+        Object.defineProperty(result, 'toString', { value: () => prefix, enumerable: false });
+        return result;
     }
     get tableName() {
         return this.collection;
@@ -149,7 +187,7 @@ export class EntityMetadata {
             if (prop.inherited || (prop.persist === false && prop.userDefined !== false)) {
                 return false;
             }
-            return prop.kind === ReferenceKind.SCALAR && ['string', 'number', 'boolean', 'Date'].includes(prop.type);
+            return (prop.kind === ReferenceKind.SCALAR && !prop.array && ['string', 'number', 'boolean', 'Date'].includes(prop.type));
         });
         this.hydrateProps = this.props.filter(prop => {
             // `prop.userDefined` is either `undefined` or `false`
@@ -176,9 +214,10 @@ export class EntityMetadata {
         // Virtual entities evaluate expressions at query time, view entities create actual database views.
         this.virtual = !!this.expression && !this.view;
         if (config) {
+            const platform = config.getPlatform();
             for (const prop of this.props) {
                 if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => typeof item === 'string')) {
-                    const name = config.getNamingStrategy().indexName(this.tableName, prop.fieldNames, 'check');
+                    const name = platform.getIndexName(this.tableName, prop.fieldNames, 'check');
                     const exists = this.checks.findIndex(check => check.name === name);
                     if (exists !== -1) {
                         this.checks.splice(exists, 1);
@@ -186,9 +225,7 @@ export class EntityMetadata {
                     this.checks.push({
                         name,
                         property: prop.name,
-                        expression: config
-                            .getPlatform()
-                            .getEnumCheckConstraintExpression(prop.fieldNames[0], prop.items),
+                        expression: platform.getEnumCheckConstraintExpression(prop.fieldNames[0], prop.items),
                     });
                 }
             }
@@ -244,8 +281,8 @@ export class EntityMetadata {
         }, { __gettersDefined: { value: true, enumerable: false } });
     }
     initIndexes(prop) {
-        const simpleIndex = this.indexes.find(index => index.properties === prop.name && !index.options && !index.type && !index.expression);
-        const simpleUnique = this.uniques.find(index => index.properties === prop.name && !index.options);
+        const simpleIndex = this.indexes.find(index => index.properties === prop.name && !index.options && !index.type && !index.expression && index.where == null);
+        const simpleUnique = this.uniques.find(index => index.properties === prop.name && !index.options && !index.expression && index.where == null);
         const owner = prop.kind === ReferenceKind.MANY_TO_ONE;
         if (!prop.index && simpleIndex) {
             Utils.defaultValue(simpleIndex, 'name', true);