typeorm-extensions 2.1.0 → 2.2.0-rc.1

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const prototype_utils_1 = require("../utils/prototype.utils");
+const query_builder_utils_1 = require("../utils/query-builder.utils");
+const sql_utils_1 = require("../utils/sql.utils");
+const where_utils_1 = require("../utils/where.utils");
+/* eslint-enable @typescript-eslint/no-empty-interface, @typescript-eslint/no-unused-vars */
+// patching
+const extension = {
+    prototype: {
+        innerJoinUnnest(field, array, arrayType) {
+            return innerJoinUnnest(this, field, array, arrayType);
+        },
+    },
+};
+(0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
+// implementation
+function innerJoinUnnest(builder, field, array, arrayType) {
+    const castTo = (0, sql_utils_1.assertArrayType)(arrayType !== null && arrayType !== void 0 ? arrayType : columnArrayType(builder, field));
+    if (!(array === null || array === void 0 ? void 0 : array.length)) {
+        // narrows the whole WHERE, as the join does: after .where(a).orWhere(b) not a OR b AND FALSE
+        return (0, where_utils_1.andWhereNarrowing)(builder, 'FALSE');
+    }
+    const paramName = (0, sql_utils_1.createUniqueParameterName)('unnest');
+    const alias = (0, sql_utils_1.createUniqueParameterName)('unnest');
+    const value = builder.escape('value');
+    // DISTINCT: a value repeated in the array would repeat the rows it matches
+    return builder.innerJoin(`(SELECT DISTINCT unnest(CAST(:${paramName} AS ${castTo})) AS ${value})`, alias, `${(0, query_builder_utils_1.toFieldSql)(builder, field)} = ${builder.escape(alias)}.${value}`, { [paramName]: array });
+}
+/** `<column type>[]` of the entity column `field` names, as the driver spells the type. */
+function columnArrayType(builder, field) {
+    const column = (0, query_builder_utils_1.findFieldColumn)(builder, field);
+    if (!column || column.type === 'enum' || column.type === 'simple-enum') {
+        throw new TypeError(`innerJoinUnnest: pass the array type for "${field}", e.g. 'uuid[]': ` +
+            (column ? 'the type of an enum column is named by the database' : 'it is not an entity column'));
+    }
+    const driver = builder.connection.driver;
+    return `${driver.normalizeType(column)}[]`;
+}

package/dist/extensions/order.extension.js

@@ -8,6 +8,8 @@ const prototype_utils_1 = require("../utils/prototype.utils");
 const table_utils_1 = require("../utils/table.utils");
 const order_utils_1 = require("../utils/order.utils");
 const query_builder_utils_1 = require("../utils/query-builder.utils");
+const sql_utils_1 = require("../utils/sql.utils");
+const calculated_column_utils_1 = require("../utils/calculated-column.utils");
 // patching
 const extension = {
     prototype: {
@@ -37,19 +39,28 @@ function getOrderOption(builder, orderBy, options) {
     const { field, direction, isReversed, nulls: nullsOrder, tableAlias: otherTableAlias, } = orderBy;
     const alias = otherTableAlias || customAlias ||
         (alwaysAliasFields.includes(field) ? defaultAlias : undefined);
-    const table = (0, table_utils_1.tableHelper)(alias, { useQuotes });
-    // TypeORM maps an unquoted `alias.property` to the column itself; anything else must name the
-    // column: `@Column({ name: 'created_at' }) createdAt` is ordered by "created_at", not "createdAt"
-    const column = alias && !useQuotes
-        ? field
-        : (_a = (0, query_builder_utils_1.getColumnDatabaseName)(builder, alias, field)) !== null && _a !== void 0 ? _a : field;
-    const selector = table.column(column);
     const order = typeof isReversed === 'boolean' && (0, common_utils_1.isNil)(direction)
         ? (isReversed ? 'DESC' : 'ASC')
         : (0, order_utils_1.toSqlOrderDirection)(direction);
     const nulls = typeof nullsOrder === 'string' && /first|last/i.test(nullsOrder)
         ? `NULLS ${nullsOrder.toUpperCase()}`
         : constants_1.defaultNullsOrder;
+    // a @CalculatedColumn has no column: order by its value, selected with addSelectCalculated
+    const calculatedAlias = alias !== null && alias !== void 0 ? alias : defaultAlias;
+    if ((0, calculated_column_utils_1.isCalculatedColumn)(builder, field, calculatedAlias)) {
+        return {
+            selector: (0, calculated_column_utils_1.selectCalculatedForOrder)(builder, field, calculatedAlias, 'applyOrder'),
+            order,
+            nulls,
+        };
+    }
+    const table = (0, table_utils_1.tableHelper)(alias, { useQuotes, driver: (0, sql_utils_1.getDriverType)(builder) });
+    // TypeORM maps an unquoted `alias.property` to the column itself; anything else must name the
+    // column: `@Column({ name: 'created_at' }) createdAt` is ordered by "created_at", not "createdAt"
+    const column = alias && !useQuotes
+        ? field
+        : (_a = (0, query_builder_utils_1.getColumnDatabaseName)(builder, alias, field)) !== null && _a !== void 0 ? _a : field;
+    const selector = table.column(column);
     return {
         selector,
         order,

package/dist/extensions/query-returning.extension.d.ts

@@ -0,0 +1,29 @@
+import { ObjectLiteral } from 'typeorm';
+import type { QueryReturningResult } from '../types/extensions/query-returning.types';
+export interface QueryReturningMethods {
+    /**
+     * Runs a raw statement and resolves its rows and the row count it touched, in the same shape
+     * whatever the statement: `{ records, affected }`.
+     *
+     * `query()` shapes its result by the command instead. On PostgreSQL an UPDATE or a DELETE resolves
+     * to `[rows, rowCount]`, while a SELECT or an INSERT resolves to the rows, so `(await query(sql))[0]`
+     * is the first row of an INSERT … RETURNING but the whole rows array of an UPDATE … RETURNING:
+     * truthy, so a `if (!row) throw` check passes, and every field of it reads `undefined`.
+     *
+     * On an entity manager bound to a query runner (inside a transaction) the statement runs on that
+     * runner, so it stays in the transaction; otherwise it gets a query runner of its own and releases it.
+     */
+    queryReturning<Row = ObjectLiteral>(query: string, parameters?: unknown[]): Promise<QueryReturningResult<Row>>;
+}
+declare module 'typeorm/entity-manager/EntityManager' {
+    interface EntityManager extends QueryReturningMethods {
+    }
+}
+declare module 'typeorm/repository/Repository' {
+    interface Repository<Entity extends ObjectLiteral> extends QueryReturningMethods {
+    }
+}
+declare module 'typeorm/data-source/DataSource' {
+    interface DataSource extends QueryReturningMethods {
+    }
+}

package/dist/extensions/query-returning.extension.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const prototype_utils_1 = require("../utils/prototype.utils");
+/* eslint-enable @typescript-eslint/no-empty-interface, @typescript-eslint/no-unused-vars */
+// patching
+(0, prototype_utils_1.patchPrototype)(typeorm_1.EntityManager, {
+    prototype: {
+        queryReturning: function (query, parameters) {
+            return queryReturning(this, query, parameters);
+        },
+    },
+});
+(0, prototype_utils_1.patchPrototype)(typeorm_1.Repository, {
+    prototype: {
+        queryReturning: function (query, parameters) {
+            return queryReturning(this.manager, query, parameters);
+        },
+    },
+});
+(0, prototype_utils_1.patchPrototype)(typeorm_1.DataSource, {
+    prototype: {
+        queryReturning: function (query, parameters) {
+            return queryReturning(this.manager, query, parameters);
+        },
+    },
+});
+// implementation
+const WRITE_RETURNING = /^(?:INSERT|UPDATE|DELETE)\s[\s\S]*\bRETURNING\b/i;
+async function queryReturning(manager, query, parameters) {
+    var _a, _b, _c;
+    const boundQueryRunner = manager.queryRunner;
+    // TypeORM 1.x names the manager's data source `dataSource`; 0.3 calls it `connection`
+    const dataSource = (_a = manager.dataSource) !== null && _a !== void 0 ? _a : manager.connection;
+    const queryRunner = boundQueryRunner !== null && boundQueryRunner !== void 0 ? boundQueryRunner : dataSource.createQueryRunner();
+    // TypeORM 0.3's runner of the sqlite3 driver runs a statement that starts with `INSERT ` / `UPDATE ` /
+    // `DELETE ` without reading rows, which drops a RETURNING; after a line break it reads them.
+    // A string: TypeORM 1.x has no 'sqlite' driver type
+    const driverType = dataSource.options.type;
+    const sql = driverType === 'sqlite' && WRITE_RETURNING.test(query) ? `\n${query}` : query;
+    try {
+        const result = await queryRunner.query(sql, parameters, true);
+        return { records: (_b = result.records) !== null && _b !== void 0 ? _b : [], affected: (_c = result.affected) !== null && _c !== void 0 ? _c : null };
+    }
+    finally {
+        if (!boundQueryRunner) {
+            await queryRunner.release();
+        }
+    }
+}

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

@@ -1,4 +1,6 @@
 export * from './typed-distinct/typed-distinct.extension';
+export * from './typed-group-by/typed-group-by.extension';
+export * from './typed-having/typed-having.extension';
 export * from './typed-joins/typed-joins.extension';
 export * from './typed-order-by/typed-order-by.extension';
 export * from './typed-select/typed-select.extension';
@@ -14,3 +16,4 @@ 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-root.extension';

package/dist/extensions/typed/index.js

@@ -16,8 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 //Extensions
 __exportStar(require("./typed-distinct/typed-distinct.extension"), exports);
-// export * from './typed/typed-group-by/typed-group-by.extension';
-// export * from './typed/typed-having/typed-having.extension';
+__exportStar(require("./typed-group-by/typed-group-by.extension"), exports);
+__exportStar(require("./typed-having/typed-having.extension"), exports);
 __exportStar(require("./typed-joins/typed-joins.extension"), exports);
 __exportStar(require("./typed-order-by/typed-order-by.extension"), exports);
 __exportStar(require("./typed-select/typed-select.extension"), exports);
@@ -33,3 +33,4 @@ __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-root.extension"), exports);

package/dist/extensions/typed/typed-distinct/typed-distinct.extension.d.ts

@@ -1,14 +1,15 @@
 import { ObjectLiteral } from 'typeorm';
 import { KeyProxyCallback } from '../../../types/modules/proxy-callback.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
     interface SelectQueryBuilder<Entity extends ObjectLiteral> {
         /**
          * Sets the distinct on clause for Postgres.
          */
-        distinctOnTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, ...distinctOn: Array<KeyProxyCallback<Type>>): SelectQueryBuilder<Entity>;
+        distinctOnTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, ...distinctOn: Array<KeyProxyCallback<Type>>): SelectQueryBuilder<Entity>;
         /**
          * Sets the distinct on clause for Postgres.
          */
-        distinctOnTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, distinctOn: KeyProxyCallback<Type>): SelectQueryBuilder<Entity>;
+        distinctOnTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, distinctOn: KeyProxyCallback<Type>): SelectQueryBuilder<Entity>;
     }
 }

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

