@mikro-orm/core 7.3.0-dev.1 → 7.3.0-dev.2

package/metadata/MetadataDiscovery.js

@@ -547,7 +547,7 @@ export class MetadataDiscovery {
             const fieldNames1 = prop.targetMeta.getPrimaryProps().flatMap(pk => pk.fieldNames);
             const idColumns = fieldNames1.map(fieldName => this.#namingStrategy.joinKeyColumnName(prop.discriminator, fieldName, fieldNames1.length > 1));
             prop.fieldNames ??= [prop.discriminatorColumn, ...idColumns];
-            prop.joinColumns ??= idColumns;
+            prop.joinColumns ??= prop.fieldNames.slice(1);
             prop.referencedColumnNames ??= fieldNames1;
             prop.referencedTableName ??= prop.targetMeta.tableName;
             return;
@@ -1175,12 +1175,24 @@ export class MetadataDiscovery {
         if (!prop.discriminator && !prop.discriminatorColumn && !prop.discriminatorMap && !Array.isArray(prop.target)) {
             return;
         }
+        const isToOne = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind);
+        const isUnionTargetMN = prop.kind === ReferenceKind.MANY_TO_MANY && Array.isArray(prop.target);
         prop.polymorphic = true;
         prop.discriminator ??= prop.name;
+        // explicit `fieldNames` use the `[discriminatorColumn, ...fkIdColumns]` layout
+        if (isToOne && prop.fieldNames && prop.fieldNames.length > 1) {
+            prop.discriminatorColumn ??= prop.fieldNames[0];
+            // `EntitySchema` mirrors `fieldNames` into `joinColumns`, let `initManyToOneFields` derive them after embedded prefixing
+            if (Utils.equals(prop.joinColumns, prop.fieldNames)) {
+                delete prop.joinColumns;
+            }
+        }
         prop.discriminatorColumn ??= this.#namingStrategy.discriminatorColumnName(prop.discriminator);
         prop.createForeignKeyConstraint = false;
-        const isToOne = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind);
-        const isUnionTargetMN = prop.kind === ReferenceKind.MANY_TO_MANY && Array.isArray(prop.target);
+        // a single field name can only be the FK column, e.g. mirrored from `joinColumn`
+        if (isToOne && prop.fieldNames?.length === 1) {
+            prop.fieldNames = [prop.discriminatorColumn, ...prop.fieldNames];
+        }
         if (isToOne || isUnionTargetMN) {
             const types = prop.type.split(/ ?\| ?/);
             prop.polymorphTargets = discovered.filter(m => types.includes(m.className) && !m.embeddable);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.3.0-dev.1",
+  "version": "7.3.0-dev.2",
   "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",

package/utils/QueryHelper.d.ts

@@ -38,6 +38,18 @@ export declare class QueryHelper {
     /** Copies the plain object and array structure of the condition, keeping the leaf values (e.g. entities) by reference. */
     private static cloneWhere;
     static processWhere<T extends object>(options: ProcessWhereOptions<T>): FilterQuery<T>;
+    /** @internal Splits a polymorphic target key like `imageable[Article]` into the property and target class names. */
+    static splitPolymorphicKey(key: string): [string, string?];
+    /** @internal Resolves the target entity of a condition key, including polymorphic target keys like `imageable[Article]`. */
+    static findTargetMeta(prop: EntityProperty | null | undefined, key: string): EntityMetadata | undefined;
+    /**
+     * Routes conditions on polymorphic to-one relations to the targets that define all the queried properties,
+     * e.g. `{ imageable: { title } }` becomes `{ 'imageable[Article]': { title } }`, or an `$or` of such keys
+     * when more targets match. The first target alone keeps the regular relation join.
+     */
+    private static splitPolymorphicConditions;
+    /** Property names used in a condition, including those nested in group operators. */
+    private static collectConditionKeys;
     static getActiveFilters<T>(meta: EntityMetadata<T>, options: FilterOptions | undefined, filters: Dictionary<FilterDef>): FilterDef[];
     /** @internal Sentinel wrapping for arguments accessed while statically resolving an `rls` filter condition. */
     static readonly RLS_SENTINEL_PREFIX = "__mikro_rls_arg__";

package/utils/QueryHelper.js

@@ -158,17 +158,18 @@ export class QueryHelper {
                     })));
         }
         Object.keys(where).forEach(k => {
-            const prop = meta.properties[k];
-            const meta2 = metadata.find(prop?.targetMeta?.class) || meta;
+            const prop = meta.properties[QueryHelper.splitPolymorphicKey(k)[0]];
+            const meta2 = metadata.find(QueryHelper.findTargetMeta(prop, k)?.class) || meta;
             if (this.inlinePrimaryKeyObjects(where[k], meta2, metadata, k)) {
                 // Skip the PK collapse when an owning M:1/1:1 relation's FK column count does not match
                 // the target's PK column count (e.g. FK references target PK + an extra unique column).
                 // The criteria layer would otherwise emit a malformed predicate such as
                 // `(joinCol1, joinCol2) = scalar`. Limited to owning relations — `joinColumns` on the
                 // inverse side (1:m) describes the owning entity's FK columns, not the LHS tuple.
+                // Polymorphic relations are skipped too, a scalar would be compared to the discriminator column.
                 if (prop?.owner &&
                     [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
-                    prop.joinColumns.length !== meta2.primaryKeys.length) {
+                    (prop.polymorphic || prop.joinColumns.length !== meta2.primaryKeys.length)) {
                     return;
                 }
                 where[k] = Utils.getPrimaryKeyValues(where[k], meta2, true);
@@ -230,6 +231,9 @@ export class QueryHelper {
         if (!Utils.isPlainObject(where)) {
             return where;
         }
+        if (meta && options.type !== 'orderBy') {
+            where = QueryHelper.splitPolymorphicConditions(meta, where);
+        }
         return Utils.getObjectQueryKeys(where).reduce((o, key) => {
             let value = where[key];
             const customExpression = Raw.isKnownFragmentSymbol(key);
@@ -277,10 +281,11 @@ export class QueryHelper {
                 return o;
             }
             if (Utils.isPlainObject(value)) {
+                const targetMeta = customExpression ? undefined : QueryHelper.findTargetMeta(prop, key);
                 o[key] = QueryHelper.processWhere({
                     ...options,
                     where: value,
-                    entityName: prop?.targetMeta?.class ?? entityName,
+                    entityName: targetMeta?.class ?? entityName,
                     root: false,
                 });
             }
@@ -290,6 +295,62 @@ export class QueryHelper {
             return o;
         }, {});
     }
+    /** @internal Splits a polymorphic target key like `imageable[Article]` into the property and target class names. */
+    static splitPolymorphicKey(key) {
+        const match = /^(\w+)\[(\w+)]$/.exec(key);
+        return match ? [match[1], match[2]] : [key];
+    }
+    /** @internal Resolves the target entity of a condition key, including polymorphic target keys like `imageable[Article]`. */
+    static findTargetMeta(prop, key) {
+        const [, targetName] = QueryHelper.splitPolymorphicKey(key);
+        return targetName ? prop?.polymorphTargets?.find(t => t.className === targetName) : prop?.targetMeta;
+    }
+    /**
+     * Routes conditions on polymorphic to-one relations to the targets that define all the queried properties,
+     * e.g. `{ imageable: { title } }` becomes `{ 'imageable[Article]': { title } }`, or an `$or` of such keys
+     * when more targets match. The first target alone keeps the regular relation join.
+     */
+    static splitPolymorphicConditions(meta, payload) {
+        let ret = payload;
+        for (const key of Object.keys(payload)) {
+            const prop = meta.properties[key];
+            const value = payload[key];
+            if (!prop?.polymorphTargets ||
+                ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) ||
+                !Utils.isPlainObject(value)) {
+                continue;
+            }
+            const keys = this.collectConditionKeys(value);
+            const targets = prop.polymorphTargets.filter(target => keys.every(k => k in target.properties));
+            const primaryKeys = keys.every(k => targets.every(target => target.primaryKeys.includes(k)));
+            // PK conditions compare the FK columns without checking the type, so only when every target defines them
+            if (keys.length === 0 ||
+                targets.length === 0 ||
+                (primaryKeys && targets.length === prop.polymorphTargets.length) ||
+                (!primaryKeys && targets.length === 1 && targets[0] === prop.targetMeta)) {
+                continue;
+            }
+            const branches = targets.map(target => ({ [`${key}[${target.className}]`]: value }));
+            ret = { ...ret };
+            delete ret[key];
+            if (branches.length === 1) {
+                Object.assign(ret, branches[0]);
+            }
+            else {
+                ret.$and = [...(ret.$and ?? []), { $or: branches }];
+            }
+        }
+        return ret;
+    }
+    /** Property names used in a condition, including those nested in group operators. */
+    static collectConditionKeys(payload) {
+        return Object.keys(payload).flatMap(k => {
+            if (k in GroupOperator || k === '$not') {
+                return Utils.asArray(payload[k]).flatMap(item => Utils.isPlainObject(item) ? this.collectConditionKeys(item) : []);
+            }
+            return Utils.isOperator(k) ? [] : [k];
+        });
+    }
     static getActiveFilters(meta, options, filters) {
         if (options === false) {
             return [];
@@ -450,7 +511,7 @@ export class QueryHelper {
     }
     static findProperty(fieldName, options) {
         const parts = fieldName.split('.');
-        const propName = parts.pop();
+        const propName = QueryHelper.splitPolymorphicKey(parts.pop())[0];
         const alias = parts.length > 0 ? parts.join('.') : undefined;
         const entityName = alias ? options.aliasMap?.[alias] : options.entityName;
         const meta = entityName ? options.metadata.find(entityName) : undefined;

package/utils/Utils.js

@@ -153,7 +153,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.3.0-dev.1';
+    static #ORM_VERSION = '7.3.0-dev.2';
     /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
     static getRlsSettingName(filterName, argName) {
         return `mikro.${filterName}.${argName}`;