typeorm-extensions 1.3.5 → 2.1.0

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

@@ -1,87 +1,43 @@
 import { ObjectLiteral } from 'typeorm';
-import { ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
-import { TypedWhereOptions } from '../../../types/extensions/typed-where.types';
+import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import { TypedWhereArgs, TypeOrDefault, UnsetType } from '../../../types/modules/typed-params.types';
+/**
+ * Typesafe WHERE conditions: the column comes from an entity property.
+ * `Type` defaults to the query builder's entity; with the `strictParams` option (see `TypeormExtensionsConfig`)
+ * the parameter is checked against the type of the selected column.
+ */
+export interface TypedWhereMethods<Entity extends ObjectLiteral> {
+    /**
+     * 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 = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => 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, Entity>>) => 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, Entity>>) => Value, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, Value>): this;
+}
 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?: unknown, 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?: unknown, 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?: unknown, options?: TypedWhereOptions): this;
+    interface WhereExpressionBuilder extends TypedWhereMethods<ObjectLiteral> {
     }
 }
 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?: unknown, 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?: unknown, 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?: unknown, options?: TypedWhereOptions): this;
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereMethods<Entity> {
     }
 }
 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?: unknown, 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?: unknown, 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?: unknown, options?: TypedWhereOptions): this;
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereMethods<Entity> {
     }
 }
 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?: unknown, 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?: unknown, 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?: unknown, options?: TypedWhereOptions): this;
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereMethods<Entity> {
     }
 }

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

@@ -1,21 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const typeorm_1 = require("typeorm");
-const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
+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");
+/* eslint-enable @typescript-eslint/no-empty-interface */
 // patching
+const createWhereTypedMethod = (method) => function (where, conditions, parameters, options) {
+    return attachTypedWhere(this, method, where, conditions, parameters, options);
+};
 const extension = {
     prototype: {
-        whereTyped: function (where, operator, parameters, options) {
-            return attachTypedWhere(this, 'where', where, operator, parameters, options);
-        },
-        andWhereTyped: function (where, operator, parameters, options) {
-            return attachTypedWhere(this, 'andWhere', where, operator, parameters, options);
-        },
-        orWhereTyped: function (where, operator, parameters, options) {
-            return attachTypedWhere(this, 'orWhere', where, operator, parameters, options);
-        },
+        whereTyped: createWhereTypedMethod('where'),
+        andWhereTyped: createWhereTypedMethod('andWhere'),
+        orWhereTyped: createWhereTypedMethod('orWhere'),
     },
 };
 const queryBuilders = [
@@ -28,18 +26,12 @@ queryBuilders.forEach((builder) => {
 });
 // implementation
 function attachTypedWhere(builder, method, where, conditions, parameters, options) {
-    const { useDoubleQuotes, addValue = true } = options || {};
+    const { addValue } = options || {};
     if (typeof where === 'function') {
-        const alias = builder.alias;
-        const key = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(where, alias, useDoubleQuotes);
-        if (Array.isArray(key)) {
-            for (const k of key) {
-                builder = (0, where_utils_1.attachWhere)(builder, method, k, conditions, parameters, {
-                    addValue,
-                });
-            }
-            return builder;
-        }
+        // 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 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/where-array.extension.d.ts

@@ -0,0 +1,70 @@
+import { ObjectLiteral } from 'typeorm';
+import { ArgsType } from '../types/util-types';
+/**
+ * Conditions on PostgreSQL array columns (`text[]`, `int[]`, `uuid[]`, …).
+ * The values are bound as one array parameter; `arrayType` (e.g. `'uuid[]'`) casts it:
+ * `CAST(:values AS uuid[])`. The operators can use a GIN index on the column.
+ */
+export interface WhereArrayMethods {
+    /**
+     * Sets WHERE `field @> :values` condition (PostgreSQL): the array column contains every value.
+     * An empty array matches every row with a non-null column.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereArrayContains(field: string, values: ArgsType, arrayType?: string): this;
+    /**
+     * Adds new AND WHERE `field @> :values` condition (PostgreSQL): the array column contains every value.
+     */
+    andWhereArrayContains(field: string, values: ArgsType, arrayType?: string): this;
+    /**
+     * Adds new OR WHERE `field @> :values` condition (PostgreSQL): the array column contains every value.
+     */
+    orWhereArrayContains(field: string, values: ArgsType, arrayType?: string): this;
+    /**
+     * Sets WHERE `field <@ :values` condition (PostgreSQL): every element of the array column is one of the values.
+     * An empty column array always matches.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereArrayContainedBy(field: string, values: ArgsType, arrayType?: string): this;
+    /**
+     * Adds new AND WHERE `field <@ :values` condition (PostgreSQL): every element of the array column is one of the values.
+     */
+    andWhereArrayContainedBy(field: string, values: ArgsType, arrayType?: string): this;
+    /**
+     * Adds new OR WHERE `field <@ :values` condition (PostgreSQL): every element of the array column is one of the values.
+     */
+    orWhereArrayContainedBy(field: string, values: ArgsType, arrayType?: string): this;
+    /**
+     * Sets WHERE `field && :values` condition (PostgreSQL): the array column has at least one of the values.
+     * An empty array matches nothing.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereArrayOverlaps(field: string, values: ArgsType, arrayType?: string): this;
+    /**
+     * Adds new AND WHERE `field && :values` condition (PostgreSQL): the array column has at least one of the values.
+     */
+    andWhereArrayOverlaps(field: string, values: ArgsType, arrayType?: string): this;
+    /**
+     * Adds new OR WHERE `field && :values` condition (PostgreSQL): the array column has at least one of the values.
+     */
+    orWhereArrayOverlaps(field: string, values: ArgsType, arrayType?: string): this;
+}
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder extends WhereArrayMethods {
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends WhereArrayMethods {
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends WhereArrayMethods {
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereArrayMethods {
+    }
+}

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

@@ -0,0 +1,47 @@
+"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");
+const createWhereArrayMethod = (method, operator) => function (field, values, arrayType) {
+    return attachWhereArray(this, method, field, operator, values, arrayType);
+};
+const extension = {
+    prototype: {
+        whereArrayContains: createWhereArrayMethod('where', '@>'),
+        andWhereArrayContains: createWhereArrayMethod('andWhere', '@>'),
+        orWhereArrayContains: createWhereArrayMethod('orWhere', '@>'),
+        whereArrayContainedBy: createWhereArrayMethod('where', '<@'),
+        andWhereArrayContainedBy: createWhereArrayMethod('andWhere', '<@'),
+        orWhereArrayContainedBy: createWhereArrayMethod('orWhere', '<@'),
+        whereArrayOverlaps: createWhereArrayMethod('where', '&&'),
+        andWhereArrayOverlaps: createWhereArrayMethod('andWhere', '&&'),
+        orWhereArrayOverlaps: createWhereArrayMethod('orWhere', '&&'),
+    },
+};
+const queryBuilders = [
+    typeorm_1.SelectQueryBuilder,
+    typeorm_1.UpdateQueryBuilder,
+    typeorm_1.DeleteQueryBuilder,
+];
+queryBuilders.forEach((builder) => {
+    (0, prototype_utils_1.patchPrototype)(builder, extension);
+});
+// implementation
+function attachWhereArray(builder, method, field, operator, values, arrayType) {
+    if (!method || typeof field !== 'string') {
+        return builder;
+    }
+    if (!Array.isArray(values)) {
+        // a missing array has no safe meaning here: `@> '{}'` would match every row
+        throw new TypeError(`Array condition on "${field}" expects an array of values, got ${values}`);
+    }
+    const castTo = arrayType === undefined ? undefined : (0, sql_utils_1.assertArrayType)(arrayType);
+    const paramName = (0, sql_utils_1.createUniqueParameterName)(method);
+    // CAST(... AS ...) rather than `::type`: TypeORM would read `::text` as a `:text` parameter
+    const parameter = castTo ? `CAST(:${paramName} AS ${castTo})` : `:${paramName}`;
+    // the array is bound as is, empty arrays included: PostgreSQL's own semantics apply
+    // ("table"."tags" @> :param, where :param is the whole array)
+    return builder[method](`${(0, query_builder_utils_1.toFieldSql)(builder, field)} ${operator} ${parameter}`, { [paramName]: values });
+}

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

@@ -0,0 +1,142 @@
+import { ObjectLiteral } from 'typeorm';
+import { ArgsType } from '../types/util-types';
+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;
+    }
+}
+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>;
+    }
+}
+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>;
+    }
+}
+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>;
+    }
+}

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

