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

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

@@ -2,10 +2,7 @@ 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.
- */
+/** 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;
 /**
  * Database name of an entity property's column (`@Column({ name })`), looked up in the metadata of

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTypedSelectionKey = exports.getTypedSingleColumnKey = exports.isTypedJsonPath = exports.getTypedColumnKey = exports.toFieldSql = exports.findFieldColumn = exports.getColumnDatabaseName = exports.resolveDeferredKeys = 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");
@@ -52,49 +53,99 @@ function findQueryAlias(queryBuilder, aliasName) {
 const DEFERRED_KEY_START = '\uE000';
 const DEFERRED_PROPERTY = '\uE001';
 const DEFERRED_FIELD = '\uE002';
+const DEFERRED_UNQUOTED = '\uE004';
 const DEFERRED_KEY_END = '\uE003';
-const DEFERRED_KEY = /\uE000([^\uE000-\uE003]+)([\uE001\uE002])([^\uE000-\uE003]+)\uE003/g;
+const DEFERRED_KEY = /\uE000([^\uE000-\uE004]+)([\uE001\uE002\uE004])([^\uE000-\uE004]+)\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.
+ * Placeholder for a column of an alias the query doesn't have yet, e.g. a join added after the call: resolved when
+ * the alias is added (`resolveAliasKeys`) or, at the latest, when the SQL is built (`resolveDeferredKeys`).
  */
 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.
+ * SQL of a deferred key for `alias`, undefined while the query doesn't have it:
+ * - a quoted key: the database column through the alias' entity, quoted, `"usr"."receipts_email"`; the name
+ *   quoted without an entity;
+ * - an unquoted one (select, order, group by, distinct without `useQuotes`): `alias.property` on an alias with an
+ *   entity, which TypeORM maps and reads as a column of the entity; quoted on an alias without one (a subquery, a
+ *   CTE), as on an alias known at the call; as written on an unknown alias.
  */
