@mikro-orm/sql 7.0.0-dev.99 → 7.0.0-rc.0

package/query/CriteriaNodeFactory.js

@@ -6,26 +6,26 @@ import { ScalarCriteriaNode } from './ScalarCriteriaNode.js';
  * @internal
  */
 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;
+    static createNode(metadata, entityName, payload, parent, key, validate = true) {
+        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);
+            return this.createArrayNode(metadata, entityName, payload, parent, key, validate);
         }
         if (Utils.isPlainObject(payload) && !scalar) {
-            return this.createObjectNode(metadata, entityName, payload, parent, key);
+            return this.createObjectNode(metadata, entityName, payload, parent, key, validate);
         }
-        return this.createScalarNode(metadata, entityName, payload, parent, key);
+        return this.createScalarNode(metadata, entityName, payload, parent, key, validate);
     }
-    static createScalarNode(metadata, entityName, payload, parent, key) {
-        const node = new ScalarCriteriaNode(metadata, entityName, parent, key);
+    static createScalarNode(metadata, entityName, payload, parent, key, validate = true) {
+        const node = new ScalarCriteriaNode(metadata, entityName, parent, key, validate);
         node.payload = payload;
         return node;
     }
-    static createArrayNode(metadata, entityName, payload, parent, key) {
-        const node = new ArrayCriteriaNode(metadata, entityName, parent, key);
+    static createArrayNode(metadata, entityName, payload, parent, key, validate = true) {
+        const node = new ArrayCriteriaNode(metadata, entityName, parent, key, validate);
         node.payload = payload.map((item, index) => {
-            const n = this.createNode(metadata, entityName, item, node);
+            const n = this.createNode(metadata, entityName, item, node, undefined, validate);
             // we care about branching only for $and
             if (key === '$and' && payload.length > 1) {
                 n.index = index;
@@ -34,57 +34,59 @@ export class CriteriaNodeFactory {
         });
         return node;
     }
-    static createObjectNode(metadata, entityName, payload, parent, key) {
+    static createObjectNode(metadata, entityName, payload, parent, key, validate = true) {
         const meta = metadata.find(entityName);
-        const node = new ObjectCriteriaNode(metadata, entityName, parent, key, true, payload.__strict);
+        const node = new ObjectCriteriaNode(metadata, entityName, parent, key, validate, 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, validate);
         }
         return node;
     }
-    static createObjectItemNode(metadata, entityName, node, payload, key, meta) {
-        const prop = meta?.properties[key];
-        const childEntity = prop && prop.kind !== ReferenceKind.SCALAR ? prop.type : entityName;
-        const isNotEmbedded = prop?.kind !== ReferenceKind.EMBEDDED;
+    static createObjectItemNode(metadata, entityName, node, payload, key, meta, validate = true) {
+        const rawField = RawQueryFragment.isKnownFragmentSymbol(key);
+        const prop = rawField ? null : meta?.properties[key];
+        const childEntity = prop && prop.kind !== ReferenceKind.SCALAR ? prop.targetMeta.class : entityName;
+        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, validate);
         }
-        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, validate);
         }
-        if (payload[key] == null) {
+        if (val == null) {
             const map = Object.keys(prop.embeddedProps).reduce((oo, k) => {
                 oo[prop.embeddedProps[k].name] = null;
                 return oo;
             }, {});
-            return this.createNode(metadata, entityName, map, node, key);
+            return this.createNode(metadata, entityName, map, node, key, validate);
         }
         // 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;
         }, {});
-        return this.createNode(metadata, entityName, map, node, key);
+        return this.createNode(metadata, entityName, map, node, key, validate);
     }
 }

package/query/NativeQueryBuilder.d.ts

@@ -1,4 +1,4 @@
-import { type Dictionary, LockMode, type QueryFlag, RawQueryFragment } from '@mikro-orm/core';
+import { type Dictionary, LockMode, type QueryFlag, RawQueryFragment, type Subquery } from '@mikro-orm/core';
 import { QueryType } from './enums.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 interface Options {
@@ -48,8 +48,9 @@ interface OnConflictClause {
     };
 }
 /** @internal */
