@mikro-orm/sql 7.1.10-dev.1 → 7.1.10-dev.11

package/AbstractSqlDriver.js

@@ -1675,14 +1675,15 @@ export class AbstractSqlDriver extends DatabaseDriver {
         // (including virtual ones, as the owner FK of a polymorphic pivot is only mapped via non-persisted relations)
         const pivotRelations = meta.pivotTable && !meta.compositePK ? meta.relations.filter(p => p.kind === ReferenceKind.MANY_TO_ONE) : [];
         for (const item of rawResults) {
-            let pk = Utils.getCompositeKeyHash(item, meta);
+            // flat hash, so nested composite PK values keep their own separators and cannot collide
+            let pk = Utils.getCompositeKeyHash(item, meta, false, undefined, true);
             if (pivotRelations.length > 0) {
                 pk = Utils.getPrimaryKeyHash([
                     pk,
                     ...pivotRelations.flatMap(p => {
                         const value = item[p.name];
                         // composite FKs are mapped to an array of values, which `extractPK` does not accept
-                        return (Array.isArray(value) ? value : Utils.extractPK(value, p.targetMeta));
+                        return (Array.isArray(value) ? Utils.flatten(value, true) : Utils.extractPK(value, p.targetMeta));
                     }),
                 ]);
             }

package/package.json

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

package/query/QueryBuilder.d.ts

@@ -506,6 +506,17 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * @internal
      */
     applyJoinedFilters(em: EntityManager, filterOptions: FilterOptions | undefined): Promise<void>;
+    /**
+     * The `on` clause of `condJoin` — its explicit join condition or a filter condition merged into
+     * it — can reference the alias of any join in its subtree, both auto-joins created while
+     * processing the condition and pre-existing joined paths, all of which render after `condJoin`
+     * and would be forward alias references (issues #7681, #8090, #8099). When that happens, fold the
+     * subtree into `condJoin`, so it renders as a single parenthesized join group and every alias
+     * shares the scope of the outer `on` clause.
+     */
+    private nestReferencedJoins;
+    private getJoinSubtree;
+    private condReferencesAlias;
     withSubQuery(subQuery: RawQueryFragment | NativeQueryBuilder, alias: string): this;
     /**
      * Adds a WHERE clause to the query using an object condition.

package/query/QueryBuilder.js

@@ -433,6 +433,7 @@ export class QueryBuilder {
                 else {
                     join.cond = { ...cond };
                 }
+                this.nestReferencedJoins(join);
                 // For polymorphic LEFT JOIN filters, add a WHERE condition to enforce the filter
                 // only for rows matching this target's discriminator value. This ensures rows pointing
                 // to other polymorphic targets are not excluded.
@@ -456,6 +457,45 @@ export class QueryBuilder {
             }
         }
     }
+    /**
+     * The `on` clause of `condJoin` — its explicit join condition or a filter condition merged into
+     * it — can reference the alias of any join in its subtree, both auto-joins created while
+     * processing the condition and pre-existing joined paths, all of which render after `condJoin`
+     * and would be forward alias references (issues #7681, #8090, #8099). When that happens, fold the
+     * subtree into `condJoin`, so it renders as a single parenthesized join group and every alias
+     * shares the scope of the outer `on` clause.
+     */
+    nestReferencedJoins(condJoin) {
+        // m:n pivot joins might not have the target join entry created
+        if (!condJoin) {
+            return;
+        }
+        const subtree = this.getJoinSubtree(condJoin);
+        if (!subtree.some(j => this.condReferencesAlias(condJoin.cond, j.alias))) {
+            return;
+        }
+        for (const j of subtree) {
+            const parent = j.ownerAlias === condJoin.alias ? condJoin : subtree.find(p => p.alias === j.ownerAlias);
+            if (!parent.nested?.has(j)) {
+                const nested = (parent.nested ??= new Set());
+                j.type = j.type === JoinType.innerJoin ? JoinType.nestedInnerJoin : JoinType.nestedLeftJoin;
+                nested.add(j);
+            }
+        }
+    }
+    getJoinSubtree(join) {
+        const children = Object.values(this.#state.joins).filter(j => j !== join && j.ownerAlias === join.alias);
+        return children.flatMap(j => [j, ...this.getJoinSubtree(j)]);
+    }
+    condReferencesAlias(cond, alias) {
+        if (Array.isArray(cond)) {
+            return cond.some(c => this.condReferencesAlias(c, alias));
+        }
+        if (Utils.isPlainObject(cond)) {
+            return Object.entries(cond).some(([key, value]) => key.startsWith(`${alias}.`) || this.condReferencesAlias(value, alias));
+        }
+        return false;
+    }
     withSubQuery(subQuery, alias) {
         this.ensureNotFinalized();
         if (isRaw(subQuery)) {
@@ -1104,7 +1144,9 @@ export class QueryBuilder {
         }
         if (stack.length > 0) {
             const merged = this.driver.mergeJoinedResult(stack, this.mainAlias.meta, joinedProps);
-            yield this.mapResult(merged[0], options.mapResults);
+            for (const row of merged) {
+                yield this.mapResult(row, options.mapResults);
+            }
         }
     }
     /**
@@ -1412,7 +1454,6 @@ export class QueryBuilder {
             aliased: [QueryType.SELECT, QueryType.COUNT].includes(this.type),
         });
         const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, prop.targetMeta.class, cond);
-        const joinCountBefore = Object.keys(this.#state.joins).length;
         cond = criteriaNode.process(this, { ignoreBranching: true, alias });
         let aliasedName = `${fromAlias}.${prop.name}#${alias}`;
         path ??= `${Object.values(this.#state.joins).find(j => j.alias === fromAlias)?.path ?? Utils.className(entityName)}.${prop.name}`;
@@ -1442,20 +1483,7 @@ export class QueryBuilder {
             this.#state.joins[aliasedName] = this.helper.joinManyToOneReference(prop, ownerAlias, alias, type, cond, schema);
             this.#state.joins[aliasedName].path ??= path;
         }
-        // auto-joins added by cond processing that depend on the new alias would otherwise produce a
-        // forward reference (the auto-join's ON refers to alias, while alias's ON refers back to it);
-        // fold them into the new join so both aliases share scope in the outer ON clause (issue #7681)
-        const condJoin = this.#state.joins[aliasedName];
-        const joinKeys = Object.keys(this.#state.joins);
-        for (let i = joinCountBefore; i < joinKeys.length; i++) {
-            const j = this.#state.joins[joinKeys[i]];
-            if (j === condJoin || j.ownerAlias !== alias) {
-                continue;
-            }
-            const nested = (condJoin.nested ??= new Set());
-            j.type = j.type === JoinType.innerJoin ? JoinType.nestedInnerJoin : JoinType.nestedLeftJoin;
-            nested.add(j);
-        }
+        this.nestReferencedJoins(this.#state.joins[aliasedName]);
         return { prop, key: aliasedName };
     }
     prepareFields(fields, type = 'where', schema) {

package/schema/SchemaHelper.d.ts

@@ -124,6 +124,8 @@ export declare abstract class SchemaHelper {
     getAddColumnsSQL(table: DatabaseTable, columns: Column[]): string[];
     getDropColumnsSQL(tableName: string, columns: Column[], schemaName?: string): string;
     hasNonDefaultPrimaryKeyName(table: DatabaseTable): boolean;
+    /** Returns the `constraint <name> ` prefix for a primary key definition, empty when the server assigns the default name on its own. */
+    protected getPrimaryKeyConstraintPrefix(table: DatabaseTable, index: IndexDef): string;
     castColumn(name: string, type: string): string;
     alterTableColumn(column: Column, table: DatabaseTable, changedProperties: Set<string>): string[];
     /** Returns the bare `collate <name>` clause for column DDL. Overridden by PostgreSQL to quote the identifier. */

package/schema/SchemaHelper.js

@@ -521,6 +521,10 @@ export class SchemaHelper {
         const defaultName = this.platform.getDefaultPrimaryName(table.name, pkIndex.columnNames);
         return pkIndex?.keyName !== defaultName;
     }
+    /** Returns the `constraint <name> ` prefix for a primary key definition, empty when the server assigns the default name on its own. */
+    getPrimaryKeyConstraintPrefix(table, index) {
+        return this.hasNonDefaultPrimaryKeyName(table) ? `constraint ${this.quote(index.keyName)} ` : '';
+    }
     /* v8 ignore next */
     castColumn(name, type) {
         return '';
@@ -766,7 +770,7 @@ export class SchemaHelper {
         const primaryKey = table.getPrimaryKey();
         const createPrimary = !table.getColumns().some(c => c.autoincrement && c.primary) || this.hasNonDefaultPrimaryKeyName(table);
         if (createPrimary && primaryKey) {
-            const name = this.hasNonDefaultPrimaryKeyName(table) ? `constraint ${this.quote(primaryKey.keyName)} ` : '';
+            const name = this.getPrimaryKeyConstraintPrefix(table, primaryKey);
             sql += `, ${name}primary key (${primaryKey.columnNames.map(c => this.quote(c)).join(', ')})`;
         }
         sql += ')';
@@ -849,7 +853,7 @@ export class SchemaHelper {
         const columns = index.columnNames.map(c => this.quote(c)).join(', ');
         const defer = index.deferMode ? ` deferrable initially ${index.deferMode}` : '';
         if (index.primary) {
-            const keyName = this.hasNonDefaultPrimaryKeyName(table) ? `constraint ${index.keyName} ` : '';
+            const keyName = this.getPrimaryKeyConstraintPrefix(table, index);
             return `alter table ${table.getQuotedName()} add ${keyName}primary key (${columns})${defer}`;
         }
         if (index.type === 'fulltext') {