@@ -0,0 +1,24 @@
+import { ObjectLiteral } from 'typeorm';
+import type { DeepUnwrapArray } 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[];
+export interface TypedGroupByMethods<Entity extends ObjectLiteral> {
+    /**
+     * Sets GROUP BY to the columns the callback selects: `user => user.id`, or several at once,
+     * `user => [user.id, user.email]`. Replaces previously set GROUP BY.
+     */
+    groupByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selection: GroupBySelection<Type>, options?: TypedGroupByOptions): this;
+    /**
+     * Adds the columns the callback selects to GROUP BY.
+     */
+    addGroupByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selection: GroupBySelection<Type>, options?: TypedGroupByOptions): this;
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedGroupByMethods<Entity> {
+    }
+}
+export {};

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+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
+const extension = {
+    prototype: {
+        groupByTyped(selection, options) {
+            // keys first: a JSON path throws before the previous GROUP BY is dropped
+            const [first, ...rest] = toGroupByKeys(this, selection, options);
+            if (first === undefined) {
+                return this.groupBy();
+            }
+            return addGroupByKeys(this.groupBy(first), rest);
+        },
+        addGroupByTyped(selection, options) {
+            return addGroupByKeys(this, toGroupByKeys(this, selection, options));
+        },
+    },
+};
+(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);
+    return Array.isArray(keys) ? keys : [keys];
+}
+function addGroupByKeys(builder, keys) {
+    return keys.reduce((query, key) => query.addGroupBy(key), builder);
+}

