typeorm-extensions 1.2.3 → 1.2.4

package/dist/constants/index.d.ts

@@ -0,0 +1,5 @@
+export declare const defaultPageSize = 10;
+export declare const defaultUseTakeAndSkip = false;
+export declare const defaultUseDoubleQuotes = true;
+export declare const defaultOrderDirection = "ASC";
+export declare const defaultNullsOrder: undefined;

package/dist/constants/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultNullsOrder = exports.defaultOrderDirection = exports.defaultUseDoubleQuotes = exports.defaultUseTakeAndSkip = exports.defaultPageSize = void 0;
+exports.defaultPageSize = 10;
+exports.defaultUseTakeAndSkip = false;
+exports.defaultUseDoubleQuotes = true;
+exports.defaultOrderDirection = 'ASC';
+exports.defaultNullsOrder = undefined;

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

@@ -0,0 +1,16 @@
+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>>;
+    }
+}

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 || {};
+    const { limit, offset } = loadAll
+        ? { limit: null, offset: null }
+        : (0, pagination_utils_1.getLimitAndOffset)(paginationFilter);
+    const requests = [];
+    if (!disableTotalsCalculation) {
+        requests[0] = this.getCount();
+    }
+    else {
+        requests[0] = Promise.resolve(null);
+    }
+    if (loadAll) {
+        requests[1] = this.getMany();
+    }
+    else {
+        requests[1] = this.applyPaginationFilter(paginationFilter).getMany();
+    }
+    const [totalCount, list] = (await Promise.all(requests));
+    return {
+        list,
+        totalCount: totalCount,
+        limit,
+        offset,
+    };
+};

package/dist/extensions/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./get-many-with-totals.extension"), exports);
+__exportStar(require("./order.extension"), exports);
+__exportStar(require("./pagination.extension"), exports);
+__exportStar(require("./typed"), exports);

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

@@ -0,0 +1,15 @@
+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 {};

package/dist/extensions/order.extension.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrderOption = void 0;
+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 alwaysAliasWhiteList = [
+    'id',
+    'createdAt',
+    'created_at',
+    'updatedAt',
+    'updated_at',
+    '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) => {
+    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
+        ? `NULLS ${nullsOrder.toUpperCase()}`
+        : undefined;
+    return {
+        selector,
+        order,
+        nulls,
+    };
+};
+exports.getOrderOption = getOrderOption;

package/dist/extensions/ordering.extension.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrderOption = void 0;
+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 alwaysAliasWhiteList = [
+    'id',
+    'createdAt',
+    'created_at',
+    'updatedAt',
+    'updated_at',
+    '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) => {
+    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
+        ? `NULLS ${nullsOrder.toUpperCase()}`
+        : undefined;
+    return {
+        selector,
+        order,
+        nulls,
+    };
+};
+exports.getOrderOption = getOrderOption;

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

@@ -0,0 +1,10 @@
+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 {};

package/dist/extensions/pagination.extension.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 { useTakeAndSkip = constants_1.defaultUseTakeAndSkip } = options || {};
+    const { limit, offset } = (0, pagination_utils_1.getLimitAndOffset)(paginationFilter);
+    if (useTakeAndSkip) {
+        return this.take(limit).skip(offset);
+    }
+    return this.limit(limit).offset(offset);
+};

package/{src/extensions/typed/index.ts → dist/extensions/typed/index.d.ts}

@@ -1,12 +1,7 @@
-//Extensions
 export * from './typed-distinct/typed-distinct.extension';
-// export * from './typed/typed-group-by/typed-group-by.extension';
-// export * from './typed/typed-having/typed-having.extension';
 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';
-
-// Types
 export * from './typeorm-querybuilder.types';
 export * from './typeorm.types';

package/dist/extensions/typed/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+//Extensions
+__exportStar(require("./typed-distinct/typed-distinct.extension"), exports);
+// export * from './typed/typed-group-by/typed-group-by.extension';
+// export * from './typed/typed-having/typed-having.extension';
+__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);

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

@@ -0,0 +1,14 @@
+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>;
+    }
+}

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
+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);
+        return this.distinctOn(keys);
+    }
+    return this;
+};

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

