typeorm-extensions 2.2.0-rc.8 → 2.2.0-rc.9

package/dist/utils/prototype.utils.d.ts

@@ -1,9 +1,18 @@
+import { DeleteQueryBuilder, SelectQueryBuilder, UpdateQueryBuilder } from 'typeorm';
+import { SoftDeleteQueryBuilder } from 'typeorm/query-builder/SoftDeleteQueryBuilder';
 export type PatchPrototypeOptions = {
     /** Leave a method the target already has, own or inherited: TypeORM's, or another library's. */
     onlyMissing?: boolean;
 };
+/** The query builders with a WHERE clause, which the where extensions patch. */
+export declare const WHERE_QUERY_BUILDERS: (typeof SelectQueryBuilder | typeof UpdateQueryBuilder | typeof DeleteQueryBuilder | typeof SoftDeleteQueryBuilder)[];
 export declare function patchPrototype<T extends {
     prototype: any;
 }, S extends {
     prototype: any;
 }>(target: T, source: S, options?: PatchPrototypeOptions): void;
+export declare function patchPrototypes<S extends {
+    prototype: any;
+}>(targets: ReadonlyArray<{
+    prototype: any;
+}>, source: S, options?: PatchPrototypeOptions): void;

package/dist/utils/prototype.utils.js

@@ -1,7 +1,11 @@
 "use strict";
