@mikro-orm/sql 7.0.0-dev.112 → 7.0.0-dev.114

package/AbstractSqlDriver.js

@@ -167,7 +167,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
     async wrapVirtualExpressionInSubquery(meta, expression, where, options, type) {
         const qb = await this.createQueryBuilderFromOptions(meta, where, options);
         qb.setFlag(QueryFlag.DISABLE_PAGINATE);
-        const isCursorPagination = [options.first, options.last, options.before, options.after].some(v => v != null);
+        const isCursorPagination = [
+            options.first,
+            options.last,
+            options.before,
+            options.after,
+        ].some(v => v != null);
         const native = qb.getNativeQuery(false);
         if (type === QueryType.COUNT) {
             native
@@ -830,7 +835,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             populateWhere: undefined,
             // @ts-ignore
             _populateWhere: 'infer',
-            populateFilter: !Utils.isEmpty(options?.populateFilter) ? { [pivotProp2.name]: options?.populateFilter } : undefined,
+            populateFilter: !Utils.isEmpty(options?.populateFilter) || RawQueryFragment.hasObjectFragments(options?.populateFilter) ? { [pivotProp2.name]: options?.populateFilter } : undefined,
         });
         const map = {};
         for (const owner of owners) {
@@ -844,7 +849,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         return map;
     }
     getPivotOrderBy(prop, pivotProp, orderBy, parentOrderBy) {
-        if (!Utils.isEmpty(orderBy)) {
+        if (!Utils.isEmpty(orderBy) || RawQueryFragment.hasObjectFragments(orderBy)) {
             return Utils.asArray(orderBy).map(o => ({ [pivotProp.name]: o }));
         }
         if (prop.kind === ReferenceKind.MANY_TO_MANY && Utils.asArray(parentOrderBy).some(o => o[prop.name])) {
@@ -852,7 +857,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 .filter(o => o[prop.name])
                 .map(o => ({ [pivotProp.name]: o[prop.name] }));
         }
-        if (!Utils.isEmpty(prop.orderBy)) {
+        if (!Utils.isEmpty(prop.orderBy) || RawQueryFragment.hasObjectFragments(prop.orderBy)) {
             return Utils.asArray(prop.orderBy).map(o => ({ [pivotProp.name]: o }));
         }
         if (prop.fixedOrder) {
@@ -1152,21 +1157,21 @@ export class AbstractSqlDriver extends DatabaseDriver {
         for (const hint of joinedProps) {
             const [propName] = hint.field.split(':', 2);
             const prop = meta.properties[propName];
-            if (!Utils.isEmpty(prop.where)) {
+            if (!Utils.isEmpty(prop.where) || RawQueryFragment.hasObjectFragments(prop.where)) {
                 where[prop.name] = Utils.copy(prop.where);
             }
             if (hint.children) {
                 const inner = this.buildPopulateWhere(prop.targetMeta, hint.children, {});
-                if (!Utils.isEmpty(inner)) {
+                if (!Utils.isEmpty(inner) || RawQueryFragment.hasObjectFragments(inner)) {
                     where[prop.name] ??= {};
                     Object.assign(where[prop.name], inner);
                 }
             }
         }
-        if (Utils.isEmpty(options.populateWhere)) {
+        if (Utils.isEmpty(options.populateWhere) && !RawQueryFragment.hasObjectFragments(options.populateWhere)) {
             return where;
         }
-        if (Utils.isEmpty(where)) {
+        if (Utils.isEmpty(where) && !RawQueryFragment.hasObjectFragments(where)) {
             return options.populateWhere;
         }
         /* v8 ignore next */
@@ -1178,31 +1183,31 @@ export class AbstractSqlDriver extends DatabaseDriver {
         // as `options.populateWhere` will be always recomputed to respect filters
         const populateWhereAll = options._populateWhere !== 'infer' && !Utils.isEmpty(options._populateWhere);
         const path = (populateWhereAll ? '[populate]' : '') + meta.className;
+        const optionsOrderBy = Utils.asArray(options.orderBy);
         const populateOrderBy = this.buildPopulateOrderBy(qb, meta, Utils.asArray(options.populateOrderBy ?? options.orderBy), path, !!options.populateOrderBy);
         const joinedPropsOrderBy = this.buildJoinedPropsOrderBy(qb, meta, joinedProps, options, path);
-        return [...Utils.asArray(options.orderBy), ...populateOrderBy, ...joinedPropsOrderBy];
+        return [...optionsOrderBy, ...populateOrderBy, ...joinedPropsOrderBy];
     }
     buildPopulateOrderBy(qb, meta, populateOrderBy, parentPath, explicit, parentAlias = qb.alias) {
         const orderBy = [];
         for (let i = 0; i < populateOrderBy.length; i++) {
             const orderHint = populateOrderBy[i];
-            for (const propName of Utils.keys(orderHint)) {
-                const raw = RawQueryFragment.getKnownFragment(propName, explicit);
-                if (raw) {
-                    const sql = raw.sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), parentAlias);
-                    const raw2 = new RawQueryFragment(sql, raw.params);
-                    orderBy.push({ [raw2]: orderHint[propName] });
+            for (const field of Utils.getObjectQueryKeys(orderHint)) {
+                const childOrder = orderHint[field];
+                if (RawQueryFragment.isKnownFragmentSymbol(field)) {
+                    const { sql, params } = RawQueryFragment.getKnownFragment(field);
+                    const key = raw(sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), parentAlias), params);
+                    orderBy.push({ [key]: childOrder });
                     continue;
                 }
-                const prop = meta.properties[propName];
+                const prop = meta.properties[field];
                 if (!prop) {
-                    throw new Error(`Trying to order by not existing property ${meta.className}.${propName}`);
+                    throw new Error(`Trying to order by not existing property ${meta.className}.${field}`);
                 }
                 let path = parentPath;
                 const meta2 = this.metadata.find(prop.type);
-                const childOrder = orderHint[prop.name];
                 if (prop.kind !== ReferenceKind.SCALAR && (![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) || !prop.owner || Utils.isPlainObject(childOrder))) {
-                    path += `.${propName}`;
+                    path += `.${field}`;
                 }
                 if (prop.kind === ReferenceKind.MANY_TO_MANY && typeof childOrder !== 'object') {
                     path += '[pivot]';
@@ -1228,9 +1233,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     }
                     continue;
                 }
-                const order = typeof childOrder === 'object' ? childOrder[propName] : childOrder;
+                const order = typeof childOrder === 'object' ? childOrder[field] : childOrder;
                 if (order) {
-                    orderBy.push({ [`${propAlias}.${propName}`]: order });
+                    orderBy.push({ [`${propAlias}.${field}`]: order });
                 }
             }
         }
@@ -1256,15 +1261,16 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             if (propOrderBy) {
                 for (const item of Utils.asArray(propOrderBy)) {
-                    for (const field of Utils.keys(item)) {
-                        const rawField = RawQueryFragment.getKnownFragment(field, false);
-                        if (rawField) {
-                            const sql = propAlias ? rawField.sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), propAlias) : rawField.sql;
-                            const raw2 = raw(sql, rawField.params);
-                            orderBy.push({ [raw2.toString()]: item[field] });
+                    for (const field of Utils.getObjectQueryKeys(item)) {
+                        const order = item[field];
+                        if (RawQueryFragment.isKnownFragmentSymbol(field)) {
+                            const { sql, params } = RawQueryFragment.getKnownFragment(field);
+                            const sql2 = propAlias ? sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), propAlias) : sql;
+                            const key = raw(sql2, params);
+                            orderBy.push({ [key]: order });
                             continue;
                         }
-                        orderBy.push({ [`${propAlias}.${field}`]: item[field] });
+                        orderBy.push({ [`${propAlias}.${field}`]: order });
                     }
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.112",
+  "version": "7.0.0-dev.114",
   "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.",
   "type": "module",
   "exports": {
@@ -56,6 +56,6 @@
     "@mikro-orm/core": "^6.6.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.112"
+    "@mikro-orm/core": "7.0.0-dev.114"
   }
 }

package/query/CriteriaNode.d.ts

@@ -1,4 +1,4 @@
-import { type EntityKey, type EntityProperty, type MetadataStorage } from '@mikro-orm/core';
+import { type EntityKey, type EntityProperty, type MetadataStorage, type RawQueryFragmentSymbol } from '@mikro-orm/core';
 import type { ICriteriaNode, ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings.js';
 /**
  * Helper for working with deeply nested where/orderBy/having criteria. Uses composite pattern to build tree from the payload.
@@ -9,12 +9,12 @@ export declare class CriteriaNode<T extends object> implements ICriteriaNode<T>
     protected readonly metadata: MetadataStorage;
     readonly entityName: string;
     readonly parent?: ICriteriaNode<T> | undefined;
-    readonly key?: EntityKey<T> | undefined;
+    readonly key?: (EntityKey<T> | RawQueryFragmentSymbol) | undefined;
     readonly strict: boolean;
     payload: any;
     prop?: EntityProperty<T>;
     index?: number;
-    constructor(metadata: MetadataStorage, entityName: string, parent?: ICriteriaNode<T> | undefined, key?: EntityKey<T> | undefined, validate?: boolean, strict?: boolean);
+    constructor(metadata: MetadataStorage, entityName: string, parent?: ICriteriaNode<T> | undefined, key?: (EntityKey<T> | RawQueryFragmentSymbol) | undefined, validate?: boolean, strict?: boolean);
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
     unwrap(): any;
     shouldInline(payload: any): boolean;

package/query/CriteriaNode.js

@@ -20,7 +20,7 @@ export class CriteriaNode {
         this.key = key;
         this.strict = strict;
         const meta = parent && metadata.find(parent.entityName);
-        if (meta && key) {
+        if (meta && key && !RawQueryFragment.isKnownFragmentSymbol(key)) {
             const pks = Utils.splitPrimaryKeys(key);
             if (pks.length > 1) {
                 return;
@@ -29,7 +29,7 @@ export class CriteriaNode {
                 this.prop = meta.props.find(prop => prop.name === k || (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`)
-                if (validate && !isProp && !k.includes('.') && !k.includes('::') && !Utils.isOperator(k) && !RawQueryFragment.isKnownFragment(k)) {
+                if (validate && !isProp && !k.includes('.') && !k.includes('::') && !Utils.isOperator(k)) {
                     throw new Error(`Trying to query by not existing property ${entityName}.${k}`);
                 }
             }
@@ -50,11 +50,9 @@ export class CriteriaNode {
     shouldRename(payload) {
         const type = this.prop ? this.prop.kind : null;
         const composite = this.prop?.joinColumns ? this.prop.joinColumns.length > 1 : false;
-        const customExpression = RawQueryFragment.isKnownFragment(this.key);
-        const scalar = payload === null || Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
-        const plainObject = Utils.isPlainObject(payload);
-        const keys = plainObject ? Object.keys(payload) : [];
-        const operator = plainObject && keys.every(k => Utils.isOperator(k, false));
+        const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
+        const scalar = payload === null || Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || rawField;
+        const operator = Utils.isPlainObject(payload) && Utils.getObjectQueryKeys(payload).every(k => Utils.isOperator(k, false));
         if (composite) {
             return true;
         }
@@ -84,7 +82,7 @@ export class CriteriaNode {
         const parentPath = this.parent?.getPath(addParentIndex) ?? this.entityName;
         const index = addIndex && this.index != null ? `[${this.index}]` : '';
         // ignore group operators to allow easier mapping (e.g. for orderBy)
-        const key = this.key && !['$and', '$or', '$not'].includes(this.key) ? '.' + this.key : '';
+        const key = this.key && !RawQueryFragment.isKnownFragmentSymbol(this.key) && !['$and', '$or', '$not'].includes(this.key) ? '.' + this.key : '';
         const ret = parentPath + index + key;
         if (this.isPivotJoin()) {
             // distinguish pivot table join from target entity join
@@ -96,9 +94,9 @@ export class CriteriaNode {
         if (!this.key || !this.prop) {
             return false;
         }
-        const customExpression = RawQueryFragment.isKnownFragment(this.key);
-        const scalar = this.payload === null || Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || customExpression;
-        const operator = Utils.isObject(this.payload) && Object.keys(this.payload).every(k => Utils.isOperator(k, false));
+        const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
+        const scalar = this.payload === null || Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || rawField;
+        const operator = Utils.isObject(this.payload) && Utils.getObjectQueryKeys(this.payload).every(k => Utils.isOperator(k, false));
         return this.prop.kind === ReferenceKind.MANY_TO_MANY && (scalar || operator);
     }
     getPivotPath(path) {

package/query/CriteriaNodeFactory.d.ts

@@ -1,12 +1,12 @@
-import { type Dictionary, type EntityKey, type EntityMetadata, type MetadataStorage } from '@mikro-orm/core';
+import { type Dictionary, type EntityKey, type EntityMetadata, type MetadataStorage, type RawQueryFragmentSymbol } from '@mikro-orm/core';
 import type { ICriteriaNode } from '../typings.js';
 /**
  * @internal
  */
 export declare class CriteriaNodeFactory {
-    static createNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
-    static createScalarNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T> | RawQueryFragmentSymbol): ICriteriaNode<T>;
+    static createScalarNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T> | RawQueryFragmentSymbol): ICriteriaNode<T>;
     static createArrayNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any[], parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
     static createObjectNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: Dictionary, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
-    static createObjectItemNode<T extends object>(metadata: MetadataStorage, entityName: string, node: ICriteriaNode<T>, payload: Dictionary, key: EntityKey<T>, meta?: EntityMetadata<T>): ICriteriaNode<T>;
+    static createObjectItemNode<T extends object>(metadata: MetadataStorage, entityName: string, node: ICriteriaNode<T>, payload: Dictionary, key: EntityKey<T> | RawQueryFragmentSymbol, meta?: EntityMetadata<T>): ICriteriaNode<T>;
 }

package/query/CriteriaNodeFactory.js

@@ -7,8 +7,8 @@ import { ScalarCriteriaNode } from './ScalarCriteriaNode.js';
  */
 export class CriteriaNodeFactory {
     static createNode(metadata, entityName, payload, parent, key) {
-        const customExpression = RawQueryFragment.isKnownFragment(key || '');
-        const scalar = Utils.isPrimaryKey(payload) || isRaw(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
+        const rawField = RawQueryFragment.isKnownFragmentSymbol(key);
+        const scalar = Utils.isPrimaryKey(payload) || isRaw(payload) || payload instanceof RegExp || payload instanceof Date || rawField;
         if (Array.isArray(payload) && !scalar) {
             return this.createArrayNode(metadata, entityName, payload, parent, key);
         }
@@ -38,25 +38,27 @@ export class CriteriaNodeFactory {
         const meta = metadata.find(entityName);
         const node = new ObjectCriteriaNode(metadata, entityName, parent, key, true, payload.__strict);
         node.payload = {};
-        for (const key of Object.keys(payload)) {
-            node.payload[key] = this.createObjectItemNode(metadata, entityName, node, payload, key, meta);
+        for (const k of Utils.getObjectQueryKeys(payload)) {
+            node.payload[k] = this.createObjectItemNode(metadata, entityName, node, payload, k, meta);
         }
         return node;
     }
     static createObjectItemNode(metadata, entityName, node, payload, key, meta) {
-        const prop = meta?.properties[key];
+        const rawField = RawQueryFragment.isKnownFragmentSymbol(key);
+        const prop = rawField ? null : meta?.properties[key];
         const childEntity = prop && prop.kind !== ReferenceKind.SCALAR ? prop.type : entityName;
-        const isNotEmbedded = prop?.kind !== ReferenceKind.EMBEDDED;
+        const isNotEmbedded = rawField || prop?.kind !== ReferenceKind.EMBEDDED;
+        const val = payload[key];
         if (isNotEmbedded && prop?.customType instanceof JsonType) {
-            return this.createScalarNode(metadata, childEntity, payload[key], node, key);
+            return this.createScalarNode(metadata, childEntity, val, node, key);
         }
-        if (prop?.kind === ReferenceKind.SCALAR && payload[key] != null && Object.keys(payload[key]).some(f => f in GroupOperator)) {
+        if (prop?.kind === ReferenceKind.SCALAR && val != null && Object.keys(val).some(f => f in GroupOperator)) {
             throw ValidationError.cannotUseGroupOperatorsInsideScalars(entityName, prop.name, payload);
         }
         if (isNotEmbedded) {
-            return this.createNode(metadata, childEntity, payload[key], node, key);
+            return this.createNode(metadata, childEntity, val, node, key);
         }
-        if (payload[key] == null) {
+        if (val == null) {
             const map = Object.keys(prop.embeddedProps).reduce((oo, k) => {
                 oo[prop.embeddedProps[k].name] = null;
                 return oo;
@@ -65,23 +67,23 @@ export class CriteriaNodeFactory {
         }
         // array operators can be used on embedded properties
         const allowedOperators = ['$contains', '$contained', '$overlap'];
-        const operator = Object.keys(payload[key]).some(f => Utils.isOperator(f) && !allowedOperators.includes(f));
+        const operator = Object.keys(val).some(f => Utils.isOperator(f) && !allowedOperators.includes(f));
         if (operator) {
             throw ValidationError.cannotUseOperatorsInsideEmbeddables(entityName, prop.name, payload);
         }
-        const map = Object.keys(payload[key]).reduce((oo, k) => {
+        const map = Object.keys(val).reduce((oo, k) => {
             const embeddedProp = prop.embeddedProps[k] ?? Object.values(prop.embeddedProps).find(p => p.name === k);
             if (!embeddedProp && !allowedOperators.includes(k)) {
                 throw ValidationError.invalidEmbeddableQuery(entityName, k, prop.type);
             }
             if (embeddedProp) {
-                oo[embeddedProp.name] = payload[key][k];
+                oo[embeddedProp.name] = val[k];
             }
-            else if (typeof payload[key][k] === 'object') {
-                oo[k] = JSON.stringify(payload[key][k]);
+            else if (typeof val[k] === 'object') {
+                oo[k] = JSON.stringify(val[k]);
             }
             else {
-                oo[k] = payload[key][k];
+                oo[k] = val[k];
             }
             return oo;
         }, {});

package/query/NativeQueryBuilder.js

@@ -27,8 +27,7 @@ export class NativeQueryBuilder {
     }
     from(tableName, options) {
         if (tableName instanceof NativeQueryBuilder) {
-            const { sql, params } = tableName.compile();
-            tableName = raw(sql, params);
+            tableName = tableName.toRaw();
         }
         if (typeof tableName === 'string') {
             const alias = options?.alias ? ` as ${this.platform.quoteIdentifier(options.alias)}` : '';

package/query/ObjectCriteriaNode.js

@@ -9,7 +9,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
         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, matchPopulateJoins });
         const ownerAlias = options?.alias || qb.alias;
-        const keys = Object.keys(this.payload);
+        const keys = Utils.getObjectQueryKeys(this.payload);
         let alias = options?.alias;
         if (nestedAlias) {
             alias = nestedAlias;
@@ -31,7 +31,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
                     return [QueryType.SELECT, QueryType.COUNT].includes(qb.type) ? `${knownKey ? alias : ownerAlias}.${pk}` : pk;
                 });
                 for (const key of keys) {
-                    if (!['$some', '$none', '$every'].includes(key)) {
+                    if (typeof key !== 'string' || !['$some', '$none', '$every'].includes(key)) {
                         throw new Error('Mixing collection operators with other filters is not allowed.');
                     }
                     const payload = this.payload[key].unwrap();
@@ -78,7 +78,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
             const childNode = this.payload[field];
             const payload = childNode.process(qb, { ...options, alias: this.prop ? alias : ownerAlias });
             const operator = Utils.isOperator(field);
-            const isRawField = RawQueryFragment.isKnownFragment(field);
+            const isRawField = RawQueryFragment.isKnownFragmentSymbol(field);
             // we need to keep the prefixing for formulas otherwise we would lose aliasing context when nesting inside group operators
             const virtual = childNode.prop?.persist === false && !childNode.prop?.formula;
             // if key is missing, we are inside group operator and we need to prefix with alias
@@ -106,12 +106,12 @@ export class ObjectCriteriaNode extends CriteriaNode {
         }, {});
     }
     isStrict() {
-        return this.strict || Object.keys(this.payload).some(key => {
+        return this.strict || Utils.getObjectQueryKeys(this.payload).some(key => {
             return this.payload[key].isStrict();
         });
     }
     unwrap() {
-        return Object.keys(this.payload).reduce((o, field) => {
+        return Utils.getObjectQueryKeys(this.payload).reduce((o, field) => {
             o[field] = this.payload[field].unwrap();
             return o;
         }, {});
@@ -119,7 +119,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
     willAutoJoin(qb, alias, options) {
         const nestedAlias = qb.getAliasForJoinPath(this.getPath(), options);
         const ownerAlias = alias || qb.alias;
-        const keys = Object.keys(this.payload);
+        const keys = Utils.getObjectQueryKeys(this.payload);
         if (nestedAlias) {
             alias = nestedAlias;
         }
@@ -132,9 +132,9 @@ export class ObjectCriteriaNode extends CriteriaNode {
         });
     }
     shouldInline(payload) {
-        const customExpression = RawQueryFragment.isKnownFragment(this.key);
-        const scalar = Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
-        const operator = Utils.isObject(payload) && Object.keys(payload).every(k => Utils.isOperator(k, false));
+        const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
+        const scalar = Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || rawField;
+        const operator = Utils.isObject(payload) && Utils.getObjectQueryKeys(payload).every(k => Utils.isOperator(k, false));
         return !!this.prop && this.prop.kind !== ReferenceKind.SCALAR && !scalar && !operator;
     }
     getChildKey(k, prop, childAlias, alias) {
@@ -145,8 +145,8 @@ export class ObjectCriteriaNode extends CriteriaNode {
     }
     inlineArrayChildPayload(obj, payload, k, prop, childAlias, alias) {
         const key = this.getChildKey(k, prop, childAlias);
-        const value = payload.map((child) => Object.keys(child).reduce((inner, childKey) => {
-            const key = (this.isPrefixed(childKey) || Utils.isOperator(childKey)) ? childKey : this.aliased(childKey, childAlias);
+        const value = payload.map((child) => Utils.getObjectQueryKeys(child).reduce((inner, childKey) => {
+            const key = (RawQueryFragment.isKnownFragmentSymbol(childKey) || this.isPrefixed(childKey) || Utils.isOperator(childKey)) ? childKey : this.aliased(childKey, childAlias);
             inner[key] = child[childKey];
             return inner;
         }, {}));
@@ -154,8 +154,11 @@ export class ObjectCriteriaNode extends CriteriaNode {
     }
     inlineChildPayload(o, payload, field, alias, childAlias) {
         const prop = this.metadata.find(this.entityName).properties[field];
-        for (const k of Object.keys(payload)) {
-            if (Utils.isOperator(k, false)) {
+        for (const k of Utils.getObjectQueryKeys(payload)) {
+            if (RawQueryFragment.isKnownFragmentSymbol(k)) {
+                o[k] = payload[k];
+            }
+            else if (Utils.isOperator(k, false)) {
                 const tmp = payload[k];
                 delete payload[k];
                 o[this.aliased(field, alias)] = { [k]: tmp, ...o[this.aliased(field, alias)] };
@@ -167,9 +170,6 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 const key = this.getChildKey(k, prop, childAlias, alias);
                 this.inlineCondition(key, o, payload[k]);
             }
-            else if (RawQueryFragment.isKnownFragment(k)) {
-                o[k] = payload[k];
-            }
             else {
                 o[this.aliased(k, childAlias)] = payload[k];
             }
@@ -194,8 +194,8 @@ export class ObjectCriteriaNode extends CriteriaNode {
         if (!this.prop || !this.parent) {
             return false;
         }
-        const keys = Object.keys(this.payload);
-        if (keys.every(k => k.includes('.') && k.startsWith(`${qb.alias}.`))) {
+        const keys = Utils.getObjectQueryKeys(this.payload);
+        if (keys.every(k => typeof k === 'string' && k.includes('.') && k.startsWith(`${qb.alias}.`))) {
             return false;
         }
         if (keys.some(k => ['$some', '$none', '$every'].includes(k))) {
@@ -206,21 +206,21 @@ export class ObjectCriteriaNode extends CriteriaNode {
         const knownKey = [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE, ReferenceKind.EMBEDDED].includes(this.prop.kind) || (this.prop.kind === ReferenceKind.ONE_TO_ONE && this.prop.owner);
         const operatorKeys = knownKey && keys.every(key => Utils.isOperator(key, false));
         const primaryKeys = knownKey && keys.every(key => {
-            if (!meta.primaryKeys.includes(key)) {
+            if (typeof key !== 'string' || !meta.primaryKeys.includes(key)) {
                 return false;
             }
             if (!Utils.isPlainObject(this.payload[key].payload) || ![ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(meta.properties[key].kind)) {
                 return true;
             }
-            return Object.keys(this.payload[key].payload).every(k => meta.properties[key].targetMeta.primaryKeys.includes(k));
+            return Utils.getObjectQueryKeys(this.payload[key].payload).every(k => typeof k === 'string' && meta.properties[key].targetMeta.primaryKeys.includes(k));
         });
         return !primaryKeys && !nestedAlias && !operatorKeys && !embeddable;
     }
     autoJoin(qb, alias, options) {
         const nestedAlias = qb.getNextAlias(this.prop?.pivotTable ?? this.entityName);
-        const customExpression = RawQueryFragment.isKnownFragment(this.key);
-        const scalar = Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || customExpression;
-        const operator = Utils.isPlainObject(this.payload) && Object.keys(this.payload).every(k => Utils.isOperator(k, false));
+        const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
+        const scalar = Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || rawField;
+        const operator = Utils.isPlainObject(this.payload) && Utils.getObjectQueryKeys(this.payload).every(k => Utils.isOperator(k, false));
         const field = `${alias}.${this.prop.name}`;
         const method = qb.hasFlag(QueryFlag.INFER_POPULATE) ? 'joinAndSelect' : 'join';
         const path = this.getPath();

package/query/QueryBuilder.d.ts

@@ -98,8 +98,6 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     __populateWhere?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
     /** @internal */
     _populateMap: Dictionary<string>;
-    /** @internal */
-    readonly rawFragments: Set<string>;
     protected aliasCounter: number;
     protected flags: Set<QueryFlag>;
     protected finalized: boolean;
@@ -175,11 +173,11 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     applyJoinedFilters(em: EntityManager, filterOptions: FilterOptions | undefined): Promise<void>;
     withSubQuery(subQuery: RawQueryFragment | NativeQueryBuilder, alias: string): this;
     where(cond: QBFilterQuery<Entity>, operator?: keyof typeof GroupOperator): this;
-    where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;
+    where(cond: string | RawQueryFragment, params?: any[], operator?: keyof typeof GroupOperator): this;
     andWhere(cond: QBFilterQuery<Entity>): this;
-    andWhere(cond: string, params?: any[]): this;
+    andWhere(cond: string | RawQueryFragment, params?: any[]): this;
     orWhere(cond: QBFilterQuery<Entity>): this;
-    orWhere(cond: string, params?: any[]): this;
+    orWhere(cond: string | RawQueryFragment, params?: any[]): this;
     orderBy(orderBy: QBQueryOrderMap<Entity> | QBQueryOrderMap<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     andOrderBy(orderBy: QBQueryOrderMap<Entity> | QBQueryOrderMap<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     private processOrderBy;
@@ -225,10 +223,6 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     from<Entity extends AnyEntity<Entity> = AnyEntity>(target: QueryBuilder<Entity>, aliasName?: string): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     from<Entity extends AnyEntity<Entity> = AnyEntity>(target: EntityName<Entity>): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     getNativeQuery(processVirtualEntity?: boolean): NativeQueryBuilder;
-    /**
-     * @internal
-     */
-    clearRawFragmentsCache(): void;
     /**
      * Returns the query with parameters as wildcards.
      */