typeorm-extensions 2.0.0 → 2.2.0-rc.0

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

@@ -2,6 +2,7 @@ import '../../where-array.extension';
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
 import { ArgsType } from '../../../types/util-types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 /**
  * Typesafe conditions on PostgreSQL array columns: the column comes from an entity property.
  * See {@link WhereArrayMethods}.
@@ -12,43 +13,43 @@ export interface TypedWhereArrayMethods<Entity extends ObjectLiteral> {
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereArrayContainsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    whereArrayContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new AND WHERE `column @> :values` condition (PostgreSQL): the array column contains every value.
      */
-    andWhereArrayContainsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    andWhereArrayContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new OR WHERE `column @> :values` condition (PostgreSQL): the array column contains every value.
      */
-    orWhereArrayContainsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    orWhereArrayContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Sets WHERE `column <@ :values` condition (PostgreSQL): every element of the array column is one of the values.
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereArrayContainedByTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    whereArrayContainedByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new AND WHERE `column <@ :values` condition (PostgreSQL): every element of the array column is one of the values.
      */
-    andWhereArrayContainedByTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    andWhereArrayContainedByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new OR WHERE `column <@ :values` condition (PostgreSQL): every element of the array column is one of the values.
      */
-    orWhereArrayContainedByTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    orWhereArrayContainedByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Sets WHERE `column && :values` condition (PostgreSQL): the array column has at least one of the values.
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereArrayOverlapsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    whereArrayOverlapsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new AND WHERE `column && :values` condition (PostgreSQL): the array column has at least one of the values.
      */
-    andWhereArrayOverlapsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    andWhereArrayOverlapsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new OR WHERE `column && :values` condition (PostgreSQL): the array column has at least one of the values.
      */
-    orWhereArrayOverlapsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    orWhereArrayOverlapsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereArrayMethods<ObjectLiteral> {

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 require("../../where-array.extension");
 const typeorm_1 = require("typeorm");
 const query_builder_utils_1 = require("../../../utils/query-builder.utils");
+const sql_utils_1 = require("../../../utils/sql.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");
 /* eslint-enable @typescript-eslint/no-empty-interface */
 // patching
@@ -36,6 +37,37 @@ function attachWhereArrayTyped(builder, method, where, values, arrayType) {
         return builder;
     }
     const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`);
+    if ((0, query_builder_utils_1.isTypedJsonPath)(builder, where)) {
+        return attachWhereJsonArray(builder, method, where, values, arrayType);
+    }
     // .andWhereArrayContains(`"table"."column"`, ['value'])
     return builder[method](key, values, arrayType);
 }
+const JSON_ARRAY_METHOD = /^(where|andWhere|orWhere)Array(Contains|ContainedBy|Overlaps)$/;
+const JSON_ARRAY_OPERATORS = { Contains: '@>', ContainedBy: '<@', Overlaps: '?|' };
+/**
+ * The array conditions on an array inside a JSON column, with jsonb operators: `@>` and `<@` against the
+ * values as a JSON array, and `?|` (any of the strings is an element) for the overlap. Empty arrays keep
+ * PostgreSQL's semantics, as for array columns.
+ */
+function attachWhereJsonArray(builder, method, where, values, arrayType) {
+    const methodName = `${method}Typed`;
+    const [, whereMethod, condition] = JSON_ARRAY_METHOD.exec(method);
+    if (!Array.isArray(values)) {
+        throw new TypeError(`${methodName} expects an array of values, got ${values}`);
+    }
+    if (arrayType !== undefined) {
+        throw new TypeError(`${methodName}: arrayType is for array columns, not for an array inside a JSON column`);
+    }
+    const jsonArray = `CAST(${(0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, methodName, { accessor: 'json' })} AS jsonb)`;
+    const paramName = (0, sql_utils_1.createUniqueParameterName)(whereMethod);
+    // a string or an object at the path isn't an array, but <@ and ?| would match it
+    const onArray = (condition) => `(jsonb_typeof(${jsonArray}) = 'array' AND ${condition})`;
+    if (condition === 'Overlaps') {
+        if (!values.every((value) => typeof value === 'string')) {
+            throw new TypeError(`${methodName} on an array inside a JSON column takes strings: the ?| operator matches string elements`);
+        }
+        return builder[whereMethod](onArray(`${jsonArray} ?| CAST(:${paramName} AS text[])`), { [paramName]: values });
+    }
+    return builder[whereMethod](onArray(`${jsonArray} ${JSON_ARRAY_OPERATORS[condition]} CAST(:${paramName} AS jsonb)`), { [paramName]: JSON.stringify(values) });
+}

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

@@ -1,6 +1,7 @@
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
 import type { SearchSelector, TypedILikeOptions, TypedSearchOptions } from '../../../types/extensions/search.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 /**
  * Case-insensitive search methods: `ILIKE` on PostgreSQL, `LIKE` on MySQL / MariaDB and SQLite.
  * `%`, `_` and `\` in the value are escaped, and a blank value adds no condition.
@@ -13,17 +14,17 @@ export interface TypedWhereILikeMethods<Entity extends ObjectLiteral> {
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereILikeTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedILikeOptions): this;
+    whereILikeTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedILikeOptions): this;
     /**
      * Adds new AND WHERE `column ILIKE :pattern` condition in the query builder.
      * `null`, `undefined` or a blank value adds no condition.
      */
-    andWhereILikeTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedILikeOptions): this;
+    andWhereILikeTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedILikeOptions): this;
     /**
      * Adds new OR WHERE `column ILIKE :pattern` condition in the query builder.
      * `null`, `undefined` or a blank value adds no condition.
      */
-    orWhereILikeTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedILikeOptions): this;
+    orWhereILikeTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedILikeOptions): this;
     /**
      * Sets WHERE `(col1 ILIKE :pattern OR col2 ILIKE :pattern …)` condition in the query builder:
      * one group, one parameter for every column. A selector is a typed callback (it may select
@@ -32,17 +33,17 @@ export interface TypedWhereILikeMethods<Entity extends ObjectLiteral> {
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereSearchTyped<Type extends ObjectLiteral = Entity>(selectors: ReadonlyArray<SearchSelector<Type>>, value: string | null | undefined, options?: TypedSearchOptions): this;
+    whereSearchTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selectors: ReadonlyArray<SearchSelector<Type>>, value: string | null | undefined, options?: TypedSearchOptions): this;
     /**
      * Adds new AND WHERE `(col1 ILIKE :pattern OR col2 ILIKE :pattern …)` condition in the query builder.
      * A value shorter than `options.minLength` (default 1, after trimming) adds no condition.
      */
-    andWhereSearchTyped<Type extends ObjectLiteral = Entity>(selectors: ReadonlyArray<SearchSelector<Type>>, value: string | null | undefined, options?: TypedSearchOptions): this;
+    andWhereSearchTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selectors: ReadonlyArray<SearchSelector<Type>>, value: string | null | undefined, options?: TypedSearchOptions): this;
     /**
      * Adds new OR WHERE `(col1 ILIKE :pattern OR col2 ILIKE :pattern …)` condition in the query builder.
      * A value shorter than `options.minLength` (default 1, after trimming) adds no condition.
      */
-    orWhereSearchTyped<Type extends ObjectLiteral = Entity>(selectors: ReadonlyArray<SearchSelector<Type>>, value: string | null | undefined, options?: TypedSearchOptions): this;
+    orWhereSearchTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selectors: ReadonlyArray<SearchSelector<Type>>, value: string | null | undefined, options?: TypedSearchOptions): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereILikeMethods<ObjectLiteral> {

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

@@ -1,144 +1,54 @@
 import '../../where-is-any.extension';
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
-import { ArgsType } from '../../../types/util-types';
+import { TypedArrayArg, TypeOrDefault, UnsetType } from '../../../types/modules/typed-params.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
+export interface TypedWhereIsAnyMethods<Entity extends ObjectLiteral> {
+    /**
+     * Sets WHERE `column = 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.
+     */
+    whereIsAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
+    /**
+     * Adds new AND WHERE `column = ANY(:array)` condition in the query builder (PostgreSQL).
+     */
+    andWhereIsAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
+    /**
+     * Adds new OR WHERE `column = ANY(:array)` condition in the query builder (PostgreSQL).
+     */
+    orWhereIsAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
+    /**
+     * Sets WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL):
+     * the column differs from every value of the array.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereIsNotAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
+    /**
+     * Adds new AND WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL).
+     */
+    andWhereIsNotAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
+    /**
+     * Adds new OR WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL).
+     */
+    orWhereIsNotAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
+}
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
-    interface WhereExpressionBuilder {
-        /**
-         * Sets WHERE `column = 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.
-         */
-        whereIsAnyTyped<Type extends ObjectLiteral>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new AND WHERE `column = ANY(:array)` condition in the query builder (PostgreSQL).
-         */
-        andWhereIsAnyTyped<Type extends ObjectLiteral>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new OR WHERE `column = ANY(:array)` condition in the query builder (PostgreSQL).
-         */
-        orWhereIsAnyTyped<Type extends ObjectLiteral>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Sets WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL):
-         * the column differs from every value of the array.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotAnyTyped<Type extends ObjectLiteral>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new AND WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL).
-         */
-        andWhereIsNotAnyTyped<Type extends ObjectLiteral>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new OR WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL).
-         */
-        orWhereIsNotAnyTyped<Type extends ObjectLiteral>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
+    interface WhereExpressionBuilder extends TypedWhereIsAnyMethods<ObjectLiteral> {
     }
 }
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
-    interface SelectQueryBuilder<Entity extends ObjectLiteral> {
-        /**
-         * Sets WHERE `column = 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.
-         */
-        whereIsAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new AND WHERE `column = ANY(:array)` condition in the query builder (PostgreSQL).
-         */
-        andWhereIsAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new OR WHERE `column = ANY(:array)` condition in the query builder (PostgreSQL).
-         */
-        orWhereIsAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Sets WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL):
-         * the column differs from every value of the array.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new AND WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL).
-         */
-        andWhereIsNotAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new OR WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL).
-         */
-        orWhereIsNotAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereIsAnyMethods<Entity> {
     }
 }
 declare module 'typeorm/query-builder/UpdateQueryBuilder' {
-    interface UpdateQueryBuilder<Entity extends ObjectLiteral> {
-        /**
-         * Sets WHERE `column = 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.
-         */
-        whereIsAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new AND WHERE `column = ANY(:array)` condition in the query builder (PostgreSQL).
-         */
-        andWhereIsAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new OR WHERE `column = ANY(:array)` condition in the query builder (PostgreSQL).
-         */
-        orWhereIsAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Sets WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL):
-         * the column differs from every value of the array.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new AND WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL).
-         */
-        andWhereIsNotAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new OR WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL).
-         */
-        orWhereIsNotAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereIsAnyMethods<Entity> {
     }
 }
 declare module 'typeorm/query-builder/DeleteQueryBuilder' {
-    interface DeleteQueryBuilder<Entity extends ObjectLiteral> {
-        /**
-         * Sets WHERE `column = 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.
-         */
-        whereIsAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new AND WHERE `column = ANY(:array)` condition in the query builder (PostgreSQL).
-         */
-        andWhereIsAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new OR WHERE `column = ANY(:array)` condition in the query builder (PostgreSQL).
-         */
-        orWhereIsAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Sets WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL):
-         * the column differs from every value of the array.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new AND WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL).
-         */
-        andWhereIsNotAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
-        /**
-         * Adds new OR WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL).
-         */
-        orWhereIsNotAnyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType, arrayType?: string): this;
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereIsAnyMethods<Entity> {
     }
 }

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

