@mikro-orm/core 7.0.0-dev.99 → 7.0.0-rc.1

package/utils/EntityComparator.js

@@ -2,10 +2,13 @@ import { clone } from './clone.js';
 import { ReferenceKind } from '../enums.js';
 import { compareArrays, compareBooleans, compareBuffers, compareObjects, equals, parseJsonSafe, Utils } from './Utils.js';
 import { JsonType } from '../types/JsonType.js';
-import { RawQueryFragment } from './RawQueryFragment.js';
+import { Raw } from './RawQueryFragment.js';
+import { EntityIdentifier } from '../entity/EntityIdentifier.js';
+import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 export class EntityComparator {
     metadata;
     platform;
+    config;
     comparators = new Map();
     mappers = new Map();
     snapshotGenerators = new Map();
@@ -13,9 +16,10 @@ export class EntityComparator {
     pkGettersConverted = new Map();
     pkSerializers = new Map();
     tmpIndex = 0;
-    constructor(metadata, platform) {
+    constructor(metadata, platform, config) {
         this.metadata = metadata;
         this.platform = platform;
+        this.config = config;
     }
     /**
      * Computes difference between two entities.
@@ -33,21 +37,21 @@ export class EntityComparator {
      * References will be mapped to primary keys, collections to arrays of primary keys.
      */
     prepareEntity(entity) {
-        const generator = this.getSnapshotGenerator(entity.constructor.name);
+        const generator = this.getSnapshotGenerator(entity.constructor);
         return Utils.callCompiledFunction(generator, entity);
     }
     /**
      * Maps database columns to properties.
      */
-    mapResult(entityName, result) {
-        const mapper = this.getResultMapper(entityName);
+    mapResult(meta, result) {
+        const mapper = this.getResultMapper(meta);
         return Utils.callCompiledFunction(mapper, result);
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getPkGetter(meta) {
-        const exists = this.pkGetters.get(meta.className);
+        const exists = this.pkGetters.get(meta);
         /* v8 ignore next */
         if (exists) {
             return exists;
@@ -87,17 +91,18 @@ export class EntityComparator {
             }
             lines.push(`  return entity${this.wrap(pk)};`);
         }
-        const code = `// compiled pk serializer for entity ${meta.className}\n`
+        const code = `// compiled pk getter for entity ${meta.className}\n`
             + `return function(entity) {\n${lines.join('\n')}\n}`;
-        const pkSerializer = Utils.createFunction(context, code);
-        this.pkGetters.set(meta.className, pkSerializer);
+        const fnKey = `pkGetter-${meta.uniqueName}`;
+        const pkSerializer = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
+        this.pkGetters.set(meta, pkSerializer);
         return pkSerializer;
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getPkGetterConverted(meta) {
-        const exists = this.pkGettersConverted.get(meta.className);
+        const exists = this.pkGettersConverted.get(meta);
         /* v8 ignore next */
         if (exists) {
             return exists;
@@ -139,15 +144,16 @@ export class EntityComparator {
         }
         const code = `// compiled pk getter (with converted custom types) for entity ${meta.className}\n`
             + `return function(entity) {\n${lines.join('\n')}\n}`;
-        const pkSerializer = Utils.createFunction(context, code);
-        this.pkGettersConverted.set(meta.className, pkSerializer);
+        const fnKey = `pkGetterConverted-${meta.uniqueName}`;
+        const pkSerializer = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
+        this.pkGettersConverted.set(meta, pkSerializer);
         return pkSerializer;
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getPkSerializer(meta) {
-        const exists = this.pkSerializers.get(meta.className);
+        const exists = this.pkSerializers.get(meta);
         /* v8 ignore next */
         if (exists) {
             return exists;
@@ -191,25 +197,25 @@ export class EntityComparator {
         }
         const code = `// compiled pk serializer for entity ${meta.className}\n`
             + `return function(entity) {\n${lines.join('\n')}\n}`;
-        const pkSerializer = Utils.createFunction(context, code);
-        this.pkSerializers.set(meta.className, pkSerializer);
+        const fnKey = `pkSerializer-${meta.uniqueName}`;
+        const pkSerializer = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
+        this.pkSerializers.set(meta, pkSerializer);
         return pkSerializer;
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getSnapshotGenerator(entityName) {
-        entityName = Utils.className(entityName);
-        const exists = this.snapshotGenerators.get(entityName);
+        const meta = this.metadata.find(entityName);
+        const exists = this.snapshotGenerators.get(meta);
         if (exists) {
             return exists;
         }
-        const meta = this.metadata.find(entityName);
         const lines = [];
         const context = new Map();
         context.set('clone', clone);
         context.set('cloneEmbeddable', (o) => this.platform.cloneEmbeddable(o)); // do not clone prototypes
-        if (meta.discriminatorValue) {
+        if (meta.root.inheritanceType === 'sti' && meta.discriminatorValue) {
             lines.push(`  ret${this.wrap(meta.root.discriminatorColumn)} = '${meta.discriminatorValue}'`);
         }
         const getRootProperty = (prop) => prop.embedded ? getRootProperty(meta.properties[prop.embedded[0]]) : prop;
@@ -221,8 +227,9 @@ export class EntityComparator {
         })
             .forEach(prop => lines.push(this.getPropertySnapshot(meta, prop, context, this.wrap(prop.name), this.wrap(prop.name), [prop.name])));
         const code = `return function(entity) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
-        const snapshotGenerator = Utils.createFunction(context, code);
-        this.snapshotGenerators.set(entityName, snapshotGenerator);
+        const fnKey = `snapshotGenerator-${meta.uniqueName}`;
+        const snapshotGenerator = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
+        this.snapshotGenerators.set(meta, snapshotGenerator);
         return snapshotGenerator;
     }
     /**
@@ -272,14 +279,14 @@ export class EntityComparator {
     /**
      * @internal Highly performance-sensitive method.
      */
-    getResultMapper(entityName) {
-        const exists = this.mappers.get(entityName);
+    getResultMapper(meta) {
+        const exists = this.mappers.get(meta);
         if (exists) {
             return exists;
         }
-        const meta = this.metadata.get(entityName);
         const lines = [];
         const context = new Map();
+        context.set('PolymorphicRef', PolymorphicRef);
         const tz = this.platform.getTimezone();
         const parseDate = (key, value, padding = '') => {
             lines.push(`${padding}    if (${value} == null || ${value} instanceof Date) {`);
@@ -306,12 +313,28 @@ export class EntityComparator {
                 if (!prop.fieldNames) {
                     continue;
                 }
+                if (prop.polymorphic && prop.fieldNames.length >= 2) {
+                    const discriminatorField = prop.fieldNames[0];
+                    const idFields = prop.fieldNames.slice(1);
+                    lines.push(`${padding}  if (${prop.fieldNames.map(field => `typeof ${this.propName(field)} === 'undefined'`).join(' && ')}) {`);
+                    lines.push(`${padding}  } else if (${prop.fieldNames.map(field => `${this.propName(field)} != null`).join(' && ')}) {`);
+                    if (idFields.length === 1) {
+                        lines.push(`${padding}    ret${this.wrap(prop.name)} = new PolymorphicRef(${this.propName(discriminatorField)}, ${this.propName(idFields[0])});`);
+                    }
+                    else {
+                        lines.push(`${padding}    ret${this.wrap(prop.name)} = new PolymorphicRef(${this.propName(discriminatorField)}, [${idFields.map(f => this.propName(f)).join(', ')}]);`);
+                    }
+                    lines.push(...prop.fieldNames.map(field => `${padding}    ${this.propName(field, 'mapped')} = true;`));
+                    lines.push(`${padding}  } else if (${prop.fieldNames.map(field => `${this.propName(field)} == null`).join(' && ')}) {\n${padding}    ret${this.wrap(prop.name)} = null;`);
+                    lines.push(...prop.fieldNames.map(field => `${padding}    ${this.propName(field, 'mapped')} = true;`), '  }');
+                    continue;
+                }
                 if (prop.targetMeta && prop.fieldNames.length > 1) {
                     lines.push(`${padding}  if (${prop.fieldNames.map(field => `typeof ${this.propName(field)} === 'undefined'`).join(' && ')}) {`);
                     lines.push(`${padding}  } else if (${prop.fieldNames.map(field => `${this.propName(field)} != null`).join(' && ')}) {`);
                     lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.createCompositeKeyArray(prop)};`);
                     lines.push(...prop.fieldNames.map(field => `${padding}    ${this.propName(field, 'mapped')} = true;`));
-                    lines.push(`${padding}  } else if (${prop.fieldNames.map(field => `${this.propName(field)} == null`).join(' && ')}) {\n    ret${this.wrap(prop.name)} = null;`);
+                    lines.push(`${padding}  } else if (${prop.fieldNames.map(field => `${this.propName(field)} == null`).join(' && ')}) {\n${padding}    ret${this.wrap(prop.name)} = null;`);
                     lines.push(...prop.fieldNames.map(field => `${padding}    ${this.propName(field, 'mapped')} = true;`), '  }');
                     continue;
                 }
@@ -336,9 +359,9 @@ export class EntityComparator {
                     context.set(`mapEmbeddedResult_${idx}`, (data) => {
                         const item = parseJsonSafe(data);
                         if (Array.isArray(item)) {
-                            return item.map(row => row == null ? row : this.getResultMapper(prop.type)(row));
+                            return item.map(row => row == null ? row : this.getResultMapper(prop.targetMeta)(row));
                         }
-                        return item == null ? item : this.getResultMapper(prop.type)(item);
+                        return item == null ? item : this.getResultMapper(prop.targetMeta)(item);
                     });
                     lines.push(`${padding}  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
                     lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])} == null ? ${this.propName(prop.fieldNames[0])} : mapEmbeddedResult_${idx}(${this.propName(prop.fieldNames[0])});`);
@@ -370,8 +393,9 @@ export class EntityComparator {
         lines.push(`  for (let k in result) { if (Object.hasOwn(result, k) && !mapped[k] && ret[k] === undefined) ret[k] = result[k]; }`);
         const code = `// compiled mapper for entity ${meta.className}\n`
             + `return function(result) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
-        const resultMapper = Utils.createFunction(context, code);
-        this.mappers.set(entityName, resultMapper);
+        const fnKey = `resultMapper-${meta.uniqueName}`;
+        const resultMapper = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
+        this.mappers.set(meta, resultMapper);
         return resultMapper;
     }
     getPropertyCondition(path) {
@@ -482,7 +506,7 @@ export class EntityComparator {
         const convertorKey = this.safeKey(prop.name);
         context.set(`convertToDatabaseValue_${convertorKey}`, (val) => {
             /* v8 ignore next */
-            if (RawQueryFragment.isKnownFragment(val)) {
+            if (Raw.isKnownFragment(val)) {
                 return val;
             }
             return prop.customType.convertToDatabaseValue(val, this.platform, { mode: 'serialization' });
@@ -511,16 +535,51 @@ export class EntityComparator {
                     ret += `    ret${dataKey} = entity${entityKey};\n`;
                 }
             }
+            else if (prop.polymorphic) {
+                const discriminatorMapKey = `discriminatorMapReverse_${prop.name}`;
+                const reverseMap = new Map();
+                for (const [key, value] of Object.entries(prop.discriminatorMap)) {
+                    reverseMap.set(value, key);
+                }
+                context.set(discriminatorMapKey, reverseMap);
+                this.setToArrayHelper(context);
+                context.set('EntityIdentifier', EntityIdentifier);
+                context.set('PolymorphicRef', PolymorphicRef);
+                ret += `    if (entity${entityKey} === null) {\n`;
+                ret += `      ret${dataKey} = null;\n`;
+                ret += `    } else if (typeof entity${entityKey} !== 'undefined') {\n`;
+                ret += `      const val${level} = entity${entityKey}${unwrap};\n`;
+                ret += `      const discriminator = ${discriminatorMapKey}.get(val${level}?.constructor);\n`;
+                ret += `      const pk = val${level}?.__helper?.__identifier && !val${level}?.__helper?.hasPrimaryKey()\n`;
+                ret += `        ? val${level}.__helper.__identifier\n`;
+                ret += `        : toArray(val${level}?.__helper?.getPrimaryKey(true));\n`;
+                ret += `      ret${dataKey} = new PolymorphicRef(discriminator, pk);\n`;
+                ret += `    }\n`;
+            }
+            else if (prop.targetKey) {
+                // When targetKey is set, extract that property value instead of the PK
+                const targetProp = prop.targetMeta?.properties[prop.targetKey];
+                ret += `    if (entity${entityKey} === null) {\n`;
+                ret += `      ret${dataKey} = null;\n`;
+                ret += `    } else if (typeof entity${entityKey} !== 'undefined') {\n`;
+                ret += `      const val${level} = entity${entityKey}${unwrap};\n`;
+                if (targetProp?.customType) {
+                    // If targetKey property has a custom type, convert to database value
+                    const convertorKey = this.registerCustomType(targetProp, context);
+                    ret += `      ret${dataKey} = convertToDatabaseValue_${convertorKey}(val${level}?.${prop.targetKey});\n`;
+                }
+                else {
+                    ret += `      ret${dataKey} = val${level}?.${prop.targetKey};\n`;
+                }
+                ret += `    }\n`;
+            }
             else {
-                const toArray = (val) => {
-                    if (Utils.isPlainObject(val)) {
-                        return Object.values(val).map(v => toArray(v));
-                    }
-                    return val;
-                };
-                context.set('toArray', toArray);
+                this.setToArrayHelper(context);
+                context.set('EntityIdentifier', EntityIdentifier);
                 ret += `    if (entity${entityKey} === null) {\n`;
                 ret += `      ret${dataKey} = null;\n`;
+                ret += `    } else if (entity${entityKey}?.__helper.__identifier && !entity${entityKey}.__helper.hasPrimaryKey()) {\n`;
+                ret += `      ret${dataKey} = entity${entityKey}?.__helper.__identifier;\n`;
                 ret += `    } else if (typeof entity${entityKey} !== 'undefined') {\n`;
                 ret += `      ret${dataKey} = toArray(entity${entityKey}.__helper.getPrimaryKey(true));\n`;
                 ret += `    }\n`;
@@ -544,11 +603,11 @@ export class EntityComparator {
      * @internal Highly performance-sensitive method.
      */
     getEntityComparator(entityName) {
-        const exists = this.comparators.get(entityName);
+        const meta = this.metadata.find(entityName);
+        const exists = this.comparators.get(meta);
         if (exists) {
             return exists;
         }
-        const meta = this.metadata.find(entityName);
         const lines = [];
         const context = new Map();
         context.set('compareArrays', compareArrays);
@@ -569,8 +628,9 @@ export class EntityComparator {
         lines.push(`}`);
         const code = `// compiled comparator for entity ${meta.className}\n`
             + `return function(last, current, options) {\n  const diff = {};\n${lines.join('\n')}\n  return diff;\n}`;
-        const comparator = Utils.createFunction(context, code);
-        this.comparators.set(entityName, comparator);
+        const fnKey = `comparator-${meta.uniqueName}`;
+        const comparator = Utils.createFunction(context, code, this.config?.get('compiledFunctions'), fnKey);
+        this.comparators.set(meta, comparator);
         return comparator;
     }
     getGenericComparator(prop, cond) {
@@ -586,18 +646,28 @@ export class EntityComparator {
     getPropertyComparator(prop, context) {
         let type = prop.type.toLowerCase();
         if (prop.kind !== ReferenceKind.SCALAR && prop.kind !== ReferenceKind.EMBEDDED) {
-            const meta2 = this.metadata.find(prop.type);
-            if (meta2.primaryKeys.length > 1) {
-                type = 'array';
+            if (prop.polymorphic) {
+                type = 'object';
             }
             else {
-                type = meta2.properties[meta2.primaryKeys[0]].type.toLowerCase();
+                const meta2 = prop.targetMeta;
+                if (meta2.primaryKeys.length > 1) {
+                    type = 'array';
+                }
+                else {
+                    type = meta2.getPrimaryProp().type.toLowerCase();
+                }
             }
         }
         if (prop.customType) {
             if (prop.customType.compareValues) {
                 const idx = this.tmpIndex++;
-                context.set(`compareValues_${idx}`, (a, b) => prop.customType.compareValues(a, b));
+                context.set(`compareValues_${idx}`, (a, b) => {
+                    if (Raw.isKnownFragment(a) || Raw.isKnownFragment(b)) {
+                        return Raw.getKnownFragment(a) === Raw.getKnownFragment(b);
+                    }
+                    return prop.customType.compareValues(a, b);
+                });
                 return this.getGenericComparator(this.wrap(prop.name), `!compareValues_${idx}(last${this.wrap(prop.name)}, current${this.wrap(prop.name)})`);
             }
             type = prop.customType.compareAsType().toLowerCase();
@@ -638,6 +708,22 @@ export class EntityComparator {
     safeKey(key) {
         return key.replace(/\W/g, '_');
     }
+    /**
+     * Sets the toArray helper in the context if not already set.
+     * Used for converting composite PKs to arrays.
+     */
+    setToArrayHelper(context) {
+        if (context.has('toArray')) {
+            return;
+        }
+        const toArray = (val) => {
+            if (Utils.isPlainObject(val)) {
+                return Object.values(val).map(v => toArray(v));
+            }
+            return val;
+        };
+        context.set('toArray', toArray);
+    }
     /**
      * perf: used to generate list of comparable properties during discovery, so we speed up the runtime comparison
      */

package/utils/QueryHelper.d.ts

@@ -1,12 +1,17 @@
-import type { Dictionary, EntityMetadata, EntityProperty, FilterDef, FilterQuery } from '../typings.js';
+import type { Dictionary, EntityMetadata, EntityName, EntityProperty, FilterDef, FilterQuery } from '../typings.js';
+import { type QueryOrderMap } from '../enums.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { FilterOptions } from '../drivers/IDatabaseDriver.js';
 /** @internal */
 export declare class QueryHelper {
     static readonly SUPPORTED_OPERATORS: string[];
+    /**
+     * Finds the discriminator value (key) for a given entity class in a discriminator map.
+     */
+    static findDiscriminatorValue<T>(discriminatorMap: Dictionary<T>, targetClass: T): string | undefined;
     static processParams(params: unknown): any;
-    static processObjectParams<T extends object>(params?: T): T;
+    static processObjectParams<T extends Dictionary>(params?: T): T;
     /**
      * converts `{ account: { $or: [ [Object], [Object] ] } }`
      * to `{ $or: [ { account: [Object] }, { account: [Object] } ] }`
@@ -14,22 +19,27 @@ export declare class QueryHelper {
     static liftGroupOperators<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): string | undefined;
     static inlinePrimaryKeyObjects<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): boolean;
     static processWhere<T extends object>(options: ProcessWhereOptions<T>): FilterQuery<T>;
-    static getActiveFilters(entityName: string, options: FilterOptions | undefined, filters: Dictionary<FilterDef>): FilterDef[];
+    static getActiveFilters<T>(meta: EntityMetadata<T>, options: FilterOptions | undefined, filters: Dictionary<FilterDef>): FilterDef[];
     static mergePropertyFilters(propFilters: FilterOptions | undefined, options: FilterOptions | undefined): FilterOptions | undefined;
-    static isFilterActive(entityName: string, filterName: string, filter: FilterDef, options: Dictionary<boolean | Dictionary>): boolean;
+    static isFilterActive<T>(meta: EntityMetadata<T>, filterName: string, filter: FilterDef, options: Dictionary<boolean | Dictionary>): boolean;
     static processCustomType<T extends object>(prop: EntityProperty<T>, cond: FilterQuery<T>, platform: Platform, key?: string, fromQuery?: boolean): FilterQuery<T>;
     private static isSupportedOperator;
     private static processJsonCondition;
     private static getValueType;
     static findProperty<T>(fieldName: string, options: ProcessWhereOptions<T>): EntityProperty<T> | undefined;
+    /**
+     * Merges multiple orderBy sources with key-level deduplication (first-seen key wins).
+     * RawQueryFragment symbol keys are never deduped (each is unique).
+     */
+    static mergeOrderBy<T>(...sources: (QueryOrderMap<T> | QueryOrderMap<T>[] | undefined)[]): QueryOrderMap<T>[];
 }
 interface ProcessWhereOptions<T> {
     where: FilterQuery<T>;
-    entityName: string;
+    entityName: EntityName<T>;
     metadata: MetadataStorage;
     platform: Platform;
     aliased?: boolean;
-    aliasMap?: Dictionary<string>;
+    aliasMap?: Dictionary<EntityName>;
     convertCustomTypes?: boolean;
     root?: boolean;
     type?: 'where' | 'orderBy';

package/utils/QueryHelper.js

@@ -3,10 +3,16 @@ import { Utils } from './Utils.js';
 import { ARRAY_OPERATORS, GroupOperator, JSON_KEY_OPERATORS, ReferenceKind } from '../enums.js';
 import { JsonType } from '../types/JsonType.js';
 import { helper } from '../entity/wrap.js';
-import { isRaw, RawQueryFragment } from './RawQueryFragment.js';
+import { isRaw, Raw } from './RawQueryFragment.js';
 /** @internal */
 export class QueryHelper {
     static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
+    /**
+     * Finds the discriminator value (key) for a given entity class in a discriminator map.
+     */
+    static findDiscriminatorValue(discriminatorMap, targetClass) {
+        return Object.entries(discriminatorMap).find(([, cls]) => cls === targetClass)?.[0];
+    }
     static processParams(params) {
         if (Reference.isReference(params)) {
             params = params.unwrap();
@@ -29,7 +35,7 @@ export class QueryHelper {
         return params;
     }
     static processObjectParams(params = {}) {
-        Utils.keys(params).forEach(k => {
+        Utils.getObjectQueryKeys(params).forEach(k => {
             params[k] = QueryHelper.processParams(params[k]);
         });
         return params;
@@ -62,7 +68,10 @@ export class QueryHelper {
         for (const k of keys) {
             const value = where[k];
             const prop = meta.properties[k];
-            if (!prop || ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+            // Polymorphic relations use multiple columns (discriminator + FK), so they cannot
+            // participate in the standard single-column FK expansion. Query by discriminator
+            // column directly instead, e.g. { likeableType: 'post', likeableId: 1 }.
+            if (!prop || ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) || prop.polymorphic) {
                 continue;
             }
             const op = this.liftGroupOperators(value, prop.targetMeta, metadata, k);
@@ -98,7 +107,7 @@ export class QueryHelper {
             }));
         }
         Object.keys(where).forEach(k => {
-            const meta2 = metadata.find(meta.properties[k]?.type) || meta;
+            const meta2 = metadata.find(meta.properties[k]?.targetMeta?.class) || meta;
             if (this.inlinePrimaryKeyObjects(where[k], meta2, metadata, k)) {
                 where[k] = Utils.getPrimaryKeyValues(where[k], meta2, true);
             }
@@ -126,7 +135,7 @@ export class QueryHelper {
             where = { [Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
         }
         if (Array.isArray(where) && root) {
-            const rootPrimaryKey = meta ? Utils.getPrimaryKeyHash(meta.primaryKeys) : entityName;
+            const rootPrimaryKey = meta ? Utils.getPrimaryKeyHash(meta.primaryKeys) : Utils.className(entityName);
             let cond = { [rootPrimaryKey]: { $in: where } };
             // @ts-ignore
             // detect tuple comparison, use `$or` in case the number of constituents don't match
@@ -138,12 +147,10 @@ export class QueryHelper {
         if (!Utils.isPlainObject(where)) {
             return where;
         }
-        return Object.keys(where).reduce((o, key) => {
+        return Utils.getObjectQueryKeys(where).reduce((o, key) => {
             let value = where[key];
-            const prop = this.findProperty(key, options);
-            const keys = prop?.joinColumns?.length ?? 0;
-            const composite = keys > 1;
-            if (Array.isArray(value) && value.length === 0 && RawQueryFragment.isKnownFragment(key)) {
+            const customExpression = Raw.isKnownFragmentSymbol(key);
+            if (Array.isArray(value) && value.length === 0 && customExpression) {
                 o[key] = value;
                 return o;
             }
@@ -157,6 +164,9 @@ export class QueryHelper {
                 o[rootPrimaryKey] = { [key]: QueryHelper.processWhere({ ...options, where: value, root: false }) };
                 return o;
             }
+            const prop = customExpression ? null : this.findProperty(key, options);
+            const keys = prop?.joinColumns?.length ?? 0;
+            const composite = keys > 1;
             if (prop?.customType && convertCustomTypes && !isRaw(value)) {
                 value = QueryHelper.processCustomType(prop, value, platform, undefined, true);
             }
@@ -164,7 +174,7 @@ export class QueryHelper {
             if (isJsonProperty && prop?.kind !== ReferenceKind.EMBEDDED) {
                 return this.processJsonCondition(o, value, [prop.fieldNames[0]], platform, aliased);
             }
-            if (Array.isArray(value) && !Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !key.includes('?') && options.type !== 'orderBy') {
+            if (Array.isArray(value) && !Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !(customExpression && Raw.getKnownFragment(key).params.length > 0) && options.type !== 'orderBy') {
                 // comparing single composite key - use $eq instead of $in
                 const op = composite && !value.every(v => Array.isArray(v)) ? '$eq' : '$in';
                 o[key] = { [op]: value };
@@ -174,7 +184,7 @@ export class QueryHelper {
                 o[key] = QueryHelper.processWhere({
                     ...options,
                     where: value,
-                    entityName: prop?.type ?? entityName,
+                    entityName: prop?.targetMeta?.class ?? entityName,
                     root: false,
                 });
             }
@@ -184,7 +194,7 @@ export class QueryHelper {
             return o;
         }, {});
     }
-    static getActiveFilters(entityName, options, filters) {
+    static getActiveFilters(meta, options, filters) {
         if (options === false) {
             return [];
         }
@@ -196,7 +206,7 @@ export class QueryHelper {
             Object.keys(options).forEach(filter => opts[filter] = options[filter]);
         }
         return Object.keys(filters)
-            .filter(f => QueryHelper.isFilterActive(entityName, f, filters[f], opts))
+            .filter(f => QueryHelper.isFilterActive(meta, f, filters[f], opts))
             .map(f => {
             filters[f].name = f;
             return filters[f];
@@ -220,8 +230,8 @@ export class QueryHelper {
         }
         return Utils.mergeConfig({}, propFilters, options);
     }
-    static isFilterActive(entityName, filterName, filter, options) {
-        if (filter.entity && !filter.entity.includes(entityName)) {
+    static isFilterActive(meta, filterName, filter, options) {
+        if (filter.entity && !filter.entity.includes(meta.className)) {
             return false;
         }
         if (options[filterName] === false) {
@@ -231,8 +241,8 @@ export class QueryHelper {
     }
     static processCustomType(prop, cond, platform, key, fromQuery) {
         if (Utils.isPlainObject(cond)) {
-            return Utils.keys(cond).reduce((o, k) => {
-                if (Utils.isOperator(k, true) || prop.referencedPKs?.includes(k)) {
+            return Utils.getObjectQueryKeys(cond).reduce((o, k) => {
+                if (!Raw.isKnownFragmentSymbol(k) && (Utils.isOperator(k, true) || prop.referencedPKs?.includes(k))) {
                     o[k] = QueryHelper.processCustomType(prop, cond[k], platform, k, fromQuery);
                 }
                 else {
@@ -290,4 +300,29 @@ export class QueryHelper {
         const meta = entityName ? options.metadata.find(entityName) : undefined;
         return meta?.properties[propName];
     }
+    /**
+     * Merges multiple orderBy sources with key-level deduplication (first-seen key wins).
+     * RawQueryFragment symbol keys are never deduped (each is unique).
+     */
+    static mergeOrderBy(...sources) {
+        const result = [];
+        const seenKeys = new Set();
+        for (const source of sources) {
+            if (source == null) {
+                continue;
+            }
+            for (const item of Utils.asArray(source)) {
+                for (const key of Utils.getObjectQueryKeys(item)) {
+                    if (typeof key === 'symbol') {
+                        result.push({ [key]: item[key] });
+                    }
+                    else if (!seenKeys.has(key)) {
+                        seenKeys.add(key);
+                        result.push({ [key]: item[key] });
+                    }
+                }
+            }
+        }
+        return result;
+    }
 }