typeorm-extensions 2.2.0-rc.2 → 2.2.0-rc.4

package/dist/extensions/get-many-with-totals.extension.js

@@ -5,6 +5,7 @@ const SelectQueryBuilder_1 = require("typeorm/query-builder/SelectQueryBuilder")
 const pagination_utils_1 = require("../utils/pagination.utils");
 const constants_1 = require("../constants");
 const prototype_utils_1 = require("../utils/prototype.utils");
+const query_builder_utils_1 = require("../utils/query-builder.utils");
 // patching
 const extension = {
     prototype: {
@@ -111,9 +112,12 @@ async function readWithTotals(builder, paginationFilter, options, read) {
     }
     // 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
-    const orderBy = Object.entries((_a = builder.expressionMap.allOrderBys) !== null && _a !== void 0 ? _a : {}).map(([selector, value]) => typeof value === 'string'
-        ? { selector, order: value }
-        : { selector, order: value.order, nulls: value.nulls });
+    const orderBy = Object.entries((_a = builder.expressionMap.allOrderBys) !== null && _a !== void 0 ? _a : {}).map(([key, value]) => {
+        const selector = (0, query_builder_utils_1.resolveDeferredKeys)(builder, key);
+        return typeof value === 'string'
+            ? { selector, order: value }
+            : { selector, order: value.order, nulls: value.nulls };
+    });
     return {
         list,
         total,

package/dist/extensions/typed/typed-distinct/typed-distinct.extension.js

@@ -5,7 +5,7 @@ const query_builder_utils_1 = require("../../../utils/query-builder.utils");
 // patching and implementation
 typeorm_1.SelectQueryBuilder.prototype.distinctOnTyped = function (...distinctOn) {
     if (Array.isArray(distinctOn) && distinctOn.length) {
-        const keys = distinctOn.map((callback) => (0, query_builder_utils_1.getTypedSelectionKey)(this, callback)).flat();
+        const keys = distinctOn.map((callback) => (0, query_builder_utils_1.getTypedSelectionKey)(this, callback, undefined, 'distinctOnTyped')).flat();
         return this.distinctOn(keys);
     }
     return this;

package/dist/extensions/typed/typed-group-by/typed-group-by.extension.d.ts

@@ -1,11 +1,12 @@
 import { ObjectLiteral } from 'typeorm';
-import type { DeepUnwrapArray } from '../../../types/modules/proxy-callback.types';
+import type { KeyProxyCallback } from '../../../types/modules/proxy-callback.types';
 import type { TypedGroupByOptions } from '../../../types/extensions/typed-group-by.types';
 import type { TypedRoot } from '../../../types/modules/typed-root.types';
-/** A value a column holds: a relation (`u => u.images`) or a JSON object is no column to group by. */
-type GroupedColumn = string | number | boolean | Date | ArrayBufferView | ArrayBuffer | null | undefined;
-/** One column, `user => user.id`, or several, `user => [user.id, user.email]`. */
-type GroupBySelection<Type extends ObjectLiteral> = (proxy: DeepUnwrapArray<Type>) => GroupedColumn | GroupedColumn[];
+/**
+ * One column, `user => user.id`, or several, `user => [user.id, user.email]`. A JSON column groups as a whole;
+ * a relation without a join column in its table, or an embedded entity, throws a `TypeError`.
+ */
+type GroupBySelection<Type extends ObjectLiteral> = KeyProxyCallback<Type>;
 export interface TypedGroupByMethods<Entity extends ObjectLiteral> {
     /**
      * Sets GROUP BY to the columns the callback selects: `user => user.id`, or several at once,

package/dist/extensions/typed/typed-group-by/typed-group-by.extension.js

@@ -23,7 +23,7 @@ const extension = {
 (0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
 // implementation
 function toGroupByKeys(builder, selection, options) {
-    const keys = (0, query_builder_utils_1.getTypedSelectionKey)(builder, selection, options === null || options === void 0 ? void 0 : options.useQuotes);
+    const keys = (0, query_builder_utils_1.getTypedSelectionKey)(builder, selection, options === null || options === void 0 ? void 0 : options.useQuotes, 'groupByTyped');
     return Array.isArray(keys) ? keys : [keys];
 }
 function addGroupByKeys(builder, keys) {

package/dist/extensions/typed/typed-order-by/typed-order-by.extension.js

@@ -10,7 +10,7 @@ typeorm_1.SelectQueryBuilder.prototype.orderByTyped = function (selection, order
         return this.orderBy(selection.toSql(undefined, options === null || options === void 0 ? void 0 : options.useQuotes, (0, sql_utils_1.getDriverType)(this)), order, nulls);
     }
     if (typeof selection === 'function') {
-        const key = (0, query_builder_utils_1.getTypedSelectionKey)(this, selection, options === null || options === void 0 ? void 0 : options.useQuotes);
+        const key = (0, query_builder_utils_1.getTypedSelectionKey)(this, selection, options === null || options === void 0 ? void 0 : options.useQuotes, 'orderByTyped');
         return this.orderBy(key, order, nulls);
     }
     return this;
@@ -20,7 +20,7 @@ typeorm_1.SelectQueryBuilder.prototype.addOrderByTyped = function (selection, or
         return this.addOrderBy(selection.toSql(undefined, options === null || options === void 0 ? void 0 : options.useQuotes, (0, sql_utils_1.getDriverType)(this)), order, nulls);
     }
     if (typeof selection === 'function') {
-        const key = (0, query_builder_utils_1.getTypedSelectionKey)(this, selection, options === null || options === void 0 ? void 0 : options.useQuotes);
+        const key = (0, query_builder_utils_1.getTypedSelectionKey)(this, selection, options === null || options === void 0 ? void 0 : options.useQuotes, 'addOrderByTyped');
         return this.addOrderBy(key, order, nulls);
     }
     return this;

package/dist/extensions/typed/typed-select/typed-select.extension.js

@@ -29,11 +29,11 @@ const attachSelectMethod = (query, method, selection, selectionAliasName, useQuo
     if (Array.isArray(selection)) {
         const arrayOfKeys = selection.flatMap((select) => select instanceof proxy_key_utils_1.KeyHolder
             ? (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(select, () => query.alias, useQuotes, (0, sql_utils_1.getDriverType)(query))
-            : (0, query_builder_utils_1.getTypedSelectionKey)(query, select, useQuotes));
+            : (0, query_builder_utils_1.getTypedSelectionKey)(query, select, useQuotes, `${method}Typed`));
         return query[method](arrayOfKeys);
     }
     else if (typeof selection === 'function') {
-        const keyArrayOrSingleKey = (0, query_builder_utils_1.getTypedSelectionKey)(query, selection, useQuotes);
+        const keyArrayOrSingleKey = (0, query_builder_utils_1.getTypedSelectionKey)(query, selection, useQuotes, `${method}Typed`);
         if (Array.isArray(keyArrayOrSingleKey)) {
             return query[method](keyArrayOrSingleKey);
         }

package/dist/types/extensions/typed-group-by.types.d.ts

@@ -1,8 +1,8 @@
 export type TypedGroupByOptions = {
     /**
      * Group by the quoted database column (`"ticket"."ticket_status"`) instead of `ticket.status`,
-     * which TypeORM maps to the column itself. TypeORM maps only aliases with metadata, so a subquery
-     * in FROM needs it on PostgreSQL, where an unquoted `sub.firstName` is folded to `firstname`.
+     * which TypeORM maps to the column itself. Keys of an alias without metadata (a subquery in FROM)
+     * are quoted unless this is `false`: PostgreSQL folds an unquoted `sub.firstName` to `firstname`.
      */
     useQuotes?: boolean;
 };

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

@@ -2,6 +2,11 @@ import type { ObjectLiteral, WhereExpressionBuilder } from 'typeorm';
 import type { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata';
 import type { KeyProxyCallback } from '../types/modules/proxy-callback.types';
 import { JsonPathSqlOptions } from './json-path.utils';
+/**
+ * Replaces placeholders of `deferColumnKey` in SQL built by `builder`: the database column through the entity of
+ * the alias, quoted, `"usr"."receipts_email"`. An alias still unknown or without an entity keeps the name.
+ */
+export declare function resolveDeferredKeys(builder: WhereExpressionBuilder, statement: string): string;
 /**
  * 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
@@ -47,10 +52,13 @@ export declare function isTypedJsonPath<Type extends ObjectLiteral>(builder: Whe
  */
 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.
+ * Key for typed select / order / distinct / group by on a SelectQueryBuilder.
  *
  * Without quotes it is `alias.propertyPath` (`user.name`, `images.url`, `p.address.city`),
  * which TypeORM maps to the column itself. With `useQuotes` it is the quoted database column
- * (`"t"."ticket_status"`), since TypeORM doesn't map quoted keys. Strings are kept as is.
+ * (`"t"."ticket_status"`), since TypeORM doesn't map quoted keys. An alias of the query without
+ * metadata (a subquery or a CTE in FROM or a join) is quoted unless `useQuotes` is `false`:
+ * TypeORM leaves its keys as written, and 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): string | string[];
+export declare function getTypedSelectionKey<Type extends ObjectLiteral>(builder: WhereExpressionBuilder, selection: KeyProxyCallback<Type> | string, useQuotes?: boolean, columnsFor?: string): string | string[];

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypedSelectionKey = exports.getTypedSingleColumnKey = exports.isTypedJsonPath = exports.getTypedColumnKey = exports.toFieldSql = exports.findFieldColumn = exports.getColumnDatabaseName = void 0;
+exports.getTypedSelectionKey = exports.getTypedSingleColumnKey = exports.isTypedJsonPath = exports.getTypedColumnKey = exports.toFieldSql = exports.findFieldColumn = exports.getColumnDatabaseName = exports.resolveDeferredKeys = void 0;
+const typeorm_1 = require("typeorm");
 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");
@@ -47,6 +48,55 @@ function findQueryAlias(queryBuilder, aliasName) {
     }
     return undefined;
 }
+// private-use characters: no identifier or SQL that TypeORM builds contains them
+const DEFERRED_KEY_START = '\uE000';
+const DEFERRED_PROPERTY = '\uE001';
+const DEFERRED_FIELD = '\uE002';
+const DEFERRED_KEY_END = '\uE003';
+const DEFERRED_KEY = /\uE000([^\uE000-\uE003]+)([\uE001\uE002])([^\uE000-\uE003]+)\uE003/g;
+const TWO_PART_FIELD = /^([A-Za-z_][\w$]*)\.([A-Za-z_][\w$]*)$/;
+/**
+ * Placeholder for a column of an alias the query doesn't have yet, e.g. a join added after the call. TypeORM maps
+ * property names when it builds the SQL, and so does `resolveDeferredKeys` with these, once the alias is known.
+ */
+function deferColumnKey(aliasName, separator, name) {
+    return `${DEFERRED_KEY_START}${aliasName}${separator}${name}${DEFERRED_KEY_END}`;
+}
+/**
+ * Replaces placeholders of `deferColumnKey` in SQL built by `builder`: the database column through the entity of
+ * the alias, quoted, `"usr"."receipts_email"`. An alias still unknown or without an entity keeps the name.
+ */
+function resolveDeferredKeys(builder, statement) {
+    if (typeof statement !== 'string' || !statement.includes(DEFERRED_KEY_START)) {
+        return statement;
+    }
+    const queryBuilder = builder;
+    return statement.replace(DEFERRED_KEY, (_match, aliasName, separator, name) => {
+        const metadata = getAliasMetadata(queryBuilder, aliasName);
+        const column = metadata && (separator === DEFERRED_FIELD ? findColumn(metadata, name) : metadata.findColumnWithPropertyPath(name));
+        const columnName = column && !column.isVirtualProperty ? column.databaseName : name;
+        return `${queryBuilder.escape(aliasName)}.${queryBuilder.escape(columnName)}`;
+    });
+}
+exports.resolveDeferredKeys = resolveDeferredKeys;
+const DEFERRED_KEYS_INSTALLED = Symbol.for('typeorm-extensions.deferredKeys');
+// TypeORM 0.3.12 maps property names in each part of the query, later versions once in the whole query
+function installDeferredKeyResolution() {
+    const prototype = typeorm_1.QueryBuilder.prototype;
+    if (prototype[DEFERRED_KEYS_INSTALLED]) {
+        return;
+    }
+    prototype[DEFERRED_KEYS_INSTALLED] = true;
+    for (const method of ['replacePropertyNames', 'replacePropertyNamesForTheWholeQuery']) {
+        const original = prototype[method];
+        if (typeof original === 'function') {
+            prototype[method] = function (statement) {
+                return resolveDeferredKeys(this, original.call(this, statement));
+            };
+        }
+    }
+}
+installDeferredKeyResolution();
 /** Entity metadata of a query alias (the main alias when `aliasName` is undefined), if it has any. */
 function getAliasMetadata(queryBuilder, aliasName) {
     var _a;
@@ -112,6 +162,10 @@ function toFieldSql(builder, field) {
             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]);
+        }
     }
     else {
         // only by database name: an unqualified property name may mean another table's column
@@ -222,6 +276,9 @@ function resolveTypedKeyPath(queryBuilder, keys) {
  */
 function toQuotedColumnKey(queryBuilder, { aliasName, propertyPath, metadata, column, jsonPath }, jsonOptions) {
     var _a, _b;
+    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 columnSql = aliasName === undefined
         ? queryBuilder.escape(columnName)
@@ -269,13 +326,37 @@ function getTypedSingleColumnKey(builder, callback, methodName, jsonOptions) {
 }
 exports.getTypedSingleColumnKey = getTypedSingleColumnKey;
 /**
- * Key for typed select / order / distinct on a SelectQueryBuilder.
+ * 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
+ * as written, and the database rejects it.
+ */
+function assertTableColumnKey({ metadata, propertyPath }, keys, methodName) {
+    const relation = metadata === null || metadata === void 0 ? void 0 : metadata.findRelationWithPropertyPath(propertyPath);
+    if (relation && !relation.isManyToOne && !relation.isOneToOneOwner) {
+        throw new TypeError(`${methodName}: "${keys.join('.')}" is a relation without a join column in its table. ` +
+            `Join it and address its columns by the join alias`);
+    }
+    if (!relation && (metadata === null || metadata === void 0 ? void 0 : metadata.findEmbeddedWithPropertyPath(propertyPath))) {
+        throw new TypeError(`${methodName}: "${keys.join('.')}" is an embedded entity, not a column: address its columns, e.g. ` +
+            `"${keys.join('.')}.someColumn"`);
+    }
+}
+// an alias the query doesn't know yet may still get metadata (a join added later), so it stays unquoted
+function isAliasWithoutMetadata(queryBuilder, aliasName) {
+    const alias = aliasName === undefined ? undefined : findQueryAlias(queryBuilder, aliasName);
+    return alias !== undefined && !alias.hasMetadata;
+}
+/**
+ * Key for typed select / order / distinct / group by on a SelectQueryBuilder.
  *
  * Without quotes it is `alias.propertyPath` (`user.name`, `images.url`, `p.address.city`),
  * which TypeORM maps to the column itself. With `useQuotes` it is the quoted database column
- * (`"t"."ticket_status"`), since TypeORM doesn't map quoted keys. Strings are kept as is.
+ * (`"t"."ticket_status"`), since TypeORM doesn't map quoted keys. An alias of the query without
+ * metadata (a subquery or a CTE in FROM or a join) is quoted unless `useQuotes` is `false`:
+ * TypeORM leaves its keys as written, and PostgreSQL folds an unquoted `cte.firstName` to `firstname`.
+ * Strings are kept as is.
  */
-function getTypedSelectionKey(builder, selection, useQuotes) {
+function getTypedSelectionKey(builder, selection, useQuotes, columnsFor) {
     if (typeof selection === 'string') {
         return selection;
     }
@@ -286,7 +367,10 @@ function getTypedSelectionKey(builder, selection, useQuotes) {
             throw new TypeError(`Typed key "${keyHolder.getKeys().join('.')}" points into the JSON column "${resolved.propertyPath}": ` +
                 `select, order, distinct and group by take columns only. For an expression use tableHelper().jsonColumn()`);
         }
-        if (useQuotes) {
+        if (columnsFor !== undefined) {
+            assertTableColumnKey(resolved, keyHolder.getKeys(), columnsFor);
+        }
+        if (useQuotes !== null && useQuotes !== void 0 ? useQuotes : isAliasWithoutMetadata(queryBuilder, resolved.aliasName)) {
             return toQuotedColumnKey(queryBuilder, resolved);
         }
         return resolved.aliasName === undefined

package/dist/utils/where.utils.js

@@ -13,6 +13,8 @@ function getValuePlaceholder(value, paramName) {
     return `:${paramName}`;
 }
 exports.getValuePlaceholder = getValuePlaceholder;
+/** A condition that ends with an operator, `=`, `>=`, `LIKE`, `IN`, `@>`: it needs a value after it. */
+const OPERATOR_AT_END = /(?:[=<>!~@&|?]|\b(?: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:
@@ -76,6 +78,10 @@ function attachWhere(builder, method, field, conditions, params, options) {
         const hasParams = typeof params !== 'undefined';
         // `addValue` defaults to `true` unless `conditions` already references one of the `params` keys
         addValue = addValue !== null && addValue !== void 0 ? addValue : !hasParamPlaceholder(conditions, params);
+        if (addValue && !hasParams && OPERATOR_AT_END.test(conditions)) {
+            throw new TypeError(`The value after "${fieldName} ${conditions.trim()}" is undefined, which leaves the condition without ` +
+                `an operand. Pass the value, null to compare with NULL, or a condition without one ('IS NULL')`);
+        }
         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)

package/package.json

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