@@ -0,0 +1,44 @@
+"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");
+const createWhereIsAnyMethod = (method, comparison) => function (field, array, arrayType) {
+    return attachWhereIsAny(this, method, field, comparison, array, arrayType);
+};
+const extension = {
+    prototype: {
+        whereIsAny: createWhereIsAnyMethod('where', '= ANY'),
+        andWhereIsAny: createWhereIsAnyMethod('andWhere', '= ANY'),
+        orWhereIsAny: createWhereIsAnyMethod('orWhere', '= ANY'),
+        whereIsNotAny: createWhereIsAnyMethod('where', '<> ALL'),
+        andWhereIsNotAny: createWhereIsAnyMethod('andWhere', '<> ALL'),
+        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);
+});
+// implementation
+function attachWhereIsAny(builder, method, field, comparison, array, arrayType) {
+    if (!method || typeof field !== 'string') {
+        return builder;
+    }
+    const castTo = arrayType === undefined ? undefined : (0, sql_utils_1.assertArrayType)(arrayType);
+    if (!(array === null || array === void 0 ? void 0 : array.length)) {
+        // don't bind an empty array, same as IN / NOT IN:
+        // `= ANY('{}')` matches nothing, `<> ALL('{}')` matches everything
+        return builder[method](comparison === '= ANY' ? 'FALSE' : 'TRUE');
+    }
+    const paramName = (0, sql_utils_1.createUniqueParameterName)(method);
+    // CAST(... AS ...) rather than `::type`: TypeORM would read `::text` as a `:text` parameter
+    const parameter = castTo ? `CAST(:${paramName} AS ${castTo})` : `:${paramName}`;
+    // "table"."column" = ANY(:param) / <> ALL(:param), where :param is the whole array
+    return builder[method](`${(0, query_builder_utils_1.toFieldSql)(builder, field)} ${comparison}(${parameter})`, { [paramName]: array });
+}

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