package/dist/extensions/typed/typed-having/typed-having.extension.d.ts

@@ -0,0 +1,36 @@
+import { ObjectLiteral } from 'typeorm';
+import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import { TypedWhereArgs, TypeOrDefault, UnsetType } from '../../../types/modules/typed-params.types';
+import type { TypedAggregate } from '../../../types/extensions/typed-having.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
+type Selection<Entity extends ObjectLiteral, Type, Value> = (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value;
+/**
+ * A value a column holds. A relation (`u => u.images`), the end of a key path or a JSON object is no column:
+ * `COUNT("user"."images")` would fail in the database.
+ */
+type AggregatedColumn = string | number | bigint | boolean | Date | ArrayBufferView | ArrayBuffer | readonly unknown[] | null | undefined;
+/** `'*'`, all the rows, only for COUNT. */
+type CountAll<Aggregate> = Aggregate extends 'COUNT' ? '*' : never;
+/** The value an aggregate is compared with: a count, a sum or an average is a number, MIN / MAX the column's value. */
+type AggregateValue<Aggregate, Value> = Aggregate extends 'MIN' | 'MAX' ? Value : number;
+/**
+ * Typesafe HAVING conditions on an aggregate of an entity property: `havingTyped('COUNT', u => u.images.id, '>=', 2)`
+ * gives `HAVING COUNT("images"."id") >= :having_…`. Parameters work as in `whereTyped`; with `strictParams` the
+ * value is a number for COUNT, SUM and AVG, and the column's value for MIN and MAX. `'*'` counts every row.
+ *
+ * One signature, not overloads: with overloads TypeScript checks the other arguments before the arrow
+ * function, and the column type would not be known for the value.
+ */
+export interface TypedHavingMethods<Entity extends ObjectLiteral> {
+    /** Sets HAVING `aggregate(column) condition`, replacing the previous HAVING. */
+    havingTyped<Type extends ObjectLiteral = UnsetType, Aggregate extends TypedAggregate = TypedAggregate, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(aggregate: Aggregate, selection: Selection<Entity, Type, Value & AggregatedColumn> | CountAll<Aggregate>, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, AggregateValue<Aggregate, Value>>): this;
+    /** Adds AND HAVING `aggregate(column) condition`. */
+    andHavingTyped<Type extends ObjectLiteral = UnsetType, Aggregate extends TypedAggregate = TypedAggregate, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(aggregate: Aggregate, selection: Selection<Entity, Type, Value & AggregatedColumn> | CountAll<Aggregate>, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, AggregateValue<Aggregate, Value>>): this;
+    /** Adds OR HAVING `aggregate(column) condition`. */
+    orHavingTyped<Type extends ObjectLiteral = UnsetType, Aggregate extends TypedAggregate = TypedAggregate, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(aggregate: Aggregate, selection: Selection<Entity, Type, Value & AggregatedColumn> | CountAll<Aggregate>, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, AggregateValue<Aggregate, Value>>): this;
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedHavingMethods<Entity> {
+    }
+}
+export {};

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const query_builder_utils_1 = require("../../../utils/query-builder.utils");
+const prototype_utils_1 = require("../../../utils/prototype.utils");
+const where_utils_1 = require("../../../utils/where.utils");
+const createHavingMethod = (method) => function (aggregate, selection, conditions, parameters, options) {
+    return attachTypedHaving(this, method, aggregate, selection, conditions, parameters, options);
+};
+const extension = {
+    prototype: {
+        havingTyped: createHavingMethod('having'),
+        andHavingTyped: createHavingMethod('andHaving'),
+        orHavingTyped: createHavingMethod('orHaving'),
+    },
+};
+(0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
+// implementation
+const AGGREGATES = ['COUNT', 'COUNT DISTINCT', 'SUM', 'AVG', 'MIN', 'MAX'];
+function attachTypedHaving(builder, method, aggregate, selection, conditions, parameters, options) {
+    const methodName = `${method}Typed`;
+    // the aggregate goes into the SQL as is
+    if (!AGGREGATES.includes(aggregate)) {
+        throw new TypeError(`${methodName}: the aggregate is one of ${AGGREGATES.join(', ')}, got "${String(aggregate)}"`);
+    }
+    let argument;
+    if (selection === '*') {
+        if (aggregate !== 'COUNT') {
+            throw new TypeError(`${methodName}: only COUNT takes '*', got ${aggregate}`);
+        }
+        argument = '*';
+    }
+    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 value = aggregate === 'SUM' || aggregate === 'AVG' ? 0 : aggregate === 'MIN' || aggregate === 'MAX' ? compared : undefined;
+        argument = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, selection, methodName, { value });
+    }
+    const expression = aggregate === 'COUNT DISTINCT' ? `COUNT(DISTINCT ${argument})` : `${aggregate}(${argument})`;
+    return (0, where_utils_1.attachWhere)(builder, method, expression, conditions, parameters, { addValue: options === null || options === void 0 ? void 0 : options.addValue });
+}

