@mikro-orm/sql 7.0.0-dev.336 → 7.0.0-dev.338

package/AbstractSqlPlatform.d.ts

@@ -4,6 +4,7 @@ import { type SchemaHelper } from './schema/SchemaHelper.js';
 import type { IndexDef } from './typings.js';
 import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 export declare abstract class AbstractSqlPlatform extends Platform {
+    #private;
     protected readonly schemaHelper?: SchemaHelper;
     usesPivotTable(): boolean;
     indexForeignKeys(): boolean;
@@ -48,6 +49,8 @@ export declare abstract class AbstractSqlPlatform extends Platform {
     quoteCollation(collation: string): string;
     /** @internal */
     protected validateCollationName(collation: string): void;
+    /** @internal */
+    validateJsonPropertyName(name: string): void;
     /**
      * Returns FROM clause for JSON array iteration.
      * @internal

package/AbstractSqlPlatform.js

@@ -3,6 +3,7 @@ import { SqlEntityRepository } from './SqlEntityRepository.js';
 import { SqlSchemaGenerator } from './schema/SqlSchemaGenerator.js';
 import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 export class AbstractSqlPlatform extends Platform {
+    static #JSON_PROPERTY_NAME_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
     schemaHelper;
     usesPivotTable() {
         return true;
@@ -123,6 +124,12 @@ export class AbstractSqlPlatform extends Platform {
             throw new Error(`Invalid collation name: '${collation}'. Collation names must contain only word characters.`);
         }
     }
+    /** @internal */
+    validateJsonPropertyName(name) {
+        if (!AbstractSqlPlatform.#JSON_PROPERTY_NAME_RE.test(name)) {
+            throw new Error(`Invalid JSON property name: '${name}'. JSON property names must contain only alphanumeric characters and underscores.`);
+        }
+    }
     /**
      * Returns FROM clause for JSON array iteration.
      * @internal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.336",
+  "version": "7.0.0-dev.338",
   "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": "^6.6.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.336"
+    "@mikro-orm/core": "7.0.0-dev.338"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/QueryBuilderHelper.d.ts

@@ -59,8 +59,14 @@ export declare class QueryBuilderHelper {
     private processEmbeddedArrayCondition;
     private buildJsonArrayExists;
     private resolveEmbeddedProp;
-    private buildEmbeddedArrayWhere;
     private buildEmbeddedArrayOperatorCondition;
+    private processJsonElemMatch;
+    /**
+     * Shared logic for building WHERE conditions inside JSON array EXISTS subqueries.
+     * Used by both embedded array queries (metadata-driven) and $elemMatch (type-inferred).
+     */
+    private buildArrayElementWhere;
+    private inferJsonValueType;
     processOnConflictCondition(cond: FilterQuery<any>, schema?: string): FilterQuery<any>;
     createFormulaTable(alias: string, meta: EntityMetadata, schema?: string): FormulaTable;
 }

package/query/QueryBuilderHelper.js

@@ -1,4 +1,4 @@
-import { ALIAS_REPLACEMENT, ALIAS_REPLACEMENT_RE, ArrayType, inspect, isRaw, LockMode, OptimisticLockError, QueryOperator, QueryOrderNumeric, raw, Raw, QueryHelper, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
+import { ALIAS_REPLACEMENT, ALIAS_REPLACEMENT_RE, ArrayType, JsonType, inspect, isRaw, LockMode, OptimisticLockError, QueryOperator, QueryOrderNumeric, raw, Raw, QueryHelper, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
 import { EMBEDDABLE_ARRAY_OPS, JoinType, QueryType } from './enums.js';
 /**
  * @internal
@@ -448,6 +448,15 @@ export class QueryBuilderHelper {
                     return this.processEmbeddedArrayCondition(cond[key], prop, a);
                 }
             }
+            // $elemMatch on JSON properties — iterate array elements via EXISTS subquery.
+            // When combined with other operators (e.g. $contains), processObjectSubCondition
+            // splits them first (size > 1), so $elemMatch arrives here alone.
+            if (prop && cond[key].$elemMatch != null && Utils.getObjectKeysSize(cond[key]) === 1) {
+                if (!(prop.customType instanceof JsonType)) {
+                    throw new ValidationError(`$elemMatch can only be used on JSON array properties, but '${this.#entityName}.${prop.name}' has type '${prop.type}'`);
+                }
+                return this.processJsonElemMatch(cond[key].$elemMatch, prop, a);
+            }
         }
         if (Utils.isPlainObject(cond[key]) || cond[key] instanceof RegExp) {
             return this.processObjectSubCondition(cond, key, type);
@@ -841,14 +850,18 @@ export class QueryBuilderHelper {
         return [QueryType.SELECT, QueryType.COUNT].includes(type);
     }
     processEmbeddedArrayCondition(cond, prop, alias) {
-        const fieldName = prop.fieldNames[0];
-        const column = this.#platform.quoteIdentifier(`${alias}.${fieldName}`);
+        const column = this.#platform.quoteIdentifier(`${alias}.${prop.fieldNames[0]}`);
+        const resolveProperty = (key) => {
+            const { embProp, jsonPropName } = this.resolveEmbeddedProp(prop, key);
+            return { name: jsonPropName, type: embProp.runtimeType ?? 'string' };
+        };
+        const invalidObjectError = (key) => ValidationError.invalidEmbeddableQuery(this.#entityName, key, prop.type);
         const parts = [];
         const allParams = [];
         // Top-level $not generates NOT EXISTS (no element matches the inner condition).
         const { $not, ...rest } = cond;
         if (Utils.hasObjectKeys(rest)) {
-            const result = this.buildJsonArrayExists(rest, prop, column, false);
+            const result = this.buildJsonArrayExists(rest, column, false, resolveProperty, invalidObjectError);
             if (result) {
                 parts.push(result.sql);
                 allParams.push(...result.params);
@@ -858,7 +871,7 @@ export class QueryBuilderHelper {
             if (!Utils.isPlainObject($not)) {
                 throw new ValidationError(`Invalid query: $not in embedded array queries expects an object value`);
             }
-            const result = this.buildJsonArrayExists($not, prop, column, true);
+            const result = this.buildJsonArrayExists($not, column, true, resolveProperty, invalidObjectError);
             if (result) {
                 parts.push(result.sql);
                 allParams.push(...result.params);
@@ -869,10 +882,10 @@ export class QueryBuilderHelper {
         }
         return { sql: parts.join(' and '), params: allParams };
     }
-    buildJsonArrayExists(cond, prop, column, negate) {
+    buildJsonArrayExists(cond, column, negate, resolveProperty, invalidObjectError) {
         const jeAlias = `__je${this.#jsonAliasCounter++}`;
         const referencedProps = new Map();
-        const { sql: whereSql, params } = this.buildEmbeddedArrayWhere(cond, prop, jeAlias, referencedProps);
+        const { sql: whereSql, params } = this.buildArrayElementWhere(cond, jeAlias, referencedProps, resolveProperty, invalidObjectError);
         if (!whereSql) {
             return null;
         }
@@ -890,7 +903,55 @@ export class QueryBuilderHelper {
         const jsonPropName = raw.startsWith(prefix) ? raw.slice(prefix.length) : raw;
         return { embProp, jsonPropName };
     }
-    buildEmbeddedArrayWhere(cond, prop, jeAlias, referencedProps) {
+    buildEmbeddedArrayOperatorCondition(lhs, value, params) {
+        const supported = new Set(['$eq', '$ne', '$gt', '$gte', '$lt', '$lte', '$in', '$nin', '$not', '$like', '$exists']);
+        const parts = [];
+        // Clone to avoid getOperatorReplacement mutating the original (it sets value[op] = null for $exists).
+        value = { ...value };
+        for (const op of Object.keys(value)) {
+            if (!supported.has(op)) {
+                throw new ValidationError(`Operator ${op} is not supported in embedded array queries`);
+            }
+            const replacement = this.getOperatorReplacement(op, value);
+            const val = value[op];
+            if (['$in', '$nin'].includes(op)) {
+                if (!Array.isArray(val)) {
+                    throw new ValidationError(`Invalid query: ${op} operator expects an array value`);
+                }
+                else if (val.length === 0) {
+                    parts.push(`1 = ${op === '$in' ? 0 : 1}`);
+                }
+                else {
+                    val.forEach((v) => params.push(v));
+                    parts.push(`${lhs} ${replacement} (${val.map(() => '?').join(', ')})`);
+                }
+            }
+            else if (op === '$exists') {
+                parts.push(`${lhs} ${replacement} null`);
+            }
+            else if (val === null) {
+                parts.push(`${lhs} ${replacement} null`);
+            }
+            else {
+                parts.push(`${lhs} ${replacement} ?`);
+                params.push(val);
+            }
+        }
+        return parts.join(' and ');
+    }
+    processJsonElemMatch(cond, prop, alias) {
+        const column = this.#platform.quoteIdentifier(`${alias}.${prop.fieldNames[0]}`);
+        const result = this.buildJsonArrayExists(cond, column, false, (key, value) => {
+            this.#platform.validateJsonPropertyName(key);
+            return { name: key, type: this.inferJsonValueType(value) };
+        }, () => ValidationError.invalidQueryCondition(cond));
+        return result ?? { sql: '1 = 1', params: [] };
+    }
+    /**
+     * Shared logic for building WHERE conditions inside JSON array EXISTS subqueries.
+     * Used by both embedded array queries (metadata-driven) and $elemMatch (type-inferred).
+     */
+    buildArrayElementWhere(cond, jeAlias, referencedProps, resolveProperty, invalidObjectError) {
         const parts = [];
         const params = [];
         for (const k of Object.keys(cond)) {
@@ -901,7 +962,7 @@ export class QueryBuilderHelper {
                 }
                 const subParts = [];
                 for (const item of items) {
-                    const sub = this.buildEmbeddedArrayWhere(item, prop, jeAlias, referencedProps);
+                    const sub = this.buildArrayElementWhere(item, jeAlias, referencedProps, resolveProperty, invalidObjectError);
                     if (sub.sql) {
                         subParts.push(sub.sql);
                         params.push(...sub.params);
@@ -916,22 +977,21 @@ export class QueryBuilderHelper {
             // Within $or/$and scope, $not provides element-level negation:
             // "this element does not match the condition".
             if (k === '$not') {
-                const sub = this.buildEmbeddedArrayWhere(cond[k], prop, jeAlias, referencedProps);
+                const sub = this.buildArrayElementWhere(cond[k], jeAlias, referencedProps, resolveProperty, invalidObjectError);
                 if (sub.sql) {
                     parts.push(`not (${sub.sql})`);
                     params.push(...sub.params);
                 }
                 continue;
             }
-            const { embProp, jsonPropName } = this.resolveEmbeddedProp(prop, k);
-            referencedProps.set(k, { name: jsonPropName, type: embProp.runtimeType ?? 'string' });
-            const lhs = this.#platform.getJsonArrayElementPropertySQL(jeAlias, jsonPropName, embProp.runtimeType ?? 'string');
             const value = cond[k];
+            const { name, type } = resolveProperty(k, value);
+            referencedProps.set(k, { name, type });
+            const lhs = this.#platform.getJsonArrayElementPropertySQL(jeAlias, name, type);
             if (Utils.isPlainObject(value)) {
-                // Validate that all keys are operators — nested embeddables within array elements are not supported.
                 const valueKeys = Object.keys(value);
                 if (valueKeys.some(vk => !Utils.isOperator(vk))) {
-                    throw ValidationError.invalidEmbeddableQuery(this.#entityName, k, prop.type);
+                    throw invalidObjectError(k);
                 }
                 const sub = this.buildEmbeddedArrayOperatorCondition(lhs, value, params);
                 parts.push(sub);
@@ -946,41 +1006,38 @@ export class QueryBuilderHelper {
         }
         return { sql: parts.join(' and '), params };
     }
-    buildEmbeddedArrayOperatorCondition(lhs, value, params) {
-        const supported = new Set(['$eq', '$ne', '$gt', '$gte', '$lt', '$lte', '$in', '$nin', '$not', '$like', '$exists']);
-        const parts = [];
-        // Clone to avoid getOperatorReplacement mutating the original (it sets value[op] = null for $exists).
-        value = { ...value };
-        for (const op of Object.keys(value)) {
-            if (!supported.has(op)) {
-                throw new ValidationError(`Operator ${op} is not supported in embedded array queries`);
-            }
-            const replacement = this.getOperatorReplacement(op, value);
-            const val = value[op];
-            if (['$in', '$nin'].includes(op)) {
-                if (!Array.isArray(val)) {
-                    throw new ValidationError(`Invalid query: ${op} operator expects an array value`);
+    inferJsonValueType(value) {
+        if (typeof value === 'number') {
+            return 'number';
+        }
+        if (typeof value === 'boolean') {
+            return 'boolean';
+        }
+        if (typeof value === 'bigint') {
+            return 'bigint';
+        }
+        if (Utils.isPlainObject(value)) {
+            for (const v of Object.values(value)) {
+                if (typeof v === 'number') {
+                    return 'number';
                 }
-                else if (val.length === 0) {
-                    parts.push(`1 = ${op === '$in' ? 0 : 1}`);
+                if (typeof v === 'boolean') {
+                    return 'boolean';
                 }
-                else {
-                    val.forEach((v) => params.push(v));
-                    parts.push(`${lhs} ${replacement} (${val.map(() => '?').join(', ')})`);
+                if (typeof v === 'bigint') {
+                    return 'bigint';
+                }
+                if (Array.isArray(v) && v.length > 0) {
+                    if (typeof v[0] === 'number') {
+                        return 'number';
+                    }
+                    if (typeof v[0] === 'boolean') {
+                        return 'boolean';
+                    }
                 }
-            }
-            else if (op === '$exists') {
-                parts.push(`${lhs} ${replacement} null`);
-            }
-            else if (val === null) {
-                parts.push(`${lhs} ${replacement} null`);
-            }
-            else {
-                parts.push(`${lhs} ${replacement} ?`);
-                params.push(val);
             }
         }
-        return parts.join(' and ');
+        return 'string';
     }
     processOnConflictCondition(cond, schema) {
         const meta = this.#metadata.get(this.#entityName);