typeorm-extensions 1.3.0 → 1.3.2

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

@@ -1,2 +1,8 @@
-import './declarations/get-many-with-totals.declaration';
 import './pagination.extension';
+import { PaginationFilter } from '../types/interfaces/pagination.interface';
+import type { GetManyWithTotalsOptions, ListWithTotals } from '../types/extensions';
+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

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("./declarations/get-many-with-totals.declaration");
+require("./pagination.extension");
 const SelectQueryBuilder_1 = require("typeorm/query-builder/SelectQueryBuilder");
 const pagination_utils_1 = require("../utils/pagination.utils");
-require("./pagination.extension");
 const prototype_utils_1 = require("../utils/prototype.utils");
 // patching
 const extension = {

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

@@ -1 +1,8 @@
-import './declarations/order.declaration';
+import type { OrderParam, OrderFilter } from '../types/interfaces/ordering.interface';
+import type { ApplyOrderOptions } from '../types/extensions/order.types';
+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>;
+    }
+}

package/dist/extensions/order.extension.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 /* 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");

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

@@ -1 +1,10 @@
-import './declarations/pagination.declaration';
+import { SelectQueryBuilder } from 'typeorm';
+import { PaginationFilter } from '../types/interfaces/pagination.interface';
+import { ObjectLiteral } from 'typeorm';
+import { ApplyPaginationOptions } from '../types/extensions/pagination.types';
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> {
+        applyPaginationFilter(paginationFilter: PaginationFilter, options?: ApplyPaginationOptions): SelectQueryBuilder<Entity>;
+    }
+}
+export declare const SelectQB: typeof SelectQueryBuilder;

package/dist/extensions/pagination.extension.js

@@ -1,8 +1,9 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectQB = void 0;
 /* eslint-disable @typescript-eslint/no-explicit-any */
-require("./declarations/pagination.declaration");
-const SelectQueryBuilder_1 = require("typeorm/query-builder/SelectQueryBuilder");
+const typeorm_1 = require("typeorm");
 const constants_1 = require("../constants");
 const pagination_utils_1 = require("../utils/pagination.utils");
 const prototype_utils_1 = require("../utils/prototype.utils");
@@ -14,7 +15,9 @@ const extension = {
         },
     },
 };
