@mikro-orm/sql 7.3.0-dev.3 → 7.3.0-dev.5

package/AbstractSqlDriver.js

@@ -1809,7 +1809,11 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (!this.platform.shouldHaveColumn(prop, populate, exclude)) {
             return false;
         }
-        if (!fields || fields.includes('*') || prop.primary || meta.root.discriminatorColumn === prop.name) {
+        if (!fields ||
+            fields.includes('*') ||
+            prop.primary ||
+            meta.root.discriminatorColumn === prop.name ||
+            meta.root.targetKeys?.includes(prop.name)) {
             return true;
         }
         return fields.some(f => f === prop.name || f.toString().startsWith(prop.name + '.'));
@@ -1865,11 +1869,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
                         const tptMeta = this.metadata.get(targetMeta.class);
                         this.addTPTPolymorphicJoinsForRelation(qb, tptMeta, tableAlias, fields);
                     }
-                    if (ref) {
-                        // For filter :ref hints, schedule filter check for each target (no field selection)
-                        qb.scheduleFilterCheck(targetPath);
-                    }
-                    else {
+                    // target filters apply per target, both for filter :ref hints and populated relations
+                    qb.scheduleFilterCheck(targetPath);
+                    if (!ref) {
                         // Select fields from each target table
                         fields.push(...this.getFieldsForJoinedLoad(qb, targetMeta, {
                             ...options,
@@ -2469,6 +2471,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             if (!options.fields.includes('*') && !options.fields.includes(`${qb.alias}.*`)) {
                 ret.unshift(...meta.primaryKeys.filter(pk => !options.fields.includes(pk)));
+                // `targetKey` values identify the entity like its PK, references resolve it by them
+                ret.push(...(meta.root.targetKeys ?? []).filter(key => meta.properties[key] && !options.fields.includes(key)));
             }
             if (meta.root.inheritanceType === 'sti' &&
                 !options.fields.includes(`${qb.alias}.${meta.root.discriminatorColumn}`)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.3.0-dev.3",
+  "version": "7.3.0-dev.5",
   "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",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.2.1"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.3.0-dev.3"
+    "@mikro-orm/core": "7.3.0-dev.5"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/CriteriaNode.js

@@ -29,7 +29,7 @@ export class CriteriaNode {
             }
             for (const k of pks) {
                 const [name, target] = QueryHelper.splitPolymorphicKey(k);
-                this.prop = meta.props.find(prop => (prop.name === name && (!target || !!prop.polymorphTargets?.some(t => t.className === target))) ||
+                this.prop = meta.props.find(prop => (prop.name === name && (!target || QueryHelper.findTargetMetas(prop, k).length > 0)) ||
                     (prop.fieldNames?.length === 1 && prop.fieldNames[0] === k && prop.persist !== false));
                 const isProp = this.prop || meta.props.find(prop => (prop.fieldNames || []).includes(k));
                 // do not validate if the key is prefixed or type casted (e.g. `k::text`)

package/query/CriteriaNodeFactory.js

@@ -52,7 +52,7 @@ export class CriteriaNodeFactory {
         const rawField = RawQueryFragment.isKnownFragmentSymbol(key);
         const prop = rawField ? null : meta?.properties[QueryHelper.splitPolymorphicKey(key)[0]];
         const target = rawField ? undefined : QueryHelper.findTargetMeta(prop, key);
-        const childEntity = prop && prop.kind !== ReferenceKind.SCALAR ? (target ?? prop.targetMeta).class : entityName;
+        const childEntity = prop && prop.kind !== ReferenceKind.SCALAR && target ? target.class : entityName;
         const isNotEmbedded = rawField || prop?.kind !== ReferenceKind.EMBEDDED;
         const val = payload[key];
         if (isNotEmbedded && prop?.customType instanceof JsonType) {

package/query/ObjectCriteriaNode.d.ts

@@ -5,6 +5,8 @@ import type { ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings.js';
  */
 export declare class ObjectCriteriaNode<T extends object> extends CriteriaNode<T> {
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
+    /** Orders by the first non-null value of the property across the joined polymorphic targets. */
+    private processPolymorphicOrderBy;
     isStrict(): boolean;
     unwrap(): any;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;

package/query/ObjectCriteriaNode.js

@@ -1,4 +1,4 @@
-import { ALIAS_REPLACEMENT, GroupOperator, QueryFlag, raw, RawQueryFragment, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { ALIAS_REPLACEMENT, GroupOperator, QueryFlag, QueryHelper, raw, RawQueryFragment, ReferenceKind, Utils, } from '@mikro-orm/core';
 import { CriteriaNode } from './CriteriaNode.js';
 import { JoinType, QueryType } from './enums.js';
 const COLLECTION_OPERATORS = ['$some', '$none', '$every', '$size', '$all'];
@@ -7,6 +7,10 @@ const COLLECTION_OPERATORS = ['$some', '$none', '$every', '$size', '$all'];
  */
 export class ObjectCriteriaNode extends CriteriaNode {
     process(qb, options) {
+        const targets = this.isPolymorphicBranch() ? QueryHelper.findTargetMetas(this.prop, this.key) : [];
+        if (options?.type === 'orderBy' && targets.length > 1) {
+            return this.processPolymorphicOrderBy(qb, targets, options);
+        }
         const matchPopulateJoins = options?.matchPopulateJoins ||
             (this.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
         const nestedAlias = qb.getAliasForJoinPath(this.getPath(options), { ...options, matchPopulateJoins });
@@ -150,12 +154,31 @@ export class ObjectCriteriaNode extends CriteriaNode {
             return o;
         }, {});
         // the target is left joined, so its condition must only match rows that point to it
-        if (this.isPolymorphicBranch() && alias) {
+        if (this.isPolymorphicBranch() && alias && options?.type !== 'orderBy') {
             const pk = this.metadata.find(this.entityName).primaryKeys[0];
             this.inlineCondition(`${alias}.${pk}`, ret, { $ne: null });
         }
         return ret;
     }
+    /** Orders by the first non-null value of the property across the joined polymorphic targets. */
+    processPolymorphicOrderBy(qb, targets, options) {
+        const ownerAlias = options.alias || qb.alias;
+        const aliases = targets.map(target => {
+            const path = `${this.parent.getPath()}.${this.prop.name}[${target.className}]`;
+            const alias = qb.getAliasForJoinPath(path, { ...options, matchPopulateJoins: true });
+            if (alias) {
+                return alias;
+            }
+            const newAlias = qb.getNextAlias(target.class);
+            qb.addPolymorphicJoin(this.prop, target, ownerAlias, newAlias, JoinType.leftJoin, path);
+            return newAlias;
+        });
+        return Utils.getObjectQueryKeys(this.payload).reduce((o, field) => {
+            const columns = targets.map((target, i) => `${aliases[i]}.${target.properties[field].fieldNames[0]}`);
+            o[raw(`coalesce(${columns.map(() => '??').join(', ')})`, columns)] = this.payload[field].payload;
+            return o;
+        }, {});
+    }
     isStrict() {
         return (this.strict ||
             Utils.getObjectQueryKeys(this.payload).some(key => {
@@ -192,8 +215,9 @@ export class ObjectCriteriaNode extends CriteriaNode {
         const operator = Utils.isObject(payload) &&
             Utils.getObjectQueryKeys(payload).every(k => {
                 if (k === '$not' && Utils.isPlainObject(payload[k])) {
-                    // $not wrapping non-operator conditions (entity props) should be inlined
-                    return Utils.getObjectQueryKeys(payload[k]).every(ik => Utils.isOperator(ik, false));
+                    // $not wrapping non-operator conditions (entity props) or an empty one should be inlined
+                    const inner = Utils.getObjectQueryKeys(payload[k]);
+                    return inner.length > 0 && inner.every(ik => Utils.isOperator(ik, false));
                 }
                 return Utils.isOperator(k, false);
             });
@@ -224,9 +248,12 @@ export class ObjectCriteriaNode extends CriteriaNode {
             }
             else if (k === '$not' &&
                 Utils.isPlainObject(payload[k]) &&
-                Utils.getObjectQueryKeys(payload[k]).some(ik => !Utils.isOperator(ik, false))) {
-                // $not wraps entity conditions (from auto-join), inline at current level
-                this.inlineCondition(k, o, payload[k]);
+                (!Utils.hasObjectKeys(payload[k]) ||
+                    Utils.getObjectQueryKeys(payload[k]).some(ik => !Utils.isOperator(ik, false)))) {
+                // $not wraps entity conditions (from auto-join) or an empty one, inline at current level with the same key mapping
+                const inner = {};
+                this.inlineChildPayload(inner, payload[k], field, alias, childAlias);
+                this.inlineCondition(k, o, inner);
             }
             else if (Utils.isOperator(k, false)) {
                 const tmp = payload[k];
@@ -301,6 +328,13 @@ export class ObjectCriteriaNode extends CriteriaNode {
             });
         const primaryKeys = knownKey &&
             keys.every(key => {
+                if (key === '$not') {
+                    // e.g. `{ author: { $not: { id: 1 } } }` compares the FK column, relation PKs still need the join
+                    const childPayload = this.payload[key].payload;
+                    return (Utils.isPlainObject(childPayload) &&
+                        Utils.getObjectQueryKeys(childPayload).every(k => meta.primaryKeys.includes(k) &&
+                            meta.properties[k].kind === ReferenceKind.SCALAR));
+                }
                 if (typeof key !== 'string' || !meta.primaryKeys.includes(key)) {
                     return false;
                 }

package/query/QueryBuilder.js

@@ -1032,9 +1032,11 @@ export class QueryBuilder {
      * @internal
      */
     addPolymorphicJoin(prop, targetMeta, ownerAlias, alias, type, path, schema) {
-        // Override referencedColumnNames to use the specific target's PK columns
+        // Override referencedColumnNames to use the specific target's PK (or `targetKey`) columns
         // (polymorphic targets may have different PK column names, e.g. org_id vs user_id)
-        const referencedColumnNames = targetMeta.getPrimaryProps().flatMap(pk => pk.fieldNames);
+        const referencedColumnNames = prop.targetKey
+            ? targetMeta.properties[prop.targetKey].fieldNames
+            : targetMeta.getPrimaryProps().flatMap(pk => pk.fieldNames);
         const targetProp = { ...prop, targetMeta, referencedColumnNames };
         const aliasedName = `${ownerAlias}.${prop.name}[${targetMeta.className}]#${alias}`;
         this.#state.joins[aliasedName] = this.helper.joinManyToOneReference(targetProp, ownerAlias, alias, type, {}, schema);