typeorm-extensions 2.0.0 → 2.1.0

package/README.md

@@ -27,13 +27,10 @@ npm install typeorm-extensions
 ## Usage
 
 ```typescript
-import { tableHelper } from 'typeorm-extensions'; // Importing the library root extends the QueryBuilder with all extensions
+import 'typeorm-extensions'; // Importing the library root extends the QueryBuilder with all extensions
 
 // Or init specific extension: import 'typeorm-extensions/dist/extensions/pagination.extension';
 
-// Type-safe SQL fragments for an entity alias
-const t = tableHelper<UserEntity>('users');
-
 const query = myDataSource
   .getRepository(UserEntity)
   .createQueryBuilder('users')
@@ -47,7 +44,8 @@ const query = myDataSource
     user.images.url,
   ])
   .whereTyped(user => user.name, 'ILIKE', 'John')
-  .andWhereTyped(user => user.metadata, `${t.jsonPath('metadata', '->>', 'role')} =`, 'admin')
+  // Paths into JSON columns: "users"."metadata" ->> 'role' = :param
+  .andWhereTyped(user => user.metadata.role, '=', 'admin')
   // Order by type-safe own and relation properties
   .orderByTyped(user => user.images.url, 'ASC', 'NULLS LAST')
   // Use pagination as simple as that

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

@@ -10,7 +10,7 @@ const period_utils_1 = require("../../../utils/period.utils");
 const extension = {
     prototype: {
         applyPeriodFilterTyped(selection, periodFilter, options) {
-            const column = (0, query_builder_utils_1.getTypedSingleColumnKey)(this, selection, 'applyPeriodFilterTyped');
+            const column = (0, query_builder_utils_1.getTypedSingleColumnKey)(this, selection, 'applyPeriodFilterTyped', { asTimestamp: true });
             return (0, period_utils_1.attachPeriodFilter)(this, column, periodFilter, options);
         },
     },

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

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

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

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

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

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

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

@@ -1,132 +1,50 @@
 import '../../where-is-in.extension';
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
-import { ArgsType } from '../../../types/util-types';
+import { TypedArrayArg, TypeOrDefault, UnsetType } from '../../../types/modules/typed-params.types';
+export interface TypedWhereIsInMethods<Entity extends ObjectLiteral> {
+    /**
+     * Sets WHERE IN condition in the query builder.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereIsInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>): this;
+    /**
+     * Adds new AND WHERE IN condition in the query builder.
+     */
+    andWhereIsInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>): this;
+    /**
+     * Adds new OR WHERE IN condition in the query builder.
+     */
+    orWhereIsInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>): this;
+    /**
+     * Sets WHERE NOT IN condition in the query builder.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     */
+    whereIsNotInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>): this;
+    /**
+     * Adds new AND WHERE NOT IN condition in the query builder.
+     */
+    andWhereIsNotInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>): this;
+    /**
+     * Adds new OR WHERE NOT IN condition in the query builder.
+     */
+    orWhereIsNotInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>): this;
+}
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
-    interface WhereExpressionBuilder {
-        /**
-         * Sets WHERE IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsInTyped<Type extends ObjectLiteral>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE IN condition in the query builder.
-         */
-        andWhereIsInTyped<Type extends ObjectLiteral>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE IN condition in the query builder.
-         */
-        orWhereIsInTyped<Type extends ObjectLiteral>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Sets WHERE NOT IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE NOT IN condition in the query builder.
-         */
-        andWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE NOT IN condition in the query builder.
-         */
-        orWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
+    interface WhereExpressionBuilder extends TypedWhereIsInMethods<ObjectLiteral> {
     }
 }
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
-    interface SelectQueryBuilder<Entity extends ObjectLiteral> {
-        /**
-         * Sets WHERE IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE IN condition in the query builder.
-         */
-        andWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE IN condition in the query builder.
-         */
-        orWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Sets WHERE NOT IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE NOT IN condition in the query builder.
-         */
-        andWhereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE NOT IN condition in the query builder.
-         */
-        orWhereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereIsInMethods<Entity> {
     }
 }
 declare module 'typeorm/query-builder/UpdateQueryBuilder' {
-    interface UpdateQueryBuilder<Entity extends ObjectLiteral> {
-        /**
-         * Sets WHERE IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE IN condition in the query builder.
-         */
-        andWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE IN condition in the query builder.
-         */
-        orWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Sets WHERE NOT IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE NOT IN condition in the query builder.
-         */
-        andWhereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE NOT IN condition in the query builder.
-         */
-        orWhereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereIsInMethods<Entity> {
     }
 }
 declare module 'typeorm/query-builder/DeleteQueryBuilder' {
-    interface DeleteQueryBuilder<Entity extends ObjectLiteral> {
-        /**
-         * Sets WHERE IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE IN condition in the query builder.
-         */
-        andWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE IN condition in the query builder.
-         */
-        orWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Sets WHERE NOT IN condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         */
-        whereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new AND WHERE NOT IN condition in the query builder.
-         */
-        andWhereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
-        /**
-         * Adds new OR WHERE NOT IN condition in the query builder.
-         */
-        orWhereIsNotInTyped<Type extends ObjectLiteral = Entity>(subQuery: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, array?: ArgsType): this;
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereIsInMethods<Entity> {
     }
 }

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.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.extension.d.ts

@@ -1,87 +1,43 @@
 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';
+/**
+ * Typesafe WHERE conditions: the column comes from an entity property.
+ * `Type` defaults to the query builder's entity; with the `strictParams` option (see `TypeormExtensionsConfig`)
+ * the parameter is checked against the type of the selected column.
+ */
+export interface TypedWhereMethods<Entity extends ObjectLiteral> {
+    /**
+     * Sets WHERE condition in the query builder.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     * Additionally you can add parameters used in where expression.
+     */
+    whereTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, Value>): this;
+    /**
+     * Adds new AND WHERE condition in the query builder.
+     * Additionally you can add parameters used in where expression.
+     */
+    andWhereTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, Value>): this;
+    /**
+     * Adds new OR WHERE condition in the query builder.
+     * Additionally you can add parameters used in where expression.
+     */
+    orWhereTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, Value>): this;
+}
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
-    interface WhereExpressionBuilder {
-        /**
-         * Sets WHERE condition in the query builder.
-         * If you had previously WHERE expression defined,
-         * calling this function will override previously set WHERE conditions.
-         * Additionally you can add parameters used in where expression.
-         */
-        whereTyped<Type extends ObjectLiteral>(subQuery: (proxy: 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/index.d.ts

@@ -1,5 +1,6 @@
 export * from './extensions';
 export * from './types/interfaces';
 export * from './types/extensions';
+export type { Json } from './types/modules/proxy-callback.types';
 export * from './utils/table.utils';
 export { escapeLikePattern } from './utils/search.utils';

package/dist/types/interfaces/config.interface.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Compile-time options of the library, switched on by augmenting this interface in your project:
+ *
+ * ```ts
+ * declare module 'typeorm-extensions' {
+ *   interface TypeormExtensionsConfig {
+ *     strictParams: true;
+ *   }
+ * }
+ * ```
+ *
+ * - `strictParams`: typed where methods check their value against the type of the column the callback
+ *   selects (`whereTyped(q => q.price, '>', '10')` doesn't compile for a `number` column). Applies to calls
+ *   without an explicit type argument: `whereTyped<Joins>(…)` keeps unchecked parameters.
+ */
+export interface TypeormExtensionsConfig {
+}

package/dist/types/interfaces/config.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/interfaces/index.d.ts

@@ -2,3 +2,4 @@ export * from './ordering.interface';
 export * from './pagination.interface';
 export * from './period.interface';
 export * from './cursor-pagination.interface';
+export * from './config.interface';

package/dist/types/interfaces/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./ordering.interface"), exports);
 __exportStar(require("./pagination.interface"), exports);
 __exportStar(require("./period.interface"), exports);
 __exportStar(require("./cursor-pagination.interface"), exports);
+__exportStar(require("./config.interface"), exports);

package/dist/types/modules/proxy-callback.types.d.ts

@@ -4,25 +4,49 @@ import { ColumnValueType } from "./column.types";
 import { UnwrapArray } from "../util-types";
 export type ProxyColumnValueType = ColumnValueType | ':value';
 type ProxyPropertyType<V> = NonNullable<V> extends readonly (infer U)[] ? NonNullable<U> : NonNullable<V>;
+/** Objects that are column values, not relations or JSON objects to go into. */
+type ProxyLeafObject = Date | ArrayBufferView | ArrayBuffer;
+type IsProxyBranch<V> = ProxyPropertyType<V> extends ProxyLeafObject ? false : ProxyPropertyType<V> extends object ? true : false;
+declare const jsonColumn: unique symbol;
+/**
+ * Marks an entity property as a JSON column for typed callbacks, which then go into it at any depth:
+ * `(e) => e.details.meta.endTs` is `"e"."details" -> 'meta' ->> 'endTs'` in where methods. Without it a typed key
+ * stops at `alias.column` (`e.details.outcome`), as it does for relations. Values are assignable both ways.
+ *
+ * @example
+ * @Column({ type: 'jsonb' })
+ * details: Json<ExecutionDetails>;
+ */
+export type Json<T> = T & {
+    readonly [jsonColumn]?: true;
+};
+type IsJsonColumn<V> = typeof jsonColumn extends keyof NonNullable<V> ? true : false;
+type IsJsonObject<V> = NonNullable<V> extends ProxyLeafObject | readonly unknown[] ? false : NonNullable<V> extends object ? true : false;
+/** Inside a JSON column: objects to go into at any depth, while arrays and dates are values. */
+type JsonPathProxy<T> = {
+    [K in keyof T as K extends typeof jsonColumn ? never : K]-?: IsJsonObject<T[K]> extends true ? JsonPathProxy<NonNullable<T[K]>> : T[K];
+};
+type JsonColumnProxy<V> = NonNullable<V> extends readonly unknown[] ? V : JsonPathProxy<NonNullable<V>>;
 /**
  * End of a typed key path. Typed keys are `column` or `alias.column` (`relation.column`),
  * so an object at the second level (a nested relation, a JSON sub-object) can be selected
  * as a whole but not dereferenced further: `u => u.images.user.email` is a compile error.
- * Address deeper relations by their join alias with an alias-keyed type instead.
+ * Address deeper relations by their join alias with an alias-keyed type instead, and mark
+ * JSON columns with {@link Json} to go deeper into them.
  */
 export interface KeyPathEnd {
     readonly __keyPathEnd: never;
 }
 type ProxySecondLevel<T> = {
-    [K in keyof T]-?: ProxyPropertyType<T[K]> extends object ? KeyPathEnd : T[K];
+    [K in keyof T]-?: IsJsonColumn<T[K]> extends true ? JsonColumnProxy<T[K]> : IsProxyBranch<T[K]> extends true ? KeyPathEnd : T[K];
 };
 /**
  * Type of the proxy passed to typed callbacks: two levels (`column` or `alias.column`),
  * with arrays unwrapped (`user.images.url` for `images: ImageEntity[]`) and optional
- * properties made required.
+ * properties made required. A {@link Json} column is open at any depth.
  */
 export type DeepUnwrapArray<T> = {
-    [K in keyof T]-?: ProxyPropertyType<T[K]> extends object ? ProxySecondLevel<ProxyPropertyType<T[K]>> : T[K];
+    [K in keyof T]-?: IsJsonColumn<T[K]> extends true ? JsonColumnProxy<T[K]> : IsProxyBranch<T[K]> extends true ? ProxySecondLevel<ProxyPropertyType<T[K]>> : T[K];
 };
 export type KeyProxyCallback<T extends ObjectLiteral> = (proxy: DeepUnwrapArray<T>) => ProxyColumnValueType | Array<ProxyColumnValueType>;
 export type RelationalKeyProxyCallback<T extends ObjectLiteral> = (proxy: DeepUnwrapArray<EntityOnlyWithRelations<T>>) => ProxyColumnValueType;

package/dist/types/modules/typed-params.types.d.ts

@@ -0,0 +1,45 @@
+import type { TypeormExtensionsConfig } from '../interfaces/config.interface';
+import type { TypedWhereOptions } from '../extensions/typed-where.types';
+import type { ArgsType } from '../util-types';
+declare const unsetType: unique symbol;
+/**
+ * Default of the `Type` argument of typed methods. Tells a call without a type argument, whose proxy is
+ * typed by the query builder's entity, from an explicit `whereTyped<Joins>(…)`.
+ */
+export interface UnsetType {
+    readonly [unsetType]: true;
+}
+/** Blocks inference from this position, so the column type comes from the callback alone (`NoInfer` before TypeScript 5.4). */
+type NoInferType<T> = [T][T extends unknown ? 0 : never];
+/** Whether `Type` was left out; an explicit `<any>` is assignable to `UnsetType` but was given. */
+type IsUnset<Type> = 0 extends 1 & Type ? false : [Type] extends [UnsetType] ? true : false;
+export type TypeOrDefault<Type, Default> = IsUnset<Type> extends true ? Default : Type;
+type IsStrict<Type> = TypeormExtensionsConfig extends {
+    strictParams: true;
+} ? IsUnset<Type> : false;
+/** A column's value as a parameter: never `null` / `undefined` (they turn `= :value` into `= NULL`); a date may be a string. */
+export type ParamValue<Value> = NonNullable<Value> extends Date ? Date | string : NonNullable<Value>;
+type IsValueObject<P> = [P] extends [Date | ArrayBufferView | ArrayBuffer | readonly unknown[]] ? true : false;
+/**
+ * The value itself, or a `{ name: value }` params object. A plain object value (a JSON column) can only be
+ * passed in a params object: at runtime a plain object always is one.
+ */
+type DirectOrField<P> = [P] extends [object] ? IsValueObject<P> extends true ? P | Readonly<Record<string, P>> : Readonly<Record<string, P>> : P | Readonly<Record<string, P>>;
+type Trim<S extends string> = S extends ` ${infer Rest}` ? Trim<Rest> : S extends `${infer Rest} ` ? Trim<Rest> : S;
+type NoValueOperator = 'IS NULL' | 'IS NOT NULL' | 'IS TRUE' | 'IS NOT TRUE' | 'IS FALSE' | 'IS NOT FALSE' | 'IS UNKNOWN' | 'IS NOT UNKNOWN';
+type ComparisonOperator = '=' | '!=' | '<>' | '>' | '<' | '>=' | '<=';
+type DistinctOperator = 'IS DISTINCT FROM' | 'IS NOT DISTINCT FROM';
+type NullOperator = 'IS' | 'IS NOT';
+type ListOperator = 'IN' | 'NOT IN';
+type PatternOperator = 'LIKE' | 'NOT LIKE' | 'ILIKE' | 'NOT ILIKE';
+type LooseWhereArgs = [parameters?: unknown, options?: TypedWhereOptions];
+type ValueArgs<P> = [parameters: DirectOrField<P>, options?: TypedWhereOptions];
+type StrictWhereArgs<Operator extends string, Value> = Uppercase<Trim<Operator>> extends infer Op ? Op extends NoValueOperator ? [parameters?: undefined, options?: TypedWhereOptions] : Op extends ComparisonOperator ? ValueArgs<ParamValue<Value>> : Op extends DistinctOperator ? ValueArgs<ParamValue<Value> | null> : Op extends NullOperator ? ValueArgs<null> : Op extends ListOperator ? ValueArgs<readonly ParamValue<Value>[]> : Op extends PatternOperator ? ValueArgs<string> : LooseWhereArgs : never;
+/**
+ * Parameters and options of `whereTyped`. With `strictParams` the parameter is checked against the column type
+ * for the operators it knows; conditions written as SQL (`'BETWEEN :from AND :to'`, `'= true'`) aren't checked.
+ */
+export type TypedWhereArgs<Type, Operator extends string, Value> = IsStrict<Type> extends true ? StrictWhereArgs<NoInferType<Operator>, NoInferType<Value>> : LooseWhereArgs;
+/** Values of `whereIsInTyped` / `whereIsAnyTyped`; with `strictParams`, of the column's type. */
+export type TypedArrayArg<Type, Value> = IsStrict<Type> extends true ? readonly ParamValue<NoInferType<Value>>[] : ArgsType;
+export {};

package/dist/types/modules/typed-params.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/json-path.utils.d.ts

@@ -0,0 +1,22 @@
+import type { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata';
+import type { DatabaseType } from 'typeorm';
+/** `->>` gives the value as text (as an SQL value on SQLite), `->` as JSON. */
+export type JsonAccessor = 'text' | 'json';
+export declare const isJsonColumn: (column: ColumnMetadata) => boolean;
+/** `-> 'settings' ->> 'theme'`: every key but the last one with `->`, the last one with `jsonOperator`. */
+export declare function buildJsonPath(fieldNames: readonly string[], jsonOperator: '->>' | '->'): string;
+export interface JsonPathSqlOptions {
+    /** Defaults to `'text'`. */
+    accessor?: JsonAccessor;
+    /** The value the path is compared with: on PostgreSQL a `'text'` path is cast to its type. */
+    value?: unknown;
+    /** Compares a `'text'` path as a timestamp whatever `value` is, since a period also takes date strings. */
+    asTimestamp?: boolean;
+}
+/**
+ * SQL for a path inside a JSON column: `"exec"."details" -> 'meta' ->> 'endTs'`, cast on PostgreSQL to the
+ * type of the compared value (`CAST(… AS numeric)`). A `simple-json` column is text there, so it is cast to
+ * `jsonb` first. SQLite (3.38+) has the same operators, and `->>` gives SQL values, so it needs no cast, except
+ * for a timestamp: there it is rewritten in the format TypeORM stores dates and binds `Date` parameters in.
+ */
+export declare function toJsonPathSql(driver: DatabaseType | undefined, columnSql: string, column: ColumnMetadata, jsonPath: readonly string[], { accessor, value, asTimestamp }?: JsonPathSqlOptions): string;

package/dist/utils/json-path.utils.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toJsonPathSql = exports.buildJsonPath = exports.isJsonColumn = void 0;
+const sql_utils_1 = require("./sql.utils");
+const JSON_COLUMN_TYPES = ['json', 'jsonb', 'simple-json'];
+const isJsonColumn = (column) => JSON_COLUMN_TYPES.includes(String(column.type));
+exports.isJsonColumn = isJsonColumn;
+/** Wraps a JSON key in single quotes, doubling any quote inside it (standard SQL string literal). */
+const toJsonKeyLiteral = (fieldName) => `'${String(fieldName).replace(/'/g, "''")}'`;
+/** `-> 'settings' ->> 'theme'`: every key but the last one with `->`, the last one with `jsonOperator`. */
+function buildJsonPath(fieldNames, jsonOperator) {
+    return fieldNames
+        .map((fieldName, index) => `${index === fieldNames.length - 1 ? jsonOperator : '->'} ${toJsonKeyLiteral(fieldName)}`)
+        .join(' ');
+}
+exports.buildJsonPath = buildJsonPath;
+const isDate = (value) => Object.prototype.toString.call(value) === '[object Date]';
+/**
+ * PostgreSQL type to compare a `->>` value (text) with `value` as: text compares `'9' >= '10'` as true.
+ * An array (IN, ANY) is typed by its first value; strings and unknown values stay text.
+ */
+function getJsonTextCast(value) {
+    const sample = Array.isArray(value) ? value.find((item) => item !== null && item !== undefined) : value;
+    if (typeof sample === 'number' || typeof sample === 'bigint') {
+        return 'numeric';
+    }
+    if (typeof sample === 'boolean') {
+        return 'boolean';
+    }
+    if (isDate(sample)) {
+        return 'timestamptz';
+    }
+    return undefined;
+}
+/**
+ * SQL for a path inside a JSON column: `"exec"."details" -> 'meta' ->> 'endTs'`, cast on PostgreSQL to the
+ * type of the compared value (`CAST(… AS numeric)`). A `simple-json` column is text there, so it is cast to
+ * `jsonb` first. SQLite (3.38+) has the same operators, and `->>` gives SQL values, so it needs no cast, except
+ * for a timestamp: there it is rewritten in the format TypeORM stores dates and binds `Date` parameters in.
+ */
+function toJsonPathSql(driver, columnSql, column, jsonPath, { accessor = 'text', value, asTimestamp = false } = {}) {
+    const path = buildJsonPath(jsonPath, accessor === 'json' ? '->' : '->>');
+    const isTimestamp = asTimestamp && accessor === 'text';
+    if ((0, sql_utils_1.isSqliteLikeDriver)(driver)) {
+        const sql = `${columnSql} ${path}`;
+        return isTimestamp ? `strftime('%Y-%m-%d %H:%M:%f', ${sql})` : sql;
+    }
+    if (!(0, sql_utils_1.isPostgresLikeDriver)(driver)) {
+        throw new TypeError(`Typed keys into a JSON column (${column.propertyPath}.${jsonPath.join('.')}) are supported on PostgreSQL and SQLite, ` +
+            `not on ${driver !== null && driver !== void 0 ? driver : 'a query without a connection'}`);
+    }
+    const source = String(column.type) === 'simple-json' ? `CAST(${columnSql} AS jsonb)` : columnSql;
+    const sql = `${source} ${path}`;
+    const cast = isTimestamp ? 'timestamptz' : accessor === 'text' ? getJsonTextCast(value) : undefined;
+    return cast ? `CAST(${sql} AS ${cast})` : sql;
+}
+exports.toJsonPathSql = toJsonPathSql;

