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

package/README.md

@@ -93,14 +93,6 @@ TypeORM 0.3.12 and later, and 1.x. CI runs the test suite on SQLite with TypeORM
 
 The [documentation](https://koenigstag.github.io/typeorm-extensions/) has a page for every method, with its signature, options and examples, and the [playground](https://koenigstag.github.io/typeorm-extensions/playground/) runs them.
 
-## ToDo list
-
-- [x] Add tests for pagination and order extensions
-- [x] Calculated columns: the `@CalculatedColumn` decorator and `addSelectCalculated`. `getMany`, `getOne` and `getManyWithTotals` fill them as they are, so they need no variants of their own
-- [x] Order by a calculated column: `orderByCalculated`, and `applyOrder` orders a `@CalculatedColumn` field by its value
-- [x] Generated columns: the `@GeneratedColumn` decorator, a `@Column` that TypeORM reads and never writes
-- [x] `tableHelper(Entity, alias)` writes the database names of renamed columns
-
 ## License
 
 [MIT](./LICENSE)

package/dist/extensions/calculated-column.extension.d.ts

@@ -1,6 +1,6 @@
-import { ObjectLiteral, SelectQueryBuilder } from 'typeorm';
-/** `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>);
+import { ObjectLiteral } from 'typeorm';
+import { CalculatedSelection } from '../utils/calculated-column.utils';
+export type { CalculatedSelection };
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
     interface SelectQueryBuilder<Entity extends ObjectLiteral> {
         /**

package/dist/extensions/calculated-column.extension.js

@@ -7,27 +7,14 @@ const calculated_column_utils_1 = require("../utils/calculated-column.utils");
 const extension = {
     prototype: {
         addSelectCalculated(selection, property, alias) {
-            return addSelectCalculated(this, selection, property, alias);
+            return (0, calculated_column_utils_1.addSelectCalculatedColumn)(this, selection, property, alias, 'addSelectCalculated');
         },
         orderByCalculated(property, order, nulls, alias) {
-            return attachOrderByCalculated(this, 'orderBy', property, order, nulls, alias);
+            return (0, calculated_column_utils_1.orderByCalculatedColumn)(this, 'orderBy', property, order, nulls, alias, 'orderByCalculated');
         },
         addOrderByCalculated(property, order, nulls, alias) {
-            return attachOrderByCalculated(this, 'addOrderBy', property, order, nulls, alias);
+            return (0, calculated_column_utils_1.orderByCalculatedColumn)(this, 'addOrderBy', property, order, nulls, alias, 'addOrderByCalculated');
         },
     },
 };
 (0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
-// implementation
-function addSelectCalculated(builder, selection, property, aliasName) {
-    const { key } = (0, calculated_column_utils_1.resolveCalculatedColumn)(builder, property, aliasName, 'addSelectCalculated');
-    // 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);
-}
-function attachOrderByCalculated(builder, method, property, order, nulls, aliasName) {
-    const orderAlias = (0, calculated_column_utils_1.selectCalculatedForOrder)(builder, property, aliasName, `${method}Calculated`);
-    return builder[method](orderAlias, order, nulls);
-}

package/dist/extensions/cursor-pagination.extension.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidCursorError = void 0;
 const SelectQueryBuilder_1 = require("typeorm/query-builder/SelectQueryBuilder");
-const constants_1 = require("../constants");
+const pagination_utils_1 = require("../utils/pagination.utils");
 const prototype_utils_1 = require("../utils/prototype.utils");
 const order_utils_1 = require("../utils/order.utils");
 const where_utils_1 = require("../utils/where.utils");
@@ -45,14 +45,11 @@ function getCursorKeys(builder, orderBy) {
     }
     return keys;
 }
-const getPageSize = (pageSize) => typeof pageSize === 'number' && Number.isFinite(pageSize) && pageSize >= 1
-    ? Math.floor(pageSize)
-    : constants_1.defaultPageSize;
 async function getManyWithCursor(builder, cursorFilter, options) {
     const { orderBy, useTakeAndSkip = false } = options !== null && options !== void 0 ? options : {};
     const keys = getCursorKeys(builder, orderBy);
     const fields = keys.map((key) => key.column.propertyPath);
-    const pageSize = getPageSize(cursorFilter === null || cursorFilter === void 0 ? void 0 : cursorFilter.pageSize);
+    const pageSize = (0, pagination_utils_1.normalizePageSize)(cursorFilter === null || cursorFilter === void 0 ? void 0 : cursorFilter.pageSize);
     const query = builder.clone();
     const alias = query.alias;
     const driver = query.connection.driver.options.type;
@@ -83,12 +80,7 @@ async function getManyWithCursor(builder, cursorFilter, options) {
         .map((key, i) => ({ key, i }))
         .filter(({ key }) => key.column.isPrimary)
         .map(({ key, i }) => ({ column: key.column, keyAlias: keyAliases[i] }));
-    if (useTakeAndSkip) {
-        query.take(pageSize + 1);
-    }
-    else {
-        query.limit(pageSize + 1);
-    }
+    (0, pagination_utils_1.setPageLimit)(query, pageSize + 1, useTakeAndSkip);
     const { entities, raw } = await query.getRawAndEntities();
     const list = entities.slice(0, pageSize);
     if (entities.length <= pageSize) {

package/dist/extensions/get-many-with-totals.extension.js

@@ -31,8 +31,7 @@ const extension = {
  * runner, so the one that starts second finds a transaction active and does not open its own.
  */
 function canCountConcurrently(builder) {
-    const queryBuilder = builder;
-    return !queryBuilder.queryRunner;
+    return !(0, query_builder_utils_1.getQueryRunner)(builder);
 }
 function getManyWithTotals(builder, paginationFilter, options) {
     return readWithTotals(builder, paginationFilter, options, {
@@ -70,15 +69,9 @@ async function readWithTotals(builder, paginationFilter, options, read) {
         }
         const paged = builder.applyPaginationFilter(paginationFilter, paginationOptions);
         if (probeForMore) {
-            const probeLimit = limit + 1;
             const { useTakeAndSkip = constants_1.defaultUseTakeAndSkip } = paginationOptions;
             // replaces the limit applyPaginationFilter just set, keeping its offset
-            if (useTakeAndSkip) {
-                paged.take(probeLimit);
-            }
-            else {
-                paged.limit(probeLimit);
-            }
+            (0, pagination_utils_1.setPageLimit)(paged, limit + 1, useTakeAndSkip);
         }
         return read.rows(paged);
     };
@@ -140,9 +133,6 @@ async function bothOrFirstError(first, second) {
 function settle(promise) {
     return promise.then((value) => ({ fulfilled: true, value }), (reason) => ({ fulfilled: false, reason }));
 }
-function getQueryRunner(builder) {
-    return builder.queryRunner;
-}
 /**
  * Counts the rows of a raw query without its pagination and ORDER BY. The query goes into a
  * subquery, so the count is that of its result rows whatever it groups or filters. A
@@ -151,13 +141,7 @@ function getQueryRunner(builder) {
  */
 async function countRawRows(builder, countExpression) {
     var _a;
-    const unpaged = cloneForCount(builder)
-        .orderBy()
-        .offset(undefined)
-        .limit(undefined)
-        .skip(undefined)
-        .take(undefined)
-        .setOption('disable-global-order');
+    const unpaged = (0, query_builder_utils_1.withoutPaging)(cloneForCount(builder));
     let counting;
     if (countExpression) {
         // the expression counts on its own: DISTINCT ON next to an aggregate is an error
@@ -168,7 +152,7 @@ async function countRawRows(builder, countExpression) {
     else {
         // on the builder's query runner, if it has one: inside its transaction
         const counter = builder.connection
-            .createQueryBuilder(getQueryRunner(builder))
+            .createQueryBuilder((0, query_builder_utils_1.getQueryRunner)(builder))
             .select('COUNT(*)', 'count')
             .from(`(${unpaged.getQuery()})`, 'counted')
             .setParameters(unpaged.getParameters());

package/dist/extensions/join-lateral.extension.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const typeorm_1 = require("typeorm");
 const parameter_utils_1 = require("../utils/parameter.utils");
+const query_builder_utils_1 = require("../utils/query-builder.utils");
 const prototype_utils_1 = require("../utils/prototype.utils");
 /* eslint-enable @typescript-eslint/no-empty-interface, @typescript-eslint/no-unused-vars */
 // patching
@@ -32,18 +33,15 @@ function toLateralSql(builder, subQuery) {
         return { sql: `(${subQuery})`, parameters: {} };
     }
     const subBuilder = typeof subQuery === 'function' ? subQuery(detachedSubQuery(builder)) : subQuery;
-    const query = subBuilder.getQuery();
-    // a builder from subQuery() wraps itself in parentheses, any other doesn't
-    const wrapped = subBuilder.expressionMap.subQuery ? query : `(${query})`;
-    const [sql, parameters] = (0, parameter_utils_1.withUniqueParameterNames)(wrapped, subBuilder.getParameters());
-    return { sql, parameters };
+    const [sql, parameters] = (0, parameter_utils_1.toSubQuerySql)(subBuilder);
+    return { sql: `(${sql})`, parameters };
 }
 /**
  * A subquery builder for a factory, as TypeORM's `subQuery()` but without a parent: TypeORM's would
  * set the factory's parameters on the outer query under their own names, before they can be renamed.
  */
 function detachedSubQuery(builder) {
-    const queryRunner = builder.queryRunner;
+    const queryRunner = (0, query_builder_utils_1.getQueryRunner)(builder);
     const subQuery = builder.connection.createQueryBuilder(queryRunner);
     subQuery.expressionMap.subQuery = true;
     return subQuery;

package/dist/extensions/period-filter.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 period_utils_1 = require("../utils/period.utils");
@@ -14,12 +12,4 @@ const extension = {
         },
     },
 };
-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);

package/dist/extensions/typed/index.d.ts

@@ -17,4 +17,5 @@ export * from './typed-where/typed-where-lower.extension';
 export * from './typed-where/typed-where-similar.extension';
 export * from './typed-returning/typed-returning.extension';
 export * from './typed-order-by/typed-order-by-array-position.extension';
+export * from './typed-calculated/typed-calculated-column.extension';
 export * from './typed-root.extension';

package/dist/extensions/typed/index.js

@@ -34,4 +34,5 @@ __exportStar(require("./typed-where/typed-where-lower.extension"), exports);
 __exportStar(require("./typed-where/typed-where-similar.extension"), exports);
 __exportStar(require("./typed-returning/typed-returning.extension"), exports);
 __exportStar(require("./typed-order-by/typed-order-by-array-position.extension"), exports);
+__exportStar(require("./typed-calculated/typed-calculated-column.extension"), exports);
 __exportStar(require("./typed-root.extension"), exports);

package/dist/extensions/typed/typed-calculated/typed-calculated-column.extension.d.ts

@@ -0,0 +1,25 @@
+import { ObjectLiteral } from 'typeorm';
+import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
+import { CalculatedSelection } from '../../../utils/calculated-column.utils';
+type CalculatedPropertyCallback<Type extends ObjectLiteral> = (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType;
+export interface TypedCalculatedColumnMethods<Entity extends ObjectLiteral> {
+    /**
+     * `addSelectCalculated` with the `@CalculatedColumn` picked by a typed callback: `(user) => user.imagesCount`, or
+     * `(q) => q.owner.imagesCount` for the entity of the joined alias `owner`. The callback starts at the root set with
+     * `typed<Root>()`, else at the entity. Throws a `TypeError` if the property isn't a `@CalculatedColumn`.
+     */
+    addSelectCalculatedTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>, SubEntity extends ObjectLiteral = ObjectLiteral>(selection: CalculatedSelection<SubEntity>, property: CalculatedPropertyCallback<Type>): this;
+    /**
+     * `orderByCalculated` with the `@CalculatedColumn` picked by a typed callback: ORDER BY its value, selected with
+     * `addSelectCalculated` / `addSelectCalculatedTyped` first. Replaces the previous ORDER BY, like `orderBy`.
+     */
+    orderByCalculatedTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(property: CalculatedPropertyCallback<Type>, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST'): this;
+    /** `addOrderByCalculated` with the `@CalculatedColumn` picked by a typed callback, like `addOrderBy`. */
+    addOrderByCalculatedTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(property: CalculatedPropertyCallback<Type>, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST'): this;
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedCalculatedColumnMethods<Entity> {
+    }
+}
+export {};

package/dist/extensions/typed/typed-calculated/typed-calculated-column.extension.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SelectQueryBuilder_1 = require("typeorm/query-builder/SelectQueryBuilder");
+const calculated_column_utils_1 = require("../../../utils/calculated-column.utils");
+const query_builder_utils_1 = require("../../../utils/query-builder.utils");
+const prototype_utils_1 = require("../../../utils/prototype.utils");
+/* eslint-enable @typescript-eslint/no-empty-interface */
+// patching
+const createOrderByCalculatedTypedMethod = (method) => function (property, order, nulls) {
+    const methodName = `${method}CalculatedTyped`;
+    const { aliasName, propertyPath } = (0, query_builder_utils_1.resolveTypedProperty)(this, property, methodName);
+    return (0, calculated_column_utils_1.orderByCalculatedColumn)(this, method, propertyPath, order, nulls, aliasName, methodName);
+};
+const extension = {
+    prototype: {
+        addSelectCalculatedTyped(selection, property) {
+            const { aliasName, propertyPath } = (0, query_builder_utils_1.resolveTypedProperty)(this, property, 'addSelectCalculatedTyped');
+            return (0, calculated_column_utils_1.addSelectCalculatedColumn)(this, selection, propertyPath, aliasName, 'addSelectCalculatedTyped');
+        },
+        orderByCalculatedTyped: createOrderByCalculatedTypedMethod('orderBy'),
+        addOrderByCalculatedTyped: createOrderByCalculatedTypedMethod('addOrderBy'),
+    },
+};
+(0, prototype_utils_1.patchPrototype)(SelectQueryBuilder_1.SelectQueryBuilder, extension);

package/dist/extensions/typed/typed-having/typed-having.extension.js

@@ -33,7 +33,7 @@ function attachTypedHaving(builder, method, aggregate, selection, conditions, pa
     else {
         // a path into a JSON column is cast: to a number to add it up, and for MIN / MAX to the type of the
         // value it is compared with, as in whereTyped; a count needs no cast
-        const compared = (0, where_utils_1.isParamsObject)(parameters) ? Object.values(parameters)[0] : parameters;
+        const compared = (0, where_utils_1.getComparedValue)(parameters);
         const value = aggregate === 'SUM' || aggregate === 'AVG' ? 0 : aggregate === 'MIN' || aggregate === 'MAX' ? compared : undefined;
         argument = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, selection, methodName, { value });
     }

package/dist/extensions/typed/typed-joins/typed-join-and-map.extension.js

@@ -2,19 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
+const prototype_utils_1 = require("../../../utils/prototype.utils");
 // patching
-typeorm_1.SelectQueryBuilder.prototype.leftJoinAndMapOneTyped = function (mapToProperty, entity, alias, condition, parameters) {
-    return addJoinAndMap(this, 'leftJoinAndMapOne', mapToProperty, entity, alias, condition, parameters);
+const createJoinAndMapTypedMethod = (method) => function (mapToProperty, entity, alias, condition, parameters) {
+    return addJoinAndMap(this, method, mapToProperty, entity, alias, condition, parameters);
 };
-typeorm_1.SelectQueryBuilder.prototype.innerJoinAndMapOneTyped = function (mapToProperty, entity, alias, condition, parameters) {
-    return addJoinAndMap(this, 'innerJoinAndMapOne', mapToProperty, entity, alias, condition, parameters);
-};
-typeorm_1.SelectQueryBuilder.prototype.leftJoinAndMapManyTyped = function (mapToProperty, entity, alias, condition, parameters) {
-    return addJoinAndMap(this, 'leftJoinAndMapMany', mapToProperty, entity, alias, condition, parameters);
-};
-typeorm_1.SelectQueryBuilder.prototype.innerJoinAndMapManyTyped = function (mapToProperty, entity, alias, condition, parameters) {
-    return addJoinAndMap(this, 'innerJoinAndMapMany', mapToProperty, entity, alias, condition, parameters);
+const extension = {
+    prototype: {
+        leftJoinAndMapOneTyped: createJoinAndMapTypedMethod('leftJoinAndMapOne'),
+        innerJoinAndMapOneTyped: createJoinAndMapTypedMethod('innerJoinAndMapOne'),
+        leftJoinAndMapManyTyped: createJoinAndMapTypedMethod('leftJoinAndMapMany'),
+        innerJoinAndMapManyTyped: createJoinAndMapTypedMethod('innerJoinAndMapMany'),
+    },
 };
+(0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
 function addJoinAndMap(query, method, mapToProperty, entity, alias, condition, parameters) {
     // `() => query.alias`: `(q) => q.photo.owner` needs no main alias, only `(u) => u.profile` does
     const key = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(mapToProperty, () => query.alias, false);

package/dist/extensions/typed/typed-joins/typed-joins.extension.js

@@ -2,31 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
+const prototype_utils_1 = require("../../../utils/prototype.utils");
 // patching
-typeorm_1.SelectQueryBuilder.prototype.leftJoinTyped = function (selection, alias, condition, parameters) {
-    if (typeof selection === 'function') {
-        return addJoin(this, 'leftJoin', selection, alias, condition, parameters);
-    }
-    return this;
+const createJoinTypedMethod = (method) => function (selection, alias, condition, parameters) {
+    return addJoin(this, method, selection, alias, condition, parameters);
 };
-typeorm_1.SelectQueryBuilder.prototype.innerJoinTyped = function (selection, alias, condition, parameters) {
-    if (typeof selection === 'function') {
-        return addJoin(this, 'innerJoin', selection, alias, condition, parameters);
-    }
-    return this;
-};
-typeorm_1.SelectQueryBuilder.prototype.leftJoinAndSelectTyped = function (selection, alias, condition, parameters) {
-    if (typeof selection === 'function') {
-        return addJoin(this, 'leftJoinAndSelect', selection, alias, condition, parameters);
-    }
-    return this;
-};
-typeorm_1.SelectQueryBuilder.prototype.innerJoinAndSelectTyped = function (selection, alias, condition, parameters) {
-    if (typeof selection === 'function') {
-        return addJoin(this, 'innerJoinAndSelect', selection, alias, condition, parameters);
-    }
-    return this;
+const extension = {
+    prototype: {
+        leftJoinTyped: createJoinTypedMethod('leftJoin'),
+        innerJoinTyped: createJoinTypedMethod('innerJoin'),
+        leftJoinAndSelectTyped: createJoinTypedMethod('leftJoinAndSelect'),
+        innerJoinAndSelectTyped: createJoinTypedMethod('innerJoinAndSelect'),
+    },
 };
+(0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
 function addJoin(query, method, selection, alias, condition, parameters) {
     // `() => query.alias`: `(q) => q.base.images` needs no main alias, only `(u) => u.images` does
     const key = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(selection, () => query.alias, false);

package/dist/extensions/typed/typed-order-by/typed-order-by.extension.js

@@ -3,25 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
 const query_builder_utils_1 = require("../../../utils/query-builder.utils");
-const sql_utils_1 = require("../../../utils/sql.utils");
+const prototype_utils_1 = require("../../../utils/prototype.utils");
 // patching and implementation
-typeorm_1.SelectQueryBuilder.prototype.orderByTyped = function (selection, order, nulls, options) {
-    if (selection instanceof proxy_key_utils_1.KeyHolder) {
-        return this.orderBy(selection.toSql(undefined, options === null || options === void 0 ? void 0 : options.useQuotes, (0, sql_utils_1.getDriverType)(this)), order, nulls);
-    }
-    if (typeof selection === 'function') {
-        const key = (0, query_builder_utils_1.getTypedSelectionKey)(this, selection, options === null || options === void 0 ? void 0 : options.useQuotes, 'orderByTyped');
-        return this.orderBy(key, order, nulls);
+const createOrderByTypedMethod = (method) => function (selection, order, nulls, options) {
+    if (selection instanceof proxy_key_utils_1.KeyHolder || typeof selection === 'function') {
+        const key = (0, query_builder_utils_1.getTypedSelectionKey)(this, selection, options === null || options === void 0 ? void 0 : options.useQuotes, `${method}Typed`);
+        return this[method](key, order, nulls);
     }
     return this;
 };
-typeorm_1.SelectQueryBuilder.prototype.addOrderByTyped = function (selection, order, nulls, options) {
-    if (selection instanceof proxy_key_utils_1.KeyHolder) {
-        return this.addOrderBy(selection.toSql(undefined, options === null || options === void 0 ? void 0 : options.useQuotes, (0, sql_utils_1.getDriverType)(this)), order, nulls);
-    }
-    if (typeof selection === 'function') {
-        const key = (0, query_builder_utils_1.getTypedSelectionKey)(this, selection, options === null || options === void 0 ? void 0 : options.useQuotes, 'addOrderByTyped');
-        return this.addOrderBy(key, order, nulls);
-    }
-    return this;
+const extension = {
+    prototype: {
+        orderByTyped: createOrderByTypedMethod('orderBy'),
+        addOrderByTyped: createOrderByTypedMethod('addOrderBy'),
+    },
 };
+(0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);

package/dist/extensions/typed/typed-returning/typed-returning.extension.js

@@ -27,12 +27,4 @@ const extension = {
         },
     },
 };
-const queryBuilders = [
-    typeorm_1.InsertQueryBuilder,
-    typeorm_1.UpdateQueryBuilder,
-    typeorm_1.DeleteQueryBuilder,
-    SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder,
-];
-queryBuilders.forEach((builder) => {
-    (0, prototype_utils_1.patchPrototype)(builder, extension);
-});
+(0, prototype_utils_1.patchPrototypes)([typeorm_1.InsertQueryBuilder, typeorm_1.UpdateQueryBuilder, typeorm_1.DeleteQueryBuilder, SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder], extension);

package/dist/extensions/typed/typed-select/typed-select.extension.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
 const query_builder_utils_1 = require("../../../utils/query-builder.utils");
-const sql_utils_1 = require("../../../utils/sql.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");
 // patching
 const extension = {
@@ -23,16 +22,11 @@ const extension = {
 (0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
 // implementation
 const attachSelectMethod = (query, method, selection, selectionAliasName, useQuotes) => {
-    if (selection instanceof proxy_key_utils_1.KeyHolder) {
-        return query[method](selection.toSql(undefined, useQuotes, (0, sql_utils_1.getDriverType)(query)), selectionAliasName);
-    }
     if (Array.isArray(selection)) {
-        const arrayOfKeys = selection.flatMap((select) => select instanceof proxy_key_utils_1.KeyHolder
-            ? (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(select, () => query.alias, useQuotes, (0, sql_utils_1.getDriverType)(query))
-            : (0, query_builder_utils_1.getTypedSelectionKey)(query, select, useQuotes, `${method}Typed`));
+        const arrayOfKeys = selection.flatMap((select) => (0, query_builder_utils_1.getTypedSelectionKey)(query, select, useQuotes, `${method}Typed`));
         return query[method](arrayOfKeys);
     }
-    else if (typeof selection === 'function') {
+    else if (selection instanceof proxy_key_utils_1.KeyHolder || typeof selection === 'function') {
         const keyArrayOrSingleKey = (0, query_builder_utils_1.getTypedSelectionKey)(query, selection, useQuotes, `${method}Typed`);
         if (Array.isArray(keyArrayOrSingleKey)) {
             return query[method](keyArrayOrSingleKey);

package/dist/extensions/typed/typed-where/typed-period-filter.extension.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("../../period-filter.extension");
-const typeorm_1 = require("typeorm");
-const SoftDeleteQueryBuilder_1 = require("typeorm/query-builder/SoftDeleteQueryBuilder");
 const query_builder_utils_1 = require("../../../utils/query-builder.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");
 const period_utils_1 = require("../../../utils/period.utils");
@@ -16,12 +14,4 @@ const extension = {
         },
     },
 };
-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);

package/dist/extensions/typed/typed-where/typed-where-array.extension.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("../../where-array.extension");
-const typeorm_1 = require("typeorm");
-const SoftDeleteQueryBuilder_1 = require("typeorm/query-builder/SoftDeleteQueryBuilder");
 const query_builder_utils_1 = require("../../../utils/query-builder.utils");
 const sql_utils_1 = require("../../../utils/sql.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");
+const typed_where_utils_1 = require("../../../utils/typed-where.utils");
 /* eslint-enable @typescript-eslint/no-empty-interface */
 // patching
 const createWhereArrayTypedMethod = (method) => function (where, values, arrayType) {
@@ -24,26 +23,13 @@ const extension = {
         orWhereArrayOverlapsTyped: createWhereArrayTypedMethod('orWhereArrayOverlaps'),
     },
 };
-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 attachWhereArrayTyped(builder, method, where, values, arrayType) {
-    if (typeof where !== 'function') {
-        return builder;
-    }
-    const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`);
-    if ((0, query_builder_utils_1.isTypedJsonPath)(builder, where)) {
+    if (typeof where === 'function' && (0, query_builder_utils_1.isTypedJsonPath)(builder, where)) {
         return attachWhereJsonArray(builder, method, where, values, arrayType);
     }
-    // .andWhereArrayContains(`"table"."column"`, ['value'])
-    return builder[method](key, values, arrayType);
+    return (0, typed_where_utils_1.attachTypedColumnWhere)(builder, method, where, undefined, values, arrayType);
 }
 const JSON_ARRAY_METHOD = /^(where|andWhere|orWhere)Array(Contains|ContainedBy|Overlaps)$/;
 const JSON_ARRAY_OPERATORS = { Contains: '@>', ContainedBy: '<@', Overlaps: '?|' };

package/dist/extensions/typed/typed-where/typed-where-ilike.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 query_builder_utils_1 = require("../../../utils/query-builder.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");
 const sql_utils_1 = require("../../../utils/sql.utils");
@@ -43,15 +41,7 @@ const extension = {
         orWhereSearchTyped: createWhereSearchTypedMethod('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
 /** Quoted columns and raw expressions of the search selectors, in order. */
 function getSearchColumns(builder, selectors, methodName) {

package/dist/extensions/typed/typed-where/typed-where-is-any.extension.js

@@ -1,14 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("../../where-is-any.extension");
-const typeorm_1 = require("typeorm");
-const SoftDeleteQueryBuilder_1 = require("typeorm/query-builder/SoftDeleteQueryBuilder");
-const query_builder_utils_1 = require("../../../utils/query-builder.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");
+const typed_where_utils_1 = require("../../../utils/typed-where.utils");
 /* eslint-enable @typescript-eslint/no-empty-interface */
 // patching
 const createWhereIsAnyTypedMethod = (method) => function (where, array, arrayType) {
-    return attachWhereIsAnyTyped(this, method, where, array, arrayType);
+    return (0, typed_where_utils_1.attachTypedColumnWhere)(this, method, where, { value: array }, array, arrayType);
 };
 const extension = {
     prototype: {
@@ -20,21 +18,4 @@ const extension = {
         orWhereIsNotAnyTyped: createWhereIsAnyTypedMethod('orWhereIsNotAny'),
     },
 };
-const queryBuilders = [
-    typeorm_1.SelectQueryBuilder,
-    typeorm_1.UpdateQueryBuilder,
-    typeorm_1.DeleteQueryBuilder,
-    SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder,
-];
-queryBuilders.forEach((builder) => {
-    (0, prototype_utils_1.patchPrototype)(builder, extension);
-});
-// implementation
-function attachWhereIsAnyTyped(builder, method, where, array, arrayType) {
-    if (typeof where !== 'function') {
-        return builder;
-    }
-    const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`, { value: array });
-    // .andWhere(`"table"."column" = ANY(:param)`, { param: ['value'] })
-    return builder[method](key, array, arrayType);
-}
+(0, prototype_utils_1.patchPrototypes)(prototype_utils_1.WHERE_QUERY_BUILDERS, extension);

package/dist/extensions/typed/typed-where/typed-where-is-distinct-from.extension.js

@@ -1,14 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("../../where-is-distinct-from.extension");
-const typeorm_1 = require("typeorm");
-const SoftDeleteQueryBuilder_1 = require("typeorm/query-builder/SoftDeleteQueryBuilder");
-const query_builder_utils_1 = require("../../../utils/query-builder.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");
+const typed_where_utils_1 = require("../../../utils/typed-where.utils");
 /* eslint-enable @typescript-eslint/no-empty-interface */
 // patching
 const createWhereDistinctTypedMethod = (method) => function (where, value) {
-    return attachWhereDistinctTyped(this, method, where, value);
+    return (0, typed_where_utils_1.attachTypedColumnWhere)(this, method, where, { value }, value);
 };
 const extension = {
     prototype: {
@@ -20,21 +18,4 @@ const extension = {
         orWhereIsNotDistinctFromTyped: createWhereDistinctTypedMethod('orWhereIsNotDistinctFrom'),
     },
 };
-const queryBuilders = [
-    typeorm_1.SelectQueryBuilder,
-    typeorm_1.UpdateQueryBuilder,
-    typeorm_1.DeleteQueryBuilder,
-    SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder,
-];
-queryBuilders.forEach((builder) => {
-    (0, prototype_utils_1.patchPrototype)(builder, extension);
-});
-// implementation
-function attachWhereDistinctTyped(builder, method, where, value) {
-    if (typeof where !== 'function') {
-        return builder;
-    }
-    const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`, { value });
-    // .andWhereIsDistinctFrom(`"table"."column"`, value)
-    return builder[method](key, value);
-}
+(0, prototype_utils_1.patchPrototypes)(prototype_utils_1.WHERE_QUERY_BUILDERS, extension);