typeorm-extensions 1.3.5 → 2.0.0

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`);
+    // .andWhereIsDistinctFrom(`"table"."column"`, value)
+    return builder[method](key, value);
+}

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

@@ -1,8 +1,7 @@
 import '../../where-is-in.extension';
 import { ObjectLiteral } from 'typeorm';
-import { ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
 import { ArgsType } from '../../../types/util-types';
-import { TypedWhereIsInOptions } from '../../../types/extensions/typed-where.types';
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder {
         /**
@@ -10,29 +9,29 @@ declare module 'typeorm/query-builder/WhereExpressionBuilder' {
          * If you had previously WHERE expression defined,
          * calling this function will override previously set WHERE conditions.
          */
-        whereIsInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        orWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
     }
 }
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
@@ -42,29 +41,29 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
          * If you had previously WHERE expression defined,
          * calling this function will override previously set WHERE conditions.
          */
-        whereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        orWhereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
     }
 }
 declare module 'typeorm/query-builder/UpdateQueryBuilder' {
@@ -74,29 +73,29 @@ declare module 'typeorm/query-builder/UpdateQueryBuilder' {
          * If you had previously WHERE expression defined,
          * calling this function will override previously set WHERE conditions.
          */
-        whereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        orWhereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
     }
 }
 declare module 'typeorm/query-builder/DeleteQueryBuilder' {
@@ -106,28 +105,28 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
          * If you had previously WHERE expression defined,
          * calling this function will override previously set WHERE conditions.
          */
-        whereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        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>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        orWhereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
     }
 }

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

@@ -2,28 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 require("../../where-is-in.extension");
 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: {
-        whereIsInTyped: function (where, array, options) {
-            return attachWhereIsIn(this, 'whereIsIn', where, array, options);
+        whereIsInTyped: function (where, array) {
+            return attachWhereIsIn(this, 'whereIsIn', where, array);
         },
-        andWhereIsInTyped: function (where, array, options) {
-            return attachWhereIsIn(this, 'andWhereIsIn', where, array, options);
+        andWhereIsInTyped: function (where, array) {
+            return attachWhereIsIn(this, 'andWhereIsIn', where, array);
         },
-        orWhereIsInTyped: function (where, array, options) {
-            return attachWhereIsIn(this, 'orWhereIsIn', where, array, options);
+        orWhereIsInTyped: function (where, array) {
+            return attachWhereIsIn(this, 'orWhereIsIn', where, array);
         },
-        whereIsNotInTyped: function (where, array, options) {
-            return attachWhereIsIn(this, 'whereIsNotIn', where, array, options);
+        whereIsNotInTyped: function (where, array) {
+            return attachWhereIsIn(this, 'whereIsNotIn', where, array);
         },
-        andWhereIsNotInTyped: function (where, array, options) {
-            return attachWhereIsIn(this, 'andWhereIsNotIn', where, array, options);
+        andWhereIsNotInTyped: function (where, array) {
+            return attachWhereIsIn(this, 'andWhereIsNotIn', where, array);
         },
-        orWhereIsNotInTyped: function (where, array, options) {
-            return attachWhereIsIn(this, 'orWhereIsNotIn', where, array, options);
+        orWhereIsNotInTyped: function (where, array) {
+            return attachWhereIsIn(this, 'orWhereIsNotIn', where, array);
         },
     },
 };
@@ -36,17 +36,10 @@ queryBuilders.forEach((builder) => {
     (0, prototype_utils_1.patchPrototype)(builder, extension);
 });
 // implementation
-function attachWhereIsIn(builder, method, where, array, options) {
-    const { useDoubleQuotes } = options || {};
+function attachWhereIsIn(builder, method, where, array) {
     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 = builder[method](k, array);
-            }
-            return builder;
-        }
+        // several columns have no single meaning (AND? OR?), and `where…` kept only the last one
+        const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`);
         // .andWhere(`"table"."column"   IN (:...values)`, { values: ['value'] })
         return builder[method](key, array);
     }

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

