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

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 {

package/entity/defineEntity.js

@@ -173,6 +173,16 @@ export class UniversalPropertyOptionsBuilder {
     ref() {
         return this.assignOptions({ ref: true });
     }
+    /**
+     * 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() {
+        // purely type-level — no runtime metadata change
+        return this;
+    }
     /**
      * Set to true to omit the property when {@link https://mikro-orm.io/docs/serializing Serializing}.
      */
@@ -306,6 +316,13 @@ export class UniversalPropertyOptionsBuilder {
     comment(comment) {
         return this.assignOptions({ comment });
     }
+    /**
+     * 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) {
+        return this.assignOptions({ collation });
+    }
     /** mysql only */
     extra(extra) {
         return this.assignOptions({ extra });

package/entity/utils.js

@@ -94,11 +94,10 @@ export function applyPopulateHints(populate, hints) {
         if (!entry) {
             continue;
         }
-        if (hint.strategy != null) {
-            entry.strategy = hint.strategy;
-        }
-        if (hint.joinType != null) {
-            entry.joinType = hint.joinType;
+        for (const key of Object.keys(hint)) {
+            if (hint[key] != null) {
+                entry[key] = hint[key];
+            }
         }
     }
 }

package/enums.d.ts

@@ -1,5 +1,5 @@
 import type { EntityKey, ExpandProperty } from './typings.js';
-import type { Transaction } from './connections/Connection.js';
+import type { InflightQueryAbortStrategy, Transaction } from './connections/Connection.js';
 import type { LogContext } from './logging/Logger.js';
 /** Controls when the `EntityManager` flushes pending changes to the database. */
 export declare enum FlushMode {
@@ -307,6 +307,13 @@ export interface TransactionOptions {
     flushMode?: FlushMode | `${FlushMode}`;
     ignoreNestedTransactions?: boolean;
     loggerContext?: LogContext;
+    /**
+     * `AbortSignal` cancelling every query within the transaction (including the implicit flush).
+     * Cancelling mid-transaction triggers a rollback once the in-flight query settles.
+     */
+    signal?: AbortSignal;
+    /** Cancellation strategy paired with {@link signal}. */
+    inflightQueryAbortStrategy?: InflightQueryAbortStrategy;
 }
 export declare abstract class PlainObject {
 }

package/index.d.ts

@@ -3,7 +3,7 @@
  * @module core
  */
 export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, EntityName, IndexHints, } from './typings.js';
-export type { CompiledFunctions, Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, InferEntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, EntityDTOFlat, EntityDTOProp, SerializeDTO, MigrationDiff, GenerateOptions, FilterObject, IndexFilterQuery, ExtractIndexHints, IndexName, IndexColumns, WithUsingOptions, IMigrationRunner, IEntityGenerator, ISeedManager, SeederObject, IMigratorStorage, RequiredEntityData, CheckCallback, TriggerCallback, IndexCallback, FormulaCallback, FormulaTable, SchemaTable, SchemaColumns, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, MigrationInfo, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, TypeConfig, AnyString, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, RequiredNullable, DefineConfig, Opt, Hidden, EntitySchemaWithMeta, InferEntity, CheckConstraint, TriggerDef, GeneratedColumnCallback, FilterDef, EntityCtor, Subquery, PopulateHintOptions, Prefixes, } from './typings.js';
+export type { CompiledFunctions, Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, InferEntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, EntityDTOFlat, EntityDTOProp, SerializeDTO, MigrationDiff, GenerateOptions, FilterObject, IndexFilterQuery, ExtractIndexHints, IndexName, IndexColumns, WithUsingOptions, IMigrationRunner, IEntityGenerator, ISeedManager, SeederObject, IMigratorStorage, RequiredEntityData, CheckCallback, TriggerCallback, IndexCallback, FormulaCallback, FormulaColumns, FormulaTable, SchemaTable, SchemaColumns, SchemaColumnRef, EntityDataPropValue, SimpleColumnMeta, Rel, Ref, LazyRef, ScalarRef, EntityRef, ISchemaGenerator, MigrationInfo, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, TypeConfig, AnyString, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, RequiredNullable, DefineConfig, Opt, Hidden, EntitySchemaWithMeta, InferEntity, CheckConstraint, TriggerDef, RoutineReturns, RoutineBodyCallback, RoutineJsBody, RoutineIgnoreField, RoutineParamConfig, RoutineConfig, RoutineRuntimeType, RoutineArgs, RoutineReturn, GeneratedColumnCallback, FilterDef, EntityCtor, Subquery, PopulateHintOptions, Prefixes, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/metadata/EntitySchema.js

@@ -85,6 +85,9 @@ export class EntitySchema {
         if (options.items instanceof Function) {
             options.items = Utils.extractEnumValues(options.items());
         }
+        else if (options.items && !Array.isArray(options.items) && typeof options.items === 'object') {
+            options.items = Utils.extractEnumValues(options.items);
+        }
         // enum arrays are simple numeric/string arrays, the constraint is enforced in the custom type only
         if (options.array && !options.type) {
             options.type = new EnumArrayType(`${this._meta.className}.${name}`, options.items);
@@ -251,6 +254,21 @@ export class EntitySchema {
             return this;
         }
         this.setClass(this._meta.class);
+        // `discriminator` is the property name on the entity / embeddable; `discriminatorColumn` is an
+        // optional column-name override on that property. For backward compat, when only
+        // `discriminatorColumn` is given (legacy), it is treated as the property name. Once normalized,
+        // `meta.discriminatorColumn` always holds the property name (so existing readers keep working),
+        // and `meta.discriminatorFieldName` carries the explicit column override (if any).
+        if (this._meta.discriminator &&
+            this._meta.discriminatorColumn &&
+            this._meta.discriminator !== this._meta.discriminatorColumn) {
+            this._meta.discriminatorFieldName = this._meta.discriminatorColumn;
+            this._meta.discriminatorColumn = this._meta.discriminator;
+        }
+        else {
+            this._meta.discriminatorColumn ??= this._meta.discriminator;
+            this._meta.discriminator ??= this._meta.discriminatorColumn;
+        }
         // Abstract TPT entities keep their name because they have their own table
         const isTPT = this._meta.inheritance === 'tpt' || this.isPartOfTPTHierarchy();
         if (this._meta.abstract && !this._meta.discriminatorColumn && !isTPT) {

package/metadata/MetadataDiscovery.d.ts

@@ -76,6 +76,7 @@ export declare class MetadataDiscovery {
     private initPolyEmbeddables;
     private initPolymorphicRelation;
     private initEmbeddables;
+    private sameRelationTargetRoot;
     private initSingleTableInheritance;
     /**
      * First pass of TPT initialization: sets up hierarchy relationships

package/metadata/MetadataDiscovery.js

@@ -114,7 +114,12 @@ export class MetadataDiscovery {
             }
             else {
                 const name = prop.name;
-                if (prop.kind === ReferenceKind.SCALAR || prop.kind === ReferenceKind.EMBEDDED) {
+                // For to-one relations, only swap to the accessor for the documented
+                // backing-field convention (a `_`-prefixed property like `_draft` paired
+                // with `accessor: 'draft'`). The non-prefixed sibling-helper pattern
+                // (`author` + `accessor: 'authorId'`) keeps the property name as the
+                // canonical FK column source, so this stays non-breaking.
+                if (prop.kind === ReferenceKind.SCALAR || prop.kind === ReferenceKind.EMBEDDED || name.startsWith('_')) {
                     prop.name = prop.accessor;
                 }
                 this.initRelation(prop);
@@ -568,6 +573,12 @@ export class MetadataDiscovery {
             }
         }
         meta.forceConstructor ??= this.shouldForceConstructorUsage(meta);
+        // Fail fast when the platform rejects the metadata, so users see the platform-specific
+        // error (e.g. "SqlitePlatform does not support partitioned tables") instead of a
+        // downstream core validator message that assumes partitioning is supported.
+        if (meta.partitionBy && !this.#platform.supportsPartitionedTables()) {
+            this.#platform.validateMetadata(meta);
+        }
         this.#validator.validateEntityDefinition(this.#metadata, meta.class, this.#config.get('discovery'));
         for (const prop of Object.values(meta.properties)) {
             this.initNullability(prop);
@@ -594,6 +605,10 @@ export class MetadataDiscovery {
                 prop.pivotEntity = pivotMeta.class;
                 if (prop.inversedBy) {
                     prop.targetMeta.properties[prop.inversedBy].pivotEntity = pivotMeta.class;
+                    const targetRoot = prop.targetMeta.root;
+                    if (targetRoot !== prop.targetMeta && targetRoot.properties[prop.inversedBy]) {
+                        targetRoot.properties[prop.inversedBy].pivotEntity = pivotMeta.class;
+                    }
                 }
                 // Propagate pivotEntity to ALL inverse collections using mappedBy pointing at this
                 // owner prop. Covers three cases:
@@ -1019,10 +1034,14 @@ export class MetadataDiscovery {
                 meta.propertyOrder.set(prop.name, (order += 0.01));
             });
         }
-        meta.indexes = Utils.unique([...base.indexes, ...meta.indexes]);
-        meta.uniques = Utils.unique([...base.uniques, ...meta.uniques]);
-        meta.checks = Utils.unique([...base.checks, ...meta.checks]);
-        meta.triggers = Utils.unique([...base.triggers, ...meta.triggers]);
+        // TPT children have their own tables that don't contain the parent's columns,
+        // so propagating parent indexes/uniques/checks/triggers would target missing columns.
+        if (meta.inheritanceType !== 'tpt' || !meta.tptParent) {
+            meta.indexes = Utils.unique([...base.indexes, ...meta.indexes]);
+            meta.uniques = Utils.unique([...base.uniques, ...meta.uniques]);
+            meta.checks = Utils.unique([...base.checks, ...meta.checks]);
+            meta.triggers = Utils.unique([...base.triggers, ...meta.triggers]);
+        }
         const pks = Object.values(meta.properties)
             .filter(p => p.primary)
             .map(p => p.name);
@@ -1253,6 +1272,19 @@ export class MetadataDiscovery {
             });
         }
     }
+    sameRelationTargetRoot(rootProp, prop) {
+        if (!rootProp || rootProp.kind !== prop.kind) {
+            return false;
+        }
+        if (prop.kind !== ReferenceKind.MANY_TO_ONE &&
+            prop.kind !== ReferenceKind.ONE_TO_ONE &&
+            prop.kind !== ReferenceKind.ONE_TO_MANY &&
+            prop.kind !== ReferenceKind.MANY_TO_MANY) {
+            return false;
+        }
+        const aRoot = this.#metadata.getByClassName(prop.type, false)?.root;
+        return aRoot != null && aRoot === this.#metadata.getByClassName(rootProp.type, false)?.root;
+    }
     initSingleTableInheritance(meta, metadata) {
         if (meta.root !== meta && !meta.__processed) {
             meta.root = metadata.find(m => m.class === meta.root.class);
@@ -1293,12 +1325,24 @@ export class MetadataDiscovery {
         Object.values(meta.properties).forEach(prop => {
             const newProp = { ...prop };
             const rootProp = meta.root.properties[prop.name];
+            // A child that narrows a relation to a subclass of the root's declared
+            // target (same STI hierarchy) shares the FK column with the root; treat
+            // that as matching so the rename branch below doesn't run (which would
+            // crash — `targetMeta` is only populated later, in `initRelation`).
+            const narrowedRelationOverride = rootProp != null && rootProp.type !== prop.type && this.sameRelationTargetRoot(rootProp, prop);
             // stiMerged is set during inlineProperties when a property was merged
             // from multiple polymorphic variants with different types. The flag is
             // cleared implicitly when the first child claims the root property via
             // addProperty below, so subsequent children correctly trigger renaming.
-            const typesMatch = rootProp?.type === prop.type || rootProp?.stiMerged === true;
+            const typesMatch = rootProp?.type === prop.type || rootProp?.stiMerged === true || narrowedRelationOverride;
+            // Inverse-side relations (1:m, inverse m:n) have no FK column on this
+            // entity, so the rename branch — which exists to disambiguate physical
+            // columns shared across STI children — doesn't apply. Skipping it also
+            // avoids crashing on `[...rootProp.fieldNames]` since fieldNames is
+            // never populated for inverse-side properties.
+            const isInverseSideRelation = prop.kind === ReferenceKind.ONE_TO_MANY || (prop.kind === ReferenceKind.MANY_TO_MANY && !prop.owner);
             if (rootProp &&
+                !isInverseSideRelation &&
                 (!typesMatch ||
                     (rootProp.fieldNames && prop.fieldNames && !compareArrays(rootProp.fieldNames, prop.fieldNames)))) {
                 const name = newProp.name;
@@ -1347,6 +1391,20 @@ export class MetadataDiscovery {
             }
             newProp.nullable = true;
             newProp.inherited = !rootProp;
+            // For narrowed relation overrides, keep the root's declaration intact so
+            // the full target union (e.g. `Food`) is preserved for populates from the
+            // abstract root — otherwise the last child processed would win.
+            if (narrowedRelationOverride) {
+                return;
+            }
+            // STI siblings can declare the same property name on inverse-side relations
+            // pointing to disjoint targets (e.g. `Dog.items → DogItem` and
+            // `Cat.items → CatItem` with no shared base). There's no physical column
+            // to manage at root, and propagating would clobber the first child's
+            // declaration; each child keeps its local typed property instead.
+            if (isInverseSideRelation && rootProp && rootProp.type !== prop.type) {
+                return;
+            }
             meta.root.addProperty(newProp);
         });
         meta.tableName = meta.root.tableName;
@@ -1362,10 +1420,10 @@ export class MetadataDiscovery {
         if (meta.root !== meta) {
             meta.root = metadata.find(m => m.class === meta.root.class);
         }
-        const inheritance = meta.inheritance;
-        if (inheritance === 'tpt' && meta.root === meta) {
-            meta.inheritanceType = 'tpt';
-            meta.tptChildren = [];
+        // init the root eagerly so children iterated before the root (e.g. alphabetical glob order) still get linked
+        if (meta.root.inheritance === 'tpt' && meta.root.inheritanceType !== 'tpt') {
+            meta.root.inheritanceType = 'tpt';
+            meta.root.tptChildren ??= [];
         }
         if (meta.root.inheritanceType !== 'tpt') {
             return;
@@ -1524,13 +1582,18 @@ export class MetadataDiscovery {
         });
     }
     createDiscriminatorProperty(meta) {
-        meta.addProperty({
+        const prop = {
             name: meta.discriminatorColumn,
             type: 'string',
             enum: true,
             kind: ReferenceKind.SCALAR,
             userDefined: false,
-        });
+        };
+        // honor the column-name override set via `discriminatorColumn` when `discriminator` is also given
+        if (meta.discriminatorFieldName) {
+            prop.fieldName = meta.discriminatorFieldName;
+        }
+        meta.addProperty(prop);
     }
     initAutoincrement(meta) {
         const pks = meta.getPrimaryProps();
@@ -1553,7 +1616,7 @@ export class MetadataDiscovery {
         const table = this.createSchemaTable(meta);
         for (const check of meta.checks) {
             const fieldNames = check.property ? meta.properties[check.property].fieldNames : [];
-            check.name ??= this.#namingStrategy.indexName(meta.tableName, fieldNames, 'check');
+            check.name ??= this.#platform.getIndexName(meta.tableName, fieldNames, 'check');
             if (check.expression instanceof Function) {
                 check.expression = check.expression(columns, table);
             }
@@ -1578,7 +1641,7 @@ export class MetadataDiscovery {
                 }
                 if (expression) {
                     meta.checks.push({
-                        name: this.#namingStrategy.indexName(meta.tableName, prop.fieldNames, 'check'),
+                        name: this.#platform.getIndexName(meta.tableName, prop.fieldNames, 'check'),
                         property: prop.name,
                         expression,
                     });
@@ -1754,6 +1817,7 @@ export class MetadataDiscovery {
             prop.customType &&
             !(prop.customType instanceof t.array) &&
             !(prop.customType instanceof t.enumArray) &&
+            !(prop.customType instanceof t.json) &&
             prop.kind === ReferenceKind.SCALAR) {
             const innerType = prop.customType;
             innerType.platform = this.#platform;
@@ -1789,7 +1853,7 @@ export class MetadataDiscovery {
         if (!prop.customType && prop.array && prop.items) {
             prop.customType = new t.enumArray(`${meta.className}.${prop.name}`, prop.items);
         }
-        const isArray = prop.type?.toLowerCase() === 'array' || prop.type?.toString().endsWith('[]');
+        const isArray = prop.array || prop.type?.toLowerCase() === 'array' || prop.type?.toString().endsWith('[]');
         if (objectEmbeddable && !prop.customType && isArray) {
             prop.customType = new t.json();
         }

package/metadata/MetadataValidator.d.ts

@@ -1,4 +1,5 @@
 import type { EntityMetadata, EntityName } from '../typings.js';
+import type { Routine } from './Routine.js';
 import { type MetadataDiscoveryOptions } from '../utils/Configuration.js';
 import type { MetadataStorage } from './MetadataStorage.js';
 /**
@@ -6,7 +7,32 @@ import type { MetadataStorage } from './MetadataStorage.js';
  */
 export declare class MetadataValidator {
     validateEntityDefinition<T>(metadata: MetadataStorage, name: EntityName<T>, options: MetadataDiscoveryOptions): void;
+    validateRoutineDefinition(routine: Routine): void;
     validateDiscovered(discovered: EntityMetadata[], options: MetadataDiscoveryOptions): void;
+    private validatePartitioning;
+    /**
+     * Find the first partition name whose normalized form (case-folded for unquoted segments,
+     * quoted segments preserved) has already been seen. Returns the offending name in its
+     * original form for the error message.
+     */
+    private findDuplicatePartitionName;
+    /**
+     * Partition names may be bare (`child`), schema-qualified (`schema.child`), or use quoted
+     * identifiers (`"my.schema"."child"`). Reject anything with more than one unquoted `.`.
+     */
+    private hasValidPartitionName;
+    private hasPartitionExpression;
+    private validatePartitionKeyConstraints;
+    /**
+     * Returns the list of physical field names that a partition expression references, or
+     * `undefined` when the expression is opaque (callback, or raw SQL like `date_trunc('day', x)`
+     * that we cannot statically parse). Opaque expressions intentionally bypass the primary-key /
+     * unique-constraint coverage checks — users are trusted to ensure the referenced columns are
+     * part of the partition key, since PostgreSQL will surface the violation at DDL execution.
+     */
+    private getPartitionKeyFields;
+    private resolvePartitionKeyField;
+    private getConstraintFields;
     private validateReference;
     private validateTargetKey;
     /**