linkgress-orm 0.4.58 → 0.4.60

package/dist/query/query-builder.js

@@ -6006,12 +6006,22 @@ class CollectionQueryBuilder {
         const sourceTable = this.sourceTable;
         // Build JOINs needed inside the EXISTS subquery
         const allJoins = [];
+        // Inside a lateral, the collection's λ-root table is visible only under the
+        // lateral's generated alias (e.g. `FROM "cart_discount_code" "lateral_3_cartDiscountCodes"`).
+        // The first bridge hop / root correlation must anchor on that alias, not the raw
+        // table name — mirrors lateral-collection-strategy's own correlation handling.
+        // Only the λ-root is translated: bridge-internal aliases are emitted by this very
+        // subquery and must never be remapped, even if they collide with a lateral's
+        // target table name.
+        const aliasMap = context.lateralTableAliasMap;
+        const rootAnchor = (alias) => aliasMap?.get(alias) || alias;
         // Navigation path joins (for reference navigation like pc.order → orders)
-        for (const nav of this.navigationPath) {
+        for (const [index, nav] of this.navigationPath.entries()) {
             const joinType = nav.isMandatory ? 'JOIN' : 'LEFT JOIN';
             const fk = nav.foreignKeys[0];
             const pk = (nav.matches && nav.matches.length > 0) ? nav.matches[0] : 'id';
-            allJoins.push(`${joinType} "${nav.targetTable}" "${nav.alias}" ON "${nav.sourceAlias}"."${fk}" = "${nav.alias}"."${pk}"`);
+            const src = index === 0 ? rootAnchor(nav.sourceAlias) : nav.sourceAlias;
+            allJoins.push(`${joinType} "${nav.targetTable}" "${nav.alias}" ON "${src}"."${fk}" = "${nav.alias}"."${pk}"`);
         }
         // SelectMany joins (for selectMany navigation through intermediate tables)
         for (const nav of this.selectManyJoins) {
@@ -6020,18 +6030,62 @@ class CollectionQueryBuilder {
             const pk = (nav.matches && nav.matches.length > 0) ? nav.matches[0] : 'id';
             allJoins.push(`${joinType} "${nav.targetTable}" "${nav.alias}" ON "${nav.sourceAlias}"."${fk}" = "${nav.alias}"."${pk}"`);
         }
+        // Joins required by REFERENCE navigations inside the collection's own
+        // where-condition, e.g. `exists(links.where(l => eq(l.campaign.isPublic, true)))`.
+        // Navigation joins were historically derived from selectors only; an EXISTS
+        // aggregation has no selector, so a where-navigated alias rendered unjoined and
+        // the statement failed with `missing FROM-clause entry for table "<alias>"`.
+        // Reuses the selector path's machinery: seed aliases + chains from the
+        // condition's FieldRefs, then resolve multi-hop paths against the target schema.
+        if (this.whereCond) {
+            const joinedAliases = new Set([
+                ...this.navigationPath.map(nav => nav.alias),
+                ...this.selectManyJoins.map(nav => nav.alias),
+            ]);
+            const targetSchema = this.schemaRegistry?.get(targetTable);
+            if (targetSchema) {
+                const whereJoins = [];
+                const whereAliases = new Set();
+                for (const ref of this.whereCond.getFieldRefs()) {
+                    const refAlias = ref?.__tableAlias;
+                    // Direct columns of the target arrive under the `__collection_<table>__`
+                    // marker (rewritten below) or the bare table name — neither needs a join.
+                    if (!refAlias || refAlias === targetTable || refAlias.startsWith('__collection_') || joinedAliases.has(refAlias)) {
+                        continue;
+                    }
+                    this.addNavigationJoinForFieldRef(ref, whereJoins, targetTable, targetSchema, whereAliases);
+                }
+                if (whereAliases.size > 0) {
+                    this.resolveNavigationJoins(whereAliases, whereJoins, targetSchema);
+                }
+                for (const nav of whereJoins) {
+                    if (joinedAliases.has(nav.alias)) {
+                        continue;
+                    }
+                    joinedAliases.add(nav.alias);
+                    const joinType = nav.isMandatory ? 'JOIN' : 'LEFT JOIN';
+                    const fk = nav.foreignKeys[0];
+                    const pk = (nav.matches && nav.matches.length > 0) ? nav.matches[0] : 'id';
+                    allJoins.push(`${joinType} "${nav.targetTable}" "${nav.alias}" ON "${nav.sourceAlias}"."${fk}" = "${nav.alias}"."${pk}"`);
+                }
+            }
+        }
         const navJoinsSQL = allJoins.join('\n');
         // Build WHERE clause: correlation + additional conditions
         // Use full composite-FK / literal-predicate form when navigation declared
         // multiple key pairs (e.g. SCD2 `[productId, isCurrent] / [id, true]`).
         const fkTableAlias = this.foreignKeyTableAlias || targetTable;
+        // Root-attached collections correlate on the λ-root itself, which a lateral
+        // exposes only under its generated alias; nav-derived collections correlate on
+        // the bridge's terminal alias, which this subquery emits itself — never remap it.
+        const correlationSource = this.navigationPath.length === 0 ? rootAnchor(sourceTable) : sourceTable;
         let whereSQL;
         if (this.foreignKeys && this.foreignKeys.length > 0) {
             const matches = this.matches && this.matches.length > 0 ? this.matches : ['id'];
-            whereSQL = (0, join_utils_1.buildCollectionCorrelationWhere)(fkTableAlias, sourceTable, this.foreignKeys, matches);
+            whereSQL = (0, join_utils_1.buildCollectionCorrelationWhere)(fkTableAlias, correlationSource, this.foreignKeys, matches);
         }
         else {
-            whereSQL = `"${fkTableAlias}"."${foreignKey}" = "${sourceTable}"."id"`;
+            whereSQL = `"${fkTableAlias}"."${foreignKey}" = "${correlationSource}"."id"`;
         }
         if (this.whereCond) {
             const condBuilder = new conditions_1.ConditionBuilder();
@@ -6369,6 +6423,10 @@ class CollectionQueryBuilder {
                     paramCounter: context.paramCounter,
                     params: context.allParams,
                     placeholders: context.placeholders, // Pass placeholders for prepared statements
+                    // Thread the lateral alias scope into fragments: an EXISTS collection
+                    // rendered inside this lateral must anchor its λ-root on the lateral's
+                    // generated alias (see CollectionQueryBuilder.buildSql rootAnchor).
+                    lateralTableAliasMap: context.lateralTableAliasMap,
                 };
                 const fragmentSql = field.buildSql(sqlBuildContext);
                 context.paramCounter = sqlBuildContext.paramCounter;