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

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.7",
+  "version": "2.2.0-rc.9",
   "description": "typeorm commonly used extensions",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",