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

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

@@ -0,0 +1,17 @@
+"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 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');
+        },
+    },
+};
+(0, prototype_utils_1.patchPrototype)(SelectQueryBuilder_1.SelectQueryBuilder, extension);

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

@@ -4,12 +4,14 @@ 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.
+         * Sets the distinct on clause for Postgres. A `@CalculatedColumn` selected with `addSelectCalculated`
+         * goes in under the alias `orderByCalculated` orders it by, as DISTINCT ON has to match the leading ORDER BY.
          */
-        distinctOnTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, ...distinctOn: Array<KeyProxyCallback<Type>>): SelectQueryBuilder<Entity>;
+        distinctOnTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, ...distinctOn: Array<KeyProxyCallback<Type>>): this;
         /**
-         * Sets the distinct on clause for Postgres.
+         * Sets the distinct on clause for Postgres. A `@CalculatedColumn` selected with `addSelectCalculated`
+         * goes in under the alias `orderByCalculated` orders it by, as DISTINCT ON has to match the leading ORDER BY.
          */
-        distinctOnTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, distinctOn: KeyProxyCallback<Type>): SelectQueryBuilder<Entity>;
+        distinctOnTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, distinctOn: KeyProxyCallback<Type>): this;
     }
 }

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

@@ -2,11 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const typeorm_1 = require("typeorm");
 const query_builder_utils_1 = require("../../../utils/query-builder.utils");
+const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
+const calculated_column_utils_1 = require("../../../utils/calculated-column.utils");
 // patching and implementation
 typeorm_1.SelectQueryBuilder.prototype.distinctOnTyped = function (...distinctOn) {
     if (Array.isArray(distinctOn) && distinctOn.length) {
-        const keys = distinctOn.map((callback) => (0, query_builder_utils_1.getTypedSelectionKey)(this, callback)).flat();
-        return this.distinctOn(keys);
+        const keys = distinctOn.flatMap((callback) => [(0, proxy_key_utils_1.getKeyHolder)(callback)].flat().map((keyHolder) => {
+            const calculated = (0, query_builder_utils_1.findTypedCalculatedProperty)(this, keyHolder);
+            return calculated
+                ? (0, calculated_column_utils_1.selectCalculatedForOrder)(this, calculated.propertyPath, calculated.aliasName, 'distinctOnTyped')
+                : (0, query_builder_utils_1.getTypedSelectionKey)(this, keyHolder, undefined, 'distinctOnTyped');
+        }));
+        return this.distinctOn(keys.flat());
     }
     return this;
 };

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

@@ -1,21 +1,22 @@
 import { ObjectLiteral } from 'typeorm';
-import type { DeepUnwrapArray } from '../../../types/modules/proxy-callback.types';
+import type { KeyProxyCallback } 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[];
+/**
+ * One column, `user => user.id`, or several, `user => [user.id, user.email]`. A JSON column groups as a whole;
+ * a relation without a join column in its table, or an embedded entity, throws a `TypeError`.
+ */
+type GroupBySelection<Type extends ObjectLiteral> = KeyProxyCallback<Type>;
 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;