package/dist/extensions/typed/typed-joins/typed-joins.extension.d.ts

@@ -1,10 +1,11 @@
 import { ObjectLiteral } from 'typeorm';
 import { RelationalKeyProxyCallback } from '../../../types/modules/proxy-callback.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
     interface SelectQueryBuilder<Entity extends ObjectLiteral> {
-        leftJoinTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): SelectQueryBuilder<Entity>;
-        innerJoinTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): SelectQueryBuilder<Entity>;
-        leftJoinAndSelectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): SelectQueryBuilder<Entity>;
-        innerJoinAndSelectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): SelectQueryBuilder<Entity>;
+        leftJoinTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): SelectQueryBuilder<Entity>;
+        innerJoinTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): SelectQueryBuilder<Entity>;
+        leftJoinAndSelectTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): SelectQueryBuilder<Entity>;
+        innerJoinAndSelectTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): SelectQueryBuilder<Entity>;
     }
 }

package/dist/extensions/typed/typed-order-by/typed-order-by-array-position.extension.d.ts

@@ -2,17 +2,18 @@ import '../../order-by-array-position.extension';
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
 import type { ArgsType } from '../../../types/util-types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 export interface TypedOrderByArrayPositionMethods<Entity extends ObjectLiteral> {
     /**
      * Sets ORDER BY the position of the property's column value in `values` (PostgreSQL):
      * `array_position(:values, column)`. Rows whose value isn't in `values` come last.
      * Like `orderBy`, it replaces the previous ORDER BY. See `orderByArrayPosition`.
      */
