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

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

@@ -130,10 +130,11 @@ async function readWithTotals(builder, paginationFilter, options, read) {
  */
 async function bothOrFirstError(first, second) {
     const [a, b] = await Promise.all([settle(first), settle(second)]);
-    if (!a.fulfilled) {
+    // `=== false`: without strictNullChecks `!fulfilled` doesn't narrow the union
+    if (a.fulfilled === false) {
         throw a.reason;
     }
-    if (!b.fulfilled) {
+    if (b.fulfilled === false) {
         throw b.reason;
     }
     return [a.value, b.value];

package/dist/types/modules/typed-root.types.d.ts

@@ -8,6 +8,10 @@ declare class TypedRootMark<Root> {
  * with an optional symbol method that only types carry. Entities loaded with it are plain entities.
  */
 export type WithTypedRoot<Entity, Root extends ObjectLiteral> = Entity & TypedRootMark<Root>;
-/** The root of a builder's typed callbacks: the one set with `typed<Root>()`, or else its entity. */
-export type TypedRoot<Entity> = Entity extends TypedRootMark<infer Root> ? Root extends ObjectLiteral ? Root : Entity : Entity;
+/**
+ * The root of a builder's typed callbacks: the one set with `typed<Root>()`, or else its entity. The key check
+ * comes first: without `strictNullChecks` an entity with an index signature (`ObjectLiteral`) matches the
+ * optional mark too, and its root would be inferred as `unknown`.
+ */
+export type TypedRoot<Entity> = typeof typedRoot extends keyof Entity ? Entity extends TypedRootMark<infer Root> ? Root extends ObjectLiteral ? Root : Entity : Entity : Entity;
 export {};

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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typeorm-extensions",
-  "version": "2.2.0-rc.0",
+  "version": "2.2.0-rc.2",
   "description": "typeorm commonly used extensions",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,7 +14,7 @@
   "scripts": {
     "build": "tsc -p .",
     "lint": "eslint . --ext .ts",
-    "test:types": "tsc -p test/types"
+    "test:types": "tsc -p test/types && tsc -p test/types/tsconfig.loose.json"
   },
   "keywords": [
     "typeorm",