-export declare class NativeQueryBuilder {
+export declare class NativeQueryBuilder implements Subquery {
     protected readonly platform: AbstractSqlPlatform;
+    readonly __subquery: true;
     protected type?: QueryType;
     protected parts: string[];
     protected params: unknown[];

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

@@ -1,21 +1,22 @@
 import { ALIAS_REPLACEMENT, GroupOperator, QueryFlag, 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'];
 /**
  * @internal
  */
 export class ObjectCriteriaNode extends CriteriaNode {
     process(qb, 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, matchPopulateJoins });
+        const nestedAlias = qb.getAliasForJoinPath(this.getPath(options), { ...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;
         }
         if (this.shouldAutoJoin(qb, nestedAlias)) {
-            if (keys.some(k => ['$some', '$none', '$every'].includes(k))) {
+            if (keys.some(k => COLLECTION_OPERATORS.includes(k))) {
                 if (![ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(this.prop.kind)) {
                     // ignore collection operators when used on a non-relational property - this can happen when they get into
                     // populateWhere via `infer` on m:n properties with select-in strategy
@@ -31,22 +32,31 @@ 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' || !COLLECTION_OPERATORS.includes(key)) {
                         throw new Error('Mixing collection operators with other filters is not allowed.');
                     }
                     const payload = this.payload[key].unwrap();
-                    const qb2 = qb.clone(true);
+                    const qb2 = qb.clone(true, ['_schema']);
+                    const joinAlias = qb2.getNextAlias(this.prop.targetMeta.class);
                     const sub = qb2
-                        .from(parentMeta.className)
-                        .innerJoin(this.key, qb2.getNextAlias(this.prop.type))
+                        .from(parentMeta.class)
+                    // eslint-disable-next-line no-unexpected-multiline
+                    [key === '$size' ? 'leftJoin' : 'innerJoin'](this.key, joinAlias)
                         .select(parentMeta.primaryKeys);
-                    if (key === '$every') {
+                    if (key === '$size') {
+                        const sizeCondition = typeof payload === 'number' ? { $eq: payload } : payload;
+                        const pks = this.prop.referencedColumnNames;
+                        const countExpr = raw(`count(${pks.map(() => '??').join(', ')})`, pks.map(pk => `${joinAlias}.${pk}`));
+                        sub.groupBy(parentMeta.primaryKeys);
+                        sub.having({ $and: Object.keys(sizeCondition).map(op => ({ [countExpr]: { [op]: sizeCondition[op] } })) });
+                    }
+                    else if (key === '$every') {
                         sub.where({ $not: { [this.key]: payload } });
                     }
                     else {
                         sub.where({ [this.key]: payload });
                     }
-                    const op = key === '$some' ? '$in' : '$nin';
+                    const op = ['$size', '$some'].includes(key) ? '$in' : '$nin';
                     $and.push({
                         [Utils.getPrimaryKeyHash(primaryKeys)]: { [op]: sub.getNativeQuery().toRaw() },
                     });
@@ -78,7 +88,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
@@ -96,35 +106,40 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 const rawField = RawQueryFragment.getKnownFragment(field);
                 o[raw(rawField.sql.replaceAll(ALIAS_REPLACEMENT, alias), rawField.params)] = payload;
             }
+            else if (!childNode.validate && !childNode.prop && !field.includes('.') && !operator) {
+                // wrap unknown fields in raw() to prevent alias prefixing (e.g. raw SQL aliases in HAVING)
+                // use '??' placeholder to properly quote the identifier
+                o[raw('??', [field])] = payload;
+            }
             else if (primaryKey || virtual || operator || field.includes('.') || ![QueryType.SELECT, QueryType.COUNT].includes(qb.type)) {
                 this.inlineCondition(field.replaceAll(ALIAS_REPLACEMENT, alias), o, payload);
             }
             else {
-                this.inlineCondition(`${alias}.${field}`, o, payload);
+                this.inlineCondition(`${alias ?? qb.alias}.${field}`, o, payload);
             }
             return o;
         }, {});
     }
     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;
         }, {});
     }
     willAutoJoin(qb, alias, options) {
-        const nestedAlias = qb.getAliasForJoinPath(this.getPath(), options);
+        const nestedAlias = qb.getAliasForJoinPath(this.getPath(options), options);
         const ownerAlias = alias || qb.alias;
-        const keys = Object.keys(this.payload);
+        const keys = Utils.getObjectQueryKeys(this.payload);
         if (nestedAlias) {
             alias = nestedAlias;
         }
         if (this.shouldAutoJoin(qb, nestedAlias)) {
-            return !keys.some(k => ['$some', '$none', '$every'].includes(k));
+            return !keys.some(k => COLLECTION_OPERATORS.includes(k));
         }
         return keys.some(field => {
             const childNode = this.payload[field];
@@ -132,9 +147,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 +160,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 +169,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 +185,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,11 +209,11 @@ 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))) {
+        if (keys.some(k => COLLECTION_OPERATORS.includes(k))) {
             return true;
         }
         const meta = this.metadata.find(this.entityName);
@@ -206,21 +221,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 nestedAlias = qb.getNextAlias(this.prop?.pivotEntity ?? this.entityName);
+        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();