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

package/README.md

@@ -5,62 +5,93 @@
 [![Issues](https://img.shields.io/github/issues-raw/koenigstag/typeorm-extensions.svg?maxAge=25000)](https://github.com/koenigstag/typeorm-extensions/issues)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://github.com/koenigstag/typeorm-extensions/pulls)
 
-## Description
+**Type-safe extensions for the TypeORM QueryBuilder.** Write selects, joins, conditions and ordering as property callbacks the compiler checks against your entities, page through results with totals or cursors, and build the raw SQL you still need with helpers that quote it for the database.
 
-TypeORM Extensions is a library that provides additional functionality and extensions for the TypeORM QueryBuilder. It aims to simplify common tasks and enhance the capabilities of TypeORM.
+```typescript
+import 'typeorm-extensions';
 
-## Features
+const { list, total, hasMore } = await dataSource
+  .getRepository(UserEntity)
+  .createQueryBuilder('user')
+  .leftJoinTyped(user => user.images, 'images')
+  .whereTyped(user => user.createdAt, '>', since)
+  // a key inside a JSON column: "user"."metadata" ->> 'role' = :param
+  .andWhereTyped(user => user.metadata.role, '=', 'admin')
+  .orderByTyped(user => user.images.url, 'ASC', 'NULLS LAST')
+  .getManyWithTotals({ page: 1, pageSize: 20 });
+```
 
-- Simplicity: applying pagination and ordering to queries is as simple as calling a method.
-- Type Safety: the library is written in TypeScript and provides type-safe QueryBuilder methods based on Entity  metadata.
-- Flexibility: the library is designed to be flexible and can be used with any TypeORM entity.
+Try it in the [playground](https://koenigstag.github.io/typeorm-extensions/playground/): an editor and a database in the browser.
 
-## Installation
+## Why
 
-To install `typeorm-extensions`:
+The QueryBuilder takes columns as strings. A renamed property, a typo or a half-quoted alias compiles and then fails at runtime:
 
-Install using npm, yarn or pnpm:
-```bash
-npm install typeorm-extensions
+```typescript
+.where('user.createdAt > :since', { since })   // still compiles after createdAt is renamed
+.andWhere('order."userId" = :userId', { userId }) // PostgreSQL: syntax error at or near "order"
 ```
 
-## Usage
+With the extensions a column is a property of the entity type, so the compiler catches the rename, and the SQL is built and quoted for you:
 
 ```typescript
-import 'typeorm-extensions'; // Importing the library root extends the QueryBuilder with all extensions
+.whereTyped(user => user.createdAt, '>', since)
 
-// Or init specific extension: import 'typeorm-extensions/dist/extensions/pagination.extension';
+const orders = tableHelper(OrderEntity, 'order');
+.andWhere(`${orders.userId} = :userId`, { userId }) // "order"."userId" = :userId
+```
 
-const query = myDataSource
-  .getRepository(UserEntity)
-  .createQueryBuilder('users')
-  // Join relation defined in entity model
-  .leftJoinTyped(user => user.images, 'images')
-  // Select type-safe properties
-  .selectTyped(user => [
-    user.id,
-    user.name,
-    user.email,
-    user.images.url,
-  ])
-  .whereTyped(user => user.name, 'ILIKE', 'John')
-  // Paths into JSON columns: "users"."metadata" ->> 'role' = :param
-  .andWhereTyped(user => user.metadata.role, '=', 'admin')
-  // Order by type-safe own and relation properties
-  .orderByTyped(user => user.images.url, 'ASC', 'NULLS LAST')
-  // Use pagination as simple as that
-  .applyPaginationFilter({ page: 1, pageSize: 10 }, { useTakeAndSkip: true });
+## Installation
+
+```bash
+npm install typeorm-extensions
 ```
 
-## Documentation
+`typeorm` 0.3.12 or later, or 1.x, is a peer dependency. Release candidates of the next version are published under the `next` tag: `npm install typeorm-extensions@next`.
+
+## Features
+
+**Typed queries** ([docs](https://koenigstag.github.io/typeorm-extensions/docs/api/typed/))
+- `selectTyped`, `whereTyped` (keys inside JSON columns too; `strictParams` checks the parameter against the column type), `orderByTyped`, `groupByTyped` / `havingTyped`, `distinctOnTyped`, `returningTyped`
+- typed joins and map joins (`leftJoinTyped`, `innerJoinAndMapOneTyped`, …), `typed<Root>()` for the aliases a query joins, `whereRelationExists` built from the relation metadata
+
+**Pagination** ([docs](https://koenigstag.github.io/typeorm-extensions/docs/api/pagination/))
+- `getManyWithTotals` and `getRawManyWithTotals`: the rows of a page, the total, `page` / `pageSize`, `hasMore` and the order it was read in
+- `getManyWithCursor`: keyset pagination with an opaque cursor
+- `applyPaginationFilter` for a page of any query
 
-For more information, please refer to the [documentation](https://koenigstag.github.io/typeorm-extensions).
+**Filters and ordering** ([docs](https://koenigstag.github.io/typeorm-extensions/docs/api/where/))
+- `whereIsIn` / `whereIsNotIn` that handle empty arrays, `whereIsAny`, null-safe `whereIsDistinctFrom`
+- case-insensitive search with escaped wildcards, `applyPeriodFilter` in a time zone
+- `applyOrder` from a client's order filter, `orderByArrayPosition`
 
-## ToDo list
+**Subqueries and joins**
+- `whereExists` / `whereNotExists`, with the subquery's parameters renamed so they never clash with the outer query's
+- `leftJoinLateral` / `innerJoinLateral`, `innerJoinUnnest`, `fromUnion` and CTE unions
+
+**SQL helpers** ([docs](https://koenigstag.github.io/typeorm-extensions/docs/api/utils/tableHelper/))
+- `tableHelper`: quoted column references, conditions, counts, sums, JSON objects and paths, time zones. Given the entity class it writes the database name of a renamed column
+- the reserved qualifier guard: catches SQL like `order."userId"` before PostgreSQL rejects it
+
+**Columns** ([docs](https://koenigstag.github.io/typeorm-extensions/docs/api/columns/generatedColumn/))
+- `@CalculatedColumn` with `addSelectCalculated` / `orderByCalculated`: a value each query computes
+- `@GeneratedColumn`: a column the database generates, which TypeORM reads and never writes
+
+## Entry points
+
+| Import | Gives |
+|---|---|
+| `import 'typeorm-extensions'` | every QueryBuilder extension, and all exports |
+| `import 'typeorm-extensions/dist/extensions/pagination.extension'` | one extension |
+| `import { tableHelper, GeneratedColumn } from 'typeorm-extensions/helpers'` | the helpers, with no side effects |
+
+## Compatibility
+
+TypeORM 0.3.12 and later, and 1.x. CI runs the test suite on SQLite with TypeORM 0.3.12, the latest 0.3 and 1.x, and on MySQL 8.4. Features that only work on some databases (array and JSON operators, `DISTINCT ON`, `orderByArrayPosition`, …) say so in their docs.
+
+## Documentation
 
-- [x] Add tests for pagination and order extensions
-- [x] Calculated columns: the `@CalculatedColumn` decorator and `addSelectCalculated`. `getMany`, `getOne` and `getManyWithTotals` fill them as they are, so they need no variants of their own
-- [x] Order by a calculated column: `orderByCalculated`, and `applyOrder` orders a `@CalculatedColumn` field by its value
+The [documentation](https://koenigstag.github.io/typeorm-extensions/) has a page for every method, with its signature, options and examples, and the [playground](https://koenigstag.github.io/typeorm-extensions/playground/) runs them.
 
 ## License
 

package/dist/decorators/generated-column.decorator.d.ts

@@ -0,0 +1,17 @@
+import { ColumnOptions, ColumnType } from 'typeorm';
+/** The options of `@Column`, without those that would let TypeORM write the column. */
+export type GeneratedColumnOptions = Omit<ColumnOptions, 'insert' | 'update' | 'readonly'>;
+/**
+ * A column of the table that the database computes: `GENERATED ALWAYS AS (…) STORED`. TypeORM reads it like any
+ * column and never writes it. `asExpression` alone doesn't stop TypeORM (0.3 and 1.x) from sending the column in
+ * `save`, `insert` and `update`, which the database rejects for a generated column.
+ *
+ * Pass `asExpression` and `generatedType: 'STORED'` when TypeORM creates the schema (synchronize, generated
+ * migrations); a column created by a hand-written migration needs neither.
+ *
+ * @example
+ * \@GeneratedColumn({ type: 'integer', asExpression: 'price * quantity', generatedType: 'STORED' })
+ * total: number;
+ */
+export declare function GeneratedColumn(options?: GeneratedColumnOptions): PropertyDecorator;
+export declare function GeneratedColumn(type: ColumnType, options?: GeneratedColumnOptions): PropertyDecorator;

package/dist/decorators/generated-column.decorator.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedColumn = void 0;
+const typeorm_1 = require("typeorm");
+function GeneratedColumn(typeOrOptions, options = {}) {
+    const columnOptions = typeof typeOrOptions === 'object'
+        ? { ...typeOrOptions }
+        : typeOrOptions === undefined
+            ? { ...options }
+            : { ...options, type: typeOrOptions };
+    // TypeORM 0.3 applies `readonly` after `update`: `readonly: false` from an untyped caller would turn writes back on
+    delete columnOptions.readonly;
+    return (0, typeorm_1.Column)({ ...columnOptions, insert: false, update: false });
+}
+exports.GeneratedColumn = GeneratedColumn;

package/dist/decorators/index.d.ts

@@ -1 +1,2 @@
 export * from './calculated-column.decorator';
+export * from './generated-column.decorator';

package/dist/decorators/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./calculated-column.decorator"), exports);
+__exportStar(require("./generated-column.decorator"), exports);

package/dist/extensions/calculated-column.extension.d.ts

@@ -1,6 +1,6 @@
-import { ObjectLiteral, SelectQueryBuilder } from 'typeorm';
-/** `addSelect`'s selection: an SQL expression, or a factory that builds a subquery on the builder it is given. */
-export type CalculatedSelection<SubEntity extends ObjectLiteral = ObjectLiteral> = string | ((qb: SelectQueryBuilder<ObjectLiteral>) => SelectQueryBuilder<SubEntity>);
+import { ObjectLiteral } from 'typeorm';
+import { CalculatedSelection } from '../utils/calculated-column.utils';
+export type { CalculatedSelection };
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
     interface SelectQueryBuilder<Entity extends ObjectLiteral> {
         /**

package/dist/extensions/calculated-column.extension.js

@@ -7,27 +7,14 @@ const calculated_column_utils_1 = require("../utils/calculated-column.utils");
 const extension = {
     prototype: {
         addSelectCalculated(selection, property, alias) {
-            return addSelectCalculated(this, selection, property, alias);
+            return (0, calculated_column_utils_1.addSelectCalculatedColumn)(this, selection, property, alias, 'addSelectCalculated');
         },
         orderByCalculated(property, order, nulls, alias) {
-            return attachOrderByCalculated(this, 'orderBy', property, order, nulls, alias);
+            return (0, calculated_column_utils_1.orderByCalculatedColumn)(this, 'orderBy', property, order, nulls, alias, 'orderByCalculated');
         },
         addOrderByCalculated(property, order, nulls, alias) {
-            return attachOrderByCalculated(this, 'addOrderBy', property, order, nulls, alias);
+            return (0, calculated_column_utils_1.orderByCalculatedColumn)(this, 'addOrderBy', property, order, nulls, alias, 'addOrderByCalculated');
         },
     },
 };
 (0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
-// implementation
-function addSelectCalculated(builder, selection, property, aliasName) {
-    const { key } = (0, calculated_column_utils_1.resolveCalculatedColumn)(builder, property, aliasName, 'addSelectCalculated');
-    // two calls: addSelect's overloads take a string or a factory, not their union
-    if (typeof selection === 'function') {
-        return builder.addSelect(selection, key);
-    }
-    return builder.addSelect(selection, key);
-}
-function attachOrderByCalculated(builder, method, property, order, nulls, aliasName) {
-    const orderAlias = (0, calculated_column_utils_1.selectCalculatedForOrder)(builder, property, aliasName, `${method}Calculated`);
-    return builder[method](orderAlias, order, nulls);
-}

package/dist/extensions/cursor-pagination.extension.js

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidCursorError = void 0;
 const SelectQueryBuilder_1 = require("typeorm/query-builder/SelectQueryBuilder");
-const constants_1 = require("../constants");
+const pagination_utils_1 = require("../utils/pagination.utils");
 const prototype_utils_1 = require("../utils/prototype.utils");
 const order_utils_1 = require("../utils/order.utils");
 const where_utils_1 = require("../utils/where.utils");
 const sql_utils_1 = require("../utils/sql.utils");
+const query_builder_utils_1 = require("../utils/query-builder.utils");
 const cursor_utils_1 = require("../utils/cursor.utils");
 var cursor_utils_2 = require("../utils/cursor.utils");
 Object.defineProperty(exports, "InvalidCursorError", { enumerable: true, get: function () { return cursor_utils_2.InvalidCursorError; } });
@@ -44,14 +45,11 @@ function getCursorKeys(builder, orderBy) {
     }
     return keys;
 }
-const getPageSize = (pageSize) => typeof pageSize === 'number' && Number.isFinite(pageSize) && pageSize >= 1
-    ? Math.floor(pageSize)
-    : constants_1.defaultPageSize;
 async function getManyWithCursor(builder, cursorFilter, options) {
     const { orderBy, useTakeAndSkip = false } = options !== null && options !== void 0 ? options : {};
     const keys = getCursorKeys(builder, orderBy);
     const fields = keys.map((key) => key.column.propertyPath);
-    const pageSize = getPageSize(cursorFilter === null || cursorFilter === void 0 ? void 0 : cursorFilter.pageSize);
+    const pageSize = (0, pagination_utils_1.normalizePageSize)(cursorFilter === null || cursorFilter === void 0 ? void 0 : cursorFilter.pageSize);
     const query = builder.clone();
     const alias = query.alias;
     const driver = query.connection.driver.options.type;
@@ -68,6 +66,7 @@ async function getManyWithCursor(builder, cursorFilter, options) {
     }
     query.orderBy();
     keys.forEach((key) => query.addOrderBy(`${alias}.${key.column.propertyPath}`, key.direction));
+    const appliedOrderBy = (0, query_builder_utils_1.getAppliedOrderBy)(query);
     // the key values of the last row are read from the raw result: dates and times as text, so the
     // cursor keeps the database's precision (PostgreSQL timestamps have microseconds, a JS Date has not)
     const keyAliases = keys.map((key, i) => {
@@ -81,16 +80,11 @@ async function getManyWithCursor(builder, cursorFilter, options) {
         .map((key, i) => ({ key, i }))
         .filter(({ key }) => key.column.isPrimary)
         .map(({ key, i }) => ({ column: key.column, keyAlias: keyAliases[i] }));
-    if (useTakeAndSkip) {
-        query.take(pageSize + 1);
-    }
-    else {
-        query.limit(pageSize + 1);
-    }
+    (0, pagination_utils_1.setPageLimit)(query, pageSize + 1, useTakeAndSkip);
     const { entities, raw } = await query.getRawAndEntities();
     const list = entities.slice(0, pageSize);
     if (entities.length <= pageSize) {
-        return { list, nextCursor: null, hasMore: false };
+        return { list, nextCursor: null, hasMore: false, pageSize, orderBy: appliedOrderBy };
     }
     // with joined collections there are several raw rows per entity: find one of the last entity's
     const last = list[list.length - 1];
@@ -105,5 +99,5 @@ async function getManyWithCursor(builder, cursorFilter, options) {
         }
         return value;
     });
-    return { list, nextCursor: (0, cursor_utils_1.encodeCursor)(fields, values), hasMore: true };
+    return { list, nextCursor: (0, cursor_utils_1.encodeCursor)(fields, values), hasMore: true, pageSize, orderBy: appliedOrderBy };
 }

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

@@ -31,8 +31,7 @@ const extension = {
  * runner, so the one that starts second finds a transaction active and does not open its own.
  */
 function canCountConcurrently(builder) {
-    const queryBuilder = builder;
-    return !queryBuilder.queryRunner;
+    return !(0, query_builder_utils_1.getQueryRunner)(builder);
 }
 function getManyWithTotals(builder, paginationFilter, options) {
     return readWithTotals(builder, paginationFilter, options, {
@@ -58,10 +57,9 @@ function getRawManyWithTotals(builder, paginationFilter, options) {
     });
 }
 async function readWithTotals(builder, paginationFilter, options, read) {
-    var _a;
     const { disableTotalsCalculation = false, loadAll = false, ...paginationOptions } = options || {};
-    const { limit, offset } = loadAll
-        ? { limit: null, offset: null }
+    const { limit, offset, page, pageSize } = loadAll
+        ? { limit: null, offset: null, page: null, pageSize: null }
         : (0, pagination_utils_1.getLimitAndOffset)(paginationFilter);
     // without a total, one row past the page is what tells whether more rows follow
     const probeForMore = disableTotalsCalculation && !loadAll && limit !== null;
@@ -71,15 +69,9 @@ async function readWithTotals(builder, paginationFilter, options, read) {
         }
         const paged = builder.applyPaginationFilter(paginationFilter, paginationOptions);
         if (probeForMore) {
-            const probeLimit = limit + 1;
             const { useTakeAndSkip = constants_1.defaultUseTakeAndSkip } = paginationOptions;
             // replaces the limit applyPaginationFilter just set, keeping its offset
-            if (useTakeAndSkip) {
-                paged.take(probeLimit);
-            }
-            else {
-                paged.limit(probeLimit);
-            }
+            (0, pagination_utils_1.setPageLimit)(paged, limit + 1, useTakeAndSkip);
         }
         return read.rows(paged);
     };
@@ -110,21 +102,15 @@ async function readWithTotals(builder, paginationFilter, options, read) {
         hasMore =
             total !== null && offset !== null ? offset + rows.length < total : null;
     }
-    // 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(([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,
+        page,
+        pageSize,
         limit,
         offset,
         hasMore,
-        orderBy,
+        orderBy: (0, query_builder_utils_1.getAppliedOrderBy)(builder),
     };
 }
 /**
@@ -147,9 +133,6 @@ async function bothOrFirstError(first, second) {
 function settle(promise) {
     return promise.then((value) => ({ fulfilled: true, value }), (reason) => ({ fulfilled: false, reason }));
 }
-function getQueryRunner(builder) {
-    return builder.queryRunner;
-}
 /**
  * Counts the rows of a raw query without its pagination and ORDER BY. The query goes into a
  * subquery, so the count is that of its result rows whatever it groups or filters. A
@@ -158,13 +141,7 @@ function getQueryRunner(builder) {
  */
 async function countRawRows(builder, countExpression) {
     var _a;
-    const unpaged = cloneForCount(builder)
-        .orderBy()
-        .offset(undefined)
-        .limit(undefined)
-        .skip(undefined)
-        .take(undefined)
-        .setOption('disable-global-order');
+    const unpaged = (0, query_builder_utils_1.withoutPaging)(cloneForCount(builder));
     let counting;
     if (countExpression) {
         // the expression counts on its own: DISTINCT ON next to an aggregate is an error
@@ -175,7 +152,7 @@ async function countRawRows(builder, countExpression) {
     else {
         // on the builder's query runner, if it has one: inside its transaction
         const counter = builder.connection
-            .createQueryBuilder(getQueryRunner(builder))
+            .createQueryBuilder((0, query_builder_utils_1.getQueryRunner)(builder))
             .select('COUNT(*)', 'count')
             .from(`(${unpaged.getQuery()})`, 'counted')
             .setParameters(unpaged.getParameters());

package/dist/extensions/join-lateral.extension.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const typeorm_1 = require("typeorm");
 const parameter_utils_1 = require("../utils/parameter.utils");
+const query_builder_utils_1 = require("../utils/query-builder.utils");
 const prototype_utils_1 = require("../utils/prototype.utils");
 /* eslint-enable @typescript-eslint/no-empty-interface, @typescript-eslint/no-unused-vars */
 // patching
@@ -32,18 +33,15 @@ function toLateralSql(builder, subQuery) {
         return { sql: `(${subQuery})`, parameters: {} };
     }
     const subBuilder = typeof subQuery === 'function' ? subQuery(detachedSubQuery(builder)) : subQuery;
-    const query = subBuilder.getQuery();
-    // a builder from subQuery() wraps itself in parentheses, any other doesn't
-    const wrapped = subBuilder.expressionMap.subQuery ? query : `(${query})`;
-    const [sql, parameters] = (0, parameter_utils_1.withUniqueParameterNames)(wrapped, subBuilder.getParameters());
-    return { sql, parameters };
+    const [sql, parameters] = (0, parameter_utils_1.toSubQuerySql)(subBuilder);
+    return { sql: `(${sql})`, parameters };
 }
 /**
  * A subquery builder for a factory, as TypeORM's `subQuery()` but without a parent: TypeORM's would
  * set the factory's parameters on the outer query under their own names, before they can be renamed.
  */
 function detachedSubQuery(builder) {
-    const queryRunner = builder.queryRunner;
+    const queryRunner = (0, query_builder_utils_1.getQueryRunner)(builder);
     const subQuery = builder.connection.createQueryBuilder(queryRunner);
     subQuery.expressionMap.subQuery = true;
     return subQuery;

package/dist/extensions/period-filter.extension.js

@@ -1,7 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const typeorm_1 = require("typeorm");
-const SoftDeleteQueryBuilder_1 = require("typeorm/query-builder/SoftDeleteQueryBuilder");
 const prototype_utils_1 = require("../utils/prototype.utils");
 const query_builder_utils_1 = require("../utils/query-builder.utils");
 const period_utils_1 = require("../utils/period.utils");
@@ -14,12 +12,4 @@ const extension = {
         },
     },
 };
-const queryBuilders = [
-    typeorm_1.SelectQueryBuilder,
-    typeorm_1.UpdateQueryBuilder,
-    typeorm_1.DeleteQueryBuilder,
-    SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder,
-];
-queryBuilders.forEach((builder) => {
-    (0, prototype_utils_1.patchPrototype)(builder, extension);
-});
+(0, prototype_utils_1.patchPrototypes)(prototype_utils_1.WHERE_QUERY_BUILDERS, extension);

package/dist/extensions/typed/index.d.ts

@@ -17,4 +17,5 @@ export * from './typed-where/typed-where-lower.extension';
 export * from './typed-where/typed-where-similar.extension';
 export * from './typed-returning/typed-returning.extension';
 export * from './typed-order-by/typed-order-by-array-position.extension';
+export * from './typed-calculated/typed-calculated-column.extension';
 export * from './typed-root.extension';

package/dist/extensions/typed/index.js

@@ -34,4 +34,5 @@ __exportStar(require("./typed-where/typed-where-lower.extension"), exports);
 __exportStar(require("./typed-where/typed-where-similar.extension"), exports);
 __exportStar(require("./typed-returning/typed-returning.extension"), exports);
 __exportStar(require("./typed-order-by/typed-order-by-array-position.extension"), exports);
+__exportStar(require("./typed-calculated/typed-calculated-column.extension"), exports);
 __exportStar(require("./typed-root.extension"), exports);

package/dist/extensions/typed/typed-calculated/typed-calculated-column.extension.d.ts

@@ -0,0 +1,25 @@
+import { ObjectLiteral } from 'typeorm';
+import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
+import { CalculatedSelection } from '../../../utils/calculated-column.utils';
+type CalculatedPropertyCallback<Type extends ObjectLiteral> = (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType;
+export interface TypedCalculatedColumnMethods<Entity extends ObjectLiteral> {
+    /**
+     * `addSelectCalculated` with the `@CalculatedColumn` picked by a typed callback: `(user) => user.imagesCount`, or
+     * `(q) => q.owner.imagesCount` for the entity of the joined alias `owner`. The callback starts at the root set with
+     * `typed<Root>()`, else at the entity. Throws a `TypeError` if the property isn't a `@CalculatedColumn`.
+     */
+    addSelectCalculatedTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>, SubEntity extends ObjectLiteral = ObjectLiteral>(selection: CalculatedSelection<SubEntity>, property: CalculatedPropertyCallback<Type>): this;
+    /**
+     * `orderByCalculated` with the `@CalculatedColumn` picked by a typed callback: ORDER BY its value, selected with
+     * `addSelectCalculated` / `addSelectCalculatedTyped` first. Replaces the previous ORDER BY, like `orderBy`.
+     */
+    orderByCalculatedTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(property: CalculatedPropertyCallback<Type>, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST'): this;
+    /** `addOrderByCalculated` with the `@CalculatedColumn` picked by a typed callback, like `addOrderBy`. */
+    addOrderByCalculatedTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(property: CalculatedPropertyCallback<Type>, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST'): this;
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedCalculatedColumnMethods<Entity> {
+    }
+}
+export {};

package/dist/extensions/typed/typed-calculated/typed-calculated-column.extension.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SelectQueryBuilder_1 = require("typeorm/query-builder/SelectQueryBuilder");
+const calculated_column_utils_1 = require("../../../utils/calculated-column.utils");
+const query_builder_utils_1 = require("../../../utils/query-builder.utils");
+const prototype_utils_1 = require("../../../utils/prototype.utils");
+/* eslint-enable @typescript-eslint/no-empty-interface */
+// patching
+const createOrderByCalculatedTypedMethod = (method) => function (property, order, nulls) {
+    const methodName = `${method}CalculatedTyped`;
+    const { aliasName, propertyPath } = (0, query_builder_utils_1.resolveTypedProperty)(this, property, methodName);
+    return (0, calculated_column_utils_1.orderByCalculatedColumn)(this, method, propertyPath, order, nulls, aliasName, methodName);
+};
+const extension = {
+    prototype: {
+        addSelectCalculatedTyped(selection, property) {
+            const { aliasName, propertyPath } = (0, query_builder_utils_1.resolveTypedProperty)(this, property, 'addSelectCalculatedTyped');
+            return (0, calculated_column_utils_1.addSelectCalculatedColumn)(this, selection, propertyPath, aliasName, 'addSelectCalculatedTyped');
+        },
+        orderByCalculatedTyped: createOrderByCalculatedTypedMethod('orderBy'),
+        addOrderByCalculatedTyped: createOrderByCalculatedTypedMethod('addOrderBy'),
+    },
+};
+(0, prototype_utils_1.patchPrototype)(SelectQueryBuilder_1.SelectQueryBuilder, extension);

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

@@ -33,7 +33,7 @@ function attachTypedHaving(builder, method, aggregate, selection, conditions, pa
     else {
         // a path into a JSON column is cast: to a number to add it up, and for MIN / MAX to the type of the
         // value it is compared with, as in whereTyped; a count needs no cast
-        const compared = (0, where_utils_1.isParamsObject)(parameters) ? Object.values(parameters)[0] : parameters;
+        const compared = (0, where_utils_1.getComparedValue)(parameters);
         const value = aggregate === 'SUM' || aggregate === 'AVG' ? 0 : aggregate === 'MIN' || aggregate === 'MAX' ? compared : undefined;
         argument = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, selection, methodName, { value });
     }

package/dist/extensions/typed/typed-joins/typed-join-and-map.extension.js

@@ -2,19 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
+const prototype_utils_1 = require("../../../utils/prototype.utils");
 // patching
-typeorm_1.SelectQueryBuilder.prototype.leftJoinAndMapOneTyped = function (mapToProperty, entity, alias, condition, parameters) {
-    return addJoinAndMap(this, 'leftJoinAndMapOne', mapToProperty, entity, alias, condition, parameters);
+const createJoinAndMapTypedMethod = (method) => function (mapToProperty, entity, alias, condition, parameters) {
+    return addJoinAndMap(this, method, mapToProperty, entity, alias, condition, parameters);
 };
-typeorm_1.SelectQueryBuilder.prototype.innerJoinAndMapOneTyped = function (mapToProperty, entity, alias, condition, parameters) {
-    return addJoinAndMap(this, 'innerJoinAndMapOne', mapToProperty, entity, alias, condition, parameters);
-};
-typeorm_1.SelectQueryBuilder.prototype.leftJoinAndMapManyTyped = function (mapToProperty, entity, alias, condition, parameters) {
-    return addJoinAndMap(this, 'leftJoinAndMapMany', mapToProperty, entity, alias, condition, parameters);
-};
-typeorm_1.SelectQueryBuilder.prototype.innerJoinAndMapManyTyped = function (mapToProperty, entity, alias, condition, parameters) {
-    return addJoinAndMap(this, 'innerJoinAndMapMany', mapToProperty, entity, alias, condition, parameters);
+const extension = {
+    prototype: {
+        leftJoinAndMapOneTyped: createJoinAndMapTypedMethod('leftJoinAndMapOne'),
+        innerJoinAndMapOneTyped: createJoinAndMapTypedMethod('innerJoinAndMapOne'),
+        leftJoinAndMapManyTyped: createJoinAndMapTypedMethod('leftJoinAndMapMany'),
+        innerJoinAndMapManyTyped: createJoinAndMapTypedMethod('innerJoinAndMapMany'),
+    },
 };
+(0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
 function addJoinAndMap(query, method, mapToProperty, entity, alias, condition, parameters) {
     // `() => query.alias`: `(q) => q.photo.owner` needs no main alias, only `(u) => u.profile` does
     const key = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(mapToProperty, () => query.alias, false);

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

@@ -2,31 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
+const prototype_utils_1 = require("../../../utils/prototype.utils");
 // patching
-typeorm_1.SelectQueryBuilder.prototype.leftJoinTyped = function (selection, alias, condition, parameters) {
-    if (typeof selection === 'function') {
-        return addJoin(this, 'leftJoin', selection, alias, condition, parameters);
-    }
-    return this;
+const createJoinTypedMethod = (method) => function (selection, alias, condition, parameters) {
+    return addJoin(this, method, selection, alias, condition, parameters);
 };
-typeorm_1.SelectQueryBuilder.prototype.innerJoinTyped = function (selection, alias, condition, parameters) {
-    if (typeof selection === 'function') {
-        return addJoin(this, 'innerJoin', selection, alias, condition, parameters);
-    }
-    return this;
-};
-typeorm_1.SelectQueryBuilder.prototype.leftJoinAndSelectTyped = function (selection, alias, condition, parameters) {
-    if (typeof selection === 'function') {
-        return addJoin(this, 'leftJoinAndSelect', selection, alias, condition, parameters);
-    }
-    return this;
-};
-typeorm_1.SelectQueryBuilder.prototype.innerJoinAndSelectTyped = function (selection, alias, condition, parameters) {
-    if (typeof selection === 'function') {
-        return addJoin(this, 'innerJoinAndSelect', selection, alias, condition, parameters);
-    }
-    return this;
+const extension = {
+    prototype: {
+        leftJoinTyped: createJoinTypedMethod('leftJoin'),
+        innerJoinTyped: createJoinTypedMethod('innerJoin'),
+        leftJoinAndSelectTyped: createJoinTypedMethod('leftJoinAndSelect'),
+        innerJoinAndSelectTyped: createJoinTypedMethod('innerJoinAndSelect'),
+    },
 };
+(0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
 function addJoin(query, method, selection, alias, condition, parameters) {
     // `() => query.alias`: `(q) => q.base.images` needs no main alias, only `(u) => u.images` does
     const key = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(selection, () => query.alias, false);

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

@@ -3,25 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
 const query_builder_utils_1 = require("../../../utils/query-builder.utils");
-const sql_utils_1 = require("../../../utils/sql.utils");
+const prototype_utils_1 = require("../../../utils/prototype.utils");
 // patching and implementation
-typeorm_1.SelectQueryBuilder.prototype.orderByTyped = function (selection, order, nulls, options) {
-    if (selection instanceof proxy_key_utils_1.KeyHolder) {
-        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, 'orderByTyped');
-        return this.orderBy(key, order, nulls);
+const createOrderByTypedMethod = (method) => function (selection, order, nulls, options) {
+    if (selection instanceof proxy_key_utils_1.KeyHolder || typeof selection === 'function') {
+        const key = (0, query_builder_utils_1.getTypedSelectionKey)(this, selection, options === null || options === void 0 ? void 0 : options.useQuotes, `${method}Typed`);
+        return this[method](key, order, nulls);
     }
     return this;
 };
-typeorm_1.SelectQueryBuilder.prototype.addOrderByTyped = function (selection, order, nulls, options) {
-    if (selection instanceof proxy_key_utils_1.KeyHolder) {
-        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, 'addOrderByTyped');
-        return this.addOrderBy(key, order, nulls);
-    }
-    return this;
+const extension = {
+    prototype: {
+        orderByTyped: createOrderByTypedMethod('orderBy'),
+        addOrderByTyped: createOrderByTypedMethod('addOrderBy'),
+    },
 };
+(0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);