package/dist/utils/proxy-key.utils.d.ts

@@ -21,7 +21,12 @@ export declare class KeyProxy {
 }
 /** Typed keys are `column` or `alias.column`: a deeper path can't be mapped to a query alias. */
 export declare const MAX_KEY_DEPTH = 2;
-export declare const getKeyHolder: <Type extends ObjectLiteral>(callback: KeyHolder | KeyProxyCallback<Type>) => KeyHolder | Array<KeyHolder>;
+export declare const createKeyTooDeepError: (keys: string[]) => TypeError;
+/**
+ * Keys of a typed callback. Paths deeper than `alias.column` throw, unless `allowDeepPaths` is set by a caller
+ * that checks them against the query's metadata (paths into JSON columns).
+ */
+export declare const getKeyHolder: <Type extends ObjectLiteral>(callback: KeyHolder | KeyProxyCallback<Type>, allowDeepPaths?: boolean) => KeyHolder | Array<KeyHolder>;
 export declare const getKey: <Type extends ObjectLiteral>(callback: string | KeyHolder | KeyProxyCallback<Type>) => string;
 /**
  * Alias to prefix a single-level key with: a string, or a function called only when it is needed,

package/dist/utils/proxy-key.utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSqlKeyFromProxyCallback = exports.getKey = exports.getKeyHolder = exports.MAX_KEY_DEPTH = exports.KeyProxy = exports.TypedProxy = exports.KeyHolder = void 0;
+exports.getSqlKeyFromProxyCallback = exports.getKey = exports.getKeyHolder = exports.createKeyTooDeepError = exports.MAX_KEY_DEPTH = exports.KeyProxy = exports.TypedProxy = exports.KeyHolder = void 0;
 const sql_utils_1 = require("./sql.utils");
 class KeyHolder {
     constructor(_keys = []) {
@@ -71,24 +71,31 @@ KeyProxy.defaultHandler = {
 };
 /** Typed keys are `column` or `alias.column`: a deeper path can't be mapped to a query alias. */
 exports.MAX_KEY_DEPTH = 2;