@@ -0,0 +1,56 @@
+import { ObjectLiteral } from 'typeorm';
+/**
+ * Null-safe comparisons: `NULL` is a value like any other, so `NULL` equals `NULL`
+ * and differs from `1`, where `=` / `<>` would give `NULL` and drop the row.
+ * `null` / `undefined` compare with `NULL`.
+ *
+ * PostgreSQL and most databases: `IS [NOT] DISTINCT FROM`; MySQL / MariaDB: `<=>`; SQLite: `IS [NOT]`.
+ */
+export interface WhereDistinctMethods {
+    /**
+     * Sets WHERE `field IS DISTINCT FROM :value` condition: the field differs from the value,
+     * `NULL` included (`NULL` differs from `1`, but not from `NULL`).
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereIsDistinctFrom(field: string, value: unknown): this;
+    /**
+     * Adds new AND WHERE `field IS DISTINCT FROM :value` condition: the field differs from the value, `NULL` included.
+     */
+    andWhereIsDistinctFrom(field: string, value: unknown): this;
+    /**
+     * Adds new OR WHERE `field IS DISTINCT FROM :value` condition: the field differs from the value, `NULL` included.
+     */
+    orWhereIsDistinctFrom(field: string, value: unknown): this;
+    /**
+     * Sets WHERE `field IS NOT DISTINCT FROM :value` condition: the field equals the value,
+     * `NULL` included (`NULL` equals `NULL`).
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereIsNotDistinctFrom(field: string, value: unknown): this;
+    /**
+     * Adds new AND WHERE `field IS NOT DISTINCT FROM :value` condition: the field equals the value, `NULL` included.
+     */
+    andWhereIsNotDistinctFrom(field: string, value: unknown): this;
+    /**
+     * Adds new OR WHERE `field IS NOT DISTINCT FROM :value` condition: the field equals the value, `NULL` included.
+     */
+    orWhereIsNotDistinctFrom(field: string, value: unknown): this;
+}
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder extends WhereDistinctMethods {
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends WhereDistinctMethods {
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends WhereDistinctMethods {
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereDistinctMethods {
+    }
+}

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

@@ -0,0 +1,55 @@
+"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");
+/* eslint-enable @typescript-eslint/no-empty-interface, @typescript-eslint/no-unused-vars */
+// patching
+const createWhereDistinctMethod = (method, distinct) => function (field, value) {
+    return attachWhereDistinct(this, method, field, distinct, value);
+};
+const extension = {
+    prototype: {
+        whereIsDistinctFrom: createWhereDistinctMethod('where', true),
+        andWhereIsDistinctFrom: createWhereDistinctMethod('andWhere', true),
+        orWhereIsDistinctFrom: createWhereDistinctMethod('orWhere', true),
+        whereIsNotDistinctFrom: createWhereDistinctMethod('where', false),
+        andWhereIsNotDistinctFrom: createWhereDistinctMethod('andWhere', false),
+        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);
+});
+// implementation
+/** `field IS [NOT] DISTINCT FROM value` in the database's own null-safe syntax. */
+function buildDistinctCondition(driver, field, distinct, value) {
+    if ((0, sql_utils_1.isMysqlLikeDriver)(driver)) {
+        // `<=>` is MySQL's null-safe equality
+        return distinct ? `NOT (${field} <=> ${value})` : `${field} <=> ${value}`;
+    }
+    if ((0, sql_utils_1.isSqliteLikeDriver)(driver)) {
+        // SQLite's `IS` / `IS NOT` compare any values null-safely (IS DISTINCT FROM needs SQLite 3.39+)
+        return `${field} ${distinct ? 'IS NOT' : 'IS'} ${value}`;
+    }
+    return `${field} ${distinct ? 'IS DISTINCT FROM' : 'IS NOT DISTINCT FROM'} ${value}`;
+}
+function attachWhereDistinct(builder, method, field, distinct, value) {
+    if (!method || typeof field !== 'string') {
+        return builder;
+    }
+    const driver = (0, sql_utils_1.getDriverType)(builder);
+    const column = (0, query_builder_utils_1.toFieldSql)(builder, field);
+    if (value === null || value === undefined) {
+        // compare with the NULL literal, no parameter to bind
+        return builder[method](buildDistinctCondition(driver, column, distinct, 'NULL'));
+    }
+    const paramName = (0, sql_utils_1.createUniqueParameterName)(method);
+    return builder[method](buildDistinctCondition(driver, column, distinct, `:${paramName}`), { [paramName]: value });
+}

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

