typeorm-extensions 2.2.0-rc.8 → 2.2.0-rc.9

package/dist/extensions/where-is-in.extension.d.ts

@@ -1,162 +1,52 @@
 import { ObjectLiteral } from 'typeorm';
 import { ArgsType } from '../types/util-types';
+export interface WhereIsInMethods {
+    /**
+     * Sets WHERE IN condition in the query builder.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereIsIn(field: string, array?: ArgsType): this;
+    /**
+     * Adds new AND WHERE IN condition in the query builder.
+     */
+    andWhereIsIn(field: string, array?: ArgsType): this;
+    /**
+     * Adds new OR WHERE IN condition in the query builder.
+     */
+    orWhereIsIn(field: string, array?: ArgsType): this;
+    /**
+     * Sets WHERE NOT IN condition in the query builder.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereIsNotIn(field: string, array?: ArgsType): this;
+    /**
+     * Adds new AND WHERE NOT IN condition in the query builder.
+     */
+    andWhereIsNotIn(field: string, array?: ArgsType): this;
+    /**
+     * Adds new OR WHERE NOT IN condition in the query builder.
+     */
+    orWhereIsNotIn(field: string, array?: ArgsType): this;
+}
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
-    interface WhereExpressionBuilder {
-        /**
-         * Sets WHERE IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsIn(field: string, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE IN condition in the query builder.
-         */
-        andWhereIsIn(field: string, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE IN condition in the query builder.
-         */
-        orWhereIsIn(field: string, array?: ArgsType): this;
-        /**
-         * Sets WHERE NOT IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotIn(field: string, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE NOT IN condition in the query builder.
-         */
-        andWhereIsNotIn(field: string, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE NOT IN condition in the query builder.
-         */
-        orWhereIsNotIn(field: string, array?: ArgsType): this;
+    interface WhereExpressionBuilder extends WhereIsInMethods {
     }
 }
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
-    interface SelectQueryBuilder<Entity extends ObjectLiteral> {
-        /**
-         * Sets WHERE IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsIn(field: string, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE IN condition in the query builder.
-         */
-        andWhereIsIn(field: string, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE IN condition in the query builder.
-         */
-        orWhereIsIn(field: string, array?: ArgsType): this;
-        /**
-         * Sets WHERE NOT IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotIn(field: string, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE NOT IN condition in the query builder.
-         */
-        andWhereIsNotIn(field: string, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE NOT IN condition in the query builder.
-         */
-        orWhereIsNotIn(field: string, array?: ArgsType): this;
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends WhereIsInMethods {
     }
 }
 declare module 'typeorm/query-builder/UpdateQueryBuilder' {
-    interface UpdateQueryBuilder<Entity extends ObjectLiteral> {
-        /**
-         * Sets WHERE IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsIn(field: string, array?: ArgsType): UpdateQueryBuilder<Entity>;
-        /**
-         * Adds new AND WHERE IN condition in the query builder.
-         */
-        andWhereIsIn(field: string, array?: ArgsType): UpdateQueryBuilder<Entity>;
-        /**
-         * Adds new OR WHERE IN condition in the query builder.
-         */
-        orWhereIsIn(field: string, array?: ArgsType): UpdateQueryBuilder<Entity>;
-        /**
-         * Sets WHERE NOT IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotIn(field: string, array?: ArgsType): UpdateQueryBuilder<Entity>;
-        /**
-         * Adds new AND WHERE NOT IN condition in the query builder.
-         */
-        andWhereIsNotIn(field: string, array?: ArgsType): UpdateQueryBuilder<Entity>;
-        /**
-         * Adds new OR WHERE NOT IN condition in the query builder.
-         */
-        orWhereIsNotIn(field: string, array?: ArgsType): UpdateQueryBuilder<Entity>;
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends WhereIsInMethods {
     }
 }
 declare module 'typeorm/query-builder/DeleteQueryBuilder' {
-    interface DeleteQueryBuilder<Entity extends ObjectLiteral> {
-        /**
-         * Sets WHERE IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsIn(field: string, array?: ArgsType): DeleteQueryBuilder<Entity>;
-        /**
-         * Adds new AND WHERE IN condition in the query builder.
-         */
-        andWhereIsIn(field: string, array?: ArgsType): DeleteQueryBuilder<Entity>;
-        /**
-         * Adds new OR WHERE IN condition in the query builder.
-         */
-        orWhereIsIn(field: string, array?: ArgsType): DeleteQueryBuilder<Entity>;
-        /**
-         * Sets WHERE NOT IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotIn(field: string, array?: ArgsType): DeleteQueryBuilder<Entity>;
-        /**
-         * Adds new AND WHERE NOT IN condition in the query builder.
-         */
-        andWhereIsNotIn(field: string, array?: ArgsType): DeleteQueryBuilder<Entity>;
-        /**
-         * Adds new OR WHERE NOT IN condition in the query builder.
-         */
-        orWhereIsNotIn(field: string, array?: ArgsType): DeleteQueryBuilder<Entity>;
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereIsInMethods {
     }
 }
 declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
-    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> {
-        /**
-         * Sets WHERE IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsIn(field: string, array?: ArgsType): SoftDeleteQueryBuilder<Entity>;
-        /**
-         * Adds new AND WHERE IN condition in the query builder.
-         */
-        andWhereIsIn(field: string, array?: ArgsType): SoftDeleteQueryBuilder<Entity>;
-        /**
-         * Adds new OR WHERE IN condition in the query builder.
-         */
-        orWhereIsIn(field: string, array?: ArgsType): SoftDeleteQueryBuilder<Entity>;
-        /**
-         * Sets WHERE NOT IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotIn(field: string, array?: ArgsType): SoftDeleteQueryBuilder<Entity>;
-        /**
-         * Adds new AND WHERE NOT IN condition in the query builder.
-         */
-        andWhereIsNotIn(field: string, array?: ArgsType): SoftDeleteQueryBuilder<Entity>;
-        /**
-         * Adds new OR WHERE NOT IN condition in the query builder.
-         */
-        orWhereIsNotIn(field: string, array?: ArgsType): SoftDeleteQueryBuilder<Entity>;
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereIsInMethods {
     }
 }

package/dist/extensions/where-is-in.extension.js

@@ -1,41 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const typeorm_1 = require("typeorm");
-const SoftDeleteQueryBuilder_1 = require("typeorm/query-builder/SoftDeleteQueryBuilder");
 const prototype_utils_1 = require("../utils/prototype.utils");
 const where_utils_1 = require("../utils/where.utils");
+/* eslint-enable @typescript-eslint/no-empty-interface, @typescript-eslint/no-unused-vars */
 // patching
+const createWhereIsInMethod = (method, operator) => function (field, array) {
+    return attachWhereIsIn(this, method, field, operator, array);
+};
 const extension = {
     prototype: {
-        whereIsIn: function (field, array) {
-            return attachWhereIsIn(this, 'where', field, 'IN', array);
-        },
-        andWhereIsIn: function (field, array) {
-            return attachWhereIsIn(this, 'andWhere', field, 'IN', array);
-        },
-        orWhereIsIn: function (field, array) {
-            return attachWhereIsIn(this, 'orWhere', field, 'IN', array);
-        },
-        whereIsNotIn: function (field, array) {
-            return attachWhereIsIn(this, 'where', field, 'NOT IN', array);
-        },
-        andWhereIsNotIn: function (field, array) {
-            return attachWhereIsIn(this, 'andWhere', field, 'NOT IN', array);
-        },
-        orWhereIsNotIn: function (field, array) {
-            return attachWhereIsIn(this, 'orWhere', field, 'NOT IN', array);
-        },
+        whereIsIn: createWhereIsInMethod('where', 'IN'),
+        andWhereIsIn: createWhereIsInMethod('andWhere', 'IN'),
+        orWhereIsIn: createWhereIsInMethod('orWhere', 'IN'),
+        whereIsNotIn: createWhereIsInMethod('where', 'NOT IN'),
+        andWhereIsNotIn: createWhereIsInMethod('andWhere', 'NOT IN'),
+        orWhereIsNotIn: createWhereIsInMethod('orWhere', 'NOT IN'),
     },
 };
-const queryBuilders = [
-    typeorm_1.SelectQueryBuilder,
-    typeorm_1.UpdateQueryBuilder,
-    typeorm_1.DeleteQueryBuilder,
-    SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder,
-];
-queryBuilders.forEach((builder) => {
-    (0, prototype_utils_1.patchPrototype)(builder, extension);
-});
+(0, prototype_utils_1.patchPrototypes)(prototype_utils_1.WHERE_QUERY_BUILDERS, extension);
 // implementation
 function attachWhereIsIn(builder, method, field, operator, array) {
     if (method && typeof field === 'string' && typeof operator === 'string') {

package/dist/extensions/where-json.extension.js

@@ -1,7 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const typeorm_1 = require("typeorm");
-const SoftDeleteQueryBuilder_1 = require("typeorm/query-builder/SoftDeleteQueryBuilder");
 const prototype_utils_1 = require("../utils/prototype.utils");
 const query_builder_utils_1 = require("../utils/query-builder.utils");
 const sql_utils_1 = require("../utils/sql.utils");
@@ -23,15 +21,7 @@ const extension = {
         orWhereJsonHasKey: createWhereJsonHasKeyMethod('orWhere'),
     },
 };
-const queryBuilders = [
-    typeorm_1.SelectQueryBuilder,
-    typeorm_1.UpdateQueryBuilder,
-    typeorm_1.DeleteQueryBuilder,
-    SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder,
-];
-queryBuilders.forEach((builder) => {
-    (0, prototype_utils_1.patchPrototype)(builder, extension);
-});
+(0, prototype_utils_1.patchPrototypes)(prototype_utils_1.WHERE_QUERY_BUILDERS, extension);
 // implementation
 /**
  * `CAST("table"."column" AS jsonb)`: makes `json` and `simple-json` (text) columns work, and is dropped by PostgreSQL

package/dist/extensions/where-relation-exists.extension.js

@@ -22,18 +22,12 @@ const extension = {
 // implementation
 function attachRelationExists(builder, method, negate, relationSelection, alias, where) {
     const methodName = `${method}Relation${negate ? 'Not' : ''}Exists`;
-    const key = (0, query_builder_utils_1.getTypedSelectionKey)(builder, relationSelection);
-    if (Array.isArray(key)) {
-        throw new TypeError(`${methodName} expects the callback to select one relation, got ${key.length}: ${key.join(', ')}`);
-    }
-    const dot = key.indexOf('.');
-    const ownerAlias = key.slice(0, dot);
-    const propertyPath = key.slice(dot + 1);
-    const aliases = queryAliases(builder);
+    const { aliasName: ownerAlias, propertyPath } = (0, query_builder_utils_1.resolveTypedProperty)(builder, relationSelection, methodName);
+    const aliases = (0, query_builder_utils_1.listQueryAliases)(builder);
     const owner = aliases.find((candidate) => candidate.name === ownerAlias);
     const relation = (owner === null || owner === void 0 ? void 0 : owner.hasMetadata) ? owner.metadata.findRelationWithPropertyPath(propertyPath) : undefined;
-    if (!relation) {
-        throw new TypeError(`${methodName}: ${key} is not a relation of an entity of the query`);
+    if (!owner || !relation) {
+        throw new TypeError(`${methodName}: ${ownerAlias}.${propertyPath} is not a relation of an entity of the query`);
     }
     // in the subquery the alias would hide the outer one the join condition refers to; SQLite matches
     // names without case, so 'USER' would hide 'user' there
@@ -45,26 +39,12 @@ function attachRelationExists(builder, method, negate, relationSelection, alias,
         .createQueryBuilder()
         .select('1')
         .from(relation.inverseEntityMetadata.target, alias);
-    const correlation = joinCondition(relation, ownerAlias, alias, column, subQuery);
+    const correlation = joinCondition(relation, owner.name, alias, column, subQuery);
     where === null || where === void 0 ? void 0 : where(subQuery);
     // after the caller's conditions, so a `where` or an `orWhere` of theirs can't drop or bypass it
     (0, where_utils_1.andWhereNarrowing)(subQuery, correlation);
     return (0, where_exists_extension_1.attachExists)(builder, method, subQuery, negate);
 }
-/**
- * The aliases of the query and of the queries it is part of. Inside `Brackets` the builder has the outer
- * query's main alias but none of its joins: those are on its parent.
- */
-function queryAliases(builder) {
-    const aliases = [];
-    // parentQueryBuilder is protected in TypeORM's types
-    let query = builder;
-    for (; query; query = query.parentQueryBuilder) {
-        const { aliases: own, mainAlias } = query.expressionMap;
-        aliases.push(...own, ...(mainAlias ? [mainAlias] : []));
-    }
-    return aliases;
-}
 const equal = (left, right) => `${left} = ${right}`;
 /** The condition between the related rows (`alias`) and the outer row (`ownerAlias`); joins the junction table of a many-to-many. */
 function joinCondition(relation, ownerAlias, alias, column, subQuery) {

package/dist/index.d.ts

@@ -4,9 +4,4 @@ export * from './types/interfaces';
 export * from './types/extensions';
 export type { Json } from './types/modules/proxy-callback.types';
 export type { TypedRoot, WithTypedRoot } from './types/modules/typed-root.types';
-export * from './utils/table.utils';
-export { escapeLikePattern } from './utils/search.utils';
-export { COCKROACHDB_RESERVED_KEY_WORDS, findBareReservedQualifiers, POSTGRES_RESERVED_KEY_WORDS, } from './utils/reserved-qualifier.utils';
-export type { ReservedQualifier } from './utils/reserved-qualifier.utils';
-export { disableReservedQualifierGuard, enableReservedQualifierGuard, ReservedQualifierError, } from './utils/reserved-qualifier-guard.utils';
-export type { ReservedQualifierGuardOptions } from './utils/reserved-qualifier-guard.utils';
+export * from './helpers';

package/dist/index.js

@@ -14,19 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReservedQualifierError = exports.enableReservedQualifierGuard = exports.disableReservedQualifierGuard = exports.POSTGRES_RESERVED_KEY_WORDS = exports.findBareReservedQualifiers = exports.COCKROACHDB_RESERVED_KEY_WORDS = exports.escapeLikePattern = void 0;
 __exportStar(require("./extensions"), exports);
 __exportStar(require("./decorators"), exports);
 __exportStar(require("./types/interfaces"), exports);
 __exportStar(require("./types/extensions"), exports);
-__exportStar(require("./utils/table.utils"), exports);
-var search_utils_1 = require("./utils/search.utils");
-Object.defineProperty(exports, "escapeLikePattern", { enumerable: true, get: function () { return search_utils_1.escapeLikePattern; } });
-var reserved_qualifier_utils_1 = require("./utils/reserved-qualifier.utils");
-Object.defineProperty(exports, "COCKROACHDB_RESERVED_KEY_WORDS", { enumerable: true, get: function () { return reserved_qualifier_utils_1.COCKROACHDB_RESERVED_KEY_WORDS; } });
-Object.defineProperty(exports, "findBareReservedQualifiers", { enumerable: true, get: function () { return reserved_qualifier_utils_1.findBareReservedQualifiers; } });
-Object.defineProperty(exports, "POSTGRES_RESERVED_KEY_WORDS", { enumerable: true, get: function () { return reserved_qualifier_utils_1.POSTGRES_RESERVED_KEY_WORDS; } });
-var reserved_qualifier_guard_utils_1 = require("./utils/reserved-qualifier-guard.utils");
-Object.defineProperty(exports, "disableReservedQualifierGuard", { enumerable: true, get: function () { return reserved_qualifier_guard_utils_1.disableReservedQualifierGuard; } });
-Object.defineProperty(exports, "enableReservedQualifierGuard", { enumerable: true, get: function () { return reserved_qualifier_guard_utils_1.enableReservedQualifierGuard; } });
-Object.defineProperty(exports, "ReservedQualifierError", { enumerable: true, get: function () { return reserved_qualifier_guard_utils_1.ReservedQualifierError; } });
+__exportStar(require("./helpers"), exports);

package/dist/utils/calculated-column.utils.d.ts

@@ -1,10 +1,14 @@
 import { ObjectLiteral, SelectQueryBuilder } from 'typeorm';
+import type { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata';
+/** `addSelect`'s selection: an SQL expression, or a factory that builds a subquery on the builder it is given. */
+export type CalculatedSelection<SubEntity extends ObjectLiteral = ObjectLiteral> = string | ((qb: SelectQueryBuilder<ObjectLiteral>) => SelectQueryBuilder<SubEntity>);
 type ResolvedCalculatedColumn = {
     /** The key TypeORM reads the column's value from when it builds the entity. */
     key: string;
     /** `Entity.property`, for error messages. */
     label: string;
 };
+export declare const isCalculated: (column: ColumnMetadata | undefined) => column is ColumnMetadata;
 /** Whether `property` of the entity of `aliasName` (the main alias by default) is a `@CalculatedColumn`. */
 export declare function isCalculatedColumn<Entity extends ObjectLiteral>(builder: SelectQueryBuilder<Entity>, property: string, aliasName?: string): boolean;
 /** The `@CalculatedColumn` `property` of the entity of `aliasName`; throws a `TypeError` for anything else. */
@@ -18,4 +22,8 @@ export declare function resolveCalculatedColumn<Entity extends ObjectLiteral>(bu
  * through with `take` / `skip` and joins, which takes only select aliases it knows unquoted.
  */
 export declare function selectCalculatedForOrder<Entity extends ObjectLiteral>(builder: SelectQueryBuilder<Entity>, property: string, aliasName: string | undefined, methodName: string): string;
+/** Selects `selection` into the `@CalculatedColumn` `property` of the entity of `aliasName` (the main alias by default). */
+export declare function addSelectCalculatedColumn<Entity extends ObjectLiteral, SubEntity extends ObjectLiteral>(builder: SelectQueryBuilder<Entity>, selection: CalculatedSelection<SubEntity>, property: string, aliasName: string | undefined, methodName: string): SelectQueryBuilder<Entity>;
+/** ORDER BY the value of a `@CalculatedColumn` selected with `addSelectCalculated`, through `orderBy` or `addOrderBy`. */
+export declare function orderByCalculatedColumn<Entity extends ObjectLiteral>(builder: SelectQueryBuilder<Entity>, method: 'orderBy' | 'addOrderBy', property: string, order: 'ASC' | 'DESC' | undefined, nulls: 'NULLS FIRST' | 'NULLS LAST' | undefined, aliasName: string | undefined, methodName: string): SelectQueryBuilder<Entity>;
 export {};

package/dist/utils/calculated-column.utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectCalculatedForOrder = exports.resolveCalculatedColumn = exports.isCalculatedColumn = void 0;
+exports.orderByCalculatedColumn = exports.addSelectCalculatedColumn = exports.selectCalculatedForOrder = exports.resolveCalculatedColumn = exports.isCalculatedColumn = exports.isCalculated = void 0;
 const DriverUtils_1 = require("typeorm/driver/DriverUtils");
 const sql_utils_1 = require("./sql.utils");
 function findCalculatedColumn(builder, property, aliasName) {
@@ -19,10 +19,11 @@ function findCalculatedColumn(builder, property, aliasName) {
 }
 // @CalculatedColumn: a virtual property without the query of TypeORM's @VirtualColumn
 const isCalculated = (column) => !!(column === null || column === void 0 ? void 0 : column.isVirtualProperty) && !column.query;
+exports.isCalculated = isCalculated;
 /** Whether `property` of the entity of `aliasName` (the main alias by default) is a `@CalculatedColumn`. */
 function isCalculatedColumn(builder, property, aliasName) {
     var _a;
-    return isCalculated((_a = findCalculatedColumn(builder, property, aliasName)) === null || _a === void 0 ? void 0 : _a.column);
+    return (0, exports.isCalculated)((_a = findCalculatedColumn(builder, property, aliasName)) === null || _a === void 0 ? void 0 : _a.column);
 }
 exports.isCalculatedColumn = isCalculatedColumn;
 /** The `@CalculatedColumn` `property` of the entity of `aliasName`; throws a `TypeError` for anything else. */
@@ -33,7 +34,7 @@ function resolveCalculatedColumn(builder, property, aliasName, methodName) {
         throw new TypeError(`${methodName}: the alias "${aliasName !== null && aliasName !== void 0 ? aliasName : (_a = builder.expressionMap.mainAlias) === null || _a === void 0 ? void 0 : _a.name}" has no entity with "${property}"`);
     }
     const label = `${found.entityName}.${property}`;
-    if (!isCalculated(found.column)) {
+    if (!(0, exports.isCalculated)(found.column)) {
         throw new TypeError(`${methodName}: ${label} is not a @CalculatedColumn`);
     }
     // shortened past the driver's alias length limit, as TypeORM does it
@@ -61,3 +62,19 @@ function selectCalculatedForOrder(builder, property, aliasName, methodName) {
     return orderAlias;
 }
 exports.selectCalculatedForOrder = selectCalculatedForOrder;
+/** Selects `selection` into the `@CalculatedColumn` `property` of the entity of `aliasName` (the main alias by default). */
+function addSelectCalculatedColumn(builder, selection, property, aliasName, methodName) {
+    const { key } = resolveCalculatedColumn(builder, property, aliasName, methodName);
+    // two calls: addSelect's overloads take a string or a factory, not their union
+    if (typeof selection === 'function') {
+        return builder.addSelect(selection, key);
+    }
+    return builder.addSelect(selection, key);
+}
+exports.addSelectCalculatedColumn = addSelectCalculatedColumn;
+/** ORDER BY the value of a `@CalculatedColumn` selected with `addSelectCalculated`, through `orderBy` or `addOrderBy`. */
+function orderByCalculatedColumn(builder, method, property, order, nulls, aliasName, methodName) {
+    const orderAlias = selectCalculatedForOrder(builder, property, aliasName, methodName);
+    return builder[method](orderAlias, order, nulls);
+}
+exports.orderByCalculatedColumn = orderByCalculatedColumn;

package/dist/utils/common.utils.d.ts

@@ -1,2 +1,4 @@
+/** A Date, also one from another realm (a vm context, a test runner's sandbox), where `instanceof Date` is false. */
+export declare const isDate: (value: unknown) => value is Date;
 export declare const isNil: (val: unknown) => boolean;
 export declare function randomString(length?: number): string;

package/dist/utils/common.utils.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.randomString = exports.isNil = void 0;
+exports.randomString = exports.isNil = exports.isDate = void 0;
+/** A Date, also one from another realm (a vm context, a test runner's sandbox), where `instanceof Date` is false. */
+const isDate = (value) => Object.prototype.toString.call(value) === '[object Date]';
+exports.isDate = isDate;
 const isNil = (val) => typeof val === 'undefined' || val === null;
 exports.isNil = isNil;
 function randomString(length = 21) {

package/dist/utils/cursor.utils.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildKeysetCondition = exports.getTextCastType = exports.supportsRowValueComparison = exports.decodeCursor = exports.encodeCursor = exports.InvalidCursorError = void 0;
 const sql_utils_1 = require("./sql.utils");
+const common_utils_1 = require("./common.utils");
 /** A cursor that can't be decoded or doesn't belong to the query's order (e.g. tampered with). */
 class InvalidCursorError extends TypeError {
     constructor(message) {
@@ -10,9 +11,8 @@ class InvalidCursorError extends TypeError {
     }
 }
 exports.InvalidCursorError = InvalidCursorError;
-const isDate = (value) => Object.prototype.toString.call(value) === '[object Date]';
 const toCursorValue = (value) => {
-    if (isDate(value)) {
+    if ((0, common_utils_1.isDate)(value)) {
         return { $date: value.toISOString() };
     }
     if (typeof value === 'bigint') {
@@ -77,9 +77,7 @@ function decodeCursor(cursor, fields) {
 }
 exports.decodeCursor = decodeCursor;
 /** Databases that compare row values: `(a, b) < (1, 2)`. */
-const supportsRowValueComparison = (driver) => driver === 'postgres' ||
-    driver === 'aurora-postgres' ||
-    driver === 'cockroachdb' ||
+const supportsRowValueComparison = (driver) => (0, sql_utils_1.isPostgresLikeDriver)(driver) ||
     (0, sql_utils_1.isMysqlLikeDriver)(driver) ||
     (0, sql_utils_1.isSqliteLikeDriver)(driver);
 exports.supportsRowValueComparison = supportsRowValueComparison;
@@ -88,7 +86,7 @@ exports.supportsRowValueComparison = supportsRowValueComparison;
  * (PostgreSQL timestamps have microseconds, a JS Date only milliseconds). `undefined` when unknown.
  */
 const getTextCastType = (driver) => {
-    if (driver === 'postgres' || driver === 'aurora-postgres' || driver === 'cockroachdb' || (0, sql_utils_1.isSqliteLikeDriver)(driver)) {
+    if ((0, sql_utils_1.isPostgresLikeDriver)(driver) || (0, sql_utils_1.isSqliteLikeDriver)(driver)) {
         return 'text';
     }
     if ((0, sql_utils_1.isMysqlLikeDriver)(driver)) {

package/dist/utils/json-path.utils.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toJsonPathSql = exports.buildJsonPath = exports.isJsonColumn = void 0;
 const sql_utils_1 = require("./sql.utils");
+const common_utils_1 = require("./common.utils");
 const JSON_COLUMN_TYPES = ['json', 'jsonb', 'simple-json'];
 const isJsonColumn = (column) => JSON_COLUMN_TYPES.includes(String(column.type));
 exports.isJsonColumn = isJsonColumn;
@@ -14,7 +15,6 @@ function buildJsonPath(fieldNames, jsonOperator) {
         .join(' ');
 }
 exports.buildJsonPath = buildJsonPath;
-const isDate = (value) => Object.prototype.toString.call(value) === '[object Date]';
 /**
  * PostgreSQL type to compare a `->>` value (text) with `value` as: text compares `'9' >= '10'` as true.
  * An array (IN, ANY) is typed by its first value; strings and unknown values stay text.
@@ -27,7 +27,7 @@ function getJsonTextCast(value) {
     if (typeof sample === 'boolean') {
         return 'boolean';
     }
-    if (isDate(sample)) {
+    if ((0, common_utils_1.isDate)(sample)) {
         return 'timestamptz';
     }
     return undefined;

package/dist/utils/pagination.utils.d.ts

@@ -1,4 +1,9 @@
+import type { ObjectLiteral, SelectQueryBuilder } from "typeorm";
 import { PaginationFilter } from "../types/interfaces/pagination.interface";
+/** The page size to read: a number or a numeric string of at least 1, rounded down; `defaultPageSize` otherwise. */
+export declare const normalizePageSize: (pageSize: unknown) => number;
+/** Limits the rows with `take`, which counts entities rather than rows when the query joins a collection, or with `limit`. */
+export declare const setPageLimit: <Entity extends ObjectLiteral>(builder: SelectQueryBuilder<Entity>, limit: number, useTakeAndSkip: boolean) => SelectQueryBuilder<Entity>;
 export declare const getLimitAndOffset: ({ page, pageSize }: PaginationFilter) => {
     limit: number;
     offset: number;

package/dist/utils/pagination.utils.js

@@ -1,16 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLimitAndOffset = void 0;
+exports.getLimitAndOffset = exports.setPageLimit = exports.normalizePageSize = void 0;
 const constants_1 = require("../constants");
+// an unparsed query parameter is a string: "20" + 1 would be "201"
+const toPositiveInteger = (value, fallback) => {
+    const number = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+    return typeof number === 'number' && Number.isFinite(number) && number >= 1 ? Math.floor(number) : fallback;
+};
+/** The page size to read: a number or a numeric string of at least 1, rounded down; `defaultPageSize` otherwise. */
+const normalizePageSize = (pageSize) => toPositiveInteger(pageSize, constants_1.defaultPageSize);
+exports.normalizePageSize = normalizePageSize;
+/** Limits the rows with `take`, which counts entities rather than rows when the query joins a collection, or with `limit`. */
+const setPageLimit = (builder, limit, useTakeAndSkip) => (useTakeAndSkip ? builder.take(limit) : builder.limit(limit));
+exports.setPageLimit = setPageLimit;
 const getLimitAndOffset = ({ page, pageSize }) => {
-    if (!page || page < 1) {
-        page = 1;
-    }
-    if (!pageSize || pageSize < 1) {
-        pageSize = constants_1.defaultPageSize;
-    }
-    const offset = (page >= 1 ? page - 1 : 0) * pageSize;
-    const limit = pageSize;
-    return { limit, offset, page, pageSize };
+    const normalizedPage = toPositiveInteger(page, 1);
+    const normalizedPageSize = (0, exports.normalizePageSize)(pageSize);
+    return {
+        limit: normalizedPageSize,
+        offset: (normalizedPage - 1) * normalizedPageSize,
+        page: normalizedPage,
+        pageSize: normalizedPageSize,
+    };
 };
 exports.getLimitAndOffset = getLimitAndOffset;

package/dist/utils/parameter.utils.d.ts

@@ -1,7 +1,17 @@
 import type { ObjectLiteral } from 'typeorm';
+/** The parameter names an SQL fragment refers to, as TypeORM reads its placeholders. */
+export declare function getPlaceholderNames(sql: string): string[];
 /**
  * Renames the parameters of a subquery to unique names, in its SQL and in its parameters. A query
  * has one parameter namespace, so two subqueries with a `:status` each would otherwise both read
  * whichever value was set last. Placeholders that aren't keys of `parameters` stay as they are.
  */
 export declare function withUniqueParameterNames(sql: string, parameters: ObjectLiteral): [string, ObjectLiteral];
+/**
+ * The SQL of a query, without the parentheses a `subQuery()` builder writes around itself, and its parameters, both
+ * renamed unique (see `withUniqueParameterNames`).
+ */
+export declare function toSubQuerySql(query: {
+    getQuery(): string;
+    getParameters(): ObjectLiteral;
+}): [string, ObjectLiteral];

package/dist/utils/parameter.utils.js

@@ -1,9 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withUniqueParameterNames = void 0;
+exports.toSubQuerySql = exports.withUniqueParameterNames = exports.getPlaceholderNames = void 0;
 const sql_utils_1 = require("./sql.utils");
 // TypeORM's placeholder syntax, `:name` and `:...name`, as its drivers match it
 const PARAMETER_PLACEHOLDER = /:(\.\.\.)?([A-Za-z0-9_.]+)/g;
+/** The parameter names an SQL fragment refers to, as TypeORM reads its placeholders. */
+function getPlaceholderNames(sql) {
+    // a regex of its own: a global regex keeps its position between exec calls
+    const placeholder = new RegExp(PARAMETER_PLACEHOLDER.source, 'g');
+    const names = [];
+    for (let match = placeholder.exec(sql); match !== null; match = placeholder.exec(sql)) {
+        names.push(match[2]);
+    }
+    return names;
+}
+exports.getPlaceholderNames = getPlaceholderNames;
 /**
  * Renames the parameters of a subquery to unique names, in its SQL and in its parameters. A query
  * has one parameter namespace, so two subqueries with a `:status` each would otherwise both read
@@ -19,3 +30,13 @@ function withUniqueParameterNames(sql, parameters) {
     return [renamedSql, renamedParameters];
 }
 exports.withUniqueParameterNames = withUniqueParameterNames;
+/**
+ * The SQL of a query, without the parentheses a `subQuery()` builder writes around itself, and its parameters, both
+ * renamed unique (see `withUniqueParameterNames`).
+ */
+function toSubQuerySql(query) {
+    const sql = query.getQuery();
+    const wrapped = 'expressionMap' in query && query.expressionMap.subQuery;
+    return withUniqueParameterNames(wrapped ? sql.slice(1, -1) : sql, query.getParameters());
+}
+exports.toSubQuerySql = toSubQuerySql;

package/dist/utils/period.utils.js

@@ -4,6 +4,7 @@ exports.attachPeriodFilter = void 0;
 const sql_utils_1 = require("./sql.utils");
 const where_utils_1 = require("./where.utils");
 const time_zone_utils_1 = require("./time-zone.utils");
+const common_utils_1 = require("./common.utils");
 const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
 /** `'2024-01-31'` as a UTC midnight Date, or a `TypeError` if it is not a calendar date (`'2024-02-30'`). */
 function parseDateOnly(value, name) {
@@ -18,7 +19,7 @@ function normalizeBoundary(value, name) {
     if (value === undefined || value === null || value === '') {
         return undefined;
     }
-    if (Object.prototype.toString.call(value) === '[object Date]') {
+    if ((0, common_utils_1.isDate)(value)) {
         if (isNaN(value.getTime())) {
             throw new TypeError(`Invalid ${name}: invalid Date`);
         }