@mikro-orm/sql 7.1.13-dev.9 → 7.1.14-dev.0

package/SqlEntityManager.js

@@ -81,7 +81,9 @@ export class SqlEntityManager extends EntityManager {
         const { where: rawWhere, ...countOptions } = options;
         await em.tryFlush(entityName, options);
         const where = await em.processWhere(entityName, rawWhere ?? {}, options, 'read');
-        const qb = em.createQueryBuilder(meta.class);
+        // match `em.count()` semantics: an active transaction always wins over the requested connection type
+        const connectionType = em.getTransactionContext() ? 'write' : options.connectionType;
+        const qb = em.createQueryBuilder(meta.class, undefined, connectionType);
         qb
             .select([...fields, raw('count(*) as cnt')])
             .where(where)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.13-dev.9",
+  "version": "7.1.14-dev.0",
   "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",
@@ -50,10 +50,10 @@
     "kysely": "0.29.5"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.1.12"
+    "@mikro-orm/core": "^7.1.13"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.13-dev.9"
+    "@mikro-orm/core": "7.1.14-dev.0"
   },
   "engines": {
     "node": ">= 22.17.0"

package/plugin/transformer.d.ts

@@ -1,5 +1,5 @@
 import { type EntityMetadata, type EntityProperty, type Type } from '@mikro-orm/core';
-import { type CommonTableExpressionNameNode, type DeleteQueryNode, type InsertQueryNode, type JoinNode, type MergeQueryNode, type OperationNode, type QueryId, type SelectQueryNode, type UpdateQueryNode, type WithNode, ColumnNode, IdentifierNode, OperationNodeTransformer, SelectionNode, TableNode, ValueNode } from 'kysely';
+import { type BinaryOperationNode, type CommonTableExpressionNameNode, type DeleteQueryNode, type InsertQueryNode, type JoinNode, type MergeQueryNode, type OperationNode, type QueryId, type SelectQueryNode, type UpdateQueryNode, type WithNode, ColumnNode, IdentifierNode, OperationNodeTransformer, SelectionNode, TableNode, ValueNode } from 'kysely';
 import type { MikroKyselyPluginOptions } from './index.js';
 import type { SqlEntityManager } from '../SqlEntityManager.js';
 export declare class MikroTransformer extends OperationNodeTransformer {
@@ -28,6 +28,12 @@ export declare class MikroTransformer extends OperationNodeTransformer {
     processOnUpdateHooks(node: UpdateQueryNode, meta: EntityMetadata): UpdateQueryNode;
     processInsertValues(node: InsertQueryNode, meta: EntityMetadata): InsertQueryNode;
     processUpdateValues(node: UpdateQueryNode, meta: EntityMetadata): UpdateQueryNode;
+    transformBinaryOperation(node: BinaryOperationNode, queryId: QueryId): BinaryOperationNode;
+    /** Resolve the entity property a comparison's left operand refers to, so its value operand can be converted. */
+    resolveOperandProperty(operand: OperationNode): {
+        prop: EntityProperty;
+        fieldName: string;
+    } | undefined;
     processInputValueNode(prop: EntityProperty | undefined, fieldName: string | undefined, valueNode: ValueNode): OperationNode;
     expandSelections(selections: readonly SelectionNode[]): readonly SelectionNode[];
     expandSelection(sel: SelectionNode): SelectionNode[] | null;

package/plugin/transformer.js

@@ -455,6 +455,60 @@ export class MikroTransformer extends OperationNodeTransformer {
             updates,
         };
     }
+    transformBinaryOperation(node, queryId) {
+        const transformed = super.transformBinaryOperation(node, queryId);
+        if (!this.#options.convertValues) {
+            return transformed;
+        }
+        const resolved = this.resolveOperandProperty(transformed.leftOperand);
+        if (!resolved) {
+            return transformed;
+        }
+        const { prop, fieldName } = resolved;
+        const right = transformed.rightOperand;
+        if (ValueNode.is(right)) {
+            const converted = this.processInputValueNode(prop, fieldName, right);
+            return converted === right ? transformed : { ...transformed, rightOperand: converted };
+        }
+        if (PrimitiveValueListNode.is(right)) {
+            // upgrade to ValueListNode when the type needs SQL-side wrapping, since
+            // PrimitiveValueListNode can only hold primitives
+            if (prop.hasConvertToDatabaseValueSQL) {
+                const values = right.values.map(value => this.processInputValueNode(prop, fieldName, ValueNode.create(value)));
+                return { ...transformed, rightOperand: ValueListNode.create(values) };
+            }
+            const values = right.values.map(value => this.prepareInputValue(prop, value, true));
+            return values.every((value, idx) => value === right.values[idx])
+                ? transformed
+                : { ...transformed, rightOperand: PrimitiveValueListNode.create(values) };
+        }
+        if (ValueListNode.is(right)) {
+            let changed = false;
+            const values = right.values.map(valueNode => {
+                if (!ValueNode.is(valueNode)) {
+                    return valueNode;
+                }
+                const converted = this.processInputValueNode(prop, fieldName, valueNode);
+                if (converted !== valueNode) {
+                    changed = true;
+                }
+                return converted;
+            });
+            return changed ? { ...transformed, rightOperand: ValueListNode.create(values) } : transformed;
+        }
+        return transformed;
+    }
+    /** Resolve the entity property a comparison's left operand refers to, so its value operand can be converted. */
+    resolveOperandProperty(operand) {
+        if (!ReferenceNode.is(operand) || !ColumnNode.is(operand.column)) {
+            return undefined;
+        }
+        const tableName = operand.table ? this.getTableName(operand.table) : undefined;
+        const meta = this.findOwnerMeta(tableName);
+        const fieldName = this.normalizeColumnName(operand.column.column);
+        const prop = this.findProperty(meta, fieldName);
+        return prop ? { prop, fieldName } : undefined;
+    }
     processInputValueNode(prop, fieldName, valueNode) {
         const converted = this.prepareInputValue(prop, valueNode.value, true);
         const newValueNode = converted === valueNode.value
@@ -543,8 +597,13 @@ export class MikroTransformer extends OperationNodeTransformer {
         if (name) {
             return this.lookupInContextStack(name) ?? this.#subqueryAliasMap.get(name) ?? this.findEntityMetadata(name);
         }
+        // the stack can be empty when transforming a raw root node with embedded expressions
+        const context = this.#contextStack[this.#contextStack.length - 1];
+        if (!context) {
+            return undefined;
+        }
         let single;
-        for (const meta of this.#contextStack[this.#contextStack.length - 1].values()) {
+        for (const meta of context.values()) {
             if (!meta) {
                 continue;
             }

package/query/QueryBuilder.d.ts

@@ -1001,6 +1001,13 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * would flatten them into `and` conjuncts.
      */
     private canDistributeOrBranches;
+    private getOrBranchAliases;
+    /**
+     * An entity filter's `$or` that cannot be distributed is applied intact to the `on` clause of the
+     * outermost join common to all targeted joins, nesting the targeted joins under it so the clause
+     * can reference their aliases.
+     */
+    private mergeFilterOrCondition;
     /**
      * When adding an inner join on a left joined relation, we need to nest them,
      * otherwise the inner join could discard rows of the root table.

package/query/QueryBuilder.js

@@ -2038,8 +2038,11 @@ export class QueryBuilder {
         for (const k of Object.keys(cond)) {
             if (Utils.isOperator(k)) {
                 if (Array.isArray(cond[k])) {
-                    // a partial `$or` on a join drops rows matching a sibling branch, but entity filters have no other sink, so they must pass
-                    if (k === '$or' && !filter && !this.canDistributeOrBranches(cond[k], joins)) {
+                    if (k === '$or' && !this.canDistributeOrBranches(cond[k], joins)) {
+                        // entity filters have no other sink, so their `$or` is kept intact on the outermost targeted join instead
+                        if (filter) {
+                            this.mergeFilterOrCondition(cond[k], joins);
+                        }
                         continue;
                     }
                     cond[k].forEach((c) => this.mergeOnConditions(joins, c, filter, k));
@@ -2082,6 +2085,12 @@ export class QueryBuilder {
      * would flatten them into `and` conjuncts.
      */
     canDistributeOrBranches(branches, joins) {
+        const aliases = this.getOrBranchAliases(branches);
+        const targeted = joins.filter(j => aliases.has(j.alias));
+        const flat = branches.every(branch => Object.keys(branch).every(k => !Utils.isOperator(k)));
+        return aliases.size === 1 && targeted.length === 1 && flat;
+    }
+    getOrBranchAliases(branches) {
         const aliases = new Set();
         const collectAliases = (cond) => {
             for (const k of Object.keys(cond)) {
@@ -2094,9 +2103,37 @@ export class QueryBuilder {
             }
         };
         branches.forEach(collectAliases);
-        const targeted = joins.filter(j => aliases.has(j.alias));
-        const flat = branches.every(branch => Object.keys(branch).every(k => !Utils.isOperator(k)));
-        return aliases.size === 1 && targeted.length === 1 && flat;
+        return aliases;
+    }
+    /**
+     * An entity filter's `$or` that cannot be distributed is applied intact to the `on` clause of the
+     * outermost join common to all targeted joins, nesting the targeted joins under it so the clause
+     * can reference their aliases.
+     */
+    mergeFilterOrCondition(branches, joins) {
+        const aliases = this.getOrBranchAliases(branches);
+        const chainOf = (join) => {
+            const parent = joins.find(j => j.alias === join.ownerAlias);
+            return parent ? [join, ...chainOf(parent)] : [join];
+        };
+        // chains go from each targeted join up to its root, so the first join present in all of them is the outermost common one
+        const chains = joins.filter(j => aliases.has(j.alias)).map(chainOf);
+        const anchor = chains[0]?.find(a => chains.every(chain => chain.includes(a)));
+        /* v8 ignore next 3 */
+        if (!anchor) {
+            return;
+        }
+        for (const chain of chains) {
+            // nest the chain below the anchor, so the anchor's `on` clause can reference the nested aliases
+            for (let i = 0; chain[i] !== anchor; i++) {
+                const nested = (chain[i + 1].nested ??= new Set());
+                if (!nested.has(chain[i])) {
+                    chain[i].type = chain[i].type === JoinType.innerJoin ? JoinType.nestedInnerJoin : JoinType.nestedLeftJoin;
+                    nested.add(chain[i]);
+                }
+            }
+        }
+        anchor.cond = anchor.cond.$or ? { $and: [anchor.cond, { $or: branches }] } : { ...anchor.cond, $or: branches };
     }
     /**
      * When adding an inner join on a left joined relation, we need to nest them,