typeorm 0.3.29 → 0.3.30

package/browser/query-builder/SelectQueryBuilder.js

@@ -532,9 +532,9 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     /**
      * Sets LIMIT - maximum number of rows to be selected.
-     * When joins are present, a two-query distinct-id strategy is used
-     * so that LIMIT applies to root entities rather than raw joined rows.
-     * @param limit
+     * NOTE that it may not work as you expect if you are using joins.
+     * If you want to implement pagination, and you are having join in your query,
+     * then use the take method instead.
      */
     limit(limit) {
         this.expressionMap.limit = this.validateNumericInput("limit", limit);
@@ -542,9 +542,9 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     /**
      * Sets OFFSET - selection offset.
-     * When joins are present, a two-query distinct-id strategy is used
-     * so that OFFSET applies to root entities rather than raw joined rows.
-     * @param offset
+     * NOTE that it may not work as you expect if you are using joins.
+     * If you want to implement pagination, and you are having join in your query,
+     * then use the skip method instead.
      */
     offset(offset) {
         this.expressionMap.offset = this.validateNumericInput("offset", offset);
@@ -1982,10 +1982,7 @@ export class SelectQueryBuilder extends QueryBuilder {
         // where we make two queries to find the data we need
         // first query find ids in skip and take range
         // and second query loads the actual data in given ids range
-        if ((this.expressionMap.skip ||
-            this.expressionMap.take ||
-            this.expressionMap.offset ||
-            this.expressionMap.limit) &&
+        if ((this.expressionMap.skip || this.expressionMap.take) &&
             this.expressionMap.joinAttributes.length > 0) {
             // we are skipping order by here because its not working in subqueries anyway
             // to make order by working we need to apply it on a distinct query
@@ -2002,9 +1999,6 @@ export class SelectQueryBuilder extends QueryBuilder {
                 return `${distinctAlias}.${columnAlias} AS ${this.escape(alias)}`;
             });
             const originalQuery = this.clone();
-            // clear limit/offset from the inner query since pagination is handled by the outer distinct query
-            originalQuery.expressionMap.limit = undefined;
-            originalQuery.expressionMap.offset = undefined;
             // preserve original timeTravel value since we set it to "false" in subquery
             const originalQueryTimeTravel = originalQuery.expressionMap.timeTravel;
             rawResults = await new SelectQueryBuilder(this.connection, queryRunner)
@@ -2015,8 +2009,8 @@ export class SelectQueryBuilder extends QueryBuilder {
                 .timeTravelQuery(false) // set it to "false" since time travel clause must appear at the very end and applies to the entire SELECT clause.
                 .getQuery()})`, "distinctAlias")
                 .timeTravelQuery(originalQueryTimeTravel)
-                .offset(this.expressionMap.skip ?? this.expressionMap.offset)
-                .limit(this.expressionMap.take ?? this.expressionMap.limit)
+                .offset(this.expressionMap.skip)
+                .limit(this.expressionMap.take)
                 .orderBy(orderBys)
                 .cache(this.expressionMap.cache && this.expressionMap.cacheId
                 ? `${this.expressionMap.cacheId}-pagination`
@@ -2059,14 +2053,12 @@ export class SelectQueryBuilder extends QueryBuilder {
                                 " IN (:...orm_distinct_ids)";
                     }
                 }
-                const secondQuery = this.clone()
+                rawResults = await this.clone()
                     .mergeExpressionMap({
                     extraAppendedAndWhereCondition: condition,
                 })
-                    .setParameters(parameters);
-                secondQuery.expressionMap.limit = undefined;
-                secondQuery.expressionMap.offset = undefined;
-                rawResults = await secondQuery.loadRawResults(queryRunner);
+                    .setParameters(parameters)
+                    .loadRawResults(queryRunner);
             }
         }
         else {
@@ -2572,8 +2564,21 @@ export class SelectQueryBuilder extends QueryBuilder {
                     // if all properties of where are undefined we don't need to join anything
                     // this can happen when user defines map with conditional queries inside
                     if (typeof where[key] === "object") {
-                        const allAllUndefined = Object.keys(where[key]).every((k) => where[key][k] === undefined);
-                        if (allAllUndefined) {
+                        const whereKeys = Object.keys(where[key]);
+                        // empty object — no predicates to apply, skip the join
+                        if (whereKeys.length === 0) {
+                            continue;
+                        }
+                        const allUndefined = whereKeys.every((k) => where[key][k] === undefined);
+                        if (allUndefined) {
+                            const undefinedBehavior = this.connection.options
+                                .invalidWhereValuesBehavior?.undefined ||
+                                "ignore";
+                            if (undefinedBehavior === "throw") {
+                                throw new TypeORMError(`Undefined value encountered in nested relation '${alias}.${key}' of a where condition. ` +
+                                    `All properties of the nested object are undefined. ` +
+                                    `Set 'invalidWhereValuesBehavior.undefined' to 'ignore' in connection options to skip properties with undefined values.`);
+                            }
                             continue;
                         }
                     }