@mikro-orm/core 7.1.0-dev.1 → 7.1.0-dev.11

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, FormulaCallback, EntityCtor, IsNever, IWrappedEntity, DefineConfig, Config, MaybePromise } 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;
     }>;
@@ -104,8 +118,16 @@ export interface 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>;
-    index(index?: boolean | string): PropertyChain<Value, Options>;
-    unique(unique?: boolean | string): 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;
+    }>;
+    index(index?: boolean): PropertyChain<Value, Options>;
+    /** Set column as unique. When a string name is passed, it enables type-safe `using` in `FindOptions`. (SQL only) */
+    unique<N extends string>(name: N): PropertyChain<Value, Omit<Options, 'unique'> & {
+        unique: N;
+    }>;
+    unique(unique?: boolean): PropertyChain<Value, Options>;
     comment(comment: 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;
@@ -117,7 +139,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;
@@ -127,9 +151,13 @@ export interface PropertyChain<Value, Options> {
     pivotEntity(pivotEntity: () => EntityName): HasKind<Options, 'm:n'> extends true ? PropertyChain<Value, Options> : never;
     fixedOrder(fixedOrder?: boolean): HasKind<Options, 'm:n'> extends true ? PropertyChain<Value, Options> : never;
     fixedOrderColumn(fixedOrderColumn: string): HasKind<Options, 'm:n'> extends true ? PropertyChain<Value, Options> : never;
-    array(): HasKind<Options, 'embedded' | 'enum'> extends true ? PropertyChain<Value, Omit<Options, 'array'> & {
+    array(): Options extends {
+        kind: infer K extends string;
+    } ? K extends 'embedded' | 'enum' ? PropertyChain<Value, Omit<Options, 'array'> & {
         array: true;
-    }> : never;
+    }> : never : PropertyChain<Value, Omit<Options, 'array'> & {
+        array: true;
+    }>;
     prefix(prefix: string | boolean): HasKind<Options, 'embedded'> extends true ? PropertyChain<Value, Options> : never;
     prefixMode(prefixMode: EmbeddedPrefixMode): HasKind<Options, 'embedded'> extends true ? PropertyChain<Value, Options> : never;
     object(object?: boolean): HasKind<Options, 'embedded'> extends true ? PropertyChain<Value, Options> : never;
@@ -313,9 +341,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}.
      */
@@ -334,12 +377,20 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     concurrencyCheck(concurrencyCheck?: boolean): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /**
      * Explicitly specify index on a property.
+     * When a string name is passed, it is captured as a literal type for use with the `using` option in `FindOptions`.
      */
-    index(index?: boolean | string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
+    index<N extends string>(name: N): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'index'> & {
+        index: N;
+    }, IncludeKeys>, IncludeKeys>;
+    index(index?: boolean): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /**
      * Set column as unique for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     * When a string name is passed, it is captured as a literal type for use with the `using` option in `FindOptions`.
      */
-    unique(unique?: boolean | string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
+    unique<N extends string>(name: N): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'unique'> & {
+        unique: N;
+    }, IncludeKeys>, IncludeKeys>;
+    unique(unique?: boolean): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /**
      * Specify column with check constraints. (Postgres driver only)
      *
@@ -492,7 +543,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 +609,7 @@ 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' | '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> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'triggers' | 'repository' | 'filters' | 'orderBy'> {
     name: TName;
     tableName?: TTableName;
     extends?: {
@@ -609,6 +662,15 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
         fillFactor?: number;
         disabled?: boolean;
     }[];
+    triggers?: {
+        name?: string;
+        timing: 'before' | 'after' | 'instead of';
+        events: ('insert' | 'update' | 'delete' | 'truncate')[];
+        forEach?: 'row' | 'statement';
+        body?: string | Raw | TriggerCallback<InferEntityFromProperties<TProperties, TPK, TBase>>;
+        when?: string;
+        expression?: string;
+    }[];
 }
 /** 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>;
@@ -665,7 +727,9 @@ export type InferEntityFromProperties<Properties extends Record<string, any>, PK
     [Config]?: DefineConfig<{
         forceObject: true;
     }>;
-} : {});
+} : {}) & {
+    [IndexHints]?: [Properties];
+};
 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;
@@ -707,6 +771,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}.
      */
@@ -191,15 +201,9 @@ export class UniversalPropertyOptionsBuilder {
     concurrencyCheck(concurrencyCheck = true) {
         return this.assignOptions({ concurrencyCheck });
     }
-    /**
-     * Explicitly specify index on a property.
-     */
     index(index = true) {
         return this.assignOptions({ index });
     }
-    /**
-     * Set column as unique for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
-     */
     unique(unique = true) {
         return this.assignOptions({ unique });
     }

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/errors.d.ts

@@ -74,6 +74,8 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static viewEntityWithoutExpression(meta: EntityMetadata): MetadataError;
     static mixedInheritanceStrategies(root: EntityMetadata, child: EntityMetadata): MetadataError;
     static tptNotSupportedByDriver(meta: EntityMetadata): MetadataError;
+    /** Thrown when database triggers are defined on an entity using a driver that does not support them. */
+    static triggersNotSupportedByDriver(meta: EntityMetadata): MetadataError;
     private static fromMessage;
 }
 /** Error thrown when an entity lookup fails to find the expected result. */

package/errors.js

@@ -243,6 +243,10 @@ export class MetadataError extends ValidationError {
     static tptNotSupportedByDriver(meta) {
         return new MetadataError(`Entity ${meta.className} uses TPT (Table-Per-Type) inheritance which is not supported by the current driver. TPT requires SQL JOINs and is only available with SQL drivers.`);
     }
+    /** Thrown when database triggers are defined on an entity using a driver that does not support them. */
+    static triggersNotSupportedByDriver(meta) {
+        return new MetadataError(`Entity ${meta.className} defines database triggers which are not supported by the current driver. Triggers are only available with SQL drivers.`);
+    }
     static fromMessage(meta, prop, message) {
         return new MetadataError(`${meta.className}.${prop.name} ${message}`);
     }

package/index.d.ts

@@ -2,8 +2,8 @@
  * @packageDocumentation
  * @module core
  */
-export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, EntityName, } 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, IMigrationRunner, IEntityGenerator, ISeedManager, SeederObject, IMigratorStorage, RequiredEntityData, CheckCallback, 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, GeneratedColumnCallback, FilterDef, EntityCtor, Subquery, PopulateHintOptions, Prefixes, } from './typings.js';
+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, 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, GeneratedColumnCallback, FilterDef, EntityCtor, Subquery, PopulateHintOptions, Prefixes, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/index.js

@@ -2,7 +2,7 @@
  * @packageDocumentation
  * @module core
  */
-export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, EntityName, } from './typings.js';
+export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, EntityName, IndexHints, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/metadata/MetadataDiscovery.d.ts

@@ -54,6 +54,16 @@ export declare class MetadataDiscovery {
      * Define properties for a polymorphic pivot table.
      */
     private definePolymorphicPivotProperties;
+    /**
+     * Mirror of definePolymorphicPivotProperties for union-target M:N
+     * (e.g. Post.attachments -> Image | Video via shared pivot with a target-side discriminator).
+     *
+     * Pivot shape:
+     *   (owner_fk..., discriminator_column, target_fk...)
+     *   - owner side is a normal M:1 to the single owner entity
+     *   - target side is a discriminator column + per-target-type virtual M:1 relations
+     */
+    private defineUnionTargetPolymorphicPivotProperties;
     /**
      * Create a virtual M:1 relation from pivot to a polymorphic owner entity.
      * This enables single-query join loading for inverse-side polymorphic M:N.
@@ -105,6 +115,7 @@ export declare class MetadataDiscovery {
     private initAutoincrement;
     private createSchemaTable;
     private initCheckConstraints;
+    private initTriggers;
     private initGeneratedColumn;
     private getDefaultVersionValue;
     private inferDefaultValue;

package/metadata/MetadataDiscovery.js

@@ -159,6 +159,7 @@ export class MetadataDiscovery {
         forEachProp((m, p) => this.initGeneratedColumn(m, p));
         filtered.forEach(meta => this.initAutoincrement(meta)); // once again after we init custom types
         filtered.forEach(meta => this.initCheckConstraints(meta));
+        filtered.forEach(meta => this.initTriggers(meta));
         forEachProp((_m, p) => {
             this.initDefaultValue(p);
             this.inferTypeFromDefault(p);
@@ -479,17 +480,28 @@ export class MetadataDiscovery {
             prop.polymorphic = prop2.polymorphic;
             prop.discriminator = prop2.discriminator;
             prop.discriminatorColumn = prop2.discriminatorColumn;
-            prop.discriminatorValue = prop2.discriminatorValue;
+            // For a union-target pivot each inverse side sits on one specific target class, so its
+            // discriminator value is that class's tableName. For Rails-style, prop2 has a single fixed value.
+            prop.discriminatorValue = QueryHelper.isUnionTargetPolymorphic(prop2) ? meta.tableName : prop2.discriminatorValue;
         }
         prop.referencedColumnNames ??= Utils.flatten(meta.primaryKeys.map(primaryKey => meta.properties[primaryKey].fieldNames));
-        // For polymorphic M:N, use discriminator base name for FK column (e.g., taggable_id instead of post_id)
-        if (prop.polymorphic && prop.discriminator) {
+        // Union-target polymorphic M:N: owner side is fixed (real FK), target side uses discriminator-derived names.
+        const isUnionTargetMN = QueryHelper.isUnionTargetPolymorphic(prop);
+        if (prop.polymorphic && prop.discriminator && !isUnionTargetMN) {
+            // Rails-style: owner side is polymorphic, uses discriminator base name (e.g. taggable_id instead of post_id)
             prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.#namingStrategy.joinKeyColumnName(prop.discriminator, referencedColumnName, prop.referencedColumnNames.length > 1));
         }
         else {
             prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.#namingStrategy.joinKeyColumnName(meta.root.className, referencedColumnName, meta.compositePK));
         }
-        prop.inverseJoinColumns ??= this.initManyToOneFieldName(prop, meta2.root.className);
+        if (isUnionTargetMN) {
+            // Target side uses discriminator base name (e.g. attachable_id — shared across Image/Video)
+            const targetPkCols = Utils.flatten(meta2.primaryKeys.map(pk => meta2.properties[pk].fieldNames));
+            prop.inverseJoinColumns ??= targetPkCols.map(fieldName => this.#namingStrategy.joinKeyColumnName(prop.discriminator, fieldName, targetPkCols.length > 1));
+        }
+        else {
+            prop.inverseJoinColumns ??= this.initManyToOneFieldName(prop, meta2.root.className);
+        }
     }
     isExplicitTableName(meta) {
         return meta.tableName !== this.#namingStrategy.classToTableName(meta.className);
@@ -583,6 +595,24 @@ export class MetadataDiscovery {
                 if (prop.inversedBy) {
                     prop.targetMeta.properties[prop.inversedBy].pivotEntity = pivotMeta.class;
                 }
+                // Propagate pivotEntity to ALL inverse collections using mappedBy pointing at this
+                // owner prop. Covers three cases:
+                //   - regular inverse (Tag.posts mappedBy Post.tags) — handled by inversedBy above
+                //   - union-target inverse (Image.posts mappedBy Post.attachments) — on each polymorph target
+                //   - merged inverse (Tag.owners mappedBy [Post,Video].tags) — union collection on the target
+                const inverseCandidates = QueryHelper.isUnionTargetPolymorphic(prop)
+                    ? prop.polymorphTargets
+                    : [prop.targetMeta];
+                for (const targetMeta of inverseCandidates) {
+                    for (const inverseProp of Object.values(targetMeta.properties)) {
+                        if (inverseProp.kind === ReferenceKind.MANY_TO_MANY &&
+                            inverseProp.mappedBy === prop.name &&
+                            !inverseProp.pivotEntity) {
+                            inverseProp.pivotEntity = pivotMeta.class;
+                            inverseProp.pivotTable = pivotMeta.tableName;
+                        }
+                    }
+                }
                 return pivotMeta;
             });
         }
@@ -721,8 +751,12 @@ export class MetadataDiscovery {
                 }
             }
         }
-        // For polymorphic M:N, create discriminator column and polymorphic FK
-        if (prop.polymorphic && prop.discriminatorColumn) {
+        // Union-target polymorphic M:N: discriminator + target FK share the pivot across multiple target types
+        if (prop.discriminatorColumn && QueryHelper.isUnionTargetPolymorphic(prop)) {
+            this.defineUnionTargetPolymorphicPivotProperties(pivotMeta2, meta, prop);
+        }
+        else if (prop.polymorphic && prop.discriminatorColumn) {
+            // Rails-style polymorphic M:N: multiple owners share the pivot, single target type
             this.definePolymorphicPivotProperties(pivotMeta2, meta, prop, targetMeta);
         }
         else {
@@ -809,6 +843,33 @@ export class MetadataDiscovery {
         pivotMeta.polymorphicDiscriminatorMap ??= {};
         pivotMeta.polymorphicDiscriminatorMap[prop.discriminatorValue] = meta.class;
     }
+    /**
+     * Mirror of definePolymorphicPivotProperties for union-target M:N
+     * (e.g. Post.attachments -> Image | Video via shared pivot with a target-side discriminator).
+     *
+     * Pivot shape:
+     *   (owner_fk..., discriminator_column, target_fk...)
+     *   - owner side is a normal M:1 to the single owner entity
+     *   - target side is a discriminator column + per-target-type virtual M:1 relations
+     */
+    defineUnionTargetPolymorphicPivotProperties(pivotMeta, meta, prop) {
+        const discriminatorColumn = prop.discriminatorColumn;
+        const targets = prop.polymorphTargets;
+        pivotMeta.properties[meta.name + '_owner'] = this.definePivotProperty(prop, meta.name + '_owner', meta.class, prop.discriminator, true, false);
+        const discriminatorProp = this.createPivotScalarProperty(discriminatorColumn, [this.#platform.getVarcharTypeDeclarationSQL(prop)], [discriminatorColumn], { type: 'string', primary: true, nullable: false });
+        this.initFieldName(discriminatorProp);
+        pivotMeta.properties[discriminatorColumn] = discriminatorProp;
+        const firstTargetColumnTypes = this.getPrimaryKeyColumnTypes(targets[0]);
+        pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, firstTargetColumnTypes, [...prop.inverseJoinColumns], { type: targets[0].className, primary: true, nullable: false });
+        pivotMeta.polymorphicDiscriminatorMap ??= {};
+        for (const targetMeta of targets) {
+            const relationName = `${prop.discriminator}_${targetMeta.tableName}`;
+            const relation = this.definePolymorphicOwnerRelation(prop, relationName, targetMeta);
+            relation.joinColumns = relation.fieldNames = relation.ownColumns = [...prop.inverseJoinColumns];
+            pivotMeta.properties[relationName] = relation;
+            pivotMeta.polymorphicDiscriminatorMap[targetMeta.tableName] = targetMeta.class;
+        }
+    }
     /**
      * Create a virtual M:1 relation from pivot to a polymorphic owner entity.
      * This enables single-query join loading for inverse-side polymorphic M:N.
@@ -961,6 +1022,7 @@ export class MetadataDiscovery {
         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);
@@ -1045,11 +1107,15 @@ export class MetadataDiscovery {
         prop.discriminatorColumn ??= this.#namingStrategy.discriminatorColumnName(prop.discriminator);
         prop.createForeignKeyConstraint = false;
         const isToOne = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind);
-        if (isToOne) {
+        const isUnionTargetMN = prop.kind === ReferenceKind.MANY_TO_MANY && Array.isArray(prop.target);
+        if (isToOne || isUnionTargetMN) {
             const types = prop.type.split(/ ?\| ?/);
             prop.polymorphTargets = discovered.filter(m => types.includes(m.className) && !m.embeddable);
             prop.targetMeta = prop.polymorphTargets[0];
             prop.referencedPKs = prop.targetMeta?.primaryKeys;
+            if (isUnionTargetMN && prop.polymorphTargets.length < 2) {
+                throw new MetadataError(`${meta.className}.${prop.name} union-target polymorphic M:N requires at least two target entity types; use a regular M:N relation for a single target.`);
+            }
         }
         if (prop.discriminatorMap) {
             const normalizedMap = {};
@@ -1065,7 +1131,7 @@ export class MetadataDiscovery {
             }
             prop.discriminatorMap = normalizedMap;
         }
-        else if (isToOne) {
+        else if (isToOne || isUnionTargetMN) {
             prop.discriminatorMap = {};
             const tableNameToTarget = new Map();
             for (const target of prop.polymorphTargets) {
@@ -1520,6 +1586,27 @@ export class MetadataDiscovery {
             }
         }
     }
+    initTriggers(meta) {
+        if (meta.triggers.length === 0) {
+            return;
+        }
+        const columns = meta.createSchemaColumnMappingObject();
+        const table = this.createSchemaTable(meta);
+        for (const trigger of meta.triggers) {
+            if (trigger.body && trigger.expression) {
+                throw new MetadataError(`Trigger "${trigger.name ?? '(unnamed)'}" on entity ${meta.className} defines both 'body' and 'expression'. Use one or the other.`);
+            }
+            if (!trigger.body && !trigger.expression) {
+                throw new MetadataError(`Trigger "${trigger.name ?? '(unnamed)'}" on entity ${meta.className} must define either 'body' or 'expression'.`);
+            }
+            trigger.name ??= this.#namingStrategy.indexName(meta.tableName, trigger.events, 'trigger');
+            trigger.forEach ??= 'row';
+            if (trigger.body instanceof Function) {
+                trigger.body = trigger.body(columns, table);
+            }
+        }
+        meta.hasTriggers = true;
+    }
     initGeneratedColumn(meta, prop) {
         if (!prop.generated && prop.columnTypes) {
             const match = /(.*) generated always as (.*)/i.exec(prop.columnTypes[0]);
@@ -1646,7 +1733,14 @@ export class MetadataDiscovery {
                 return (!Type.getType(t[type]).ensureComparable(meta, prop) && (prop.type === t[type] || brand === type));
             });
             if (type) {
-                prop.type = type === 'datetime' ? 'Date' : type;
+                if (prop.array) {
+                    // built-in type + array: true — force-create instance for ArrayType wrapping
+                    prop.customType = new prop.type();
+                    prop.type = prop.customType.constructor.name;
+                }
+                else {
+                    prop.type = type === 'datetime' ? 'Date' : type;
+                }
             }
             else {
                 prop.customType = new prop.type();
@@ -1656,6 +1750,30 @@ export class MetadataDiscovery {
         if (simple) {
             return;
         }
+        if (prop.array &&
+            prop.customType &&
+            !(prop.customType instanceof t.array) &&
+            !(prop.customType instanceof t.enumArray) &&
+            prop.kind === ReferenceKind.SCALAR) {
+            const innerType = prop.customType;
+            innerType.platform = this.#platform;
+            innerType.meta = meta;
+            innerType.prop = prop;
+            if (!prop.columnTypes) {
+                const arrayDecl = this.#platform.getArrayDeclarationSQL();
+                if (arrayDecl.endsWith('[]')) {
+                    // native array support (e.g. postgres) — use inner type's column type with [] suffix
+                    prop.columnTypes = [innerType.getColumnType(prop, this.#platform) + '[]'];
+                }
+                else {
+                    // non-native (e.g. mysql, sqlite) — store as text/clob
+                    prop.columnTypes = [arrayDecl];
+                }
+            }
+            const platform = this.#platform;
+            prop.customType = new t.array(v => innerType.convertToJSValue(v, platform), v => innerType.convertToDatabaseValue(v, platform));
+            prop.type = prop.customType.constructor.name;
+        }
         if (!prop.customType && ['json', 'jsonb'].includes(prop.type?.toLowerCase())) {
             prop.customType = new t.json();
         }

package/metadata/MetadataValidator.js

@@ -171,6 +171,15 @@ export class MetadataValidator {
     }
     validatePolymorphicTargets(meta, prop) {
         const targets = prop.polymorphTargets;
+        // Union-target M:N stores one scalar target FK per pivot row, so composite-PK targets
+        // can't round-trip through this schema.
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && targets.length > 1) {
+            for (const target of targets) {
+                if (target.compositePK) {
+                    throw MetadataError.incompatiblePolymorphicTargets(meta, prop, targets[0], target, `${target.className} has a composite primary key; union-target polymorphic M:N does not support composite-PK targets.`);
+                }
+            }
+        }
         // Validate targetKey exists and is compatible across all targets
         if (prop.targetKey) {
             for (const target of targets) {

package/metadata/types.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEntity, Constructor, EntityName, AnyString, CheckCallback, GeneratedColumnCallback, FormulaCallback, FilterQuery, Dictionary, AutoPath, EntityClass, IndexCallback, ObjectQuery, Raw } from '../typings.js';
+import type { AnyEntity, Constructor, EntityName, AnyString, CheckCallback, GeneratedColumnCallback, FormulaCallback, FilterQuery, Dictionary, AutoPath, EntityClass, IndexCallback, ObjectQuery, Raw, TriggerDef } from '../typings.js';
 import type { Cascade, LoadStrategy, DeferMode, QueryOrderMap, EmbeddedPrefixMode } from '../enums.js';
 import type { Type, types } from '../types/index.js';
 import type { EntityManager } from '../EntityManager.js';
@@ -57,6 +57,8 @@ export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
     };
     /** Used to make ORM aware of externally defined triggers. This is needed for MS SQL Server multi inserts, ignored in other dialects. */
     hasTriggers?: boolean;
+    /** Database triggers to create for this entity's table. (SQL drivers only) */
+    triggers?: TriggerDef<E>[];
     /** SQL query that maps to a {@doclink virtual-entities | virtual entity}, or for view entities, the view definition. */
     expression?: string | ((em: any, where: ObjectQuery<E>, options: FindOptions<E, any, any, any>, stream?: boolean) => object);
     /** Set {@doclink repositories#custom-repository | custom repository class}. */
@@ -202,6 +204,12 @@ export interface PropertyOptions<Owner> {
      * @see https://mikro-orm.io/docs/defining-entities#lazy-scalar-properties
      */
     lazy?: boolean;
+    /**
+     * Marks this property as an array. When used with a custom type, the type is automatically
+     * wrapped in an `ArrayType` that delegates element conversion to the inner type.
+     * The column type is inferred as `innerType[]` (e.g. `int[]`, `time[]`).
+     */
+    array?: boolean;
     /**
      * Set true to define entity's unique primary key identifier.
      * Alias for `@PrimaryKey()` decorator
@@ -334,7 +342,7 @@ export interface PropertyOptions<Owner> {
 }
 export interface ReferenceOptions<Owner, Target> extends PropertyOptions<Owner> {
     /** Set target entity type. For polymorphic relations, pass an array of entity types. */
-    entity?: () => EntityName<Target> | EntityName<Target>[];
+    entity?: () => EntityName<Target> | EntityName[];
     /** Set what actions on owning entity should be cascaded to the relationship. Defaults to [Cascade.PERSIST, Cascade.MERGE] (see {@doclink cascading}). */
     cascade?: Cascade[];
     /** Always load the relationship. Discouraged for use with to-many relations for performance reasons. */

package/naming-strategy/AbstractNamingStrategy.d.ts

@@ -4,7 +4,7 @@ import { type ReferenceKind } from '../enums.js';
 export declare abstract class AbstractNamingStrategy implements NamingStrategy {
     getClassName(file: string, separator?: string): string;
     classToMigrationName(timestamp: string, customMigrationName?: string): string;
-    indexName(tableName: string, columns: string[], type: 'primary' | 'foreign' | 'unique' | 'index' | 'sequence' | 'check' | 'default'): string;
+    indexName(tableName: string, columns: string[], type: 'primary' | 'foreign' | 'unique' | 'index' | 'sequence' | 'check' | 'default' | 'trigger'): string;
     /**
      * @inheritDoc
      */

package/naming-strategy/NamingStrategy.d.ts

@@ -75,7 +75,7 @@ export interface NamingStrategy {
     /**
      * Returns key/constraint name for the given type. Some drivers might not support all the types (e.g. mysql and sqlite enforce the PK name).
      */
-    indexName(tableName: string, columns: string[], type: 'primary' | 'foreign' | 'unique' | 'index' | 'sequence' | 'check' | 'default'): string;
+    indexName(tableName: string, columns: string[], type: 'primary' | 'foreign' | 'unique' | 'index' | 'sequence' | 'check' | 'default' | 'trigger'): string;
     /**
      * Returns alias name for given entity. The alias needs to be unique across the query, which is by default
      * ensured via appended index parameter. It is optional to use it as long as you ensure it will be unique.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.1.0-dev.1",
+  "version": "7.1.0-dev.11",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",