@@ -0,0 +1,55 @@
+import { ObjectLiteral } from 'typeorm';
+/**
+ * Conditions on PostgreSQL `jsonb` / `json` / `simple-json` columns. The column is cast to `jsonb`
+ * (a no-op for `jsonb` columns, so a GIN index on them is still used).
+ * `field` can also be a JSON expression, e.g. `tableHelper('u').jsonColumn('metadata', '->', 'settings')`.
+ */
+export interface WhereJsonMethods {
+    /**
+     * Sets WHERE `field @> :value` condition (PostgreSQL): the JSON document contains `value`,
+     * e.g. `{ role: 'admin' }` matches `{ "role": "admin", "age": 30 }`.
+     * `value` is serialized with `JSON.stringify`.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereJsonContains(field: string, value: unknown): this;
+    /**
+     * Adds new AND WHERE `field @> :value` condition (PostgreSQL): the JSON document contains `value`.
+     */
+    andWhereJsonContains(field: string, value: unknown): this;
+    /**
+     * Adds new OR WHERE `field @> :value` condition (PostgreSQL): the JSON document contains `value`.
+     */
+    orWhereJsonContains(field: string, value: unknown): this;
+    /**
+     * Sets WHERE `field ? :key` condition (PostgreSQL): the JSON object has the top-level key
+     * (or the JSON array has the string element).
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereJsonHasKey(field: string, key: string): this;
+    /**
+     * Adds new AND WHERE `field ? :key` condition (PostgreSQL): the JSON object has the top-level key.
+     */
+    andWhereJsonHasKey(field: string, key: string): this;
+    /**
+     * Adds new OR WHERE `field ? :key` condition (PostgreSQL): the JSON object has the top-level key.
+     */
+    orWhereJsonHasKey(field: string, key: string): this;
+}
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder extends WhereJsonMethods {
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends WhereJsonMethods {
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends WhereJsonMethods {
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereJsonMethods {
+    }
+}