+    groupByTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(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;
+    addGroupByTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(selection: GroupBySelection<Type>, options?: TypedGroupByOptions): this;
 }
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
     interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedGroupByMethods<Entity> {

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

@@ -23,7 +23,7 @@ const extension = {
 (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);
+    const keys = (0, query_builder_utils_1.getTypedSelectionKey)(builder, selection, options === null || options === void 0 ? void 0 : options.useQuotes, 'groupByTyped');
     return Array.isArray(keys) ? keys : [keys];
 }
 function addGroupByKeys(builder, keys) {

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

@@ -3,7 +3,7 @@ import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/pr
 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;
+type Selection<Root extends ObjectLiteral, Type, Value> = (proxy: DeepUnwrapArray<TypeOrDefault<Type, Root>>) => 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.
@@ -23,11 +23,11 @@ type AggregateValue<Aggregate, Value> = Aggregate extends 'MIN' | 'MAX' ? 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;
+    havingTyped<Type extends ObjectLiteral = UnsetType, Aggregate extends TypedAggregate = TypedAggregate, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(aggregate: Aggregate, selection: Selection<TypedRoot<Entity, this>, 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;
+    andHavingTyped<Type extends ObjectLiteral = UnsetType, Aggregate extends TypedAggregate = TypedAggregate, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(aggregate: Aggregate, selection: Selection<TypedRoot<Entity, this>, 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;
+    orHavingTyped<Type extends ObjectLiteral = UnsetType, Aggregate extends TypedAggregate = TypedAggregate, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(aggregate: Aggregate, selection: Selection<TypedRoot<Entity, this>, 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> {

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.d.ts

@@ -0,0 +1,19 @@
+import { ObjectLiteral } from 'typeorm';
+import { KeyProxyCallback } from '../../../types/modules/proxy-callback.types';
+import type { JoinAndMapTarget } from '../../../types/extensions/typed-join-and-map.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> {
+        /**
+         * TypeORM's `leftJoinAndMapOne` with the property to map to picked by a typed callback: `(u) => u.profile` is
+         * `'user.profile'` on the main alias, `(q) => q.photo.owner` is `'photo.owner'` with an alias-keyed root.
+         */
+        leftJoinAndMapOneTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, mapToProperty: KeyProxyCallback<Type>, entity: JoinAndMapTarget, alias: string, condition?: string, parameters?: ObjectLiteral): this;
+        /** TypeORM's `innerJoinAndMapOne` with the property to map to picked by a typed callback. */
+        innerJoinAndMapOneTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, mapToProperty: KeyProxyCallback<Type>, entity: JoinAndMapTarget, alias: string, condition?: string, parameters?: ObjectLiteral): this;
+        /** TypeORM's `leftJoinAndMapMany` with the property to map to picked by a typed callback. */
+        leftJoinAndMapManyTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, mapToProperty: KeyProxyCallback<Type>, entity: JoinAndMapTarget, alias: string, condition?: string, parameters?: ObjectLiteral): this;
+        /** TypeORM's `innerJoinAndMapMany` with the property to map to picked by a typed callback. */
+        innerJoinAndMapManyTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, mapToProperty: KeyProxyCallback<Type>, entity: JoinAndMapTarget, alias: string, condition?: string, parameters?: ObjectLiteral): this;
+    }
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+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
+const createJoinAndMapTypedMethod = (method) => function (mapToProperty, entity, alias, condition, parameters) {
+    return addJoinAndMap(this, method, 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);
+    return query[method](key, entity, alias, condition, parameters);
+}

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

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

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-array-position.extension.d.ts

@@ -9,11 +9,11 @@ export interface TypedOrderByArrayPositionMethods<Entity extends ObjectLiteral>
      * `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 = TypedRoot<Entity>>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    orderByArrayPositionTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(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 = TypedRoot<Entity>>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    addOrderByArrayPositionTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(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.extension.d.ts

@@ -9,11 +9,13 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
          * Sets ORDER BY condition in the query builder.
          * If you had previously ORDER BY expression defined,
          * calling this function will override previously set ORDER BY conditions.
+         * A `@CalculatedColumn` is ordered by its value, selected with `addSelectCalculated` first.
          */
-        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>;
+        orderByTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType | KeyHolder, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST', options?: TypedOrderByOptions): this;
         /**
          * Adds ORDER BY condition in the query builder.
+         * A `@CalculatedColumn` is ordered by its value, selected with `addSelectCalculated` first.
          */
-        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>;
+        addOrderByTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType | KeyHolder, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST', options?: TypedOrderByOptions): this;
     }
 }

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

@@ -3,25 +3,26 @@ 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 calculated_column_utils_1 = require("../../../utils/calculated-column.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);
-        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 methodName = `${method}Typed`;
+        const keyHolder = (0, proxy_key_utils_1.getKeyHolder)(selection);
+        const calculated = keyHolder instanceof proxy_key_utils_1.KeyHolder ? (0, query_builder_utils_1.findTypedCalculatedProperty)(this, keyHolder) : undefined;
+        // a @CalculatedColumn is ordered by its value, which has to be selected with addSelectCalculated first
+        const key = calculated
+            ? (0, calculated_column_utils_1.selectCalculatedForOrder)(this, calculated.propertyPath, calculated.aliasName, methodName)
+            : (0, query_builder_utils_1.getTypedSelectionKey)(this, selection, options === null || options === void 0 ? void 0 : options.useQuotes, methodName);
+        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);
-        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);

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

@@ -27,12 +27,4 @@ const extension = {
         },
     },
 };
-const queryBuilders = [
-    typeorm_1.InsertQueryBuilder,
-    typeorm_1.UpdateQueryBuilder,
-    typeorm_1.DeleteQueryBuilder,
-    SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder,
-];
-queryBuilders.forEach((builder) => {
-    (0, prototype_utils_1.patchPrototype)(builder, extension);
-});
+(0, prototype_utils_1.patchPrototypes)([typeorm_1.InsertQueryBuilder, typeorm_1.UpdateQueryBuilder, typeorm_1.DeleteQueryBuilder, SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder], extension);

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

@@ -1,13 +1,14 @@
 import { ObjectLiteral } from 'typeorm';
+import type { EntityTarget } 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.
+         * Type-only: returns the builder itself, marked with the root; its entity type stays. `from()` and `addFrom()`
+         * keep the root, so it may go before them; a second call replaces it.
          *
          * @example
          * type Joins = { checkin: CheckIn; event: Event };
@@ -19,7 +20,28 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
          *   .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>>;
+        typed<Root extends ObjectLiteral>(): WithTypedRoot<SelectQueryBuilder<Entity>, Root>;
+        /**
+         * Specifies FROM which entity's table select/update/delete will be executed.
+         * Also sets a main string alias of the selection data.
+         * Removes all previously set from-s. Keeps the root set with `typed()`.
+         */
+        from<T extends ObjectLiteral, Root extends ObjectLiteral>(this: WithTypedRoot<unknown, Root>, entityTarget: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>, aliasName: string): WithTypedRoot<SelectQueryBuilder<T>, Root>;
+        /**
+         * Specifies FROM which entity's table select/update/delete will be executed.
+         * Also sets a main string alias of the selection data.
+         * Removes all previously set from-s. Keeps the root set with `typed()`.
+         */
+        from<T extends ObjectLiteral, Root extends ObjectLiteral>(this: WithTypedRoot<unknown, Root>, entityTarget: EntityTarget<T>, aliasName: string): WithTypedRoot<SelectQueryBuilder<T>, Root>;
+        /**
+         * Specifies FROM which entity's table select/update/delete will be executed.
+         * Also sets a main string alias of the selection data. Keeps the root set with `typed()`.
+         */
+        addFrom<T extends ObjectLiteral, Root extends ObjectLiteral>(this: WithTypedRoot<unknown, Root>, entityTarget: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>, aliasName: string): WithTypedRoot<SelectQueryBuilder<T>, Root>;
+        /**
+         * Specifies FROM which entity's table select/update/delete will be executed.
+         * Also sets a main string alias of the selection data. Keeps the root set with `typed()`.
+         */
+        addFrom<T extends ObjectLiteral, Root extends ObjectLiteral>(this: WithTypedRoot<unknown, Root>, entityTarget: EntityTarget<T>, aliasName: string): WithTypedRoot<SelectQueryBuilder<T>, Root>;
     }
 }
-export {};

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

@@ -8,28 +8,28 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
          * Creates SELECT query.
          * Replaces all previous selections if they exist.
          */
-        selectTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useQuotes?: boolean): SelectQueryBuilder<Entity>;
+        selectTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useQuotes?: boolean): this;
         /**
          * Creates SELECT query and selects given data.
          * Replaces all previous selections if they exist.
          */
-        selectTyped(this: SelectQueryBuilder<Entity>, selection: string | KeyHolder, selectionAliasName?: string, useQuotes?: boolean): SelectQueryBuilder<Entity>;
+        selectTyped(this: SelectQueryBuilder<Entity>, selection: string | KeyHolder, selectionAliasName?: string, useQuotes?: boolean): this;
         /**
          * Creates SELECT query and selects given data.
          * Replaces all previous selections if they exist.
          */
-        selectTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useQuotes?: boolean): SelectQueryBuilder<Entity>;
+        selectTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useQuotes?: boolean): this;
         /**
          * Adds new selection to the SELECT query.
          */
-        addSelectTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useQuotes?: boolean): SelectQueryBuilder<Entity>;
+        addSelectTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useQuotes?: boolean): this;
         /**
          * Adds new selection to the SELECT query.
          */
-        addSelectTyped(this: SelectQueryBuilder<Entity>, selection: string | KeyHolder, selectionAliasName?: string, useQuotes?: boolean): SelectQueryBuilder<Entity>;
+        addSelectTyped(this: SelectQueryBuilder<Entity>, selection: string | KeyHolder, selectionAliasName?: string, useQuotes?: boolean): this;
         /**
          * Adds new selection to the SELECT query.
          */
-        addSelectTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useQuotes?: boolean): SelectQueryBuilder<Entity>;
+        addSelectTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useQuotes?: boolean): this;
     }
 }

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

@@ -3,7 +3,6 @@ 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,17 +22,12 @@ const extension = {
 (0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
 // implementation
 const attachSelectMethod = (query, method, selection, selectionAliasName, useQuotes) => {
-    if (selection instanceof proxy_key_utils_1.KeyHolder) {
-        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, sql_utils_1.getDriverType)(query))
-            : (0, query_builder_utils_1.getTypedSelectionKey)(query, select, useQuotes));
+        const arrayOfKeys = selection.flatMap((select) => (0, query_builder_utils_1.getTypedSelectionKey)(query, select, useQuotes, `${method}Typed`));
         return query[method](arrayOfKeys);
     }
-    else if (typeof selection === 'function') {
-        const keyArrayOrSingleKey = (0, query_builder_utils_1.getTypedSelectionKey)(query, selection, useQuotes);
+    else if (selection instanceof proxy_key_utils_1.KeyHolder || typeof selection === 'function') {
+        const keyArrayOrSingleKey = (0, query_builder_utils_1.getTypedSelectionKey)(query, selection, useQuotes, `${method}Typed`);
         if (Array.isArray(keyArrayOrSingleKey)) {
             return query[method](keyArrayOrSingleKey);
         }

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

@@ -12,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 = TypedRoot<Entity>>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, periodFilter: PeriodFilter | null | undefined, options?: ApplyPeriodOptions): this;
+    applyPeriodFilterTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, periodFilter: PeriodFilter | null | undefined, options?: ApplyPeriodOptions): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedPeriodFilterMethods<ObjectLiteral> {
@@ -30,3 +30,7 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
     interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedPeriodFilterMethods<Entity> {
     }
 }
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedPeriodFilterMethods<Entity> {
+    }
+}

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("../../period-filter.extension");
-const typeorm_1 = require("typeorm");
 const query_builder_utils_1 = require("../../../utils/query-builder.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");
 const period_utils_1 = require("../../../utils/period.utils");
@@ -15,11 +14,4 @@ const extension = {
         },
     },
 };
-const queryBuilders = [
-    typeorm_1.SelectQueryBuilder,
-    typeorm_1.UpdateQueryBuilder,
-    typeorm_1.DeleteQueryBuilder,
-];
-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/typed-where/typed-where-array.extension.d.ts

@@ -13,43 +13,43 @@ export interface TypedWhereArrayMethods<Entity extends ObjectLiteral> {
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereArrayContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    whereArrayContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new AND WHERE `column @> :values` condition (PostgreSQL): the array column contains every value.
      */
-    andWhereArrayContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    andWhereArrayContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new OR WHERE `column @> :values` condition (PostgreSQL): the array column contains every value.
      */
-    orWhereArrayContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    orWhereArrayContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Sets WHERE `column <@ :values` condition (PostgreSQL): every element of the array column is one of the values.
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereArrayContainedByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    whereArrayContainedByTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new AND WHERE `column <@ :values` condition (PostgreSQL): every element of the array column is one of the values.
      */
-    andWhereArrayContainedByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    andWhereArrayContainedByTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new OR WHERE `column <@ :values` condition (PostgreSQL): every element of the array column is one of the values.
      */
-    orWhereArrayContainedByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    orWhereArrayContainedByTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Sets WHERE `column && :values` condition (PostgreSQL): the array column has at least one of the values.
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereArrayOverlapsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    whereArrayOverlapsTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new AND WHERE `column && :values` condition (PostgreSQL): the array column has at least one of the values.
      */
-    andWhereArrayOverlapsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    andWhereArrayOverlapsTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new OR WHERE `column && :values` condition (PostgreSQL): the array column has at least one of the values.
      */
-    orWhereArrayOverlapsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    orWhereArrayOverlapsTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereArrayMethods<ObjectLiteral> {
@@ -67,3 +67,7 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
     interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereArrayMethods<Entity> {
     }
 }
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereArrayMethods<Entity> {
+    }
+}

package/dist/extensions/typed/typed-where/typed-where-array.extension.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("../../where-array.extension");
-const typeorm_1 = require("typeorm");
 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");
+const typed_where_utils_1 = require("../../../utils/typed-where.utils");
 /* eslint-enable @typescript-eslint/no-empty-interface */
 // patching
 const createWhereArrayTypedMethod = (method) => function (where, values, arrayType) {
@@ -23,25 +23,13 @@ const extension = {
         orWhereArrayOverlapsTyped: createWhereArrayTypedMethod('orWhereArrayOverlaps'),
     },
 };
-const queryBuilders = [
-    typeorm_1.SelectQueryBuilder,
-    typeorm_1.UpdateQueryBuilder,
-    typeorm_1.DeleteQueryBuilder,
-];
-queryBuilders.forEach((builder) => {
-    (0, prototype_utils_1.patchPrototype)(builder, extension);
-});
+(0, prototype_utils_1.patchPrototypes)(prototype_utils_1.WHERE_QUERY_BUILDERS, extension);
 // implementation
 function attachWhereArrayTyped(builder, method, where, values, arrayType) {
-    if (typeof where !== 'function') {
-        return builder;
-    }
-    const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`);
-    if ((0, query_builder_utils_1.isTypedJsonPath)(builder, where)) {
+    if (typeof where === 'function' && (0, query_builder_utils_1.isTypedJsonPath)(builder, where)) {
         return attachWhereJsonArray(builder, method, where, values, arrayType);
     }
-    // .andWhereArrayContains(`"table"."column"`, ['value'])
-    return builder[method](key, values, arrayType);
+    return (0, typed_where_utils_1.attachTypedColumnWhere)(builder, method, where, undefined, values, arrayType);
 }
 const JSON_ARRAY_METHOD = /^(where|andWhere|orWhere)Array(Contains|ContainedBy|Overlaps)$/;
 const JSON_ARRAY_OPERATORS = { Contains: '@>', ContainedBy: '<@', Overlaps: '?|' };