+const createKeyTooDeepError = (keys) => new TypeError(`Typed key "${keys.join('.')}" is ${keys.length} levels deep, but typed methods support only ` +
+    `"column" or "alias.column", or a path into a JSON column in where methods. Join the nested relation and ` +
+    `address it by its alias with an alias-keyed type, e.g. type Joins = { someAlias: SomeEntity }; (j) => j.someAlias.column`);
+exports.createKeyTooDeepError = createKeyTooDeepError;
 const assertKeyDepth = (keyHolder) => {
     const keys = keyHolder.getKeys();
     if (keys.length > exports.MAX_KEY_DEPTH) {
-        throw new TypeError(`Typed key "${keys.join('.')}" is ${keys.length} levels deep, but typed methods support only ` +
-            `"column" or "alias.column". Join the nested relation and address it by its alias ` +
-            `with an alias-keyed type, e.g. type Joins = { someAlias: SomeEntity }; (j) => j.someAlias.column`);
+        throw (0, exports.createKeyTooDeepError)(keys);
     }
     return keyHolder;
 };
-const getKeyHolder = (callback) => {
+/**
+ * Keys of a typed callback. Paths deeper than `alias.column` throw, unless `allowDeepPaths` is set by a caller
+ * that checks them against the query's metadata (paths into JSON columns).
+ */
+const getKeyHolder = (callback, allowDeepPaths = false) => {
+    const check = allowDeepPaths ? (keyHolder) => keyHolder : assertKeyDepth;
     if (typeof callback !== 'function') {
         if (callback instanceof KeyHolder) {
-            return assertKeyDepth(callback);
+            return check(callback);
         }
     }
     const keyHolder = callback(KeyProxy.create());
     // fail loudly instead of silently dropping levels beyond `alias.column`
-    return Array.isArray(keyHolder) ? keyHolder.map(assertKeyDepth) : assertKeyDepth(keyHolder);
+    return Array.isArray(keyHolder) ? keyHolder.map(check) : check(keyHolder);
 };
 exports.getKeyHolder = getKeyHolder;
 const getKey = (callback) => {

package/dist/utils/query-builder.utils.d.ts

@@ -1,5 +1,6 @@
 import type { ObjectLiteral, WhereExpressionBuilder } from 'typeorm';
 import type { KeyProxyCallback } from '../types/modules/proxy-callback.types';
+import { JsonPathSqlOptions } from './json-path.utils';
 /**
  * Database name of an entity property's column (`@Column({ name })`), looked up in the metadata of
  * a query alias (the main alias when `aliasName` is undefined). `undefined` when the alias has no
@@ -27,15 +28,16 @@ export declare function toFieldSql(builder: WhereExpressionBuilder, field: strin
  *
  * The property is mapped to its database column name (`@Column({ name })`, embedded columns)
  * through the metadata of the alias it belongs to (see `resolveTypedKey`). Aliases without
- * metadata (subqueries) and unknown properties keep the property name.
+ * metadata (subqueries) and unknown properties keep the property name. A path into a JSON column
+ * gives its JSON accessor, cast on PostgreSQL to the type of `jsonOptions.value`.
  */
-export declare function getTypedColumnKey<Type extends ObjectLiteral>(builder: WhereExpressionBuilder, callback: KeyProxyCallback<Type>): string | string[];
+export declare function getTypedColumnKey<Type extends ObjectLiteral>(builder: WhereExpressionBuilder, callback: KeyProxyCallback<Type>, jsonOptions?: JsonPathSqlOptions): string | string[];
 /**
  * Quoted column of a typed callback that must select exactly one column
  * (`whereIsAnyTyped`, `whereArrayContainsTyped`, …). Throws a `TypeError` for several columns:
  * one condition per column has no single obvious meaning (AND? OR?), so don't guess.
  */
-export declare function getTypedSingleColumnKey<Type extends ObjectLiteral>(builder: WhereExpressionBuilder, callback: KeyProxyCallback<Type>, methodName: string): string;
+export declare function getTypedSingleColumnKey<Type extends ObjectLiteral>(builder: WhereExpressionBuilder, callback: KeyProxyCallback<Type>, methodName: string, jsonOptions?: JsonPathSqlOptions): string;
 /**
  * Key for typed select / order / distinct on a SelectQueryBuilder.
  *

package/dist/utils/query-builder.utils.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTypedSelectionKey = exports.getTypedSingleColumnKey = exports.getTypedColumnKey = exports.toFieldSql = exports.getColumnDatabaseName = void 0;
 const proxy_key_utils_1 = require("./proxy-key.utils");
+const json_path_utils_1 = require("./json-path.utils");
 const sql_utils_1 = require("./sql.utils");
 /**
  * Whether single-level typed keys are qualified with the main alias (`user.firstName`).
@@ -94,12 +95,34 @@ function toFieldSql(builder, field) {
     return (0, sql_utils_1.stringToSQLIdentifier)(field, (0, sql_utils_1.getDriverType)(builder));
 }
 exports.toFieldSql = toFieldSql;
+/**
+ * The column that `keys` name in an entity: the longest prefix of the keys that is a column's property path
+ * (`address.city` for an embedded entity). The keys after it are a path inside the column, allowed only in a
+ * JSON column (`details` + `['meta', 'endTs']`). `undefined` when no prefix is a column, or a column that isn't
+ * JSON is followed by more keys (a relation's join column, `user` in `user.email`).
+ */
+function findColumnPath(metadata, keys) {
+    for (let length = keys.length; metadata && length >= 1; length--) {
+        const propertyPath = keys.slice(0, length).join('.');
+        const column = metadata.findColumnWithPropertyPath(propertyPath);
+        if (!column) {
+            continue;
+        }
+        if (length === keys.length) {
+            return { propertyPath, column };
+        }
+        return (0, json_path_utils_1.isJsonColumn)(column) ? { propertyPath, column, jsonPath: keys.slice(length) } : undefined;
+    }
+    return undefined;
+}
 /**
  * Splits typed keys into the alias and the property path they refer to:
  * - `t => t.status` → the query's main alias + `status` (no alias on UPDATE / DELETE);
  * - `j => j.t.status`, `u => u.images.url` → the first key, when it is an alias of the query;
  * - `p => p.address.city` → when the first key isn't an alias but the main entity has a column
  *   with that path (an embedded entity), the main alias + `address.city`;
+ * - `e => e.details.meta.endTs`, `j => j.e.details.outcome` → a JSON column of the alias' entity
+ *   followed by the keys inside it (`jsonPath`), at any depth;
  * - anything else → the first key as the alias (an alias the query builder doesn't know yet,
  *   e.g. `q => q.base.chatRoomId` before `.from(…, 'base')`).
  *
@@ -108,6 +131,14 @@ exports.toFieldSql = toFieldSql;
  * before `from()` the property name is used as the column name.
  */
 function resolveTypedKey(queryBuilder, keys) {
+    const resolved = resolveTypedKeyPath(queryBuilder, keys);
+    // deeper than `alias.column` only inside a JSON column: a nested relation can't be mapped to an alias
+    if (!resolved.jsonPath && keys.length > proxy_key_utils_1.MAX_KEY_DEPTH) {
+        throw (0, proxy_key_utils_1.createKeyTooDeepError)(keys);
+    }
+    return resolved;
+}
+function resolveTypedKeyPath(queryBuilder, keys) {
     const prefixing = isAliasPrefixingEnabled(queryBuilder);
     if (keys.length === 1) {
         const aliasName = prefixing ? requireMainAliasName(queryBuilder, keys[0]) : undefined;
@@ -122,49 +153,63 @@ function resolveTypedKey(queryBuilder, keys) {
     const mainAlias = expressionMap === null || expressionMap === void 0 ? void 0 : expressionMap.mainAlias;
     // UPDATE / DELETE have no alias to qualify with: `u => u.user.firstName` is `"firstName"` there
     if (!prefixing && (mainAlias === null || mainAlias === void 0 ? void 0 : mainAlias.name) === firstKey) {
+        const metadata = getAliasMetadata(queryBuilder, undefined);
         return {
             aliasName: undefined,
             propertyPath: restKeys.join('.'),
-            metadata: getAliasMetadata(queryBuilder, undefined),
+            metadata,
+            ...findColumnPath(metadata, restKeys),
         };
     }
     const queryAlias = expressionMap === null || expressionMap === void 0 ? void 0 : expressionMap.aliases.find((alias) => alias.name === firstKey);
     if (!queryAlias && mainAlias) {
         const mainMetadata = getAliasMetadata(queryBuilder, undefined);
-        const embeddedPath = keys.join('.');
-        if (mainMetadata === null || mainMetadata === void 0 ? void 0 : mainMetadata.findColumnWithPropertyPath(embeddedPath)) {
+        const columnPath = findColumnPath(mainMetadata, keys);
+        if (columnPath) {
             return {
                 aliasName: prefixing ? mainAlias.name : undefined,
-                propertyPath: embeddedPath,
                 metadata: mainMetadata,
+                ...columnPath,
             };
         }
     }
+    const metadata = (queryAlias === null || queryAlias === void 0 ? void 0 : queryAlias.hasMetadata) ? queryAlias.metadata : undefined;
     return {
         aliasName: firstKey,
         propertyPath: restKeys.join('.'),
-        metadata: (queryAlias === null || queryAlias === void 0 ? void 0 : queryAlias.hasMetadata) ? queryAlias.metadata : undefined,
+        metadata,
+        ...findColumnPath(metadata, restKeys),
     };
 }
-/** `"alias"."column"` (or `"column"` without an alias) with the database column name. */
-function toQuotedColumnKey(queryBuilder, { aliasName, propertyPath, metadata }) {
+/**
+ * `"alias"."column"` (or `"column"` without an alias) with the database column name, followed by the path
+ * inside a JSON column: `"exec"."details" -> 'meta' ->> 'endTs'` (see `toJsonPathSql`).
+ */
+function toQuotedColumnKey(queryBuilder, { aliasName, propertyPath, metadata, column, jsonPath }, jsonOptions) {
     var _a, _b;
-    const column = (_b = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.findColumnWithPropertyPath(propertyPath)) === null || _a === void 0 ? void 0 : _a.databaseName) !== null && _b !== void 0 ? _b : propertyPath;
-    return aliasName === undefined
-        ? queryBuilder.escape(column)
-        : `${queryBuilder.escape(aliasName)}.${queryBuilder.escape(column)}`;
+    const columnName = (_b = (_a = (column !== null && column !== void 0 ? column : metadata === null || metadata === void 0 ? void 0 : metadata.findColumnWithPropertyPath(propertyPath))) === null || _a === void 0 ? void 0 : _a.databaseName) !== null && _b !== void 0 ? _b : propertyPath;
+    const columnSql = aliasName === undefined
+        ? queryBuilder.escape(columnName)
+        : `${queryBuilder.escape(aliasName)}.${queryBuilder.escape(columnName)}`;
+    if (!column || !jsonPath) {
+        return columnSql;
+    }
+    const driver = (0, sql_utils_1.getDriverType)(queryBuilder);
+    return (0, json_path_utils_1.toJsonPathSql)(driver, columnSql, column, jsonPath, jsonOptions);
 }
 /**
  * SQL key for a typed callback on `builder`: `"alias"."column"`, or `"column"` on UPDATE / DELETE.
  *
  * The property is mapped to its database column name (`@Column({ name })`, embedded columns)
  * through the metadata of the alias it belongs to (see `resolveTypedKey`). Aliases without
- * metadata (subqueries) and unknown properties keep the property name.
+ * metadata (subqueries) and unknown properties keep the property name. A path into a JSON column
+ * gives its JSON accessor, cast on PostgreSQL to the type of `jsonOptions.value`.
  */
-function getTypedColumnKey(builder, callback) {
+function getTypedColumnKey(builder, callback, jsonOptions) {
     const queryBuilder = builder;
-    const toKey = (keyHolder) => toQuotedColumnKey(queryBuilder, resolveTypedKey(queryBuilder, keyHolder.getKeys()));
-    const keyHolder = (0, proxy_key_utils_1.getKeyHolder)(callback);
+    const toKey = (keyHolder) => toQuotedColumnKey(queryBuilder, resolveTypedKey(queryBuilder, keyHolder.getKeys()), jsonOptions);
+    // the depth is checked against the query's metadata, where a JSON column may be deeper
+    const keyHolder = (0, proxy_key_utils_1.getKeyHolder)(callback, true);
     return Array.isArray(keyHolder) ? keyHolder.map(toKey) : toKey(keyHolder);
 }
 exports.getTypedColumnKey = getTypedColumnKey;
@@ -173,8 +218,8 @@ exports.getTypedColumnKey = getTypedColumnKey;
  * (`whereIsAnyTyped`, `whereArrayContainsTyped`, …). Throws a `TypeError` for several columns:
  * one condition per column has no single obvious meaning (AND? OR?), so don't guess.
  */
-function getTypedSingleColumnKey(builder, callback, methodName) {
-    const key = getTypedColumnKey(builder, callback);
+function getTypedSingleColumnKey(builder, callback, methodName, jsonOptions) {
+    const key = getTypedColumnKey(builder, callback, jsonOptions);
     if (Array.isArray(key)) {
         throw new TypeError(`${methodName} expects the callback to select a single column, got ${key.length}: ${key.join(', ')}`);
     }
@@ -195,6 +240,10 @@ function getTypedSelectionKey(builder, selection, useQuotes) {
     const queryBuilder = builder;
     const toKey = (keyHolder) => {
         const resolved = resolveTypedKey(queryBuilder, keyHolder.getKeys());
+        if (resolved.jsonPath) {
+            throw new TypeError(`Typed key "${keyHolder.getKeys().join('.')}" points into the JSON column "${resolved.propertyPath}": ` +
+                `select, order and distinct take columns only. For an expression use tableHelper().jsonColumn()`);
+        }
         if (useQuotes) {
             return toQuotedColumnKey(queryBuilder, resolved);
         }

package/dist/utils/sql.utils.d.ts

@@ -3,6 +3,8 @@ export declare const wrapWithDoubleQoutes: (str: string) => string;
 export declare const wrapWithBackQoutes: (str: string) => string;
 /** MySQL, MariaDB and Aurora MySQL: backtick identifiers, `<=>` null-safe comparison. */
 export declare const isMysqlLikeDriver: (driver?: DatabaseType) => boolean;
+/** PostgreSQL and the databases speaking its dialect. */
+export declare const isPostgresLikeDriver: (driver?: DatabaseType) => boolean;
 /** SQLite drivers: `IS` / `IS NOT` are null-safe comparisons. */
 export declare const isSqliteLikeDriver: (driver?: DatabaseType) => boolean;
 /** Database type of the query builder's connection, e.g. `'postgres'`; undefined without one. */

package/dist/utils/sql.utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertArrayType = exports.createUniqueParameterName = exports.stringToSQLValue = exports.stringToSQLIdentifier = exports.quoteIdentifierPath = exports.quoteIdentifier = exports.getDriverType = exports.isSqliteLikeDriver = exports.isMysqlLikeDriver = exports.wrapWithBackQoutes = exports.wrapWithDoubleQoutes = void 0;
+exports.assertArrayType = exports.createUniqueParameterName = exports.stringToSQLValue = exports.stringToSQLIdentifier = exports.quoteIdentifierPath = exports.quoteIdentifier = exports.getDriverType = exports.isSqliteLikeDriver = exports.isPostgresLikeDriver = exports.isMysqlLikeDriver = exports.wrapWithBackQoutes = exports.wrapWithDoubleQoutes = void 0;
 const common_utils_1 = require("./common.utils");
 const wrapWithDoubleQoutes = (str) => str.includes('"') ? str : `"${str}"`;
 exports.wrapWithDoubleQoutes = wrapWithDoubleQoutes;
@@ -29,6 +29,10 @@ const SQLITE_LIKE_DRIVERS = [
     'nativescript',
     'react-native',
 ];
+const POSTGRES_LIKE_DRIVERS = ['postgres', 'aurora-postgres', 'cockroachdb'];
+/** PostgreSQL and the databases speaking its dialect. */
+const isPostgresLikeDriver = (driver) => driver !== undefined && POSTGRES_LIKE_DRIVERS.includes(driver);
+exports.isPostgresLikeDriver = isPostgresLikeDriver;
 /** SQLite drivers: `IS` / `IS NOT` are null-safe comparisons. */
 const isSqliteLikeDriver = (driver) => driver !== undefined && SQLITE_LIKE_DRIVERS.includes(driver);
 exports.isSqliteLikeDriver = isSqliteLikeDriver;

package/dist/utils/table.utils.js

@@ -2,18 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tableHelper = void 0;
 const sql_utils_1 = require("./sql.utils");
-/** Wraps a JSON key in single quotes, doubling any quote inside it (standard SQL string literal). */
-function toJsonKeyLiteral(fieldName) {
-    return `'${String(fieldName).replace(/'/g, "''")}'`;
-}
-function buildJsonPath(fieldNames, jsonOperator) {
-    let result = '';
-    for (let i = 0; i < fieldNames.length; i++) {
-        const op = i === fieldNames.length - 1 ? jsonOperator : '->';
-        result += `${result ? ' ' : ''}${op} ${toJsonKeyLiteral(fieldNames[i])}`;
-    }
-    return result;
-}
+const json_path_utils_1 = require("./json-path.utils");
 /**
  * Creates a type-safe SQL helper for building column references, WHERE expressions,
  * JOIN clauses, and JSONB accessors for a given entity type.
@@ -115,7 +104,7 @@ const tableHelper = (alias, options = {}) => ({
      */
     jsonColumn(columnName, jsonOperator, ...fieldNames) {
         const column = this.column(columnName);
-        const path = buildJsonPath(fieldNames, jsonOperator);
+        const path = (0, json_path_utils_1.buildJsonPath)(fieldNames, jsonOperator);
         return `${column} ${path}`;
     },
     /**
@@ -129,7 +118,7 @@ const tableHelper = (alias, options = {}) => ({
      * qb.whereTyped(u => u.metadata, `${t.jsonPath('metadata', '->>', 'role')} =`, 'admin')
      */
     jsonPath(_columnName, jsonOperator, ...fieldNames) {
-        return buildJsonPath(fieldNames, jsonOperator);
+        return (0, json_path_utils_1.buildJsonPath)(fieldNames, jsonOperator);
     }
 });
 exports.tableHelper = tableHelper;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typeorm-extensions",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "typeorm commonly used extensions",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,7 +13,8 @@
   },
   "scripts": {
     "build": "tsc -p .",
-    "lint": "eslint . --ext .ts"
+    "lint": "eslint . --ext .ts",
+    "test:types": "tsc -p test/types"
   },
   "keywords": [
     "typeorm",