-    orderByArrayPositionTyped<Type extends ObjectLiteral = Entity>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    orderByArrayPositionTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds ORDER BY the position of the property's column value in `values` (PostgreSQL), like `addOrderBy`.
      */
-    addOrderByArrayPositionTyped<Type extends ObjectLiteral = Entity>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    addOrderByArrayPositionTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
 }
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
     interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedOrderByArrayPositionMethods<Entity> {

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

@@ -9,8 +9,16 @@ const order_utils_1 = require("../../../utils/order.utils");
 // patching
 const createOrderByArrayPositionTypedMethod = (replace) => function (selection, values, arrayType) {
     const methodName = replace ? 'orderByArrayPositionTyped' : 'addOrderByArrayPositionTyped';
-    const column = (0, query_builder_utils_1.getTypedSingleColumnKey)(this, selection, methodName);
-    return (0, order_utils_1.attachOrderByArrayPosition)(this, column, values, arrayType, replace);
+    // a path into a JSON column is cast to the type of the values, as typed where methods do it,
+    // so a number in the JSON is compared as a number, not as its text
+    const value = Array.isArray(values) ? values.find((candidate) => candidate != null) : undefined;
+    const column = (0, query_builder_utils_1.getTypedSingleColumnKey)(this, selection, methodName, { value });
+    const jsonType = typeof value === 'number' ? 'number' : typeof value === 'boolean' ? 'boolean' : undefined;
+    // a JSON value of another type, a "n/a" among numbers, would fail the cast: it goes last instead
+    const key = jsonType && (0, query_builder_utils_1.isTypedJsonPath)(this, selection)
+        ? `CASE WHEN jsonb_typeof(CAST(${(0, query_builder_utils_1.getTypedSingleColumnKey)(this, selection, methodName, { accessor: 'json' })} AS jsonb)) = '${jsonType}' THEN ${column} END`
+        : column;
+    return (0, order_utils_1.attachOrderByArrayPosition)(this, key, values, arrayType, replace);
 };
 const extension = {
     prototype: {

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

@@ -2,6 +2,7 @@ import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
 import { KeyHolder } from '../../../utils/proxy-key.utils';
 import type { TypedOrderByOptions } from '../../../types/extensions/typed-order-by.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
     interface SelectQueryBuilder<Entity extends ObjectLiteral> {
         /**
@@ -9,10 +10,10 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
          * If you had previously ORDER BY expression defined,
          * calling this function will override previously set ORDER BY conditions.
          */
-        orderByTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType | KeyHolder, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST', options?: TypedOrderByOptions): SelectQueryBuilder<Entity>;
+        orderByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType | KeyHolder, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST', options?: TypedOrderByOptions): SelectQueryBuilder<Entity>;
         /**
          * Adds ORDER BY condition in the query builder.
          */
-        addOrderByTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType | KeyHolder, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST', options?: TypedOrderByOptions): SelectQueryBuilder<Entity>;
+        addOrderByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType | KeyHolder, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST', options?: TypedOrderByOptions): SelectQueryBuilder<Entity>;
     }
 }

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

@@ -3,10 +3,11 @@ 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");
 // 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), order, nulls);
+        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);
@@ -16,7 +17,7 @@ typeorm_1.SelectQueryBuilder.prototype.orderByTyped = function (selection, order
 };
 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), order, nulls);
