typeorm-extensions 2.2.0-rc.1 → 2.2.0-rc.11

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const typeorm_1 = require("typeorm");
 const query_builder_utils_1 = require("../../../utils/query-builder.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");
 const sql_utils_1 = require("../../../utils/sql.utils");
@@ -55,14 +54,7 @@ const extension = {
         orWhereIsInLowerTyped: createWhereIsInLowerTypedMethod('orWhere'),
     },
 };
-const queryBuilders = [
-    typeorm_1.SelectQueryBuilder,
-    typeorm_1.UpdateQueryBuilder,
-    typeorm_1.DeleteQueryBuilder,
-];
-queryBuilders.forEach((builder) => {
-    (0, prototype_utils_1.patchPrototype)(builder, extension);
-});
+(0, prototype_utils_1.patchPrototypes)(prototype_utils_1.WHERE_QUERY_BUILDERS, extension);
 // implementation
 const lower = (sql) => `LOWER(${sql})`;
 /**

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

@@ -14,17 +14,17 @@ export interface TypedWhereSimilarMethods<Entity extends ObjectLiteral> {
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereSimilarTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, options?: TypedSimilarOptions): this;
+    whereSimilarTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, options?: TypedSimilarOptions): this;
     /**
      * Adds new AND WHERE `column % :term` condition in the query builder (PostgreSQL, pg_trgm).
      * A blank term adds no condition.
      */
-    andWhereSimilarTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, options?: TypedSimilarOptions): this;
+    andWhereSimilarTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, options?: TypedSimilarOptions): this;
     /**
      * Adds new OR WHERE `column % :term` condition in the query builder (PostgreSQL, pg_trgm).
      * A blank term adds no condition.
      */
-    orWhereSimilarTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, options?: TypedSimilarOptions): this;
+    orWhereSimilarTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, options?: TypedSimilarOptions): this;
 }
 /** Trigram similarity score selection (PostgreSQL, `pg_trgm` extension). */
 export interface TypedSimilarityScoreMethods<Entity extends ObjectLiteral> {
@@ -35,7 +35,7 @@ export interface TypedSimilarityScoreMethods<Entity extends ObjectLiteral> {
      * (`word_similarity(:term, column)`, the score of `column %> :term`).
      * Use a lower-case alias: PostgreSQL folds an unquoted alias in ORDER BY.
      */
-    addSimilarityScoreTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, alias: string, options?: SimilarityScoreOptions): this;
+    addSimilarityScoreTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, alias: string, options?: SimilarityScoreOptions): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereSimilarMethods<ObjectLiteral> {
@@ -53,3 +53,7 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
     interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereSimilarMethods<Entity> {
     }
 }
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereSimilarMethods<Entity> {
+    }
+}

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

@@ -62,12 +62,5 @@ const scoreExtension = {
         },
     },
 };
-const queryBuilders = [
-    typeorm_1.SelectQueryBuilder,
-    typeorm_1.UpdateQueryBuilder,
-    typeorm_1.DeleteQueryBuilder,
-];
-queryBuilders.forEach((builder) => {
-    (0, prototype_utils_1.patchPrototype)(builder, extension);
-});
+(0, prototype_utils_1.patchPrototypes)(prototype_utils_1.WHERE_QUERY_BUILDERS, extension);
 (0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, scoreExtension);

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

@@ -14,17 +14,17 @@ export interface TypedWhereMethods<Entity extends ObjectLiteral> {
      * calling this function will override previously set WHERE conditions.
      * Additionally you can add parameters used in where expression.
      */
-    whereTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, Value>): this;
+    whereTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity, this>>>) => Value, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, Value>): this;
     /**
      * Adds new AND WHERE condition in the query builder.
      * Additionally you can add parameters used in where expression.
      */
-    andWhereTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, Value>): this;
+    andWhereTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity, this>>>) => Value, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, Value>): this;
     /**
      * Adds new OR WHERE condition in the query builder.
      * Additionally you can add parameters used in where expression.
      */
-    orWhereTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, Value>): this;
+    orWhereTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity, this>>>) => Value, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, Value>): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereMethods<ObjectLiteral> {
@@ -42,3 +42,7 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
     interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereMethods<Entity> {
     }
 }
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereMethods<Entity> {
+    }
+}

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const typeorm_1 = require("typeorm");
 const query_builder_utils_1 = require("../../../utils/query-builder.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");
 const where_utils_1 = require("../../../utils/where.utils");