@@ -4,6 +4,7 @@ require("../../where-is-any.extension");
 const typeorm_1 = require("typeorm");
 const query_builder_utils_1 = require("../../../utils/query-builder.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");
+/* eslint-enable @typescript-eslint/no-empty-interface */
 // patching
 const createWhereIsAnyTypedMethod = (method) => function (where, array, arrayType) {
     return attachWhereIsAnyTyped(this, method, where, array, arrayType);
@@ -31,7 +32,7 @@ function attachWhereIsAnyTyped(builder, method, where, array, arrayType) {
     if (typeof where !== 'function') {
         return builder;
     }
-    const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`);
+    const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`, { value: array });
     // .andWhere(`"table"."column" = ANY(:param)`, { param: ['value'] })
     return builder[method](key, array, arrayType);
 }

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

@@ -1,6 +1,7 @@
 import '../../where-is-distinct-from.extension';
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 /**
  * Typesafe null-safe comparisons: the column comes from an entity property.
  * See {@link WhereDistinctMethods}.
@@ -11,29 +12,29 @@ export interface TypedWhereDistinctMethods<Entity extends ObjectLiteral> {
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereIsDistinctFromTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    whereIsDistinctFromTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
     /**
      * Adds new AND WHERE `column IS DISTINCT FROM :value` condition: the column differs from the value, `NULL` included.
      */
-    andWhereIsDistinctFromTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    andWhereIsDistinctFromTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
     /**
      * Adds new OR WHERE `column IS DISTINCT FROM :value` condition: the column differs from the value, `NULL` included.
      */
-    orWhereIsDistinctFromTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    orWhereIsDistinctFromTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
     /**
      * Sets WHERE `column IS NOT DISTINCT FROM :value` condition: the column equals the value, `NULL` included.
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereIsNotDistinctFromTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    whereIsNotDistinctFromTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
     /**
      * Adds new AND WHERE `column IS NOT DISTINCT FROM :value` condition: the column equals the value, `NULL` included.
      */
-    andWhereIsNotDistinctFromTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    andWhereIsNotDistinctFromTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
     /**
      * Adds new OR WHERE `column IS NOT DISTINCT FROM :value` condition: the column equals the value, `NULL` included.
      */
-    orWhereIsNotDistinctFromTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    orWhereIsNotDistinctFromTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereDistinctMethods<ObjectLiteral> {

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

@@ -32,7 +32,7 @@ function attachWhereDistinctTyped(builder, method, where, value) {
     if (typeof where !== 'function') {
         return builder;
     }
-    const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`);
+    const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`, { value });
     // .andWhereIsDistinctFrom(`"table"."column"`, value)
     return builder[method](key, value);
 }

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