+function toDeferredKeySql(alias, aliasName, separator, name, escape) {
+    const metadata = (alias === null || alias === void 0 ? void 0 : alias.hasMetadata) ? alias.metadata : undefined;
+    if (separator === DEFERRED_UNQUOTED) {
+        return metadata || !alias ? `${aliasName}.${name}` : `${escape(aliasName)}.${escape(name)}`;
+    }
+    const column = metadata && (separator === DEFERRED_FIELD ? findColumn(metadata, name) : metadata.findColumnWithPropertyPath(name));
+    const columnName = column && !column.isVirtualProperty ? column.databaseName : name;
+    return `${escape(aliasName)}.${escape(columnName)}`;
+}
+/** Replaces placeholders of `deferColumnKey` in SQL built by `builder`, through the aliases it has by then. */
 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)}`;
-    });
+    const escape = (identifier) => queryBuilder.escape(identifier);
+    return statement.replace(DEFERRED_KEY, (_match, aliasName, separator, name) => toDeferredKeySql(findQueryAlias(queryBuilder, aliasName), aliasName, separator, name, escape));
 }
 exports.resolveDeferredKeys = resolveDeferredKeys;
+/**
+ * Resolves the placeholders of a new alias in select, order, group by and distinct on, which TypeORM reads before it
+ * builds the SQL: a select of `alias.property` is how it knows to fill the property of a joined entity.
+ */
+function resolveAliasKeys(expressionMap, alias) {
+    var _a;
+    // `connection` (TypeORM 0.3) or `dataSource` (1.x), protected in its types; read only when a key is found
+    const { connection, dataSource } = expressionMap;
+    const escape = (identifier) => (connection !== null && connection !== void 0 ? connection : dataSource).driver.escape(identifier);
+    const hasKey = (statement) => typeof statement === 'string' && statement.includes(DEFERRED_KEY_START);
+    const resolve = (statement) => hasKey(statement)
+        ? statement.replace(DEFERRED_KEY, (match, aliasName, separator, name) => aliasName === alias.name ? toDeferredKeySql(alias, aliasName, separator, name, escape) : match)
+        : statement;
+    // new objects and arrays: a clone shares them with the query it was cloned from
+    if (expressionMap.selects.some((select) => hasKey(select.selection))) {
+        expressionMap.selects = expressionMap.selects.map((select) => hasKey(select.selection) ? { ...select, selection: resolve(select.selection) } : select);
+    }
+    if (expressionMap.groupBys.some(hasKey)) {
+        expressionMap.groupBys = expressionMap.groupBys.map(resolve);
+    }
+    if ((_a = expressionMap.selectDistinctOn) === null || _a === void 0 ? void 0 : _a.some(hasKey)) {
+        expressionMap.selectDistinctOn = expressionMap.selectDistinctOn.map(resolve);
+    }
+    if (Object.keys(expressionMap.orderBys).some(hasKey)) {
+        expressionMap.orderBys = Object.fromEntries(Object.entries(expressionMap.orderBys).map(([key, order]) => [resolve(key), order]));
+    }
+}
 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]) {
+    const builderPrototype = typeorm_1.QueryBuilder.prototype;
+    const mapPrototype = QueryExpressionMap_1.QueryExpressionMap.prototype;
+    if (builderPrototype[DEFERRED_KEYS_INSTALLED]) {
         return;
     }
-    prototype[DEFERRED_KEYS_INSTALLED] = true;
+    builderPrototype[DEFERRED_KEYS_INSTALLED] = true;
+    // TypeORM 0.3.12 maps property names in each part of the query, later versions once in the whole query; keys are
+    // resolved first, so an unquoted `alias.property` is mapped too
     for (const method of ['replacePropertyNames', 'replacePropertyNamesForTheWholeQuery']) {
-        const original = prototype[method];
+        const original = builderPrototype[method];
         if (typeof original === 'function') {
-            prototype[method] = function (statement) {
-                return resolveDeferredKeys(this, original.call(this, statement));
+            builderPrototype[method] = function (statement) {
+                return original.call(this, resolveDeferredKeys(this, statement));
             };
         }
     }
+    const createAlias = mapPrototype.createAlias;
+    if (typeof createAlias === 'function') {
+        mapPrototype.createAlias = function (...args) {
+            const alias = createAlias.apply(this, args);
+            if (alias === null || alias === void 0 ? void 0 : alias.name) {
+                resolveAliasKeys(this, alias);
+            }
+            return alias;
+        };
+    }
 }
 installDeferredKeyResolution();
 /** Entity metadata of a query alias (the main alias when `aliasName` is undefined), if it has any. */
@@ -341,7 +392,7 @@ function assertTableColumnKey({ metadata, propertyPath }, keys, methodName) {
             `"${keys.join('.')}.someColumn"`);
     }
 }
-// an alias the query doesn't know yet may still get metadata (a join added later), so it stays unquoted
+// an alias the query doesn't know yet is resolved when it is added (`resolveAliasKeys`)
 function isAliasWithoutMetadata(queryBuilder, aliasName) {
     const alias = aliasName === undefined ? undefined : findQueryAlias(queryBuilder, aliasName);
     return alias !== undefined && !alias.hasMetadata;
@@ -373,6 +424,14 @@ function getTypedSelectionKey(builder, selection, useQuotes, columnsFor) {
         if (useQuotes !== null && useQuotes !== void 0 ? useQuotes : isAliasWithoutMetadata(queryBuilder, resolved.aliasName)) {
             return toQuotedColumnKey(queryBuilder, resolved);
         }
+        // an alias added later decides then: TypeORM maps an entity's keys, a subquery's are quoted
+        if (useQuotes === undefined &&
+            columnsFor !== undefined &&
+            resolved.aliasName !== undefined &&
+            !resolved.metadata &&
+            !findQueryAlias(queryBuilder, resolved.aliasName)) {
+            return deferColumnKey(resolved.aliasName, DEFERRED_UNQUOTED, resolved.propertyPath);
+        }
         return resolved.aliasName === undefined
             ? resolved.propertyPath
             : `${resolved.aliasName}.${resolved.propertyPath}`;

package/dist/utils/where.utils.js

@@ -13,8 +13,11 @@ 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;
+/**
+ * A condition that ends with an operator, `=`, `>=`, `LIKE`, `IN`, `@>`: it needs a value after it. A word after
+ * `:` 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:

package/package.json

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