+        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);

package/dist/extensions/typed/typed-root.extension.d.ts

@@ -0,0 +1,25 @@
+import { ObjectLiteral } from 'typeorm';
+import type { WithTypedRoot } from '../../types/modules/typed-root.types';
+type KnownEntity<Entity> = 0 extends 1 & Entity ? ObjectLiteral : Entity;
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> {
+        /**
+         * Sets the root of the typed callbacks of the calls that follow, instead of passing it to each of them:
+         * the aliases of the query and their entities.
+         *
+         * Type-only: returns the builder itself. Call it once; a second call merges the roots.
+         *
+         * @example
+         * type Joins = { checkin: CheckIn; event: Event };
+         *
+         * checkInRepository
+         *   .createQueryBuilder('checkin')
+         *   .innerJoin('checkin.event', 'event')
+         *   .typed<Joins>()
+         *   .selectTyped((q) => q.checkin.customerId, 'customerId')
+         *   .whereTyped((q) => q.event.eventType, '=', type) // instead of whereTyped<Joins>(…)
+         */
+        typed<Root extends ObjectLiteral>(): SelectQueryBuilder<WithTypedRoot<KnownEntity<Entity>, Root>>;
+    }
+}
+export {};

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const prototype_utils_1 = require("../../utils/prototype.utils");
+// patching
+const extension = {
+    prototype: {
+        typed() {
+            return this;
+        },
+    },
+};
+(0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);

