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

package/package.json

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