typeorm-extensions 1.3.5 → 2.1.0

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

@@ -7,28 +7,28 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
          * Creates SELECT query.
          * Replaces all previous selections if they exist.
          */
-        selectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useDoubleQuotes?: boolean): SelectQueryBuilder<Entity>;
+        selectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useQuotes?: boolean): SelectQueryBuilder<Entity>;
         /**
          * Creates SELECT query and selects given data.
          * Replaces all previous selections if they exist.
          */
-        selectTyped(this: SelectQueryBuilder<Entity>, selection: string | KeyHolder, selectionAliasName?: string, useDoubleQuotes?: boolean): SelectQueryBuilder<Entity>;
+        selectTyped(this: SelectQueryBuilder<Entity>, selection: string | KeyHolder, selectionAliasName?: string, useQuotes?: boolean): SelectQueryBuilder<Entity>;
         /**
          * Creates SELECT query and selects given data.
          * Replaces all previous selections if they exist.
          */
-        selectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useDoubleQuotes?: boolean): SelectQueryBuilder<Entity>;
+        selectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useQuotes?: boolean): SelectQueryBuilder<Entity>;
         /**
          * Adds new selection to the SELECT query.
          */
-        addSelectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useDoubleQuotes?: boolean): SelectQueryBuilder<Entity>;
+        addSelectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useQuotes?: boolean): SelectQueryBuilder<Entity>;
         /**
          * Adds new selection to the SELECT query.
          */
-        addSelectTyped(this: SelectQueryBuilder<Entity>, selection: string | KeyHolder, selectionAliasName?: string, useDoubleQuotes?: boolean): SelectQueryBuilder<Entity>;
+        addSelectTyped(this: SelectQueryBuilder<Entity>, selection: string | KeyHolder, selectionAliasName?: string, useQuotes?: boolean): SelectQueryBuilder<Entity>;
         /**
          * Adds new selection to the SELECT query.
          */
-        addSelectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useDoubleQuotes?: boolean): SelectQueryBuilder<Entity>;
+        addSelectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useQuotes?: boolean): SelectQueryBuilder<Entity>;
     }
 }

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