package/dist/extensions/typed/typed-select/typed-select.extension.d.ts

@@ -1,13 +1,14 @@
 import { ObjectLiteral } from 'typeorm';
 import { KeyProxyCallback } from '../../../types/modules/proxy-callback.types';
 import { KeyHolder } from '../../../utils/proxy-key.utils';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
     interface SelectQueryBuilder<Entity> {
         /**
          * Creates SELECT query.
          * Replaces all previous selections if they exist.
          */
-        selectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useQuotes?: boolean): SelectQueryBuilder<Entity>;
+        selectTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useQuotes?: boolean): SelectQueryBuilder<Entity>;
         /**
          * Creates SELECT query and selects given data.
          * Replaces all previous selections if they exist.
@@ -17,11 +18,11 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
          * Creates SELECT query and selects given data.
          * Replaces all previous selections if they exist.
          */
-        selectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useQuotes?: boolean): SelectQueryBuilder<Entity>;
+        selectTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useQuotes?: boolean): SelectQueryBuilder<Entity>;
         /**
          * Adds new selection to the SELECT query.
          */
-        addSelectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useQuotes?: boolean): SelectQueryBuilder<Entity>;
+        addSelectTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useQuotes?: boolean): SelectQueryBuilder<Entity>;
         /**
          * Adds new selection to the SELECT query.
          */
@@ -29,6 +30,6 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
         /**
          * Adds new selection to the SELECT query.
          */
-        addSelectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useQuotes?: boolean): SelectQueryBuilder<Entity>;
+        addSelectTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useQuotes?: boolean): SelectQueryBuilder<Entity>;
     }
 }

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

@@ -3,6 +3,7 @@ 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
 const extension = {
@@ -23,11 +24,11 @@ const extension = {
 // implementation
 const attachSelectMethod = (query, method, selection, selectionAliasName, useQuotes) => {
     if (selection instanceof proxy_key_utils_1.KeyHolder) {
-        return query[method](selection.toSql(undefined, useQuotes), selectionAliasName);
+        return query[method](selection.toSql(undefined, useQuotes, (0, sql_utils_1.getDriverType)(query)), selectionAliasName);
     }
     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, proxy_key_utils_1.getSqlKeyFromProxyCallback)(select, () => query.alias, useQuotes, (0, sql_utils_1.getDriverType)(query))
             : (0, query_builder_utils_1.getTypedSelectionKey)(query, select, useQuotes));
         return query[method](arrayOfKeys);
     }

package/dist/extensions/typed/typed-where/typed-period-filter.extension.d.ts

@@ -3,6 +3,7 @@ import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
 import type { PeriodFilter } from '../../../types/interfaces/period.interface';
 import type { ApplyPeriodOptions } from '../../../types/extensions/period.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 export interface TypedPeriodFilterMethods<Entity extends ObjectLiteral> {
     /**
      * Adds AND WHERE conditions for a period on an entity property:
@@ -11,7 +12,7 @@ export interface TypedPeriodFilterMethods<Entity extends ObjectLiteral> {
      * Both ends are inclusive unless `options.includeFrom` / `options.includeTo` is `false`.
      * A date-only string (`'2024-01-31'`) stands for the whole day: `periodTo: '2024-01-31'` → `column < '2024-02-01'`.
      */
-    applyPeriodFilterTyped<Type extends ObjectLiteral = Entity>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, periodFilter: PeriodFilter | null | undefined, options?: ApplyPeriodOptions): this;
+    applyPeriodFilterTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, periodFilter: PeriodFilter | null | undefined, options?: ApplyPeriodOptions): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedPeriodFilterMethods<ObjectLiteral> {