linkgress-orm 0.4.22 → 0.4.24

package/dist/query/query-builder.js

@@ -254,8 +254,9 @@ class QueryBuilder {
                 // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
                 Object.defineProperty(mock, relName, {
                     get: () => {
-                        return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', this.schema.name, targetSchema, this.schemaRegistry // Pass schema registry for nested navigation resolution
-                        );
+                        return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', this.schema.name, targetSchema, this.schemaRegistry, // Pass schema registry for nested navigation resolution
+                        undefined, relConfig.foreignKeys, // Propagate composite FK / literal predicates
+                        relConfig.matches);
                     },
                     enumerable: false,
                     configurable: true,
@@ -418,7 +419,8 @@ class QueryBuilder {
                 // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
                 Object.defineProperty(mock, relName, {
                     get: () => {
-                        return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', schema.name, targetSchema);
+                        return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', schema.name, targetSchema, undefined, undefined, relConfig.foreignKeys, // Propagate composite FK / literal predicates
+                        relConfig.matches);
                     },
                     enumerable: false,
                     configurable: true,
@@ -804,7 +806,8 @@ class SelectQueryBuilder {
                 // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
                 Object.defineProperty(mock, relName, {
                     get: () => {
-                        return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', schema.name, targetSchema);
+                        return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', schema.name, targetSchema, undefined, undefined, relConfig.foreignKeys, // Propagate composite FK / literal predicates
+                        relConfig.matches);
                     },
                     enumerable: false,
                     configurable: true,
@@ -2734,8 +2737,9 @@ ${joinClauses.join('\n')}`;
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', this.schema.name, targetSchema, // Pass the target schema directly
-                        this.schemaRegistry // Pass schema registry for nested resolution
-                        );
+                        this.schemaRegistry, // Pass schema registry for nested resolution
+                        undefined, relConfig.foreignKeys, // Propagate composite FK / literal predicates
+                        relConfig.matches);
                     },
                     enumerable: false,
                     configurable: true,
@@ -4474,6 +4478,9 @@ ${joinClauses.join('\n')}`;
         else {
             throw new Error('Aggregation selector must return a field reference');
         }
+        // Detect navigation property joins from WHERE condition (same as buildAggregateQuery)
+        const navJoins = [];
+        this.detectAndAddJoinsFromCondition(this.whereCond, navJoins);
         // Build WHERE clause
         let whereClause = '';
         if (this.whereCond) {
@@ -4512,6 +4519,19 @@ ${joinClauses.join('\n')}`;
                 fromClause += `\n${joinTypeStr} "${manualJoin.table}" AS "${manualJoin.alias}" ON ${condSql}`;
             }
         }
+        // Add JOINs for navigation properties referenced in WHERE clause
+        for (const join of navJoins) {
+            const joinType = join.isMandatory ? 'INNER JOIN' : 'LEFT JOIN';
+            const sourceTable = join.sourceAlias || this.schema.name;
+            const onConditions = [];
+            for (let i = 0; i < join.foreignKeys.length; i++) {
+                const fk = join.foreignKeys[i];
+                const match = join.matches[i];
+                onConditions.push(`${(0, join_utils_1.formatJoinValue)(sourceTable, fk)} = ${(0, join_utils_1.formatJoinValue)(join.alias, match)}`);
+            }
+            const joinTableName = this.getQualifiedTableName(join.targetTable, join.targetSchema);
+            fromClause += `\n${joinType} ${joinTableName} AS "${join.alias}" ON ${onConditions.join(' AND ')}`;
+        }
         const sql = `SELECT ${aggregation}("${tableAlias}"."${fieldName}") as result\n${fromClause}\n${whereClause}`.trim();
         return {
             sql,
@@ -4814,8 +4834,9 @@ class ReferenceQueryBuilder {
                                 return new CollectionQueryBuilder(relName, relConfig.targetTable, fk, this.relationName, // Use alias (relationName) for correlation in lateral joins
                                 nestedTargetSchema, // Pass the target schema directly
                                 this.schemaRegistry, // Pass schema registry for nested resolution
-                                extendedNavPath // Pass navigation path for intermediate joins (empty if main query)
-                                );
+                                extendedNavPath, // Pass navigation path for intermediate joins (empty if main query)
+                                relConfig.foreignKeys, // Propagate composite FK / literal predicates
+                                relConfig.matches);
                             },
                             enumerable: false,
                             configurable: true,
@@ -4853,7 +4874,7 @@ exports.ReferenceQueryBuilder = ReferenceQueryBuilder;
  * Collection query builder for nested queries
  */
 class CollectionQueryBuilder {
-    constructor(relationName, targetTable, foreignKey, sourceTable, targetTableSchema, schemaRegistry, navigationPath) {
+    constructor(relationName, targetTable, foreignKey, sourceTable, targetTableSchema, schemaRegistry, navigationPath, foreignKeys, matches) {
         this.orderByFields = [];
         this.isMarkedAsList = false;
         this.isDistinct = false;
@@ -4863,6 +4884,12 @@ class CollectionQueryBuilder {
         this.targetTable = targetTable;
         this.targetTableSchema = targetTableSchema;
         this.foreignKey = foreignKey;
+        // Default `foreignKeys` to the single-column form so every strategy can
+        // iterate uniformly. Constant FK predicates ([col, literal] + [id, true])
+        // arrive via the explicit `foreignKeys`/`matches` arrays passed from the
+        // navigation metadata.
+        this.foreignKeys = (foreignKeys && foreignKeys.length > 0) ? foreignKeys : (foreignKey ? [foreignKey] : []);
+        this.matches = (matches && matches.length > 0) ? matches : ['id'];
         this.sourceTable = sourceTable;
         this.schemaRegistry = schemaRegistry;
         this.navigationPath = navigationPath || [];
@@ -4883,8 +4910,9 @@ class CollectionQueryBuilder {
      */
     select(selector) {
         const newBuilder = new CollectionQueryBuilder(this.relationName, this.targetTable, this.foreignKey, this.sourceTable, this.targetTableSchema, this.schemaRegistry, // Pass schema registry for nested navigation resolution
-        this.navigationPath // Pass navigation path for intermediate joins
-        );
+        this.navigationPath, // Pass navigation path for intermediate joins
+        this.foreignKeys, // Propagate composite/literal FK metadata
+        this.matches);
         newBuilder.selector = selector;
         newBuilder.whereCond = this.whereCond;
         newBuilder.limitValue = this.limitValue;
@@ -4968,9 +4996,10 @@ class CollectionQueryBuilder {
                                 // Don't call build() - it returns schema without relations
                                 const fk = relConfig.foreignKey || relConfig.foreignKeys?.[0] || '';
                                 return new CollectionQueryBuilder(relName, relConfig.targetTable, fk, this.targetTable, undefined, // Don't pass schema, force registry lookup
-                                this.schemaRegistry // Pass schema registry for nested resolution
+                                this.schemaRegistry, // Pass schema registry for nested resolution
                                 // No navigation path needed here - direct collection access from parent
-                                );
+                                undefined, relConfig.foreignKeys, // Propagate composite FK / literal predicates
+                                relConfig.matches);
                             },
                             enumerable: false,
                             configurable: true,
@@ -5263,8 +5292,17 @@ class CollectionQueryBuilder {
         }
         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;
-        let whereSQL = `"${fkTableAlias}"."${foreignKey}" = "${sourceTable}"."id"`;
+        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);
+        }
+        else {
+            whereSQL = `"${fkTableAlias}"."${foreignKey}" = "${sourceTable}"."id"`;
+        }
         if (this.whereCond) {
             const condBuilder = new conditions_1.ConditionBuilder();
             const { sql: condSql, params, placeholders, paramCounter } = condBuilder.build(this.whereCond, context.paramCounter, context.placeholders);
@@ -5856,6 +5894,11 @@ class CollectionQueryBuilder {
             relationName: this.relationName,
             targetTable: this.targetTable,
             foreignKey: this.foreignKey,
+            // Composite FK metadata: enables strategies to emit constant FK predicates
+            // (e.g. SCD2 `is_current = TRUE` from `withForeignKey: [col, isCurrent] /
+            // withPrincipalKey: [id, true]`) in the projection WHERE clause.
+            foreignKeys: this.foreignKeys,
+            matches: this.matches,
             foreignKeyTableAlias: this.foreignKeyTableAlias,
             sourceTable: this.sourceTable,
             parentIds, // Pass parent IDs for temp table strategy