linkgress-orm 0.4.44 → 0.4.46

package/dist/query/query-builder.js

@@ -142,8 +142,18 @@ const NUMERIC_REGEX = /^-?\d+(\.\d+)?$/;
 /**
  * Query builder for a table
  */
+/**
+ * Monotonic sequence for query-chain identities. Every root builder gets a
+ * fresh id; derived builders inherit it. Field refs bake the id so a
+ * standalone subquery can detect same-table refs leaking in from an OUTER
+ * chain (alias collision → the correlation would silently bind to the inner
+ * row — see extractOuterFieldRefs).
+ */
+let chainIdSeq = 0;
 class QueryBuilder {
     constructor(schema, client, whereCond, limit, offset, orderBy, executor, manualJoins, joinCounter, collectionStrategy, schemaRegistry) {
+        /** @internal Chain identity — see chainIdSeq. */
+        this.chainId = ++chainIdSeq;
         this.orderByFields = [];
         this.manualJoins = [];
         this.joinCounter = 0;
@@ -200,7 +210,7 @@ class QueryBuilder {
         return new SelectQueryBuilder(this.schema, this.client, selector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, this.manualJoins, this.joinCounter, false, // isDistinct defaults to false
         this.schemaRegistry, // Pass schema registry for nested navigation resolution
         [], // ctes - start with empty array
-        this.collectionStrategy);
+        this.collectionStrategy, this.chainId);
     }
     /**
      * Add WHERE condition
@@ -222,7 +232,7 @@ class QueryBuilder {
      */
     with(...ctes) {
         return new SelectQueryBuilder(this.schema, this.client, (row) => row, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, this.manualJoins, this.joinCounter, false, this.schemaRegistry, // Pass schema registry for nested navigation resolution
-        ctes, this.collectionStrategy);
+        ctes, this.collectionStrategy, this.chainId);
     }
     /**
      * Create mock row for analysis
@@ -235,6 +245,7 @@ class QueryBuilder {
         }
         const mock = {};
         const tableAlias = this.schema.name;
+        const chainId = this.chainId;
         // Performance: Use pre-computed column name map if available
         const columnNameMap = getColumnNameMapForSchema(this.schema);
         // Performance: Lazy-cache FieldRef objects - only create when first accessed
@@ -258,6 +269,7 @@ class QueryBuilder {
                             __fieldName: colName,
                             __dbColumnName: dbColumnName,
                             __tableAlias: tableAlias,
+                            __chainId: chainId,
                             // Include mapper for toDriver transformation in conditions
                             __mapper: mapper,
                         };
@@ -324,7 +336,7 @@ class QueryBuilder {
             const qb = new SelectQueryBuilder(this.schema, this.client, (row) => row, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, this.manualJoins, this.joinCounter, false, // isDistinct defaults to false
             undefined, // schemaRegistry
             [], // ctes
-            this.collectionStrategy);
+            this.collectionStrategy, this.chainId);
             return qb.leftJoinSubquery(rightTable, alias, condition, selector);
         }
         const rightSchema = rightTable._getSchema();
@@ -357,7 +369,7 @@ class QueryBuilder {
         return new SelectQueryBuilder(this.schema, this.client, wrappedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, updatedJoins, newJoinCounter, false, // isDistinct defaults to false
         undefined, // schemaRegistry
         [], // ctes
-        this.collectionStrategy);
+        this.collectionStrategy, this.chainId);
     }
     /**
      * Add an INNER JOIN to the query with a selector (supports both tables and subqueries)
@@ -373,7 +385,7 @@ class QueryBuilder {
             const qb = new SelectQueryBuilder(this.schema, this.client, (row) => row, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, this.manualJoins, this.joinCounter, false, // isDistinct defaults to false
             undefined, // schemaRegistry
             [], // ctes
-            this.collectionStrategy);
+            this.collectionStrategy, this.chainId);
             return qb.innerJoinSubquery(rightTable, alias, condition, selector);
         }
         const rightSchema = rightTable._getSchema();
@@ -406,7 +418,7 @@ class QueryBuilder {
         return new SelectQueryBuilder(this.schema, this.client, wrappedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, updatedJoins, newJoinCounter, false, // isDistinct defaults to false
         undefined, // schemaRegistry
         [], // ctes
-        this.collectionStrategy);
+        this.collectionStrategy, this.chainId);
     }
     /**
      * Create mock row for a specific table/alias (for joins)
@@ -503,7 +515,7 @@ class SelectQueryBuilder {
     getQualifiedTableName(tableName, schema) {
         return schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
     }
-    constructor(schema, client, selector, whereCond, limit, offset, orderBy, executor, manualJoins, joinCounter, isDistinct, schemaRegistry, ctes, collectionStrategy) {
+    constructor(schema, client, selector, whereCond, limit, offset, orderBy, executor, manualJoins, joinCounter, isDistinct, schemaRegistry, ctes, collectionStrategy, chainId) {
         this.orderByFields = [];
         this.manualJoins = [];
         this.joinCounter = 0;
@@ -513,6 +525,7 @@ class SelectQueryBuilder {
         this.schema = schema;
         this.client = client;
         this.selector = selector;
+        this.chainId = chainId ?? ++chainIdSeq;
         this.whereCond = whereCond;
         this.limitValue = limit;
         this.offsetValue = offset;
@@ -559,13 +572,61 @@ class SelectQueryBuilder {
             const firstResult = this.selector(row);
             return selector(firstResult);
         };
-        return new SelectQueryBuilder(this.schema, this.client, composedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, this.manualJoins, this.joinCounter, this.isDistinct, this.schemaRegistry, this.ctes, this.collectionStrategy);
+        return new SelectQueryBuilder(this.schema, this.client, composedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, this.manualJoins, this.joinCounter, this.isDistinct, this.schemaRegistry, this.ctes, this.collectionStrategy, this.chainId);
     }
     /**
      * Add WHERE condition
      * Multiple where() calls are chained with AND logic
      * Note: The row parameter represents the selected shape (after select())
      */