-(0, prototype_utils_1.patchPrototype)(SelectQueryBuilder_1.SelectQueryBuilder, extension);
+(0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
+console.log('After patching:', ((_a = typeorm_1.SelectQueryBuilder.prototype.applyPaginationFilter) === null || _a === void 0 ? void 0 : _a.name) || 'not patched');
+exports.SelectQB = typeorm_1.SelectQueryBuilder;
 // implementation
 function applyPaginationFilter(builder, paginationFilter, options) {
     const { useTakeAndSkip = constants_1.defaultUseTakeAndSkip } = options || {};

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

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

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

@@ -1,6 +1,5 @@
 "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

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

@@ -1 +1,10 @@
-import '../../declarations/typed/typed-joins.declaration';
+import { ObjectLiteral } from 'typeorm';
+import { RelationalKeyProxyCallback } from '../../../types/modules/proxy-callback.types';
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> {
+        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

@@ -1,6 +1,5 @@
 "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

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

@@ -1 +1,17 @@
-import '../../declarations/typed/typed-order-by.declaration';
+import { ObjectLiteral } from 'typeorm';
+import { ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import { KeyHolder } from '../../../utils/proxy-key.utils';
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> {
+        /**
+         * 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) => ProxyColumnValueType | 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) => ProxyColumnValueType | KeyHolder, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST'): SelectQueryBuilder<Entity>;
+    }
+}

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("../../declarations/typed/typed-order-by.declaration");
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
 // patching and implementation

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

@@ -1 +1,34 @@
-import '../../declarations/typed/typed-select.declaration';
+import { ObjectLiteral } from 'typeorm';
+import { KeyProxyCallback } from '../../../types/modules/proxy-callback.types';
+import { KeyHolder } from '../../../utils/proxy-key.utils';
+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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("../../declarations/typed/typed-select.declaration");
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");

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

@@ -1,2 +1,133 @@
-import '../../declarations/typed/typed-where-is-in.declaration';
 import '../../where-is-in.extension';
+import { ObjectLiteral } from 'typeorm';
+import { ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import { ArgsType } from '../../../types/util-types';
+import { TypedWhereIsInOptions } from '../../../types/extensions/typed-where.types';
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder {
+        /**
+         * Sets WHERE IN condition in the query builder.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         */
+        whereIsInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new AND WHERE IN condition in the query builder.
+         */
+        andWhereIsInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new OR WHERE IN condition in the query builder.
+         */
+        orWhereIsInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Sets WHERE NOT IN condition in the query builder.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         */
+        whereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new AND WHERE NOT IN condition in the query builder.
+         */
+        andWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new OR WHERE NOT IN condition in the query builder.
+         */
+        orWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> {
+        /**
+         * Sets WHERE IN condition in the query builder.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         */
+        whereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new AND WHERE IN condition in the query builder.
+         */
+        andWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new OR WHERE IN condition in the query builder.
+         */
+        orWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Sets WHERE NOT IN condition in the query builder.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         */
+        whereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new AND WHERE NOT IN condition in the query builder.
+         */
+        andWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new OR WHERE NOT IN condition in the query builder.
+         */
+        orWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> {
+        /**
+         * Sets WHERE IN condition in the query builder.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         */
+        whereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new AND WHERE IN condition in the query builder.
+         */
+        andWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new OR WHERE IN condition in the query builder.
+         */
+        orWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Sets WHERE NOT IN condition in the query builder.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         */
+        whereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new AND WHERE NOT IN condition in the query builder.
+         */
+        andWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new OR WHERE NOT IN condition in the query builder.
+         */
+        orWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> {
+        /**
+         * Sets WHERE IN condition in the query builder.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         */
+        whereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new AND WHERE IN condition in the query builder.
+         */
+        andWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new OR WHERE IN condition in the query builder.
+         */
+        orWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Sets WHERE NOT IN condition in the query builder.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         */
+        whereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new AND WHERE NOT IN condition in the query builder.
+         */
+        andWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new OR WHERE NOT IN condition in the query builder.
+         */
+        orWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+    }
+}

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

@@ -1,6 +1,5 @@
 "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");

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

@@ -1 +1,87 @@
-import '../../declarations/typed/typed-where.declaration';
+import { ObjectLiteral } from 'typeorm';
+import { ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import { TypedWhereOptions } from '../../../types/extensions/typed-where.types';
+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) => ProxyColumnValueType, 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) => ProxyColumnValueType, 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) => ProxyColumnValueType, 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) => ProxyColumnValueType, 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) => ProxyColumnValueType, 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) => ProxyColumnValueType, 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) => ProxyColumnValueType, 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) => ProxyColumnValueType, 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) => ProxyColumnValueType, 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) => ProxyColumnValueType, 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) => ProxyColumnValueType, 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) => ProxyColumnValueType, conditions: string, parameters?: ObjectLiteral, options?: TypedWhereOptions): this;
+    }
+}

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("../../declarations/typed/typed-where.declaration");
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");

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

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

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("./declarations/where-is-in.daclaration");
 const typeorm_1 = require("typeorm");
 const prototype_utils_1 = require("../utils/prototype.utils");
 const where_utils_1 = require("../utils/where.utils");

package/dist/utils/prototype.utils.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.patchPrototype = void 0;
 function patchPrototype(target, source) {
-    for (const method in Object.keys(source.prototype)) {
+    for (const method of Object.keys(source.prototype)) {
         target.prototype[method] = source.prototype[method];
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typeorm-extensions",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "typeorm commonly used extensions",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,13 +25,14 @@
   ],
   "author": "koenigstag",
   "license": "ISC",
-  "dependencies": {
-    "typeorm": "^0.3.20"
+  "peerDependencies": {
+    "typeorm": "^0.3.12"
   },
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "^7.1.1",
     "@typescript-eslint/parser": "^7.1.1",
     "eslint": "^8.57.0",
+    "typeorm": "^0.3.12",
     "typescript": "5.3"
   }
 }