@@ -1,132 +1,51 @@
 import '../../where-is-in.extension';
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
-import { ArgsType } from '../../../types/util-types';
+import { TypedArrayArg, TypeOrDefault, UnsetType } from '../../../types/modules/typed-params.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
+export interface TypedWhereIsInMethods<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 = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>): this;
+    /**
+     * Adds new AND WHERE IN condition in the query builder.
+     */
+    andWhereIsInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>): this;
+    /**
+     * Adds new OR WHERE IN condition in the query builder.
+     */
+    orWhereIsInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>): 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 = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>): this;
+    /**
+     * Adds new AND WHERE NOT IN condition in the query builder.
+     */
+    andWhereIsNotInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>): this;
+    /**
+     * Adds new OR WHERE NOT IN condition in the query builder.
+     */
+    orWhereIsNotInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>): 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.
-         */
-        whereIsInTyped<Type extends ObjectLiteral>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE IN condition in the query builder.
-         */
-        andWhereIsInTyped<Type extends ObjectLiteral>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE IN condition in the query builder.
-         */
-        orWhereIsInTyped<Type extends ObjectLiteral>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, 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.
-         */
-        whereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE NOT IN condition in the query builder.
-         */
-        andWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE NOT IN condition in the query builder.
-         */
-        orWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
+    interface WhereExpressionBuilder extends TypedWhereIsInMethods<ObjectLiteral> {
     }
 }
 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: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE IN condition in the query builder.
-         */
-        andWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE IN condition in the query builder.
-         */
-        orWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, 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.
-         */
-        whereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE NOT IN condition in the query builder.
-         */
-        andWhereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE NOT IN condition in the query builder.
-         */
-        orWhereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereIsInMethods<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.
-         */
-        whereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE IN condition in the query builder.
-         */
-        andWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE IN condition in the query builder.
-         */
-        orWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, 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.
-         */
-        whereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE NOT IN condition in the query builder.
-         */
-        andWhereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE NOT IN condition in the query builder.
-         */
-        orWhereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereIsInMethods<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.
-         */
-        whereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE IN condition in the query builder.
-         */
-        andWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE IN condition in the query builder.
-         */
-        orWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, 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.
-         */
-        whereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE NOT IN condition in the query builder.
-         */
-        andWhereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE NOT IN condition in the query builder.
-         */
-        orWhereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereIsInMethods<Entity> {
     }
 }