@@ -2,34 +2,37 @@
 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");
 // patching
 const extension = {
     prototype: {
-        selectTyped(selection, selectionAliasName, useDoubleQuotes) {
+        selectTyped(selection, selectionAliasName, useQuotes) {
             return attachSelectMethod(this, 'select', selection, typeof selectionAliasName === 'string' ? selectionAliasName : undefined, typeof selectionAliasName === 'boolean'
                 ? selectionAliasName
-                : useDoubleQuotes);
+                : useQuotes);
         },
-        addSelectTyped(selection, selectionAliasName, useDoubleQuotes) {
+        addSelectTyped(selection, selectionAliasName, useQuotes) {
             return attachSelectMethod(this, 'addSelect', selection, typeof selectionAliasName === 'string' ? selectionAliasName : undefined, typeof selectionAliasName === 'boolean'
                 ? selectionAliasName
-                : useDoubleQuotes);
+                : useQuotes);
         },
     },
 };
 (0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
 // implementation
-const attachSelectMethod = (query, method, selection, selectionAliasName, useDoubleQuotes) => {
+const attachSelectMethod = (query, method, selection, selectionAliasName, useQuotes) => {
     if (selection instanceof proxy_key_utils_1.KeyHolder) {
-        return query[method](selection.toSql(undefined, useDoubleQuotes), selectionAliasName);
+        return query[method](selection.toSql(undefined, useQuotes), selectionAliasName);
     }
     if (Array.isArray(selection)) {
-        const arrayOfKeys = selection.map((select) => (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(select, query.alias, useDoubleQuotes));
+        const arrayOfKeys = selection.flatMap((select) => select instanceof proxy_key_utils_1.KeyHolder
+            ? (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(select, () => query.alias, useQuotes)
+            : (0, query_builder_utils_1.getTypedSelectionKey)(query, select, useQuotes));
         return query[method](arrayOfKeys);
     }
     else if (typeof selection === 'function') {
-        const keyArrayOrSingleKey = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(selection, query.alias, useDoubleQuotes);
+        const keyArrayOrSingleKey = (0, query_builder_utils_1.getTypedSelectionKey)(query, selection, useQuotes);
         if (Array.isArray(keyArrayOrSingleKey)) {
             return query[method](keyArrayOrSingleKey);
         }

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

@@ -0,0 +1,31 @@
+import '../../period-filter.extension';
+import { ObjectLiteral } from 'typeorm';
+import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import type { PeriodFilter } from '../../../types/interfaces/period.interface';
+import type { ApplyPeriodOptions } from '../../../types/extensions/period.types';
+export interface TypedPeriodFilterMethods<Entity extends ObjectLiteral> {
+    /**
+     * Adds AND WHERE conditions for a period on an entity property:
+     * `column >= :periodFrom AND column <= :periodTo`.
+     * Missing, `null` or empty ends are skipped, so an empty filter adds nothing.
+     * Both ends are inclusive unless `options.includeFrom` / `options.includeTo` is `false`.
+     * A date-only string (`'2024-01-31'`) stands for the whole day: `periodTo: '2024-01-31'` → `column < '2024-02-01'`.
+     */
+    applyPeriodFilterTyped<Type extends ObjectLiteral = Entity>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, periodFilter: PeriodFilter | null | undefined, options?: ApplyPeriodOptions): this;
+}
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder extends TypedPeriodFilterMethods<ObjectLiteral> {
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedPeriodFilterMethods<Entity> {
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends TypedPeriodFilterMethods<Entity> {
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedPeriodFilterMethods<Entity> {
+    }
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("../../period-filter.extension");
+const typeorm_1 = require("typeorm");
+const query_builder_utils_1 = require("../../../utils/query-builder.utils");
+const prototype_utils_1 = require("../../../utils/prototype.utils");
+const period_utils_1 = require("../../../utils/period.utils");
+/* eslint-enable @typescript-eslint/no-empty-interface */
+// patching
+const extension = {
+    prototype: {
+        applyPeriodFilterTyped(selection, periodFilter, options) {
+            const column = (0, query_builder_utils_1.getTypedSingleColumnKey)(this, selection, 'applyPeriodFilterTyped', { asTimestamp: true });
+            return (0, period_utils_1.attachPeriodFilter)(this, column, periodFilter, options);
+        },
+    },
+};
+const queryBuilders = [
+    typeorm_1.SelectQueryBuilder,
+    typeorm_1.UpdateQueryBuilder,
+    typeorm_1.DeleteQueryBuilder,
+];
+queryBuilders.forEach((builder) => {
+    (0, prototype_utils_1.patchPrototype)(builder, extension);
+});

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

@@ -0,0 +1,68 @@
+import '../../where-array.extension';
+import { ObjectLiteral } from 'typeorm';
+import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import { ArgsType } from '../../../types/util-types';
+/**
+ * Typesafe conditions on PostgreSQL array columns: the column comes from an entity property.
+ * See {@link WhereArrayMethods}.
+ */
+export interface TypedWhereArrayMethods<Entity extends ObjectLiteral> {
+    /**
+     * Sets WHERE `column @> :values` condition (PostgreSQL): the array column contains every value.
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+}
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder extends TypedWhereArrayMethods<ObjectLiteral> {
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereArrayMethods<Entity> {
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereArrayMethods<Entity> {
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereArrayMethods<Entity> {
+    }
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+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 prototype_utils_1 = require("../../../utils/prototype.utils");
+/* eslint-enable @typescript-eslint/no-empty-interface */
+// patching
+const createWhereArrayTypedMethod = (method) => function (where, values, arrayType) {
+    return attachWhereArrayTyped(this, method, where, values, arrayType);
+};
+const extension = {
+    prototype: {
+        whereArrayContainsTyped: createWhereArrayTypedMethod('whereArrayContains'),
+        andWhereArrayContainsTyped: createWhereArrayTypedMethod('andWhereArrayContains'),
+        orWhereArrayContainsTyped: createWhereArrayTypedMethod('orWhereArrayContains'),
+        whereArrayContainedByTyped: createWhereArrayTypedMethod('whereArrayContainedBy'),
+        andWhereArrayContainedByTyped: createWhereArrayTypedMethod('andWhereArrayContainedBy'),
+        orWhereArrayContainedByTyped: createWhereArrayTypedMethod('orWhereArrayContainedBy'),
+        whereArrayOverlapsTyped: createWhereArrayTypedMethod('whereArrayOverlaps'),
+        andWhereArrayOverlapsTyped: createWhereArrayTypedMethod('andWhereArrayOverlaps'),
+        orWhereArrayOverlapsTyped: createWhereArrayTypedMethod('orWhereArrayOverlaps'),
+    },
+};
+const queryBuilders = [
+    typeorm_1.SelectQueryBuilder,
+    typeorm_1.UpdateQueryBuilder,
+    typeorm_1.DeleteQueryBuilder,
+];
+queryBuilders.forEach((builder) => {
+    (0, prototype_utils_1.patchPrototype)(builder, extension);
+});
+// implementation
+function attachWhereArrayTyped(builder, method, where, values, arrayType) {
+    if (typeof where !== 'function') {
+        return builder;
+    }
+    const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`);
+    // .andWhereArrayContains(`"table"."column"`, ['value'])
+    return builder[method](key, values, arrayType);
+}

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

@@ -0,0 +1,62 @@
+import { ObjectLiteral } from 'typeorm';
+import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import type { SearchSelector, TypedILikeOptions, TypedSearchOptions } from '../../../types/extensions/search.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.
+ */
+export interface TypedWhereILikeMethods<Entity extends ObjectLiteral> {
+    /**
+     * Sets WHERE `column ILIKE :pattern` condition in the query builder,
+     * `%value%` by default (`options.match`). `%`, `_` and `\` in the value match themselves.
+     * `null`, `undefined` or a blank value adds no condition (previous conditions are kept).
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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
+     * several columns) or a raw expression `{ sql: '…' }`, which is put in parentheses.
+     * A value shorter than `options.minLength` (default 1, after trimming) adds no condition.
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+}
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder extends TypedWhereILikeMethods<ObjectLiteral> {
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereILikeMethods<Entity> {
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereILikeMethods<Entity> {
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereILikeMethods<Entity> {
+    }
+}

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

@@ -0,0 +1,84 @@
+"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");
+const search_utils_1 = require("../../../utils/search.utils");
+/* eslint-enable @typescript-eslint/no-empty-interface */
+// patching
+const createWhereILikeTypedMethod = (method) => function (where, value, options) {
+    if (typeof where !== 'function') {
+        return this;
+    }
+    const methodName = `${method}ILikeTyped`;
+    // resolve the column first: a wrong selector throws even for a blank value
+    const column = (0, query_builder_utils_1.getTypedSingleColumnKey)(this, where, methodName);
+    const term = (0, search_utils_1.toSearchTerm)(value, methodName);
+    if (term === undefined) {
+        return this;
+    }
+    return attachILike(this, method, [column], term, options);
+};
+const createWhereSearchTypedMethod = (method) => function (selectors, value, options) {
+    var _a;
+    const methodName = `${method}SearchTyped`;
+    // resolve the columns first: a wrong selector throws even for a blank value
+    const columns = getSearchColumns(this, selectors, methodName);
+    const term = (0, search_utils_1.toSearchTerm)(value, methodName);
+    const minLength = (_a = options === null || options === void 0 ? void 0 : options.minLength) !== null && _a !== void 0 ? _a : 1;
+    if (term === undefined || term.length < minLength) {
+        return this;
+    }
+    return attachILike(this, method, columns, term, options);
+};
+const extension = {
+    prototype: {
+        whereILikeTyped: createWhereILikeTypedMethod('where'),
+        andWhereILikeTyped: createWhereILikeTypedMethod('andWhere'),
+        orWhereILikeTyped: createWhereILikeTypedMethod('orWhere'),
+        whereSearchTyped: createWhereSearchTypedMethod('where'),
+        andWhereSearchTyped: createWhereSearchTypedMethod('andWhere'),
+        orWhereSearchTyped: createWhereSearchTypedMethod('orWhere'),
+    },
+};
+const queryBuilders = [
+    typeorm_1.SelectQueryBuilder,
+    typeorm_1.UpdateQueryBuilder,
+    typeorm_1.DeleteQueryBuilder,
+];
+queryBuilders.forEach((builder) => {
+    (0, prototype_utils_1.patchPrototype)(builder, extension);
+});
+// implementation
+/** Quoted columns and raw expressions of the search selectors, in order. */
+function getSearchColumns(builder, selectors, methodName) {
+    if (!Array.isArray(selectors) || selectors.length === 0) {
+        // no columns to search in: matching nothing or everything silently would hide the bug
+        throw new TypeError(`${methodName} expects a non-empty array of columns to search in`);
+    }
+    return selectors.flatMap((selector) => {
+        if (typeof selector === 'function') {
+            return (0, query_builder_utils_1.getTypedColumnKey)(builder, selector);
+        }
+        if (selector && typeof selector === 'object' && typeof selector.sql === 'string' && selector.sql.trim()) {
+            // in parentheses: the expression may have operators that bind looser than ILIKE
+            return `(${selector.sql})`;
+        }
+        throw new TypeError(`${methodName} expects a typed callback or { sql: string }, got ${JSON.stringify(selector)}`);
+    });
+}
+/**
+ * `column ILIKE :pattern` for one column, `(col1 ILIKE :pattern OR col2 ILIKE :pattern)` for several:
+ * all the columns share one parameter.
+ */
+function attachILike(builder, method, columns, term, options) {
+    const { match = 'contains', escape = true, unaccent } = options !== null && options !== void 0 ? options : {};
+    const pattern = (0, search_utils_1.toLikePattern)(term, match, escape);
+    const unaccentFunction = (0, search_utils_1.toUnaccentFunction)(unaccent);
+    const driver = (0, sql_utils_1.getDriverType)(builder);
+    const paramName = (0, sql_utils_1.createUniqueParameterName)(method);
+    const conditions = columns.map((column) => (0, search_utils_1.buildILikeCondition)(driver, column, `:${paramName}`, unaccentFunction));
+    const condition = conditions.length === 1 ? conditions[0] : `(${conditions.join(' OR ')})`;
+    return builder[method](condition, { [paramName]: pattern });
+}

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

@@ -0,0 +1,53 @@
+import '../../where-is-any.extension';
+import { ObjectLiteral } from 'typeorm';
+import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import { TypedArrayArg, TypeOrDefault, UnsetType } from '../../../types/modules/typed-params.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, 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, 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, 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, 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, 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, Entity>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
+}
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder extends TypedWhereIsAnyMethods<ObjectLiteral> {
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereIsAnyMethods<Entity> {
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereIsAnyMethods<Entity> {
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereIsAnyMethods<Entity> {
+    }
+}

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+};
+const extension = {
+    prototype: {
+        whereIsAnyTyped: createWhereIsAnyTypedMethod('whereIsAny'),
+        andWhereIsAnyTyped: createWhereIsAnyTypedMethod('andWhereIsAny'),
+        orWhereIsAnyTyped: createWhereIsAnyTypedMethod('orWhereIsAny'),
+        whereIsNotAnyTyped: createWhereIsAnyTypedMethod('whereIsNotAny'),
+        andWhereIsNotAnyTyped: createWhereIsAnyTypedMethod('andWhereIsNotAny'),
+        orWhereIsNotAnyTyped: createWhereIsAnyTypedMethod('orWhereIsNotAny'),
+    },
+};
+const queryBuilders = [
+    typeorm_1.SelectQueryBuilder,
+    typeorm_1.UpdateQueryBuilder,
+    typeorm_1.DeleteQueryBuilder,
+];
+queryBuilders.forEach((builder) => {
+    (0, prototype_utils_1.patchPrototype)(builder, extension);
+});
+// implementation
+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`, { 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

@@ -0,0 +1,53 @@
+import '../../where-is-distinct-from.extension';
+import { ObjectLiteral } from 'typeorm';
+import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+/**
+ * Typesafe null-safe comparisons: the column comes from an entity property.
+ * See {@link WhereDistinctMethods}.
+ */
+export interface TypedWhereDistinctMethods<Entity extends ObjectLiteral> {
+    /**
+     * Sets WHERE `column IS DISTINCT FROM :value` condition: the column differs from the value, `NULL` included.
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+}
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder extends TypedWhereDistinctMethods<ObjectLiteral> {
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereDistinctMethods<Entity> {
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereDistinctMethods<Entity> {
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereDistinctMethods<Entity> {
+    }
+}

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("../../where-is-distinct-from.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 createWhereDistinctTypedMethod = (method) => function (where, value) {
+    return attachWhereDistinctTyped(this, method, where, value);
+};
+const extension = {
+    prototype: {
+        whereIsDistinctFromTyped: createWhereDistinctTypedMethod('whereIsDistinctFrom'),
+        andWhereIsDistinctFromTyped: createWhereDistinctTypedMethod('andWhereIsDistinctFrom'),
+        orWhereIsDistinctFromTyped: createWhereDistinctTypedMethod('orWhereIsDistinctFrom'),
+        whereIsNotDistinctFromTyped: createWhereDistinctTypedMethod('whereIsNotDistinctFrom'),
+        andWhereIsNotDistinctFromTyped: createWhereDistinctTypedMethod('andWhereIsNotDistinctFrom'),
+        orWhereIsNotDistinctFromTyped: createWhereDistinctTypedMethod('orWhereIsNotDistinctFrom'),
+    },
+};
+const queryBuilders = [
+    typeorm_1.SelectQueryBuilder,
+    typeorm_1.UpdateQueryBuilder,
+    typeorm_1.DeleteQueryBuilder,
+];
+queryBuilders.forEach((builder) => {
+    (0, prototype_utils_1.patchPrototype)(builder, extension);
+});
+// implementation
+function attachWhereDistinctTyped(builder, method, where, value) {
+    if (typeof where !== 'function') {
+        return builder;
+    }
+    const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`, { value });
+    // .andWhereIsDistinctFrom(`"table"."column"`, value)
+    return builder[method](key, value);
+}