@@ -16,21 +15,14 @@ const extension = {
         orWhereTyped: createWhereTypedMethod('orWhere'),
     },
 };
-const queryBuilders = [
-    typeorm_1.SelectQueryBuilder,
-    typeorm_1.UpdateQueryBuilder,
-    typeorm_1.DeleteQueryBuilder,
-];
-queryBuilders.forEach((builder) => {
-    (0, prototype_utils_1.patchPrototype)(builder, extension);
-});
+(0, prototype_utils_1.patchPrototypes)(prototype_utils_1.WHERE_QUERY_BUILDERS, extension);
 // implementation
 function attachTypedWhere(builder, method, where, conditions, parameters, options) {
     const { addValue } = options || {};
     if (typeof where === 'function') {
         // several columns have no single meaning (AND? OR?), and `where…` kept only the last one
         // a path into a JSON column is cast to the type of the value it is compared with
-        const value = (0, where_utils_1.isParamsObject)(parameters) ? Object.values(parameters)[0] : parameters;
+        const value = (0, where_utils_1.getComparedValue)(parameters);
         const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`, { value });
         return (0, where_utils_1.attachWhere)(builder, method, key, conditions, parameters, {
             addValue,

package/dist/extensions/union.extension.js

@@ -46,7 +46,7 @@ function ordersOrLimits(query, sql) {
     return Object.keys(allOrderBys !== null && allOrderBys !== void 0 ? allOrderBys : {}).length > 0 || [limit, offset, take, skip].some((value) => value !== undefined);
 }
 function bindParameters(builder, query) {
-    const [sql, parameters] = (0, parameter_utils_1.withUniqueParameterNames)(query.getQuery(), query.getParameters());
+    const [sql, parameters] = (0, parameter_utils_1.toSubQuerySql)(query);
     builder.setParameters(parameters);
     return sql;
 }

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

@@ -68,3 +68,7 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
     interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereArrayMethods {
     }
 }
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereArrayMethods {
+    }
+}

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const typeorm_1 = require("typeorm");
 const prototype_utils_1 = require("../utils/prototype.utils");
 const query_builder_utils_1 = require("../utils/query-builder.utils");
 const sql_utils_1 = require("../utils/sql.utils");
@@ -20,14 +19,7 @@ const extension = {
         orWhereArrayOverlaps: createWhereArrayMethod('orWhere', '&&'),
     },
 };
-const queryBuilders = [
-    typeorm_1.SelectQueryBuilder,
-    typeorm_1.UpdateQueryBuilder,
-    typeorm_1.DeleteQueryBuilder,
-];
-queryBuilders.forEach((builder) => {
-    (0, prototype_utils_1.patchPrototype)(builder, extension);
-});
+(0, prototype_utils_1.patchPrototypes)(prototype_utils_1.WHERE_QUERY_BUILDERS, extension);
 // implementation
 function attachWhereArray(builder, method, field, operator, values, arrayType) {
     if (!method || typeof field !== 'string') {

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

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.attachExists = void 0;
-const typeorm_1 = require("typeorm");
-const SoftDeleteQueryBuilder_1 = require("typeorm/query-builder/SoftDeleteQueryBuilder");
 const prototype_utils_1 = require("../utils/prototype.utils");
 const parameter_utils_1 = require("../utils/parameter.utils");
+const query_builder_utils_1 = require("../utils/query-builder.utils");
 const existsMethods = {
     prototype: {
         whereExists(subQuery) {
@@ -33,10 +32,8 @@ const notExistsMethods = {
 };
 // only where the builder lacks them: SelectQueryBuilder keeps TypeORM's own whereExists /
 // andWhereExists / orWhereExists, and a later TypeORM that adds any of these keeps its own
-[typeorm_1.SelectQueryBuilder, typeorm_1.UpdateQueryBuilder, typeorm_1.DeleteQueryBuilder, SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder].forEach((builder) => {
-    (0, prototype_utils_1.patchPrototype)(builder, existsMethods, { onlyMissing: true });
-    (0, prototype_utils_1.patchPrototype)(builder, notExistsMethods, { onlyMissing: true });
-});
+(0, prototype_utils_1.patchPrototypes)(prototype_utils_1.WHERE_QUERY_BUILDERS, existsMethods, { onlyMissing: true });
+(0, prototype_utils_1.patchPrototypes)(prototype_utils_1.WHERE_QUERY_BUILDERS, notExistsMethods, { onlyMissing: true });
 // implementation
 function attachExists(builder, method, subQuery, negate) {
     const [condition, parameters] = (0, parameter_utils_1.withUniqueParameterNames)(...getExistsCondition(subQuery));
@@ -48,15 +45,7 @@ exports.attachExists = attachExists;
  * drops GROUP BY, which leaves a HAVING to aggregate the whole subquery: the GROUP BY stays with one.
  */
 function getExistsCondition(subQuery) {
-    const query = subQuery
-        .clone()
-        .orderBy()
-        .offset(undefined)
-        .limit(undefined)
-        .skip(undefined)
-        .take(undefined)
-        .select('1')
-        .setOption('disable-global-order');
+    const query = (0, query_builder_utils_1.withoutPaging)(subQuery.clone()).select('1');
     if (query.expressionMap.havings.length === 0) {
         query.groupBy();
     }

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

@@ -1,142 +1,55 @@
 import { ObjectLiteral } from 'typeorm';
 import { ArgsType } from '../types/util-types';
+export interface WhereIsAnyMethods {
+    /**
+     * Sets WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
+     * The array is bound as a single parameter instead of one parameter per value.
+     * `arrayType` (e.g. `'uuid[]'`) casts the parameter: `= ANY(CAST(:array AS uuid[]))`.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereIsAny(field: string, array?: ArgsType, arrayType?: string): this;
+    /**
+     * Adds new AND WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
+     */
+    andWhereIsAny(field: string, array?: ArgsType, arrayType?: string): this;
+    /**
+     * Adds new OR WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
+     */
+    orWhereIsAny(field: string, array?: ArgsType, arrayType?: string): this;
+    /**
+     * Sets WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL):
+     * the field differs from every value of the array.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereIsNotAny(field: string, array?: ArgsType, arrayType?: string): this;
+    /**
+     * Adds new AND WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL).
+     */
+    andWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): this;
+    /**
+     * Adds new OR WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL).
+     */
+    orWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): this;
+}
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
-    interface WhereExpressionBuilder {
-        /**
-         * Sets WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
-         * The array is bound as a single parameter instead of one parameter per value.
-         * `arrayType` (e.g. `'uuid[]'`) casts the parameter: `= ANY(CAST(:array AS uuid[]))`.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsAny(field: string, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new AND WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
-         */
-        andWhereIsAny(field: string, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new OR WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
-         */
-        orWhereIsAny(field: string, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Sets WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL):
-         * the field differs from every value of the array.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotAny(field: string, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new AND WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL).
-         */
-        andWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new OR WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL).
-         */
-        orWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): this;
+    interface WhereExpressionBuilder extends WhereIsAnyMethods {
     }
 }
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
-    interface SelectQueryBuilder<Entity extends ObjectLiteral> {
-        /**
-         * Sets WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
-         * The array is bound as a single parameter instead of one parameter per value.
-         * `arrayType` (e.g. `'uuid[]'`) casts the parameter: `= ANY(CAST(:array AS uuid[]))`.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsAny(field: string, array?: ArgsType, arrayType?: string): SelectQueryBuilder<Entity>;
-        /**
-         * Adds new AND WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
-         */
-        andWhereIsAny(field: string, array?: ArgsType, arrayType?: string): SelectQueryBuilder<Entity>;
-        /**
-         * Adds new OR WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
-         */
-        orWhereIsAny(field: string, array?: ArgsType, arrayType?: string): SelectQueryBuilder<Entity>;
-        /**
-         * Sets WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL):
-         * the field differs from every value of the array.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotAny(field: string, array?: ArgsType, arrayType?: string): SelectQueryBuilder<Entity>;
-        /**
-         * Adds new AND WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL).
-         */
-        andWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): SelectQueryBuilder<Entity>;
-        /**
-         * Adds new OR WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL).
-         */
-        orWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): SelectQueryBuilder<Entity>;
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends WhereIsAnyMethods {
     }
 }
 declare module 'typeorm/query-builder/UpdateQueryBuilder' {
-    interface UpdateQueryBuilder<Entity extends ObjectLiteral> {
-        /**
-         * Sets WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
-         * The array is bound as a single parameter instead of one parameter per value.
-         * `arrayType` (e.g. `'uuid[]'`) casts the parameter: `= ANY(CAST(:array AS uuid[]))`.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsAny(field: string, array?: ArgsType, arrayType?: string): UpdateQueryBuilder<Entity>;
-        /**
-         * Adds new AND WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
-         */
-        andWhereIsAny(field: string, array?: ArgsType, arrayType?: string): UpdateQueryBuilder<Entity>;
-        /**
-         * Adds new OR WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
-         */
-        orWhereIsAny(field: string, array?: ArgsType, arrayType?: string): UpdateQueryBuilder<Entity>;
-        /**
-         * Sets WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL):
-         * the field differs from every value of the array.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotAny(field: string, array?: ArgsType, arrayType?: string): UpdateQueryBuilder<Entity>;
-        /**
-         * Adds new AND WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL).
-         */
-        andWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): UpdateQueryBuilder<Entity>;
-        /**
-         * Adds new OR WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL).
-         */
-        orWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): UpdateQueryBuilder<Entity>;
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends WhereIsAnyMethods {
     }
 }
 declare module 'typeorm/query-builder/DeleteQueryBuilder' {
-    interface DeleteQueryBuilder<Entity extends ObjectLiteral> {
-        /**
-         * Sets WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
-         * The array is bound as a single parameter instead of one parameter per value.
-         * `arrayType` (e.g. `'uuid[]'`) casts the parameter: `= ANY(CAST(:array AS uuid[]))`.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsAny(field: string, array?: ArgsType, arrayType?: string): DeleteQueryBuilder<Entity>;
-        /**
-         * Adds new AND WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
-         */
-        andWhereIsAny(field: string, array?: ArgsType, arrayType?: string): DeleteQueryBuilder<Entity>;
-        /**
-         * Adds new OR WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
-         */
-        orWhereIsAny(field: string, array?: ArgsType, arrayType?: string): DeleteQueryBuilder<Entity>;
-        /**
-         * Sets WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL):
-         * the field differs from every value of the array.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotAny(field: string, array?: ArgsType, arrayType?: string): DeleteQueryBuilder<Entity>;
-        /**
-         * Adds new AND WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL).
-         */
-        andWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): DeleteQueryBuilder<Entity>;
-        /**
-         * Adds new OR WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL).
-         */
-        orWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): DeleteQueryBuilder<Entity>;
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereIsAnyMethods {
+    }
+}
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereIsAnyMethods {
     }
 }

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const typeorm_1 = require("typeorm");
 const prototype_utils_1 = require("../utils/prototype.utils");
 const query_builder_utils_1 = require("../utils/query-builder.utils");
 const sql_utils_1 = require("../utils/sql.utils");
@@ -17,14 +16,7 @@ const extension = {
         orWhereIsNotAny: createWhereIsAnyMethod('orWhere', '<> ALL'),
     },
 };
-const queryBuilders = [
-    typeorm_1.SelectQueryBuilder,
-    typeorm_1.UpdateQueryBuilder,
-    typeorm_1.DeleteQueryBuilder,
-];
-queryBuilders.forEach((builder) => {
-    (0, prototype_utils_1.patchPrototype)(builder, extension);
-});
+(0, prototype_utils_1.patchPrototypes)(prototype_utils_1.WHERE_QUERY_BUILDERS, extension);
 // implementation
 function attachWhereIsAny(builder, method, field, comparison, array, arrayType) {
     if (!method || typeof field !== 'string') {

package/dist/extensions/where-is-distinct-from.extension.d.ts

@@ -54,3 +54,7 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
     interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereDistinctMethods {
     }
 }
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereDistinctMethods {
+    }
+}

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const typeorm_1 = require("typeorm");
 const prototype_utils_1 = require("../utils/prototype.utils");
 const query_builder_utils_1 = require("../utils/query-builder.utils");
 const sql_utils_1 = require("../utils/sql.utils");
@@ -19,14 +18,7 @@ const extension = {
         orWhereIsNotDistinctFrom: createWhereDistinctMethod('orWhere', false),
     },
 };
-const queryBuilders = [
-    typeorm_1.SelectQueryBuilder,
-    typeorm_1.UpdateQueryBuilder,
-    typeorm_1.DeleteQueryBuilder,
-];
-queryBuilders.forEach((builder) => {
-    (0, prototype_utils_1.patchPrototype)(builder, extension);
-});
+(0, prototype_utils_1.patchPrototypes)(prototype_utils_1.WHERE_QUERY_BUILDERS, extension);
 // implementation
 /** `field IS [NOT] DISTINCT FROM value` in the database's own null-safe syntax. */
 function buildDistinctCondition(driver, field, distinct, value) {

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

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