@@ -0,0 +1,53 @@
+import '../../where-json.extension';
+import { ObjectLiteral } from 'typeorm';
+import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+/**
+ * Typesafe conditions on PostgreSQL `jsonb` / `json` columns: the column comes from an entity property.
+ * See {@link WhereJsonMethods}.
+ */
+export interface TypedWhereJsonMethods<Entity extends ObjectLiteral> {
+    /**
+     * Sets WHERE `column @> :value` condition (PostgreSQL): the JSON document contains `value`.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereJsonContainsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    /**
+     * Adds new AND WHERE `column @> :value` condition (PostgreSQL): the JSON document contains `value`.
+     */
+    andWhereJsonContainsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    /**
+     * Adds new OR WHERE `column @> :value` condition (PostgreSQL): the JSON document contains `value`.
+     */
+    orWhereJsonContainsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    /**
+     * Sets WHERE `column ? :key` condition (PostgreSQL): the JSON object has the top-level key.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereJsonHasKeyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, key: string): this;
+    /**
+     * Adds new AND WHERE `column ? :key` condition (PostgreSQL): the JSON object has the top-level key.
+     */
+    andWhereJsonHasKeyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, key: string): this;
+    /**
+     * Adds new OR WHERE `column ? :key` condition (PostgreSQL): the JSON object has the top-level key.
+     */
+    orWhereJsonHasKeyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, key: string): this;
+}
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder extends TypedWhereJsonMethods<ObjectLiteral> {
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereJsonMethods<Entity> {
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereJsonMethods<Entity> {
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereJsonMethods<Entity> {
+    }
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("../../where-json.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 createWhereJsonTypedMethod = (method) => function (where, value) {
+    return attachWhereJsonTyped(this, method, where, value);
+};
+const extension = {
+    prototype: {
+        whereJsonContainsTyped: createWhereJsonTypedMethod('whereJsonContains'),
+        andWhereJsonContainsTyped: createWhereJsonTypedMethod('andWhereJsonContains'),
+        orWhereJsonContainsTyped: createWhereJsonTypedMethod('orWhereJsonContains'),
+        whereJsonHasKeyTyped: createWhereJsonTypedMethod('whereJsonHasKey'),
+        andWhereJsonHasKeyTyped: createWhereJsonTypedMethod('andWhereJsonHasKey'),
+        orWhereJsonHasKeyTyped: createWhereJsonTypedMethod('orWhereJsonHasKey'),
+    },
+};
+const queryBuilders = [
+    typeorm_1.SelectQueryBuilder,
+    typeorm_1.UpdateQueryBuilder,
+    typeorm_1.DeleteQueryBuilder,
+];
+queryBuilders.forEach((builder) => {
+    (0, prototype_utils_1.patchPrototype)(builder, extension);
+});
+// implementation
+function attachWhereJsonTyped(builder, method, where, value) {
+    if (typeof where !== 'function') {
+        return builder;
+    }
+    const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`);
+    // .andWhereJsonContains(`"table"."column"`, { role: 'admin' }) / .andWhereJsonHasKey(`"table"."column"`, 'role')
+    // (one signature for both: `value` is the JSON value or the key, each method checks its own)
+    return builder[method](key, value);
+}

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

@@ -0,0 +1,59 @@
+import { ObjectLiteral } from 'typeorm';
+import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import type { TypedLowerOptions } from '../../../types/extensions/search.types';
+/**
+ * Case-insensitive equality: `LOWER(column) = LOWER(:value)`. `options.normalize` changes the
+ * wrapping of both sides, e.g. `(sql) => \`LOWER(TRIM(${sql}))\``, to match an expression index.
+ */
+export interface TypedWhereLowerMethods<Entity extends ObjectLiteral> {
+    /**
+     * Sets WHERE `LOWER(column) = LOWER(:value)` condition in the query builder.
+     * `null` / `undefined` matches nothing (`FALSE`).
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereLowerEqualsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedLowerOptions): this;
+    /**
+     * Adds new AND WHERE `LOWER(column) = LOWER(:value)` condition in the query builder.
+     * `null` / `undefined` matches nothing (`FALSE`).
+     */
+    andWhereLowerEqualsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedLowerOptions): this;
+    /**
+     * Adds new OR WHERE `LOWER(column) = LOWER(:value)` condition in the query builder.
+     * `null` / `undefined` matches nothing (`FALSE`).
+     */
+    orWhereLowerEqualsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedLowerOptions): this;
+    /**
+     * Sets WHERE `LOWER(column) IN (LOWER(:v1), LOWER(:v2), …)` condition in the query builder.
+     * An empty or missing array matches nothing (`FALSE`), like `whereIsIn`.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereIsInLowerTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ReadonlyArray<string> | null | undefined, options?: TypedLowerOptions): this;
+    /**
+     * Adds new AND WHERE `LOWER(column) IN (LOWER(:v1), LOWER(:v2), …)` condition in the query builder.
+     * An empty or missing array matches nothing (`FALSE`).
+     */
+    andWhereIsInLowerTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ReadonlyArray<string> | null | undefined, options?: TypedLowerOptions): this;
+    /**
+     * Adds new OR WHERE `LOWER(column) IN (LOWER(:v1), LOWER(:v2), …)` condition in the query builder.
+     * An empty or missing array matches nothing (`FALSE`).
+     */
+    orWhereIsInLowerTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ReadonlyArray<string> | null | undefined, options?: TypedLowerOptions): this;
+}
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder extends TypedWhereLowerMethods<ObjectLiteral> {
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereLowerMethods<Entity> {
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereLowerMethods<Entity> {
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereLowerMethods<Entity> {
+    }
+}

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

@@ -0,0 +1,86 @@
+"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");
+/* eslint-enable @typescript-eslint/no-empty-interface */
+// patching
+const createWhereLowerEqualsTypedMethod = (method) => function (where, value, options) {
+    if (typeof where !== 'function') {
+        return this;
+    }
+    const methodName = `${method}LowerEqualsTyped`;
+    const column = (0, query_builder_utils_1.getTypedSingleColumnKey)(this, where, methodName);
+    const normalize = getNormalize(options, methodName);
+    if (value === null || value === undefined) {
+        // `LOWER(col) = LOWER(NULL)` is never true either; don't bind a parameter for it
+        return this[method]('FALSE');
+    }
+    const paramName = (0, sql_utils_1.createUniqueParameterName)(method);
+    return this[method](`${normalize(column)} = ${normalize(`:${paramName}`)}`, {
+        [paramName]: value,
+    });
+};
+const createWhereIsInLowerTypedMethod = (method) => function (where, values, options) {
+    if (typeof where !== 'function') {
+        return this;
+    }
+    const methodName = `${method}IsInLowerTyped`;
+    const column = (0, query_builder_utils_1.getTypedSingleColumnKey)(this, where, methodName);
+    const normalize = getNormalize(options, methodName);
+    if (values !== null && values !== undefined && !Array.isArray(values)) {
+        throw new TypeError(`${methodName} expects an array of values, got ${typeof values}`);
+    }
+    if (!(values === null || values === void 0 ? void 0 : values.length)) {
+        // don't bind an empty list, same as whereIsIn
+        return this[method]('FALSE');
+    }
+    // one parameter per value: each one is normalized by the database, like the column
+    const paramName = (0, sql_utils_1.createUniqueParameterName)(method);
+    const parameters = {};
+    const placeholders = values.map((value, index) => {
+        parameters[`${paramName}_${index}`] = value;
+        return normalize(`:${paramName}_${index}`);
+    });
+    return this[method](`${normalize(column)} IN (${placeholders.join(', ')})`, parameters);
+};
+const extension = {
+    prototype: {
+        whereLowerEqualsTyped: createWhereLowerEqualsTypedMethod('where'),
+        andWhereLowerEqualsTyped: createWhereLowerEqualsTypedMethod('andWhere'),
+        orWhereLowerEqualsTyped: createWhereLowerEqualsTypedMethod('orWhere'),
+        whereIsInLowerTyped: createWhereIsInLowerTypedMethod('where'),
+        andWhereIsInLowerTyped: createWhereIsInLowerTypedMethod('andWhere'),
+        orWhereIsInLowerTyped: createWhereIsInLowerTypedMethod('orWhere'),
+    },
+};
+const queryBuilders = [
+    typeorm_1.SelectQueryBuilder,
+    typeorm_1.UpdateQueryBuilder,
+    typeorm_1.DeleteQueryBuilder,
+];
+queryBuilders.forEach((builder) => {
+    (0, prototype_utils_1.patchPrototype)(builder, extension);
+});
+// implementation
+const lower = (sql) => `LOWER(${sql})`;
+/**
+ * The wrapping for both sides: `options.normalize` or `LOWER(…)`. Its result must contain the
+ * expression it was given, or the column / the parameter would be dropped from the condition.
+ */
+function getNormalize(options, methodName) {
+    var _a;
+    const normalize = (_a = options === null || options === void 0 ? void 0 : options.normalize) !== null && _a !== void 0 ? _a : lower;
+    if (typeof normalize !== 'function') {
+        throw new TypeError(`${methodName} expects options.normalize to be a function`);
+    }
+    return (sql) => {
+        const result = normalize(sql);
+        if (typeof result !== 'string' || !result.includes(sql)) {
+            throw new TypeError(`${methodName}: options.normalize must return an SQL expression containing its argument ` +
+                `"${sql}", got ${JSON.stringify(result)}`);
+        }
+        return result;
+    };
+}

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

@@ -0,0 +1,54 @@
+import { ObjectLiteral } from 'typeorm';
+import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import type { SimilarityScoreOptions, TypedSimilarOptions } from '../../../types/extensions/search.types';
+/**
+ * Trigram similarity conditions (PostgreSQL, `pg_trgm` extension). The column is the left operand,
+ * the form a `gin_trgm_ops` / `gist_trgm_ops` index on the column can be used for.
+ */
+export interface TypedWhereSimilarMethods<Entity extends ObjectLiteral> {
+    /**
+     * Sets WHERE `column % :term` condition in the query builder (PostgreSQL, pg_trgm).
+     * `options.operator`: `'%'` (default), `'%>'` (`column %> :term`, same as `:term <% column`)
+     * or `'<%'` (`column <% :term`, can't use an index). A blank term adds no condition.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereSimilarTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, options?: TypedSimilarOptions): this;
+    /**
+     * Adds new AND WHERE `column % :term` condition in the query builder (PostgreSQL, pg_trgm).
+     * A blank term adds no condition.
+     */
+    andWhereSimilarTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, options?: TypedSimilarOptions): this;
+    /**
+     * Adds new OR WHERE `column % :term` condition in the query builder (PostgreSQL, pg_trgm).
+     * A blank term adds no condition.
+     */
+    orWhereSimilarTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, options?: TypedSimilarOptions): this;
+}
+/** Trigram similarity score selection (PostgreSQL, `pg_trgm` extension). */
+export interface TypedSimilarityScoreMethods<Entity extends ObjectLiteral> {
+    /**
+     * Adds `similarity(column, :term) AS alias` to the selection (PostgreSQL, pg_trgm), to order by:
+     * `.addSimilarityScoreTyped(u => u.name, term, 'score').orderBy('score', 'DESC')`.
+     * `options.function`: `'similarity'` (default), `'word_similarity'` or `'strict_word_similarity'`
+     * (`word_similarity(:term, column)`, the score of `column %> :term`).
+     * Use a lower-case alias: PostgreSQL folds an unquoted alias in ORDER BY.
+     */
+    addSimilarityScoreTyped<Type extends ObjectLiteral = Entity>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, alias: string, options?: SimilarityScoreOptions): this;
+}
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder extends TypedWhereSimilarMethods<ObjectLiteral> {
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereSimilarMethods<Entity>, TypedSimilarityScoreMethods<Entity> {
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereSimilarMethods<Entity> {
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereSimilarMethods<Entity> {
+    }
+}

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

@@ -0,0 +1,73 @@
+"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 TRIGRAM_OPERATORS = ['%', '%>', '<%'];
+const createWhereSimilarTypedMethod = (method) => function (where, term, options) {
+    if (typeof where !== 'function') {
+        return this;
+    }
+    const methodName = `${method}SimilarTyped`;
+    const column = (0, query_builder_utils_1.getTypedSingleColumnKey)(this, where, methodName);
+    const { operator = '%' } = options !== null && options !== void 0 ? options : {};
+    if (!TRIGRAM_OPERATORS.includes(operator)) {
+        // the operator is inserted into the SQL as is
+        throw new TypeError(`${methodName}: invalid operator "${operator}", expected "%", "%>" or "<%"`);
+    }
+    const value = (0, search_utils_1.toSearchTerm)(term, methodName);
+    if (value === undefined) {
+        return this;
+    }
+    const paramName = (0, sql_utils_1.createUniqueParameterName)(method);
+    // the column on the left: `col % :term`, `col %> :term` can use a trigram index on `col`
+    return this[method](`${column} ${operator} :${paramName}`, { [paramName]: value });
+};
+const SCORE_FUNCTIONS = [
+    'similarity',
+    'word_similarity',
+    'strict_word_similarity',
+];
+const extension = {
+    prototype: {
+        whereSimilarTyped: createWhereSimilarTypedMethod('where'),
+        andWhereSimilarTyped: createWhereSimilarTypedMethod('andWhere'),
+        orWhereSimilarTyped: createWhereSimilarTypedMethod('orWhere'),
+    },
+};
+const scoreExtension = {
+    prototype: {
+        addSimilarityScoreTyped: function (selection, term, alias, options) {
+            var _a;
+            const methodName = 'addSimilarityScoreTyped';
+            const column = (0, query_builder_utils_1.getTypedSingleColumnKey)(this, selection, methodName);
+            const { function: scoreFunction = 'similarity' } = options !== null && options !== void 0 ? options : {};
+            if (!SCORE_FUNCTIONS.includes(scoreFunction)) {
+                throw new TypeError(`${methodName}: invalid function "${scoreFunction}", expected "similarity", "word_similarity" or "strict_word_similarity"`);
+            }
+            if (typeof alias !== 'string' || alias.length === 0) {
+                throw new TypeError(`${methodName} expects an alias for the score`);
+            }
+            // always select the score, a query may order by its alias: a blank term scores 0
+            const value = (_a = (0, search_utils_1.toSearchTerm)(term, methodName)) !== null && _a !== void 0 ? _a : '';
+            const paramName = (0, sql_utils_1.createUniqueParameterName)('similarity');
+            const expression = scoreFunction === 'similarity'
+                ? `similarity(${column}, :${paramName})`
+                : `${scoreFunction}(:${paramName}, ${column})`;
+            return this.addSelect(expression, alias).setParameter(paramName, value);
+        },
+    },
+};
+const queryBuilders = [
+    typeorm_1.SelectQueryBuilder,
+    typeorm_1.UpdateQueryBuilder,
+    typeorm_1.DeleteQueryBuilder,
+];
+queryBuilders.forEach((builder) => {
+    (0, prototype_utils_1.patchPrototype)(builder, extension);
+});
+(0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, scoreExtension);