-/* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.patchPrototype = void 0;
+exports.patchPrototypes = exports.patchPrototype = exports.WHERE_QUERY_BUILDERS = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const typeorm_1 = require("typeorm");
+const SoftDeleteQueryBuilder_1 = require("typeorm/query-builder/SoftDeleteQueryBuilder");
+/** The query builders with a WHERE clause, which the where extensions patch. */
+exports.WHERE_QUERY_BUILDERS = [typeorm_1.SelectQueryBuilder, typeorm_1.UpdateQueryBuilder, typeorm_1.DeleteQueryBuilder, SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder];
 function patchPrototype(target, source, options = {}) {
     for (const method of Object.keys(source.prototype)) {
         if (options.onlyMissing && method in target.prototype) {
@@ -11,3 +15,9 @@ function patchPrototype(target, source, options = {}) {
     }
 }
 exports.patchPrototype = patchPrototype;
+function patchPrototypes(targets, source, options) {
+    for (const target of targets) {
+        patchPrototype(target, source, options);
+    }
+}
+exports.patchPrototypes = patchPrototypes;

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

@@ -1,9 +1,17 @@
 import { QueryBuilder } from 'typeorm';
-import type { ObjectLiteral, WhereExpressionBuilder } from 'typeorm';
+import type { ObjectLiteral, QueryRunner, SelectQueryBuilder, WhereExpressionBuilder } from 'typeorm';
 import type { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata';
+import type { Alias } from 'typeorm/query-builder/Alias';
 import type { KeyProxyCallback } from '../types/modules/proxy-callback.types';
 import type { OrderType } from '../types/interfaces/ordering.interface';
+import { KeyHolder } from './proxy-key.utils';
 import { JsonPathSqlOptions } from './json-path.utils';
+/**
+ * The aliases of the query and of the queries it is part of, its own first. The builder of a `Brackets` callback
+ * has the outer query's main alias but an empty alias list: the aliases, joins included, are on its parent. A
+ * subquery sees the aliases of the outer query too.
+ */
+export declare function listQueryAliases(builder: WhereExpressionBuilder | QueryBuilder<ObjectLiteral>): Alias[];
 /** Replaces placeholders of `deferColumnKey` in SQL built by `builder`, through the aliases it has by then. */
 export declare function resolveDeferredKeys(builder: WhereExpressionBuilder, statement: string): string;
 /**
@@ -50,6 +58,14 @@ export declare function isTypedJsonPath<Type extends ObjectLiteral>(builder: Whe
  * 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, jsonOptions?: JsonPathSqlOptions): string;
+/**
+ * The alias and the entity property a typed callback picks, for methods that take a property rather than a column
+ * (a `@CalculatedColumn`): `u => u.imagesCount` is on the main alias, `q => q.owner.imagesCount` on `owner`.
+ */
+export declare function resolveTypedProperty<Type extends ObjectLiteral>(builder: WhereExpressionBuilder, callback: KeyProxyCallback<Type>, methodName: string): {
+    aliasName: string | undefined;
+    propertyPath: string;
+};
 /**
  * Key for typed select / order / distinct / group by on a SelectQueryBuilder.
  *
@@ -61,10 +77,14 @@ export declare function getTypedSingleColumnKey<Type extends ObjectLiteral>(buil
  * PostgreSQL folds an unquoted `cte.firstName` to `firstname`.
  * Strings are kept as is.
  */
-export declare function getTypedSelectionKey<Type extends ObjectLiteral>(builder: WhereExpressionBuilder, selection: KeyProxyCallback<Type> | string, useQuotes?: boolean, columnsFor?: string): string | string[];
+export declare function getTypedSelectionKey<Type extends ObjectLiteral>(builder: WhereExpressionBuilder, selection: KeyProxyCallback<Type> | KeyHolder | string, useQuotes?: boolean, columnsFor?: string): string | string[];
 /**
  * The ORDER BY a query is built with, in the order it was applied. `allOrderBys`, not `orderBys`: it is what the SQL
  * is built from, so without an explicit order it falls back to the `orderBy` of @Entity, and respects the
  * `disable-global-order` option.
  */
 export declare function getAppliedOrderBy<Entity extends ObjectLiteral>(builder: QueryBuilder<Entity>): OrderType[];
+/** The query without paging: no ORDER BY (nor the entity's default one), LIMIT, OFFSET, take or skip. */
+export declare function withoutPaging<Entity extends ObjectLiteral>(query: SelectQueryBuilder<Entity>): SelectQueryBuilder<Entity>;
+/** The query runner a builder was created with, from a transactional manager; `undefined` for one from the pool. */
+export declare function getQueryRunner<Entity extends ObjectLiteral>(builder: QueryBuilder<Entity>): QueryRunner | undefined;

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

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAppliedOrderBy = exports.getTypedSelectionKey = exports.getTypedSingleColumnKey = exports.isTypedJsonPath = exports.getTypedColumnKey = exports.toFieldSql = exports.findFieldColumn = exports.getColumnDatabaseName = exports.resolveDeferredKeys = void 0;
+exports.getQueryRunner = exports.withoutPaging = exports.getAppliedOrderBy = exports.getTypedSelectionKey = exports.resolveTypedProperty = exports.getTypedSingleColumnKey = exports.isTypedJsonPath = exports.getTypedColumnKey = exports.toFieldSql = exports.findFieldColumn = exports.getColumnDatabaseName = exports.resolveDeferredKeys = exports.listQueryAliases = void 0;
 const typeorm_1 = require("typeorm");
 const QueryExpressionMap_1 = require("typeorm/query-builder/QueryExpressionMap");
 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");
+const calculated_column_utils_1 = require("./calculated-column.utils");
 /**
  * Whether single-level typed keys are qualified with the main alias (`user.firstName`).
  *
@@ -33,21 +34,24 @@ function requireMainAliasName(queryBuilder, key) {
     return mainAlias.name;
 }
 /**
- * An alias of the query by name, or of a query it is part of. The builder of a `Brackets` callback has the
- * outer query's main alias but an empty alias list: the aliases, joins included, are on its parent. A subquery
- * sees the aliases of the outer query too, its own first.
+ * The aliases of the query and of the queries it is part of, its own first. The builder of a `Brackets` callback
+ * has the outer query's main alias but an empty alias list: the aliases, joins included, are on its parent. A
+ * subquery sees the aliases of the outer query too.
  */
-function findQueryAlias(queryBuilder, aliasName) {
-    var _a, _b;
+function listQueryAliases(builder) {
+    var _a;
+    const aliases = [];
     // parentQueryBuilder is protected in TypeORM's types
-    for (let query = queryBuilder; query; query = query.parentQueryBuilder) {
-        const { aliases = [], mainAlias } = (_a = query.expressionMap) !== null && _a !== void 0 ? _a : {};
-        const alias = (_b = aliases.find((candidate) => candidate.name === aliasName)) !== null && _b !== void 0 ? _b : ((mainAlias === null || mainAlias === void 0 ? void 0 : mainAlias.name) === aliasName ? mainAlias : undefined);
-        if (alias) {
-            return alias;
-        }
+    for (let query = builder; query; query = query.parentQueryBuilder) {
+        const { aliases: own = [], mainAlias } = (_a = query.expressionMap) !== null && _a !== void 0 ? _a : {};
+        aliases.push(...own, ...(mainAlias ? [mainAlias] : []));
     }
-    return undefined;
+    return aliases;
+}
+exports.listQueryAliases = listQueryAliases;
+/** An alias of the query by name, or of a query it is part of (see `listQueryAliases`). */
+function findQueryAlias(queryBuilder, aliasName) {
+    return listQueryAliases(queryBuilder).find((candidate) => candidate.name === aliasName);
 }
 // private-use characters: no identifier or SQL that TypeORM builds contains them
 const DEFERRED_KEY_START = '\uE000';
@@ -74,7 +78,7 @@ function deferColumnKey(aliasName, separator, name) {
  *   subquery in the condition of a raw join): TypeORM can't map it, and PostgreSQL would fold it to lower case.
  */
 function toDeferredKeySql(alias, aliasName, separator, name, escape) {
-    const metadata = (alias === null || alias === void 0 ? void 0 : alias.hasMetadata) ? alias.metadata : undefined;
+    const metadata = metadataOf(alias);
     if (separator === DEFERRED_UNQUOTED) {
         return metadata ? `${aliasName}.${name}` : `${escape(aliasName)}.${escape(name)}`;
     }
@@ -149,13 +153,11 @@ function installDeferredKeyResolution() {
     }
 }
 installDeferredKeyResolution();
+const metadataOf = (alias) => (alias === null || alias === void 0 ? void 0 : alias.hasMetadata) ? alias.metadata : undefined;
 /** Entity metadata of a query alias (the main alias when `aliasName` is undefined), if it has any. */
 function getAliasMetadata(queryBuilder, aliasName) {
     var _a;
-    const alias = aliasName === undefined
-        ? (_a = queryBuilder.expressionMap) === null || _a === void 0 ? void 0 : _a.mainAlias
-        : findQueryAlias(queryBuilder, aliasName);
-    return (alias === null || alias === void 0 ? void 0 : alias.hasMetadata) ? alias.metadata : undefined;
+    return metadataOf(aliasName === undefined ? (_a = queryBuilder.expressionMap) === null || _a === void 0 ? void 0 : _a.mainAlias : findQueryAlias(queryBuilder, aliasName));
 }
 /**
  * Database name of an entity property's column (`@Column({ name })`), looked up in the metadata of
@@ -185,6 +187,7 @@ function findFieldColumn(builder, field) {
         const metadata = getAliasMetadata(queryBuilder, field.slice(0, dot));
         return metadata && findColumn(metadata, field.slice(dot + 1));
     }
+    // only by database name: an unqualified property name may mean another table's column
     return (_a = getAliasMetadata(queryBuilder, undefined)) === null || _a === void 0 ? void 0 : _a.columns.find((column) => column.databaseName === field);
 }
 exports.findFieldColumn = findFieldColumn;
@@ -205,27 +208,17 @@ exports.findFieldColumn = findFieldColumn;
  */
 function toFieldSql(builder, field) {
     const queryBuilder = builder;
+    const column = findFieldColumn(builder, field);
     const dot = field.indexOf('.');
-    if (dot > 0) {
-        const aliasName = field.slice(0, dot);
-        const metadata = getAliasMetadata(queryBuilder, aliasName);
-        const column = metadata && findColumn(metadata, field.slice(dot + 1));
-        if (column) {
-            const columnSql = queryBuilder.escape(column.databaseName);
-            return isAliasPrefixingEnabled(queryBuilder) ? `${queryBuilder.escape(aliasName)}.${columnSql}` : columnSql;
-        }
-        const parts = TWO_PART_FIELD.exec(field);
-        if (parts && !findQueryAlias(queryBuilder, aliasName)) {
-            return deferColumnKey(parts[1], DEFERRED_FIELD, parts[2]);
-        }
+    if (column) {
+        const columnSql = queryBuilder.escape(column.databaseName);
+        return dot > 0 && isAliasPrefixingEnabled(queryBuilder)
+            ? `${queryBuilder.escape(field.slice(0, dot))}.${columnSql}`
+            : columnSql;
     }
-    else {
-        // only by database name: an unqualified property name may mean another table's column
-        const metadata = getAliasMetadata(queryBuilder, undefined);
-        const column = metadata === null || metadata === void 0 ? void 0 : metadata.columns.find((candidate) => candidate.databaseName === field);
-        if (column) {
-            return queryBuilder.escape(column.databaseName);
-        }
+    const parts = dot > 0 ? TWO_PART_FIELD.exec(field) : null;
+    if (parts && !findQueryAlias(queryBuilder, parts[1])) {
+        return deferColumnKey(parts[1], DEFERRED_FIELD, parts[2]);
     }
     return (0, sql_utils_1.stringToSQLIdentifier)(field, (0, sql_utils_1.getDriverType)(builder));
 }
@@ -266,15 +259,13 @@ function findColumnPath(metadata, keys) {
  * before `from()` the property name is used as the column name.
  */
 function resolveTypedKey(queryBuilder, keys) {
-    var _a, _b;
     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);
     }
-    const column = (_a = resolved.column) !== null && _a !== void 0 ? _a : (_b = resolved.metadata) === null || _b === void 0 ? void 0 : _b.findColumnWithPropertyPath(resolved.propertyPath);
     // a @CalculatedColumn: TypeORM would write "alias"."property", a column the table doesn't have
-    if ((column === null || column === void 0 ? void 0 : column.isVirtualProperty) && !column.query) {
+    if ((0, calculated_column_utils_1.isCalculated)(resolved.column)) {
         throw new TypeError(`${keys.join('.')} is a @CalculatedColumn, not a column of the table: use the SQL expression that fills it`);
     }
     return resolved;
@@ -283,10 +274,12 @@ function resolveTypedKeyPath(queryBuilder, keys) {
     const prefixing = isAliasPrefixingEnabled(queryBuilder);
     if (keys.length === 1) {
         const aliasName = prefixing ? requireMainAliasName(queryBuilder, keys[0]) : undefined;
+        const metadata = getAliasMetadata(queryBuilder, aliasName);
         return {
             aliasName,
             propertyPath: keys[0],
-            metadata: getAliasMetadata(queryBuilder, aliasName),
+            metadata,
+            column: metadata === null || metadata === void 0 ? void 0 : metadata.findColumnWithPropertyPath(keys[0]),
         };
     }
     const [firstKey, ...restKeys] = keys;
@@ -314,7 +307,7 @@ function resolveTypedKeyPath(queryBuilder, keys) {
             };
         }
     }
-    const metadata = (queryAlias === null || queryAlias === void 0 ? void 0 : queryAlias.hasMetadata) ? queryAlias.metadata : undefined;
+    const metadata = metadataOf(queryAlias);
     return {
         aliasName: firstKey,
         propertyPath: restKeys.join('.'),
@@ -327,11 +320,11 @@ function resolveTypedKeyPath(queryBuilder, keys) {
  * inside a JSON column: `"exec"."details" -> 'meta' ->> 'endTs'` (see `toJsonPathSql`).
  */
 function toQuotedColumnKey(queryBuilder, { aliasName, propertyPath, metadata, column, jsonPath }, jsonOptions) {
-    var _a, _b;
+    var _a;
     if (aliasName !== undefined && !metadata && !findQueryAlias(queryBuilder, aliasName)) {
         return deferColumnKey(aliasName, DEFERRED_PROPERTY, propertyPath);
     }
-    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 columnName = (_a = column === null || column === void 0 ? void 0 : column.databaseName) !== null && _a !== void 0 ? _a : propertyPath;
     const columnSql = aliasName === undefined
         ? queryBuilder.escape(columnName)
         : `${queryBuilder.escape(aliasName)}.${queryBuilder.escape(columnName)}`;
@@ -377,6 +370,19 @@ function getTypedSingleColumnKey(builder, callback, methodName, jsonOptions) {
     return key;
 }
 exports.getTypedSingleColumnKey = getTypedSingleColumnKey;
+/**
+ * The alias and the entity property a typed callback picks, for methods that take a property rather than a column
+ * (a `@CalculatedColumn`): `u => u.imagesCount` is on the main alias, `q => q.owner.imagesCount` on `owner`.
+ */
+function resolveTypedProperty(builder, callback, methodName) {
+    const keyHolder = (0, proxy_key_utils_1.getKeyHolder)(callback);
+    if (Array.isArray(keyHolder)) {
+        throw new TypeError(`${methodName} expects the callback to pick a single property, got ${keyHolder.length}`);
+    }
+    const { aliasName, propertyPath } = resolveTypedKeyPath(builder, keyHolder.getKeys());
+    return { aliasName, propertyPath };
+}
+exports.resolveTypedProperty = resolveTypedProperty;
 /**
  * Throws for a key that names no column of its table: a relation whose join column is on the other side
  * (one-to-many, many-to-many, the inverse side of a one-to-one) or an embedded entity. TypeORM leaves such a key
@@ -457,3 +463,20 @@ function getAppliedOrderBy(builder) {
     });
 }
 exports.getAppliedOrderBy = getAppliedOrderBy;
+/** The query without paging: no ORDER BY (nor the entity's default one), LIMIT, OFFSET, take or skip. */
+function withoutPaging(query) {
+    return query
+        .orderBy()
+        .offset(undefined)
+        .limit(undefined)
+        .skip(undefined)
+        .take(undefined)
+        .setOption('disable-global-order');
+}
+exports.withoutPaging = withoutPaging;
+/** The query runner a builder was created with, from a transactional manager; `undefined` for one from the pool. */
+function getQueryRunner(builder) {
+    // queryRunner is protected in TypeORM's types
+    return builder.queryRunner;
+}
+exports.getQueryRunner = getQueryRunner;

package/dist/utils/table.utils.js

@@ -4,6 +4,7 @@ exports.tableHelper = void 0;
 const typeorm_1 = require("typeorm");
 const sql_utils_1 = require("./sql.utils");
 const json_path_utils_1 = require("./json-path.utils");
+const time_zone_utils_1 = require("./time-zone.utils");
 /**
  * The argument of an aggregate and the clause after it for a `filter` written with `syntax`:
  * `CASE WHEN filter THEN argument END`, or `argument` and ` FILTER (WHERE filter)`.
@@ -45,9 +46,9 @@ const DATE_TRUNC_UNITS = [
     'century',
     'millennium',
 ];
-function assertPostgres(method, driver) {
+function assertPostgres(method, driver, hint) {
     if (driver !== undefined && !(0, sql_utils_1.isPostgresLikeDriver)(driver)) {
-        throw new TypeError(`tableHelper.${method}(): PostgreSQL only, the driver is "${driver}"`);
+        throw new TypeError(`tableHelper.${method}(): PostgreSQL only, the driver is "${driver}"${hint ? `: ${hint}` : ''}`);
     }
 }
 function toExpression(value, toColumn) {
@@ -58,7 +59,7 @@ function toTimeZone(method, timeZone, toColumn) {
         if (!timeZone.trim()) {
             throw new TypeError(`tableHelper.${method}(): the time zone is empty`);
         }
-        return sqlString(toPostgresZone(timeZone));
+        return sqlString(toPostgresZone(method, timeZone));
     }
     if ('sql' in timeZone) {
         return timeZone.sql;
@@ -66,19 +67,18 @@ function toTimeZone(method, timeZone, toColumn) {
     const column = toColumn(timeZone.column);
     return timeZone.fallback === undefined
         ? column
-        : `COALESCE(${column}, ${sqlString(toPostgresZone(timeZone.fallback))})`;
+        : `COALESCE(${column}, ${sqlString(toPostgresZone(method, timeZone.fallback))})`;
 }
-const ISO_OFFSET = /^([+-])(\d{2}):?(\d{2})?$/;
 /**
  * PostgreSQL reads `'+02:00'` as a POSIX zone, whose offsets count west: UTC−2. An ISO 8601 offset is
  * written as the POSIX zone of the same offset, `'<+0200>-02:00'`, so `'+02:00'` is UTC+2 as everywhere else.
  */
-function toPostgresZone(timeZone) {
-    const offset = ISO_OFFSET.exec(timeZone.trim());
+function toPostgresZone(method, timeZone) {
+    const offset = (0, time_zone_utils_1.parseUtcOffset)(timeZone.trim(), `tableHelper.${method}(): "${timeZone}" is not a UTC offset`);
     if (offset === null) {
         return timeZone;
     }
-    const [, sign, hours, minutes = '00'] = offset;
+    const { sign, hours, minutes } = offset;
     return `<${sign}${hours}${minutes}>${sign === '+' ? '-' : '+'}${hours}:${minutes}`;
 }
 /** The JSON functions of a database: PostgreSQL's unless the driver is MySQL / MariaDB or SQLite. */
@@ -200,9 +200,7 @@ const createTableHelper = (alias, options = {}, databaseNames) => ({
     arrayAgg(columnName, aggOptions = {}) {
         var _a;
         const { distinct = false, orderBy, filter } = aggOptions;
-        if (options.driver !== undefined && !(0, sql_utils_1.isPostgresLikeDriver)(options.driver)) {
-            throw new TypeError(`tableHelper.arrayAgg(): arrays are PostgreSQL's, the driver is "${options.driver}": use jsonAgg`);
-        }
+        assertPostgres('arrayAgg', options.driver, 'use jsonAgg');
         const order = orderBy ? aggregateOrder('arrayAgg', orderBy, (column) => this.column(column)) : undefined;
         // PostgreSQL: "in an aggregate with DISTINCT, ORDER BY expressions must appear in argument list"
         if (distinct && order && order.column !== columnName) {

package/dist/utils/time-zone.utils.d.ts

@@ -1,3 +1,10 @@
+type UtcOffset = {
+    sign: '+' | '-';
+    hours: string;
+    minutes: string;
+};
+/** The parts of an ISO 8601 UTC offset (`+02:00`, `-0530`, `+02`); `null` for other text, a `TypeError` past 23:59. */
+export declare function parseUtcOffset(text: string, errorMessage: string): UtcOffset | null;
 /** Throws a `TypeError` for a time zone the runtime doesn't know. */
 export declare function assertTimeZone(timeZone: string): void;
 /**
@@ -6,3 +13,4 @@ export declare function assertTimeZone(timeZone: string): void;
  * instant already: it is returned as that `Date`. Any other string throws a `TypeError` naming `name`.
  */
 export declare function readInTimeZone(value: string, timeZone: string, name: string): Date;
+export {};

package/dist/utils/time-zone.utils.js

@@ -1,10 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readInTimeZone = exports.assertTimeZone = void 0;
+exports.readInTimeZone = exports.assertTimeZone = exports.parseUtcOffset = void 0;
 const DAY_MS = 24 * 60 * 60 * 1000;
 const MAX_CACHED_FORMATTERS = 500;
 const DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?(Z|[+-]\d{2}(?::?\d{2})?)?)?$/i;
 const OFFSET = /^([+-])(\d{2}):?(\d{2})?$/;
+/** The parts of an ISO 8601 UTC offset (`+02:00`, `-0530`, `+02`); `null` for other text, a `TypeError` past 23:59. */
+function parseUtcOffset(text, errorMessage) {
+    const offset = OFFSET.exec(text);
+    if (offset === null) {
+        return null;
+    }
+    const [, sign, hours, minutes = '00'] = offset;
+    if (Number(hours) > 23 || Number(minutes) > 59) {
+        throw new TypeError(errorMessage);
+    }
+    return { sign: sign, hours, minutes };
+}
+exports.parseUtcOffset = parseUtcOffset;
 const formatters = new Map();
 function getFormatter(timeZone) {
     let formatter = formatters.get(timeZone);
@@ -94,9 +107,6 @@ function getOffsetMinutes(offset, value, name) {
     if (offset.toUpperCase() === 'Z') {
         return 0;
     }
-    const [, sign, hours, minutes = '00'] = OFFSET.exec(offset);
-    if (Number(hours) > 23 || Number(minutes) > 59) {
-        throw new TypeError(`Invalid ${name} "${value}": not a UTC offset`);
-    }
+    const { sign, hours, minutes } = parseUtcOffset(offset, `Invalid ${name} "${value}": not a UTC offset`);
     return (sign === '-' ? -1 : 1) * (Number(hours) * 60 + Number(minutes));
 }

package/dist/utils/typed-where.utils.d.ts

@@ -0,0 +1,9 @@
+import { ObjectLiteral, WhereExpressionBuilder } from 'typeorm';
+import type { KeyProxyCallback } from '../types/modules/proxy-callback.types';
+import type { JsonPathSqlOptions } from './json-path.utils';
+/**
+ * Calls the untyped where `method` with the single column a typed callback picks, followed by `args`, as the typed
+ * where methods that only add the column to their untyped counterpart do. A callback that isn't a function, from
+ * untyped code, leaves the builder as it is.
+ */
+export declare function attachTypedColumnWhere<Type extends ObjectLiteral, QB extends WhereExpressionBuilder, Args extends unknown[] = unknown[]>(builder: QB, method: string, where: KeyProxyCallback<Type>, jsonOptions: JsonPathSqlOptions | undefined, ...args: Args): QB;

package/dist/utils/typed-where.utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachTypedColumnWhere = void 0;
+const query_builder_utils_1 = require("./query-builder.utils");
+/**
+ * Calls the untyped where `method` with the single column a typed callback picks, followed by `args`, as the typed
+ * where methods that only add the column to their untyped counterpart do. A callback that isn't a function, from
+ * untyped code, leaves the builder as it is.
+ */
+function attachTypedColumnWhere(builder, method, where, jsonOptions, ...args) {
+    if (typeof where !== 'function') {
+        return builder;
+    }
+    const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`, jsonOptions);
+    return builder[method](key, ...args);
+}
+exports.attachTypedColumnWhere = attachTypedColumnWhere;

package/dist/utils/where.utils.d.ts

@@ -5,6 +5,8 @@ export declare function getValuePlaceholder<T>(value: T, paramName?: string): st
  * Whether `params` is a `{ name: value }` params object (a plain object or a class instance such
  * as a DTO), rather than the value itself (a primitive, an array, a `Date`, a `Buffer`).
  */
+/** The value a condition compares with: the value of a one-key params object, or the params themselves (a Date or a Buffer is a value too). */
+export declare function getComparedValue(params: unknown): unknown;
 export declare function isParamsObject(params: unknown): params is Record<string, unknown>;
 /**
  * Checks whether `conditions` already references a key of `params` as a TypeORM

package/dist/utils/where.utils.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.andWhereNarrowing = exports.attachWhere = exports.hasParamPlaceholder = exports.isParamsObject = exports.getValuePlaceholder = void 0;
+exports.andWhereNarrowing = exports.attachWhere = exports.hasParamPlaceholder = exports.isParamsObject = exports.getComparedValue = exports.getValuePlaceholder = void 0;
 const sql_utils_1 = require("./sql.utils");
 const query_builder_utils_1 = require("./query-builder.utils");
+const parameter_utils_1 = require("./parameter.utils");
+const common_utils_1 = require("./common.utils");
 function getValuePlaceholder(value, paramName) {
     if (value === undefined || value === null || paramName === undefined) {
         return 'NULL';
@@ -18,16 +20,20 @@ exports.getValuePlaceholder = getValuePlaceholder;
  * `:` or `.` is a parameter or a column (`ILIKE :like`, `= t.in`), not an operator.
  */
 const OPERATOR_AT_END = /(?:[=<>!~@&|?]|(?<![\w$:.])(?:LIKE|ILIKE|IN|SIMILAR TO|DISTINCT FROM|BETWEEN|ANY|ALL))\s*$/i;
-const isDate = (value) => Object.prototype.toString.call(value) === '[object Date]';
 /**
  * Objects that are parameter values themselves, not `{ name: value }` params objects:
  * `Date`, and binary data (`Buffer`, typed arrays, `ArrayBuffer`).
  */
-const isValueObject = (value) => isDate(value) || ArrayBuffer.isView(value) || value instanceof ArrayBuffer;
+const isValueObject = (value) => (0, common_utils_1.isDate)(value) || ArrayBuffer.isView(value) || value instanceof ArrayBuffer;
 /**
  * Whether `params` is a `{ name: value }` params object (a plain object or a class instance such
  * as a DTO), rather than the value itself (a primitive, an array, a `Date`, a `Buffer`).
  */
+/** The value a condition compares with: the value of a one-key params object, or the params themselves (a Date or a Buffer is a value too). */
+function getComparedValue(params) {
+    return isParamsObject(params) ? Object.values(params)[0] : params;
+}
+exports.getComparedValue = getComparedValue;
 function isParamsObject(params) {
     return (params !== null &&
         typeof params === 'object' &&
@@ -44,14 +50,7 @@ function hasParamPlaceholder(conditions, params) {
     if (!isParamsObject(params)) {
         return false;
     }
-    const placeholderRegex = /:(?:\.\.\.)?([A-Za-z0-9_.]+)/g;
-    let match;
-    while ((match = placeholderRegex.exec(conditions)) !== null) {
-        if (Object.prototype.hasOwnProperty.call(params, match[1])) {
-            return true;
-        }
-    }
-    return false;
+    return (0, parameter_utils_1.getPlaceholderNames)(conditions).some((name) => Object.prototype.hasOwnProperty.call(params, name));
 }
 exports.hasParamPlaceholder = hasParamPlaceholder;
 /**
@@ -87,13 +86,12 @@ function attachWhere(builder, method, field, conditions, params, options) {
         }
         if (addValue && hasParams) {
             assertSingleValueParams(fieldName, params);
-            // pick first value from params object or pass as is (a Date or a Buffer is a value too)
-            const firstValue = isParamsObject(params) ? Object.values(params)[0] : params;
+            const firstValue = getComparedValue(params);
             // 0, false, '' are valid values like any other
             // null, undefined, NaN and invalid dates are equal to NULL
             const valueIsValid = firstValue !== undefined &&
                 (typeof firstValue === 'number' ? !isNaN(firstValue) : true) &&
-                (isDate(firstValue) ? !isNaN(firstValue.getTime()) : true);
+                ((0, common_utils_1.isDate)(firstValue) ? !isNaN(firstValue.getTime()) : true);
             const paramName = valueIsValid
                 ? (0, sql_utils_1.createUniqueParameterName)(method)
                 : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typeorm-extensions",
-  "version": "2.2.0-rc.8",
+  "version": "2.2.0-rc.9",
   "description": "typeorm commonly used extensions",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",