@@ -0,0 +1,10 @@
+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>;
+    }
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
+typeorm_1.SelectQueryBuilder.prototype.leftJoinTyped = function (selection, alias, condition, parameters) {
+    if (typeof selection === 'function') {
+        return addJoin(this, 'leftJoin', selection, alias, condition, parameters);
+    }
+    return this;
+};
+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;
+};
+function addJoin(query, method, selection, alias, condition, parameters) {
+    const key = (0, proxy_key_utils_1.getSqlKey)(selection, query.alias);
+    return query[method](key, alias, condition, parameters);
+}

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

@@ -0,0 +1,17 @@
+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>;
+    }
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.orderByTyped = function (selection, order, nulls) {
+    if (selection instanceof typeorm_querybuilder_types_1.KeyHolder) {
+        return this.orderBy(selection.toSql(), order, nulls);
+    }
+    if (typeof selection === 'function') {
+        const key = (0, proxy_key_utils_1.getSqlKey)(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) {
+        return this.addOrderBy(selection.toSql(), order, nulls);
+    }
+    if (typeof selection === 'function') {
+        const key = (0, proxy_key_utils_1.getSqlKey)(selection, this.alias);
+        return this.addOrderBy(key, order, nulls);
+    }
+    return this;
+};

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

@@ -0,0 +1,33 @@
+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>;
+    }
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 attachSelectMethod = (query, method, selection, selectionAliasName) => {
+    if (selection instanceof typeorm_querybuilder_types_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));
+        return query[method](arrayOfKeys);
+    }
+    else if (typeof selection === 'function') {
+        const keyArrayOrSingleKey = (0, proxy_key_utils_1.getSqlKey)(selection, query.alias);
+        if (Array.isArray(keyArrayOrSingleKey)) {
+            return query[method](keyArrayOrSingleKey);
+        }
+        return query[method](keyArrayOrSingleKey, selectionAliasName);
+    }
+    else if (typeof selection === 'string') {
+        return query[method](selection, selectionAliasName);
+    }
+    return query;
+};

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

@@ -0,0 +1,89 @@
+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;
+    }
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
+const queryBuilders = [
+    typeorm_1.SelectQueryBuilder,
+    typeorm_1.UpdateQueryBuilder,
+    typeorm_1.DeleteQueryBuilder,
+];
+const extension = {
+    prototype: {
+        whereTyped: function (where, conditions, parameters, options) {
+            return attachWhere(this, 'where', where, conditions, parameters, options);
+        },
+        andWhereTyped: function (where, conditions, parameters, options) {
+            return attachWhere(this, 'andWhere', where, conditions, parameters, options);
+        },
+        orWhereTyped: function (where, conditions, parameters, options) {
+            return attachWhere(this, 'orWhere', where, conditions, parameters, options);
+        },
+    },
+};
+queryBuilders.forEach((builder) => {
+    Object.assign(builder, extension);
+});
+function attachWhere(builder, method, where, conditions, parameters, options) {
+    if (typeof where === 'function') {
+        const key = (0, proxy_key_utils_1.getSqlKey)(where, builder.alias, options === null || options === void 0 ? void 0 : options.useDoubleQuotes);
+        // .andWhere(`"table"."column"   IN (:...values)`, { values: ['value'] })
+        return builder[method](`${key} ${conditions}`, parameters);
+    }
+    return builder;
+}

package/dist/extensions/typed/typeorm-querybuilder.types.d.ts

@@ -0,0 +1,22 @@
+import { ObjectLiteral } from 'typeorm';
+import { ColumnValueType, EntityOnlyWithRelations, EntityWithoutRelations } from './typeorm.types';
+export declare class KeyHolder {
+    keys: string[];
+    constructor(keys?: string[]);
+    toSql(length?: number, addDobleQuotes?: boolean): string;
+    toString(length?: number): string;
+    valueOf(): string;
+    [Symbol.toPrimitive](): string;
+    add(key: string | symbol): this;
+}
+export declare class TypedProxy {
+    static defaultHandler: {};
+    static create<T extends ObjectLiteral>(obj: object, handler?: {}): T;
+}
+export declare class KeyProxy {
+    static defaultHandler: ProxyHandler<KeyHolder>;
+    static create<T extends ObjectLiteral>(): T;
+}
+export type KeyProxyCallback<T extends ObjectLiteral> = (proxy: T) => ColumnValueType | Array<ColumnValueType>;
+export type RelationalKeyProxyCallback<T extends ObjectLiteral> = (proxy: EntityOnlyWithRelations<T>) => ColumnValueType;
+export type NonRelationalKeyProxyCallback<T extends ObjectLiteral> = (proxy: EntityWithoutRelations<T>) => ColumnValueType;