typeorm-extensions 2.0.0 → 2.2.0-rc.0

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

@@ -4,27 +4,19 @@ require("../../where-is-in.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 createWhereIsInTypedMethod = (method) => function (where, array) {
+    return attachWhereIsIn(this, method, where, array);
+};
 const extension = {
     prototype: {
-        whereIsInTyped: function (where, array) {
-            return attachWhereIsIn(this, 'whereIsIn', where, array);
-        },
-        andWhereIsInTyped: function (where, array) {
-            return attachWhereIsIn(this, 'andWhereIsIn', where, array);
-        },
-        orWhereIsInTyped: function (where, array) {
-            return attachWhereIsIn(this, 'orWhereIsIn', where, array);
-        },
-        whereIsNotInTyped: function (where, array) {
-            return attachWhereIsIn(this, 'whereIsNotIn', where, array);
-        },
-        andWhereIsNotInTyped: function (where, array) {
-            return attachWhereIsIn(this, 'andWhereIsNotIn', where, array);
-        },
-        orWhereIsNotInTyped: function (where, array) {
-            return attachWhereIsIn(this, 'orWhereIsNotIn', where, array);
-        },
+        whereIsInTyped: createWhereIsInTypedMethod('whereIsIn'),
+        andWhereIsInTyped: createWhereIsInTypedMethod('andWhereIsIn'),
+        orWhereIsInTyped: createWhereIsInTypedMethod('orWhereIsIn'),
+        whereIsNotInTyped: createWhereIsInTypedMethod('whereIsNotIn'),
+        andWhereIsNotInTyped: createWhereIsInTypedMethod('andWhereIsNotIn'),
+        orWhereIsNotInTyped: createWhereIsInTypedMethod('orWhereIsNotIn'),
     },
 };
 const queryBuilders = [
@@ -39,7 +31,7 @@ queryBuilders.forEach((builder) => {
 function attachWhereIsIn(builder, method, where, array) {
     if (typeof where === 'function') {
         // 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`);
+        const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`, { value: array });
         // .andWhere(`"table"."column"   IN (:...values)`, { values: ['value'] })
         return builder[method](key, array);
     }

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

@@ -1,6 +1,7 @@
 import '../../where-json.extension';
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 /**
  * Typesafe conditions on PostgreSQL `jsonb` / `json` columns: the column comes from an entity property.
  * See {@link WhereJsonMethods}.
@@ -11,29 +12,29 @@ export interface TypedWhereJsonMethods<Entity extends ObjectLiteral> {
      * 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;
+    whereJsonContainsTyped<Type extends ObjectLiteral = TypedRoot<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;
+    andWhereJsonContainsTyped<Type extends ObjectLiteral = TypedRoot<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;
+    orWhereJsonContainsTyped<Type extends ObjectLiteral = TypedRoot<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;
+    whereJsonHasKeyTyped<Type extends ObjectLiteral = TypedRoot<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;
+    andWhereJsonHasKeyTyped<Type extends ObjectLiteral = TypedRoot<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;
+    orWhereJsonHasKeyTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, key: string): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereJsonMethods<ObjectLiteral> {

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

@@ -32,7 +32,7 @@ function attachWhereJsonTyped(builder, method, where, value) {
     if (typeof where !== 'function') {
         return builder;
     }
-    const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`);
+    const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`, { accessor: 'json' });
     // .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

@@ -1,6 +1,7 @@
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
 import type { TypedLowerOptions } from '../../../types/extensions/search.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.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.
@@ -12,34 +13,34 @@ export interface TypedWhereLowerMethods<Entity extends ObjectLiteral> {
      * 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;
+    whereLowerEqualsTyped<Type extends ObjectLiteral = TypedRoot<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;
+    andWhereLowerEqualsTyped<Type extends ObjectLiteral = TypedRoot<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;
+    orWhereLowerEqualsTyped<Type extends ObjectLiteral = TypedRoot<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;
+    whereIsInLowerTyped<Type extends ObjectLiteral = TypedRoot<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;
+    andWhereIsInLowerTyped<Type extends ObjectLiteral = TypedRoot<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;
+    orWhereIsInLowerTyped<Type extends ObjectLiteral = TypedRoot<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> {

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

@@ -1,6 +1,7 @@
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
 import type { SimilarityScoreOptions, TypedSimilarOptions } from '../../../types/extensions/search.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.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.
@@ -13,17 +14,17 @@ export interface TypedWhereSimilarMethods<Entity extends ObjectLiteral> {
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereSimilarTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, options?: TypedSimilarOptions): this;
+    whereSimilarTyped<Type extends ObjectLiteral = TypedRoot<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;
+    andWhereSimilarTyped<Type extends ObjectLiteral = TypedRoot<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;
+    orWhereSimilarTyped<Type extends ObjectLiteral = TypedRoot<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> {
@@ -34,7 +35,7 @@ export interface TypedSimilarityScoreMethods<Entity extends ObjectLiteral> {
      * (`word_similarity(:term, column)`, the score of `column %> :term`).
      * Use a lower-case alias: PostgreSQL folds an unquoted alias in ORDER BY.
      */
-    addSimilarityScoreTyped<Type extends ObjectLiteral = Entity>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, alias: string, options?: SimilarityScoreOptions): this;
+    addSimilarityScoreTyped<Type extends ObjectLiteral = TypedRoot<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> {

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

@@ -1,87 +1,44 @@
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
-import { TypedWhereOptions } from '../../../types/extensions/typed-where.types';
+import { TypedWhereArgs, TypeOrDefault, UnsetType } from '../../../types/modules/typed-params.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.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, TypedRoot<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, TypedRoot<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, TypedRoot<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: DeepUnwrapArray<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: DeepUnwrapArray<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: DeepUnwrapArray<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: DeepUnwrapArray<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: DeepUnwrapArray<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: DeepUnwrapArray<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: DeepUnwrapArray<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: DeepUnwrapArray<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: DeepUnwrapArray<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: DeepUnwrapArray<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: DeepUnwrapArray<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: DeepUnwrapArray<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

@@ -4,18 +4,16 @@ const typeorm_1 = require("typeorm");
 const query_builder_utils_1 = require("../../../utils/query-builder.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");
 const where_utils_1 = require("../../../utils/where.utils");
+/* 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 = [
@@ -31,7 +29,9 @@ function attachTypedWhere(builder, method, where, conditions, parameters, option
     const { addValue } = options || {};
     if (typeof where === 'function') {
         // 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`);
+        // 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/union.extension.d.ts

@@ -0,0 +1,22 @@
+import { ObjectLiteral } from 'typeorm';
+import type { UnionCteOptions, UnionOptions, UnionQuery } from '../types/extensions/union.types';
+export interface UnionMethods {
+    /**
+     * Selects FROM the UNION of `queries`, as `alias`: `FROM ((A) UNION (B)) "alias"`.
+     *
+     * Unlike pasting `${a.getQuery()} UNION ${b.getQuery()}` and merging `getParameters()`, the
+     * parameters of each query are renamed: two queries with a `:status` of their own each keep
+     * their value, where a merged object keeps only the last one. A raw SQL string is used as is,
+     * its placeholders read the parameters of this builder.
+     */
+    fromUnion(queries: readonly UnionQuery[], alias: string, options?: UnionOptions): this;
+    /**
+     * Adds a common table expression (WITH) that is the UNION of `queries`:
+     * `WITH "alias" AS ((A) UNION (B))`. Parameters are renamed as in `fromUnion`.
+     */
+    addCommonTableExpressionUnion(queries: readonly UnionQuery[], alias: string, options?: UnionCteOptions): this;
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends UnionMethods {
+    }
+}

package/dist/extensions/union.extension.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const prototype_utils_1 = require("../utils/prototype.utils");
+const parameter_utils_1 = require("../utils/parameter.utils");
+const sql_utils_1 = require("../utils/sql.utils");
+/* eslint-enable @typescript-eslint/no-empty-interface, @typescript-eslint/no-unused-vars */
+// patching
+const extension = {
+    prototype: {
+        fromUnion(queries, alias, options) {
+            return this.from(`(${unionSql(this, 'fromUnion', queries, options)})`, alias);
+        },
+        addCommonTableExpressionUnion(queries, alias, options) {
+            const { all, ...cteOptions } = options !== null && options !== void 0 ? options : {};
+            return this.addCommonTableExpression(unionSql(this, 'addCommonTableExpressionUnion', queries, { all }), alias, cteOptions);
+        },
+    },
+};
+(0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
+// implementation
+/** The UNION of `queries`, with the parameters of each set on `builder` under unique names. */
+function unionSql(builder, methodName, queries, options) {
+    if (!queries.length) {
+        throw new TypeError(`${methodName}: no queries to union`);
+    }
+    const sqlite = (0, sql_utils_1.isSqliteLikeDriver)((0, sql_utils_1.getDriverType)(builder));
+    const branches = queries.map((query) => {
+        const sql = typeof query === 'string' ? query : bindParameters(builder, query);
+        if (!sqlite) {
+            return `(${sql})`;
+        }
+        // SQLite takes neither parentheses around a part of a UNION nor an ORDER BY / LIMIT inside one
+        // (a query of an entity with a default `orderBy` has an ORDER BY): such a part becomes a subquery.
+        // Only such a part: the recursive part of a CTE can't refer to the CTE from a subquery
+        return ordersOrLimits(query, sql) ? `SELECT * FROM (${sql})` : sql;
+    });
+    return branches.join((options === null || options === void 0 ? void 0 : options.all) ? ' UNION ALL ' : ' UNION ');
+}
+const ORDER_OR_LIMIT = /\b(?:ORDER\s+BY|LIMIT|OFFSET)\b/i;
+function ordersOrLimits(query, sql) {
+    if (typeof query === 'string' || !('expressionMap' in query)) {
+        return ORDER_OR_LIMIT.test(sql);
+    }
+    const { allOrderBys, limit, offset, take, skip } = query.expressionMap;
+    return Object.keys(allOrderBys !== null && allOrderBys !== void 0 ? allOrderBys : {}).length > 0 || [limit, offset, take, skip].some((value) => value !== undefined);
+}
+function bindParameters(builder, query) {
+    const [sql, parameters] = (0, parameter_utils_1.withUniqueParameterNames)(query.getQuery(), query.getParameters());
+    builder.setParameters(parameters);
+    return sql;
+}

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

@@ -0,0 +1,50 @@
+import { ObjectLiteral, SelectQueryBuilder, WhereExpressionBuilder } from 'typeorm';
+import type { WhereMethods } from '../types/extensions';
+/**
+ * `EXISTS` conditions. TypeORM has them on `SelectQueryBuilder` only, and keeps its own there;
+ * these add them to `UpdateQueryBuilder` and `DeleteQueryBuilder` with the same SQL. Unlike
+ * TypeORM's, they add the subquery's parameters under unique names.
+ */
+export interface WhereExistsMethods {
+    /** Sets `WHERE EXISTS (subQuery)`, replacing the WHERE conditions set before. */
+    whereExists<SubEntity extends ObjectLiteral>(subQuery: SelectQueryBuilder<SubEntity>): this;
+    /** Adds `AND EXISTS (subQuery)`. */
+    andWhereExists<SubEntity extends ObjectLiteral>(subQuery: SelectQueryBuilder<SubEntity>): this;
+    /** Adds `OR EXISTS (subQuery)`. */
+    orWhereExists<SubEntity extends ObjectLiteral>(subQuery: SelectQueryBuilder<SubEntity>): this;
+}
+/**
+ * `NOT EXISTS` conditions: the negation of TypeORM's `whereExists`, with the same subquery SQL.
+ * The subquery's parameters are added under unique names, so two subqueries can both use `:status`.
+ */
+export interface WhereNotExistsMethods {
+    /** Sets `WHERE NOT EXISTS (subQuery)`, replacing the WHERE conditions set before. */
+    whereNotExists<SubEntity extends ObjectLiteral>(subQuery: SelectQueryBuilder<SubEntity>): this;
+    /** Adds `AND NOT EXISTS (subQuery)`. */
+    andWhereNotExists<SubEntity extends ObjectLiteral>(subQuery: SelectQueryBuilder<SubEntity>): this;
+    /** Adds `OR NOT EXISTS (subQuery)`. */
+    orWhereNotExists<SubEntity extends ObjectLiteral>(subQuery: SelectQueryBuilder<SubEntity>): this;
+}
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder extends WhereExistsMethods, WhereNotExistsMethods {
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends WhereNotExistsMethods {
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends WhereExistsMethods, WhereNotExistsMethods {
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereExistsMethods, WhereNotExistsMethods {
+    }
+}
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereExistsMethods, WhereNotExistsMethods {
+    }
+}
+type SubQuery = SelectQueryBuilder<ObjectLiteral>;
+export declare function attachExists<QB extends WhereExpressionBuilder>(builder: QB, method: WhereMethods, subQuery: SubQuery, negate: boolean): QB;
+export {};

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachExists = void 0;
+const typeorm_1 = require("typeorm");
+const SoftDeleteQueryBuilder_1 = require("typeorm/query-builder/SoftDeleteQueryBuilder");
+const prototype_utils_1 = require("../utils/prototype.utils");
+const parameter_utils_1 = require("../utils/parameter.utils");
+const existsMethods = {
+    prototype: {
+        whereExists(subQuery) {
+            return attachExists(this, 'where', subQuery, false);
+        },
+        andWhereExists(subQuery) {
+            return attachExists(this, 'andWhere', subQuery, false);
+        },
+        orWhereExists(subQuery) {
+            return attachExists(this, 'orWhere', subQuery, false);
+        },
+    },
+};
+const notExistsMethods = {
+    prototype: {
+        whereNotExists(subQuery) {
+            return attachExists(this, 'where', subQuery, true);
+        },
+        andWhereNotExists(subQuery) {
+            return attachExists(this, 'andWhere', subQuery, true);
+        },
+        orWhereNotExists(subQuery) {
+            return attachExists(this, 'orWhere', subQuery, true);
+        },
+    },
+};
+// only where the builder lacks them: SelectQueryBuilder keeps TypeORM's own whereExists /
+// andWhereExists / orWhereExists, and a later TypeORM that adds any of these keeps its own
+[typeorm_1.SelectQueryBuilder, typeorm_1.UpdateQueryBuilder, typeorm_1.DeleteQueryBuilder, SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder].forEach((builder) => {
+    (0, prototype_utils_1.patchPrototype)(builder, existsMethods, { onlyMissing: true });
+    (0, prototype_utils_1.patchPrototype)(builder, notExistsMethods, { onlyMissing: true });
+});
+// implementation
+function attachExists(builder, method, subQuery, negate) {
+    const [condition, parameters] = (0, parameter_utils_1.withUniqueParameterNames)(...getExistsCondition(subQuery));
+    return builder[method](negate ? `NOT ${condition}` : condition, parameters);
+}
+exports.attachExists = attachExists;
+/**
+ * TypeORM's EXISTS condition: the subquery selects 1, without ORDER BY, LIMIT and OFFSET. TypeORM also
+ * drops GROUP BY, which leaves a HAVING to aggregate the whole subquery: the GROUP BY stays with one.
+ */
+function getExistsCondition(subQuery) {
+    const query = subQuery
+        .clone()
+        .orderBy()
+        .offset(undefined)
+        .limit(undefined)
+        .skip(undefined)
+        .take(undefined)
+        .select('1')
+        .setOption('disable-global-order');
+    if (query.expressionMap.havings.length === 0) {
+        query.groupBy();
+    }
+    return [`EXISTS (${query.getQuery()})`, query.getParameters()];
+}

package/dist/extensions/where-relation-exists.extension.d.ts

@@ -0,0 +1,38 @@
+import { ObjectLiteral, SelectQueryBuilder } from 'typeorm';
+import type { DeepUnwrapArray, KeyPathEnd } from '../types/modules/proxy-callback.types';
+import type { TypedRoot } from '../types/modules/typed-root.types';
+/**
+ * The relation to look in, selected by a typed callback: `user => user.images`. A relation of a joined alias
+ * (`joins => joins.owner.images`) ends the key path, so its entity type isn't known: pass it as `Related`.
+ */
+type RelationSelection<Type, Related> = (proxy: DeepUnwrapArray<Type>) => Related | KeyPathEnd | null | undefined;
+/** Narrows the rows of the related entity: `images => images.andWhere('images.url IS NOT NULL')`. */
+type RelatedCondition<Related extends ObjectLiteral> = (subQuery: SelectQueryBuilder<Related>) => unknown;
+/**
+ * `EXISTS` / `NOT EXISTS` over a relation of an entity, with the join condition taken from the relation's
+ * metadata: `andWhereRelationExists(user => user.images, 'image', (images) => images.andWhere(…))` gives
+ * `EXISTS (SELECT 1 FROM "images" "image" WHERE … AND "image"."userId" = "user"."id")`. Works for
+ * one-to-many, many-to-one, one-to-one and many-to-many (through the junction table) relations.
+ *
+ * `alias` names the related entity in the subquery and must not be an alias of the outer query.
+ * The subquery's parameters get unique names, as in `whereNotExists`.
+ */
+export interface WhereRelationExistsMethods<Entity extends ObjectLiteral> {
+    /** Sets `WHERE EXISTS (…)` over the relation, replacing the WHERE conditions set before. */
+    whereRelationExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
+    /** Adds `AND EXISTS (…)` over the relation. */
+    andWhereRelationExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
+    /** Adds `OR EXISTS (…)` over the relation. */
+    orWhereRelationExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
+    /** Sets `WHERE NOT EXISTS (…)` over the relation, replacing the WHERE conditions set before. */
+    whereRelationNotExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
+    /** Adds `AND NOT EXISTS (…)` over the relation. */
+    andWhereRelationNotExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
+    /** Adds `OR NOT EXISTS (…)` over the relation. */
+    orWhereRelationNotExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends WhereRelationExistsMethods<Entity> {
+    }
+}
+export {};