+    /**
+     * INNER JOIN used purely as a row FILTER — the selection shape is preserved
+     * (unlike innerJoin, no selector is required and the builder stays chainable
+     * as the same entity/selection type). The ON condition receives (left, right)
+     * mocks; an optional third callback contributes an extra WHERE predicate with
+     * the same (left, right) arguments.
+     *
+     * Intended for scope-style predicates that hop across an N:1 FK (e.g.
+     * order_item → invoicing_partner_data): a JOIN against the "one" side never
+     * duplicates left rows. Joining a 1:N side WILL duplicate rows — callers own
+     * that trade-off (use exists()/inSubquery for semi-join semantics instead).
+     */
+    joinFilter(rightTable, on, filter) {
+        return this.addFilterJoin('INNER', rightTable, on, filter);
+    }
+    /**
+     * LEFT JOIN used purely as a row FILTER — see joinFilter. Useful with an
+     * IS NULL predicate in the filter callback for anti-join shapes
+     * ("rows with NO matching right row").
+     */
+    leftJoinFilter(rightTable, on, filter) {
+        return this.addFilterJoin('LEFT', rightTable, on, filter);
+    }
+    addFilterJoin(type, rightTable, on, filter) {
+        const rightSchema = rightTable._getSchema();
+        const rightAlias = `${rightSchema.name}_${this.joinCounter}`;
+        this.joinCounter = this.joinCounter + 1;
+        const mockRow = this._createMockRow();
+        const selectedMock = this.selector(mockRow);
+        const leftMock = this.createFieldRefProxy(selectedMock, true);
+        const rightMock = this.createMockRowForTable(rightSchema, rightAlias);
+        const onCondition = on(leftMock, rightMock);
+        this.manualJoins = [
+            ...this.manualJoins,
+            {
+                type,
+                table: rightSchema.name,
+                alias: rightAlias,
+                schema: rightSchema,
+                condition: onCondition,
+            },
+        ];
+        if (filter) {
+            const filterCondition = filter(leftMock, rightMock);
+            this.whereCond = this.whereCond ? (0, conditions_1.and)(this.whereCond, filterCondition) : filterCondition;
+        }
+        return this;
+    }
     where(condition) {
         const mockRow = this._createMockRow();
         // Apply the selector to get the selected shape that the user sees in the WHERE condition
@@ -670,7 +731,7 @@ class SelectQueryBuilder {
             const freshMockRight = this.createMockRowForSubquery(alias, subquery);
             return selector(leftResult, freshMockRight);
         };
-        return new SelectQueryBuilder(this.schema, this.client, composedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, updatedJoins, newJoinCounter, this.isDistinct, this.schemaRegistry, this.ctes, this.collectionStrategy);
+        return new SelectQueryBuilder(this.schema, this.client, composedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, updatedJoins, newJoinCounter, this.isDistinct, this.schemaRegistry, this.ctes, this.collectionStrategy, this.chainId);
     }
     // Implementation
     leftJoin(rightTable, condition, selector, alias) {
@@ -714,7 +775,7 @@ class SelectQueryBuilder {
             const freshMockRight = this.createMockRowForTable(rightSchema, rightAlias);
             return selector(leftResult, freshMockRight);
         };
-        return new SelectQueryBuilder(this.schema, this.client, composedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, updatedJoins, newJoinCounter, this.isDistinct, this.schemaRegistry, this.ctes, this.collectionStrategy);
+        return new SelectQueryBuilder(this.schema, this.client, composedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, updatedJoins, newJoinCounter, this.isDistinct, this.schemaRegistry, this.ctes, this.collectionStrategy, this.chainId);
     }
     /**
      * Add a LEFT JOIN with a CTE
@@ -743,7 +804,7 @@ class SelectQueryBuilder {
             const freshMockRight = this.createMockRowForCte(cte);
             return selector(leftResult, freshMockRight);
         };
-        return new SelectQueryBuilder(this.schema, this.client, composedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, updatedJoins, newJoinCounter, this.isDistinct, this.schemaRegistry, this.ctes, this.collectionStrategy);
+        return new SelectQueryBuilder(this.schema, this.client, composedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, updatedJoins, newJoinCounter, this.isDistinct, this.schemaRegistry, this.ctes, this.collectionStrategy, this.chainId);
     }
     /**
      * Add an INNER JOIN with a subquery
@@ -777,7 +838,7 @@ class SelectQueryBuilder {
             const freshMockRight = this.createMockRowForSubquery(alias, subquery);
             return selector(leftResult, freshMockRight);
         };
-        return new SelectQueryBuilder(this.schema, this.client, composedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, updatedJoins, newJoinCounter, this.isDistinct, this.schemaRegistry, this.ctes, this.collectionStrategy);
+        return new SelectQueryBuilder(this.schema, this.client, composedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, updatedJoins, newJoinCounter, this.isDistinct, this.schemaRegistry, this.ctes, this.collectionStrategy, this.chainId);
     }
     /**
      * Add an INNER JOIN to the query with a selector
@@ -817,7 +878,7 @@ class SelectQueryBuilder {
             const freshMockRight = this.createMockRowForTable(rightSchema, rightAlias);
             return selector(leftResult, freshMockRight);
         };
-        return new SelectQueryBuilder(this.schema, this.client, composedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, updatedJoins, newJoinCounter, this.isDistinct, this.schemaRegistry, this.ctes, this.collectionStrategy);
+        return new SelectQueryBuilder(this.schema, this.client, composedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, updatedJoins, newJoinCounter, this.isDistinct, this.schemaRegistry, this.ctes, this.collectionStrategy, this.chainId);
     }
     /**
      * Create mock row for a specific table/alias (for joins)
@@ -996,7 +1057,7 @@ class SelectQueryBuilder {
             return selector(firstResult);
         };
         return new SelectQueryBuilder(this.schema, this.client, composedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, this.manualJoins, this.joinCounter, true, // Set isDistinct to true
-        this.schemaRegistry, this.ctes, this.collectionStrategy);
+        this.schemaRegistry, this.ctes, this.collectionStrategy, this.chainId);
     }
     /**
      * Get minimum value from the query
@@ -2857,6 +2918,7 @@ ${joinClauses.join('\n')}`;
     _createMockRow() {
         const mock = {};
         const tableAlias = this.schema.name;
+        const chainId = this.chainId;
         // Performance: Use pre-computed column name map if available
         const columnNameMap = getColumnNameMapForSchema(this.schema);
         // Performance: Lazy-cache FieldRef objects
@@ -2880,6 +2942,7 @@ ${joinClauses.join('\n')}`;
                             __fieldName: colName,
                             __dbColumnName: dbColumnName,
                             __tableAlias: tableAlias,
+                            __chainId: chainId,
                             // Include mapper for toDriver transformation in conditions
                             __mapper: mapper,
                         };
@@ -5007,8 +5070,23 @@ ${joinClauses.join('\n')}`;
                 const tableAlias = ref.__tableAlias;
                 // If the table alias doesn't match our current schema, it's from an outer query
                 // Also check if it's not a navigation property of this table (which would be in schema.relations)
+                // and not one of our own manual-join aliases (filter-joins qualify refs by join alias).
                 if (tableAlias !== currentTableName && !this.schema.relations[tableAlias]) {
-                    outerRefs.push(ref);
+                    if (!this.manualJoins.some(j => j.alias === tableAlias)) {
+                        outerRefs.push(ref);
+                    }
+                }
+                else if (tableAlias === currentTableName
+                    && ref.__chainId != null
+                    && this.chainId != null
+                    && ref.__chainId !== this.chainId) {
+                    // A ref over OUR table name that was created by a DIFFERENT query chain:
+                    // this is a same-table correlated standalone subquery. Inner and outer
+                    // FROM would share the alias, so the "correlation" would silently bind
+                    // to the INNER row and return wrong results — refuse loudly instead.
+                    throw new Error(`Correlated standalone subquery over table "${currentTableName}" references the same table from the outer query. `
+                        + `Both sides would share the alias "${currentTableName}" and the correlation would silently compare the inner row with itself. `
+                        + `Correlate through a different table or key column, or materialize the outer value before building the subquery.`);
                 }
             }
         }