@mikro-orm/core 7.1.0-dev.5 → 7.1.0-dev.50

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);
@@ -159,6 +164,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 +485,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);
@@ -556,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);
@@ -582,6 +605,28 @@ 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:
+                //   - 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 +766,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 +858,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.
@@ -958,9 +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]);
+        // 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);
@@ -1045,11 +1126,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 +1150,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) {
@@ -1187,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);
@@ -1227,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;
@@ -1281,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;
@@ -1296,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;
@@ -1458,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();
@@ -1487,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);
             }
@@ -1512,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,
                     });
@@ -1520,6 +1649,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]);
@@ -1667,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;
@@ -1702,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;
     /**