typeorm-extensions 1.2.5 → 1.3.0

package/README.md

@@ -35,16 +35,17 @@ const query = myDataSource
   .createQueryBuilder()
   .from(UserEntity, 'users')
   // Join relation defined in entity model
-  .leftJoinTyped(user => users.profile, 'profile')
+  .leftJoinTyped(user => user.images, 'images')
   // Select type-safe properties
   .selectTyped(user => ([
     id: user.id,
     name: user.name,
     email: user.email,
   ]))
-  .whereTyped(user => user.name, 'ILIKE :search', { search: 'John' })
+  .whereTyped(user => user.name, 'ILIKE', { search: 'John' })
+  .andWhereTyped(user => user.metadata, ` ->> 'jsonField' =`, { value: 'some-value' })
   // Order by type-safe own and relation properties
-  .orderByTyped(user => user.profile.avatarUrl, 'ASC', 'NULLS LAST')
+  .orderByTyped(user => user.images.url, 'ASC', 'NULLS LAST')
   // Use pagination as simple as that
   .applyPaginationFilter({ page: 1, pageSize: 10 }, { useTakeAndSkip: true });
 ```
@@ -52,3 +53,10 @@ const query = myDataSource
 ## Documentation
 
 For more information, please refer to the [documentation](https://koenigstag.github.io/typeorm-extensions).
+
+## ToDo list
+
+- [ ] Add tests for pagination and order extensions
+- [ ] Virtual column decorator and its query-builder methods (`addSelectVirtual`, `orderByVirtual`, `getManyWithVirtual`, `getOneWithVirtual`)
+- [ ] Add `withVirtualColumns` option to `findManyWithTotals` method to use `getManyWithVirtual` instead of `getMany`
+- [ ] Add `isVirtual` option to `OrderParam` to indicate usage of `orderByVirtual` method

package/dist/extensions/get-many-with-totals.extension.d.ts

@@ -1,16 +1,2 @@
-import { PaginationFilter } from '../types/interfaces/pagination.interface';
-export type GetManyWithTotalsOptions = {
-    disableTotalsCalculation?: boolean;
-    loadAll?: boolean;
-};
-export interface ListWithTotals<Entity> {
-    list: Entity[];
-    totalCount: number | null;
-    limit: number | null;
-    offset: number | null;
-}
-declare module 'typeorm/query-builder/SelectQueryBuilder' {
-    interface SelectQueryBuilder<Entity> {
-        getManyWithTotals(paginationFilter: PaginationFilter, options?: GetManyWithTotalsOptions): Promise<ListWithTotals<Entity>>;
-    }
-}
+import './declarations/get-many-with-totals.declaration';
+import './pagination.extension';

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

@@ -1,30 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+require("./declarations/get-many-with-totals.declaration");
 const SelectQueryBuilder_1 = require("typeorm/query-builder/SelectQueryBuilder");
 const pagination_utils_1 = require("../utils/pagination.utils");
-SelectQueryBuilder_1.SelectQueryBuilder.prototype.getManyWithTotals = async function (paginationFilter, options) {
-    const { disableTotalsCalculation = false, loadAll = false } = options || {};
+require("./pagination.extension");
+const prototype_utils_1 = require("../utils/prototype.utils");
+// patching
+const extension = {
+    prototype: {
+        getManyWithTotals(paginationFilter, options) {
+            return getManyWithTotals(this, paginationFilter, options);
+        },
+    },
+};
+(0, prototype_utils_1.patchPrototype)(SelectQueryBuilder_1.SelectQueryBuilder, extension);
+// implementation
+async function getManyWithTotals(builder, paginationFilter, options) {
+    const { disableTotalsCalculation = false, loadAll = false, ...paginationOptions } = options || {};
     const { limit, offset } = loadAll
         ? { limit: null, offset: null }
         : (0, pagination_utils_1.getLimitAndOffset)(paginationFilter);
     const requests = [];
     if (!disableTotalsCalculation) {
-        requests[0] = this.getCount();
+        requests[0] = await builder.getCount();
     }
     else {
-        requests[0] = Promise.resolve(null);
+        requests[0] = null;
     }
     if (loadAll) {
-        requests[1] = this.getMany();
+        requests[1] = await builder.getMany();
     }
     else {
-        requests[1] = this.applyPaginationFilter(paginationFilter).getMany();
+        requests[1] = await builder
+            .applyPaginationFilter(paginationFilter, paginationOptions)
+            .getMany();
     }
-    const [totalCount, list] = (await Promise.all(requests));
+    const [total, list] = requests;
     return {
         list,
-        totalCount: totalCount,
+        total,
         limit,
         offset,
     };
-};
+}

package/dist/extensions/index.d.ts

@@ -1,4 +1,5 @@
 export * from './get-many-with-totals.extension';
 export * from './order.extension';
 export * from './pagination.extension';
+export * from './where-is-in.extension';
 export * from './typed';

package/dist/extensions/index.js

@@ -17,4 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./get-many-with-totals.extension"), exports);
 __exportStar(require("./order.extension"), exports);
 __exportStar(require("./pagination.extension"), exports);
+__exportStar(require("./where-is-in.extension"), exports);
 __exportStar(require("./typed"), exports);

package/dist/extensions/order.extension.d.ts

@@ -1,15 +1 @@
-import type { OrderParam, OrderFilter, OrderType } from '../types/interfaces/ordering.interface';
-export type ApplyOrderOptions = {
-    useDoubleQuotes?: boolean;
-    alias?: string;
-    alwaysAliasFields?: string[];
-    resetPreviousOrder?: boolean;
-};
-declare module 'typeorm/query-builder/SelectQueryBuilder' {
-    interface SelectQueryBuilder<Entity> {
-        applyOrder<OrderEntity>(orderBy: OrderParam<OrderEntity>, options?: ApplyOrderOptions): SelectQueryBuilder<Entity>;
-        applyOrderFilter<OrderEntity>(orderFilter: OrderFilter<OrderEntity>, options?: ApplyOrderOptions): SelectQueryBuilder<Entity>;
-    }
-}
-export declare const getOrderOption: <OrderEntity>(orderBy: OrderParam<OrderEntity>, defaultAlias: string, options?: ApplyOrderOptions) => OrderType;
-export {};
+import './declarations/order.declaration';

package/dist/extensions/order.extension.js

@@ -1,10 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOrderOption = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+require("./declarations/order.declaration");
 const SelectQueryBuilder_1 = require("typeorm/query-builder/SelectQueryBuilder");
 const constants_1 = require("../constants");
 const common_utils_1 = require("../utils/common.utils");
 const identifier_utils_1 = require("../utils/identifier.utils");
+const prototype_utils_1 = require("../utils/prototype.utils");
+// patching
+const extension = {
+    prototype: {
+        applyOrder(orderBy, options) {
+            return applyOrder(this, orderBy, options);
+        },
+        applyOrderFilter(orderFilter, options) {
+            return applyOrderFilter(this, orderFilter, options);
+        },
+    },
+};
+(0, prototype_utils_1.patchPrototype)(SelectQueryBuilder_1.SelectQueryBuilder, extension);
+// implementation
 const alwaysAliasWhiteList = [
     'id',
     'createdAt',
@@ -14,29 +29,18 @@ const alwaysAliasWhiteList = [
     'deletedAt',
     'deleted_at',
 ];
-SelectQueryBuilder_1.SelectQueryBuilder.prototype.applyOrder = function (orderBy, options) {
-    const { resetPreviousOrder = false } = options !== null && options !== void 0 ? options : {};
-    const orderOption = (0, exports.getOrderOption)(orderBy, this.alias, options);
-    const query = resetPreviousOrder ? this.orderBy() : this;
-    return query.addOrderBy(orderOption.selector, orderOption.order, orderOption.nulls);
-};
-SelectQueryBuilder_1.SelectQueryBuilder.prototype.applyOrderFilter = function (orderFilter, options) {
-    if (!(0, common_utils_1.isNil)(orderFilter === null || orderFilter === void 0 ? void 0 : orderFilter.orderBy)) {
-        return orderFilter.orderBy.reduce((acc, order, index) => acc.applyOrder(order, {
-            ...options,
-            resetPreviousOrder: index === 0 ? options === null || options === void 0 ? void 0 : options.resetPreviousOrder : false,
-        }), this);
-    }
-    return this;
-};
-const getOrderOption = (orderBy, defaultAlias, options) => {
+function getOrderOption(orderBy, defaultAlias, options) {
     const { useDoubleQuotes = constants_1.defaultUseDoubleQuotes, alias: customAlias, alwaysAliasFields = alwaysAliasWhiteList, } = options !== null && options !== void 0 ? options : {};
     const { field, direction = constants_1.defaultOrderDirection, nulls: nullsOrder = constants_1.defaultNullsOrder, } = orderBy;
     const alias = customAlias !== null && customAlias !== void 0 ? customAlias : (alwaysAliasFields.includes(field) ? defaultAlias : undefined);
     const identifier = new identifier_utils_1.Identifier(field, alias, useDoubleQuotes);
     const selector = identifier.fieldIdentifier();
-    const order = direction.toUpperCase();
-    const nulls = nullsOrder
+    const order = typeof direction === 'number'
+        ? direction === -1
+            ? 'DESC'
+            : 'ASC'
+        : direction.toUpperCase();
+    const nulls = nullsOrder && /first|last/i.test(nullsOrder)
         ? `NULLS ${nullsOrder.toUpperCase()}`
         : undefined;
     return {
@@ -44,5 +48,19 @@ const getOrderOption = (orderBy, defaultAlias, options) => {
         order,
         nulls,
     };
-};
-exports.getOrderOption = getOrderOption;
+}
+function applyOrder(builder, orderBy, options) {
+    const { resetPreviousOrder = false } = options !== null && options !== void 0 ? options : {};
+    const orderOption = getOrderOption(orderBy, builder.alias, options);
+    const query = resetPreviousOrder ? builder.orderBy() : builder;
+    return query.addOrderBy(orderOption.selector, orderOption.order, orderOption.nulls);
+}
+function applyOrderFilter(builder, orderFilter, options) {
+    if ((orderFilter === null || orderFilter === void 0 ? void 0 : orderFilter.orderBy) && !(0, common_utils_1.isNil)(orderFilter === null || orderFilter === void 0 ? void 0 : orderFilter.orderBy)) {
+        return orderFilter.orderBy.reduce((acc, order, index) => acc.applyOrder(order, {
+            ...options,
+            resetPreviousOrder: index === 0 ? options === null || options === void 0 ? void 0 : options.resetPreviousOrder : false,
+        }), builder);
+    }
+    return builder;
+}

package/dist/extensions/pagination.extension.d.ts

@@ -1,10 +1 @@
-import type { PaginationFilter } from '../types/interfaces/pagination.interface';
-export type ApplyPaginationOptions = {
-    useTakeAndSkip?: boolean;
-};
-declare module 'typeorm/query-builder/SelectQueryBuilder' {
-    interface SelectQueryBuilder<Entity> {
-        applyPaginationFilter(paginationFilter: PaginationFilter, options?: ApplyPaginationOptions): SelectQueryBuilder<Entity>;
-    }
-}
-export {};
+import './declarations/pagination.declaration';

package/dist/extensions/pagination.extension.js

@@ -1,13 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+require("./declarations/pagination.declaration");
 const SelectQueryBuilder_1 = require("typeorm/query-builder/SelectQueryBuilder");
 const constants_1 = require("../constants");
 const pagination_utils_1 = require("../utils/pagination.utils");
-SelectQueryBuilder_1.SelectQueryBuilder.prototype.applyPaginationFilter = function (paginationFilter, options) {
+const prototype_utils_1 = require("../utils/prototype.utils");
+// patching
+const extension = {
+    prototype: {
+        applyPaginationFilter(paginationFilter, options) {
+            return applyPaginationFilter(this, paginationFilter, options);
+        },
+    },
+};
+(0, prototype_utils_1.patchPrototype)(SelectQueryBuilder_1.SelectQueryBuilder, extension);
+// implementation
+function applyPaginationFilter(builder, paginationFilter, options) {
     const { useTakeAndSkip = constants_1.defaultUseTakeAndSkip } = options || {};
     const { limit, offset } = (0, pagination_utils_1.getLimitAndOffset)(paginationFilter);
     if (useTakeAndSkip) {
-        return this.take(limit).skip(offset);
+        return builder.take(limit).skip(offset);
     }
-    return this.limit(limit).offset(offset);
-};
+    return builder.limit(limit).offset(offset);
+}

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

@@ -3,5 +3,4 @@ export * from './typed-joins/typed-joins.extension';
 export * from './typed-order-by/typed-order-by.extension';
 export * from './typed-select/typed-select.extension';
 export * from './typed-where/typed-where.extension';
-export * from './typeorm-querybuilder.types';
-export * from './typeorm.types';
+export * from './typed-where/typed-where-is-in.extension';

package/dist/extensions/typed/index.js

@@ -22,6 +22,4 @@ __exportStar(require("./typed-joins/typed-joins.extension"), exports);
 __exportStar(require("./typed-order-by/typed-order-by.extension"), exports);
 __exportStar(require("./typed-select/typed-select.extension"), exports);
 __exportStar(require("./typed-where/typed-where.extension"), exports);
-// Types
-__exportStar(require("./typeorm-querybuilder.types"), exports);
-__exportStar(require("./typeorm.types"), exports);
+__exportStar(require("./typed-where/typed-where-is-in.extension"), exports);

package/dist/extensions/typed/typed-distinct/typed-distinct.extension.d.ts

@@ -1,14 +1 @@
-import { ObjectLiteral } from 'typeorm';
-import { ColumnValueType } from '../typeorm.types';
-declare module 'typeorm/query-builder/SelectQueryBuilder' {
-    interface SelectQueryBuilder<Entity> {
-        /**
-         * Sets the distinct on clause for Postgres.
-         */
-        distinctOnTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, ...distinctOn: Array<(proxy: Type) => ColumnValueType>): SelectQueryBuilder<Entity>;
-        /**
-         * Sets the distinct on clause for Postgres.
-         */
-        distinctOnTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, distinctOn: (proxy: Type) => Array<ColumnValueType>): SelectQueryBuilder<Entity>;
-    }
-}
+import '../../declarations/typed/typed-distinct.declaration';

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

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+require("../../declarations/typed/typed-distinct.declaration");
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
+// patching and implementation
 typeorm_1.SelectQueryBuilder.prototype.distinctOnTyped = function (...distinctOn) {
     if (Array.isArray(distinctOn) && distinctOn.length) {
-        const keys = distinctOn.map((callback) => (0, proxy_key_utils_1.getSqlKey)(callback, this.alias)).flat(3);
+        const keys = distinctOn.map((callback) => (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(callback, this.alias)).flat();
         return this.distinctOn(keys);
     }
     return this;

package/dist/extensions/typed/typed-joins/typed-joins.extension.d.ts

@@ -1,10 +1 @@
-import { ObjectLiteral } from 'typeorm';
-import { RelationalKeyProxyCallback } from '../typeorm-querybuilder.types';
-declare module 'typeorm/query-builder/SelectQueryBuilder' {
-    interface SelectQueryBuilder<Entity> {
-        leftJoinTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): SelectQueryBuilder<Entity>;
-        innerJoinTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): SelectQueryBuilder<Entity>;
-        leftJoinAndSelectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): SelectQueryBuilder<Entity>;
-        innerJoinAndSelectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): SelectQueryBuilder<Entity>;
-    }
-}
+import '../../declarations/typed/typed-joins.declaration';

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

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+require("../../declarations/typed/typed-joins.declaration");
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
+// patching
 typeorm_1.SelectQueryBuilder.prototype.leftJoinTyped = function (selection, alias, condition, parameters) {
     if (typeof selection === 'function') {
         return addJoin(this, 'leftJoin', selection, alias, condition, parameters);
@@ -27,6 +29,6 @@ typeorm_1.SelectQueryBuilder.prototype.innerJoinAndSelectTyped = function (selec
     return this;
 };
 function addJoin(query, method, selection, alias, condition, parameters) {
-    const key = (0, proxy_key_utils_1.getSqlKey)(selection, query.alias);
+    const key = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(selection, query.alias);
     return query[method](key, alias, condition, parameters);
 }

package/dist/extensions/typed/typed-order-by/typed-order-by.extension.d.ts

@@ -1,17 +1 @@
-import { ObjectLiteral } from 'typeorm';
-import { ColumnValueType } from '../typeorm.types';
-import { KeyHolder } from '../typeorm-querybuilder.types';
-declare module 'typeorm/query-builder/SelectQueryBuilder' {
-    interface SelectQueryBuilder<Entity> {
-        /**
-         * Sets ORDER BY condition in the query builder.
-         * If you had previously ORDER BY expression defined,
-         * calling this function will override previously set ORDER BY conditions.
-         */
-        orderByTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: (proxy: Type) => ColumnValueType | KeyHolder, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST'): SelectQueryBuilder<Entity>;
-        /**
-         * Adds ORDER BY condition in the query builder.
-         */
-        addOrderByTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: (proxy: Type) => ColumnValueType | KeyHolder, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST'): SelectQueryBuilder<Entity>;
-    }
-}
+import '../../declarations/typed/typed-order-by.declaration';

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

@@ -1,24 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+require("../../declarations/typed/typed-order-by.declaration");
 const typeorm_1 = require("typeorm");
-const typeorm_querybuilder_types_1 = require("../typeorm-querybuilder.types");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
+// patching and implementation
 typeorm_1.SelectQueryBuilder.prototype.orderByTyped = function (selection, order, nulls) {
-    if (selection instanceof typeorm_querybuilder_types_1.KeyHolder) {
+    if (selection instanceof proxy_key_utils_1.KeyHolder) {
         return this.orderBy(selection.toSql(), order, nulls);
     }
     if (typeof selection === 'function') {
-        const key = (0, proxy_key_utils_1.getSqlKey)(selection, this.alias);
+        const key = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(selection, this.alias);
         return this.orderBy(key, order, nulls);
     }
     return this;
 };
 typeorm_1.SelectQueryBuilder.prototype.addOrderByTyped = function (selection, order, nulls) {
-    if (selection instanceof typeorm_querybuilder_types_1.KeyHolder) {
+    if (selection instanceof proxy_key_utils_1.KeyHolder) {
         return this.addOrderBy(selection.toSql(), order, nulls);
     }
     if (typeof selection === 'function') {
-        const key = (0, proxy_key_utils_1.getSqlKey)(selection, this.alias);
+        const key = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(selection, this.alias);
         return this.addOrderBy(key, order, nulls);
     }
     return this;

package/dist/extensions/typed/typed-select/typed-select.extension.d.ts

@@ -1,33 +1 @@
-import { ObjectLiteral } from 'typeorm';
-import { KeyHolder, KeyProxyCallback } from '../typeorm-querybuilder.types';
-declare module 'typeorm/query-builder/SelectQueryBuilder' {
-    interface SelectQueryBuilder<Entity> {
-        /**
-         * Creates SELECT query.
-         * Replaces all previous selections if they exist.
-         */
-        selectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string): SelectQueryBuilder<Entity>;
-        /**
-         * Creates SELECT query and selects given data.
-         * Replaces all previous selections if they exist.
-         */
-        selectTyped(this: SelectQueryBuilder<Entity>, selection: string | KeyHolder, selectionAliasName?: string): SelectQueryBuilder<Entity>;
-        /**
-         * Creates SELECT query and selects given data.
-         * Replaces all previous selections if they exist.
-         */
-        selectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>): SelectQueryBuilder<Entity>;
-        /**
-         * Adds new selection to the SELECT query.
-         */
-        addSelectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string): SelectQueryBuilder<Entity>;
-        /**
-         * Adds new selection to the SELECT query.
-         */
-        addSelectTyped(this: SelectQueryBuilder<Entity>, selection: string | KeyHolder, selectionAliasName?: string): SelectQueryBuilder<Entity>;
-        /**
-         * Adds new selection to the SELECT query.
-         */
-        addSelectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>): SelectQueryBuilder<Entity>;
-    }
-}
+import '../../declarations/typed/typed-select.declaration';

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

@@ -1,24 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+require("../../declarations/typed/typed-select.declaration");
 const typeorm_1 = require("typeorm");
-const typeorm_querybuilder_types_1 = require("../typeorm-querybuilder.types");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
-typeorm_1.SelectQueryBuilder.prototype.selectTyped = function (selection, selectionAliasName) {
-    return attachSelectMethod(this, 'select', selection, selectionAliasName);
-};
-typeorm_1.SelectQueryBuilder.prototype.addSelectTyped = function (selection, selectionAliasName) {
-    return attachSelectMethod(this, 'addSelect', selection, selectionAliasName);
+const prototype_utils_1 = require("../../../utils/prototype.utils");
+// patching
+const extension = {
+    prototype: {
+        selectTyped(selection, selectionAliasName) {
+            return attachSelectMethod(this, 'select', selection, selectionAliasName);
+        },
+        addSelectTyped(selection, selectionAliasName) {
+            return attachSelectMethod(this, 'addSelect', selection, selectionAliasName);
+        },
+    },
 };
+(0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
+// implementation
 const attachSelectMethod = (query, method, selection, selectionAliasName) => {
-    if (selection instanceof typeorm_querybuilder_types_1.KeyHolder) {
+    if (selection instanceof proxy_key_utils_1.KeyHolder) {
         return query[method](selection.toSql(), selectionAliasName);
     }
     if (Array.isArray(selection)) {
-        const arrayOfKeys = selection.map((value) => (0, proxy_key_utils_1.getSqlKey)(value, query.alias));
+        const arrayOfKeys = selection.map((select) => (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(select, query.alias));
         return query[method](arrayOfKeys);
     }
     else if (typeof selection === 'function') {
-        const keyArrayOrSingleKey = (0, proxy_key_utils_1.getSqlKey)(selection, query.alias);
+        const keyArrayOrSingleKey = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(selection, query.alias);
         if (Array.isArray(keyArrayOrSingleKey)) {
             return query[method](keyArrayOrSingleKey);
         }

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

@@ -0,0 +1,2 @@
+import '../../declarations/typed/typed-where-is-in.declaration';
+import '../../where-is-in.extension';

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("../../declarations/typed/typed-where-is-in.declaration");
+require("../../where-is-in.extension");
+const typeorm_1 = require("typeorm");
+const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
+const prototype_utils_1 = require("../../../utils/prototype.utils");
+// patching
+const extension = {
+    prototype: {
+        whereIsInTyped: function (where, array, options) {
+            return attachWhereIsIn(this, 'whereIsIn', where, array, options);
+        },
+        andWhereIsInTyped: function (where, array, options) {
+            return attachWhereIsIn(this, 'andWhereIsIn', where, array, options);
+        },
+        orWhereIsInTyped: function (where, array, options) {
+            return attachWhereIsIn(this, 'orWhereIsIn', where, array, options);
+        },
+        whereIsNotInTyped: function (where, array, options) {
+            return attachWhereIsIn(this, 'whereIsNotIn', where, array, options);
+        },
+        andWhereIsNotInTyped: function (where, array, options) {
+            return attachWhereIsIn(this, 'andWhereIsNotIn', where, array, options);
+        },
+        orWhereIsNotInTyped: function (where, array, options) {
+            return attachWhereIsIn(this, 'orWhereIsNotIn', where, array, options);
+        },
+    },
+};
+const queryBuilders = [
+    typeorm_1.SelectQueryBuilder,
+    typeorm_1.UpdateQueryBuilder,
+    typeorm_1.DeleteQueryBuilder,
+];
+queryBuilders.forEach((builder) => {
+    (0, prototype_utils_1.patchPrototype)(builder, extension);
+});
+// implementation
+function attachWhereIsIn(builder, method, where, array, options) {
+    const { useDoubleQuotes } = options || {};
+    if (typeof where === 'function') {
+        const alias = builder.alias;
+        const key = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(where, alias, useDoubleQuotes);
+        if (Array.isArray(key)) {
+            for (const k of key) {
+                builder = builder[method](k, array);
+            }
+            return builder;
+        }
+        // .andWhere(`"table"."column"   IN (:...values)`, { values: ['value'] })
+        return builder[method](key, array);
+    }
+    return builder;
+}

package/dist/extensions/typed/typed-where/typed-where.extension.d.ts

@@ -1,89 +1 @@
-import { ObjectLiteral } from 'typeorm';
-import { ColumnValueType } from '../typeorm.types';
-export interface TypedWhereOptions {
-    useDoubleQuotes?: boolean;
-}
-declare module 'typeorm/query-builder/WhereExpressionBuilder' {
-    interface WhereExpressionBuilder {
-        /**
-         * Sets WHERE condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         * Additionally you can add parameters used in where expression.
-         */
-        whereTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ColumnValueType, conditions: string, parameters?: ObjectLiteral, options?: TypedWhereOptions): this;
-        /**
-         * Adds new AND WHERE condition in the query builder.
-         * Additionally you can add parameters used in where expression.
-         */
-        andWhereTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ColumnValueType, conditions: string, parameters?: ObjectLiteral, options?: TypedWhereOptions): this;
-        /**
-         * Adds new OR WHERE condition in the query builder.
-         * Additionally you can add parameters used in where expression.
-         */
-        orWhereTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ColumnValueType, conditions: string, parameters?: ObjectLiteral, options?: TypedWhereOptions): this;
-    }
-}
-declare module 'typeorm/query-builder/SelectQueryBuilder' {
-    interface SelectQueryBuilder<Entity> {
-        /**
-         * Sets WHERE condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         * Additionally you can add parameters used in where expression.
-         */
-        whereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ColumnValueType, conditions: string, parameters?: ObjectLiteral, options?: TypedWhereOptions): this;
-        /**
-         * Adds new AND WHERE condition in the query builder.
-         * Additionally you can add parameters used in where expression.
-         */
-        andWhereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ColumnValueType, conditions: string, parameters?: ObjectLiteral, options?: TypedWhereOptions): this;
-        /**
-         * Adds new OR WHERE condition in the query builder.
-         * Additionally you can add parameters used in where expression.
-         */
-        orWhereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ColumnValueType, conditions: string, parameters?: ObjectLiteral, options?: TypedWhereOptions): this;
-    }
-}
-declare module 'typeorm/query-builder/UpdateQueryBuilder' {
-    interface UpdateQueryBuilder<Entity> {
-        /**
-         * Sets WHERE condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         * Additionally you can add parameters used in where expression.
-         */
-        whereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ColumnValueType, conditions: string, parameters?: ObjectLiteral, options?: TypedWhereOptions): this;
-        /**
-         * Adds new AND WHERE condition in the query builder.
-         * Additionally you can add parameters used in where expression.
-         */
-        andWhereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ColumnValueType, conditions: string, parameters?: ObjectLiteral, options?: TypedWhereOptions): this;
-        /**
-         * Adds new OR WHERE condition in the query builder.
-         * Additionally you can add parameters used in where expression.
-         */
-        orWhereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ColumnValueType, conditions: string, parameters?: ObjectLiteral, options?: TypedWhereOptions): this;
-    }
-}
-declare module 'typeorm/query-builder/DeleteQueryBuilder' {
-    interface DeleteQueryBuilder<Entity> {
-        /**
-         * Sets WHERE condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         * Additionally you can add parameters used in where expression.
-         */
-        whereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ColumnValueType, conditions: string, parameters?: ObjectLiteral, options?: TypedWhereOptions): this;
-        /**
-         * Adds new AND WHERE condition in the query builder.
-         * Additionally you can add parameters used in where expression.
-         */
-        andWhereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ColumnValueType, conditions: string, parameters?: ObjectLiteral, options?: TypedWhereOptions): this;
-        /**
-         * Adds new OR WHERE condition in the query builder.
-         * Additionally you can add parameters used in where expression.
-         */
-        orWhereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ColumnValueType, conditions: string, parameters?: ObjectLiteral, options?: TypedWhereOptions): this;
-    }
-}
+import '../../declarations/typed/typed-where.declaration';