typeorm-extensions 2.2.0-rc.1 → 2.2.0-rc.3

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

@@ -47,10 +47,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[];

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

@@ -30,12 +30,29 @@ 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.
+ */
+function findQueryAlias(queryBuilder, aliasName) {
+    var _a, _b;
+    // 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;
+        }
+    }
+    return undefined;
+}
 /** Entity metadata of a query alias (the main alias when `aliasName` is undefined), if it has any. */
 function getAliasMetadata(queryBuilder, aliasName) {
-    const expressionMap = queryBuilder.expressionMap;
+    var _a;
     const alias = aliasName === undefined
-        ? expressionMap === null || expressionMap === void 0 ? void 0 : expressionMap.mainAlias
-        : expressionMap === null || expressionMap === void 0 ? void 0 : expressionMap.aliases.find((queryAlias) => queryAlias.name === aliasName);
+        ? (_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;
 }
 /**
@@ -85,14 +102,11 @@ exports.findFieldColumn = findFieldColumn;
  *   `stringToSQLIdentifier` does, in the driver's quotes.
  */
 function toFieldSql(builder, field) {
-    var _a;
     const queryBuilder = builder;
     const dot = field.indexOf('.');
     if (dot > 0) {
         const aliasName = field.slice(0, dot);
-        const metadata = ((_a = queryBuilder.expressionMap) === null || _a === void 0 ? void 0 : _a.aliases.some((alias) => alias.name === aliasName))
-            ? getAliasMetadata(queryBuilder, aliasName)
-            : undefined;
+        const metadata = getAliasMetadata(queryBuilder, aliasName);
         const column = metadata && findColumn(metadata, field.slice(dot + 1));
         if (column) {
             const columnSql = queryBuilder.escape(column.databaseName);
@@ -182,7 +196,7 @@ function resolveTypedKeyPath(queryBuilder, keys) {
             ...findColumnPath(metadata, restKeys),
         };
     }
-    const queryAlias = expressionMap === null || expressionMap === void 0 ? void 0 : expressionMap.aliases.find((alias) => alias.name === firstKey);
+    const queryAlias = findQueryAlias(queryBuilder, firstKey);
     if (!queryAlias && mainAlias) {
         const mainMetadata = getAliasMetadata(queryBuilder, undefined);
         const columnPath = findColumnPath(mainMetadata, keys);
@@ -254,12 +268,20 @@ function getTypedSingleColumnKey(builder, callback, methodName, jsonOptions) {
     return key;
 }
 exports.getTypedSingleColumnKey = getTypedSingleColumnKey;
+// 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 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.
  */
 function getTypedSelectionKey(builder, selection, useQuotes) {
     if (typeof selection === 'string') {
@@ -272,7 +294,7 @@ 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 (useQuotes !== null && useQuotes !== void 0 ? useQuotes : isAliasWithoutMetadata(queryBuilder, resolved.aliasName)) {
             return toQuotedColumnKey(queryBuilder, resolved);
         }
         return resolved.aliasName === undefined

package/package.json

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