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

package/dist/extensions/where-is-any.extension.d.ts

@@ -44,30 +44,30 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
          * If you had previously WHERE expression defined,
          * calling this function will override previously set WHERE conditions.
          */
-        whereIsAny(field: string, array?: ArgsType, arrayType?: string): SelectQueryBuilder<Entity>;
+        whereIsAny(field: string, array?: ArgsType, arrayType?: string): this;
         /**
          * Adds new AND WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
          */
-        andWhereIsAny(field: string, array?: ArgsType, arrayType?: string): SelectQueryBuilder<Entity>;
+        andWhereIsAny(field: string, array?: ArgsType, arrayType?: string): this;
         /**
          * Adds new OR WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
          */
-        orWhereIsAny(field: string, array?: ArgsType, arrayType?: string): SelectQueryBuilder<Entity>;
+        orWhereIsAny(field: string, array?: ArgsType, arrayType?: string): this;
         /**
          * Sets WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL):
          * the field differs from every value of the array.
          * If you had previously WHERE expression defined,
          * calling this function will override previously set WHERE conditions.
          */
-        whereIsNotAny(field: string, array?: ArgsType, arrayType?: string): SelectQueryBuilder<Entity>;
+        whereIsNotAny(field: string, array?: ArgsType, arrayType?: string): this;
         /**
          * Adds new AND WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL).
          */
-        andWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): SelectQueryBuilder<Entity>;
+        andWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): this;
         /**
          * Adds new OR WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL).
          */
-        orWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): SelectQueryBuilder<Entity>;
+        orWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): this;
     }
 }
 declare module 'typeorm/query-builder/UpdateQueryBuilder' {
@@ -140,3 +140,38 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
         orWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): DeleteQueryBuilder<Entity>;
     }
 }
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> {
+        /**
+         * Sets WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
+         * The array is bound as a single parameter instead of one parameter per value.
+         * `arrayType` (e.g. `'uuid[]'`) casts the parameter: `= ANY(CAST(:array AS uuid[]))`.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         */
+        whereIsAny(field: string, array?: ArgsType, arrayType?: string): SoftDeleteQueryBuilder<Entity>;
+        /**
+         * Adds new AND WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
+         */
+        andWhereIsAny(field: string, array?: ArgsType, arrayType?: string): SoftDeleteQueryBuilder<Entity>;
+        /**
+         * Adds new OR WHERE `field = ANY(:array)` condition in the query builder (PostgreSQL).
+         */
+        orWhereIsAny(field: string, array?: ArgsType, arrayType?: string): SoftDeleteQueryBuilder<Entity>;
+        /**
+         * Sets WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL):
+         * the field differs from every value of the array.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         */
+        whereIsNotAny(field: string, array?: ArgsType, arrayType?: string): SoftDeleteQueryBuilder<Entity>;
+        /**
+         * Adds new AND WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL).
+         */
+        andWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): SoftDeleteQueryBuilder<Entity>;
+        /**
+         * Adds new OR WHERE `field <> ALL(:array)` condition in the query builder (PostgreSQL).
+         */
+        orWhereIsNotAny(field: string, array?: ArgsType, arrayType?: string): SoftDeleteQueryBuilder<Entity>;
+    }
+}

package/dist/extensions/where-is-any.extension.js

@@ -1,6 +1,7 @@
 "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 sql_utils_1 = require("../utils/sql.utils");
@@ -21,6 +22,7 @@ const queryBuilders = [
     typeorm_1.SelectQueryBuilder,
     typeorm_1.UpdateQueryBuilder,
     typeorm_1.DeleteQueryBuilder,
+    SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder,
 ];
 queryBuilders.forEach((builder) => {
     (0, prototype_utils_1.patchPrototype)(builder, extension);

package/dist/extensions/where-is-distinct-from.extension.d.ts

@@ -54,3 +54,7 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
     interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereDistinctMethods {
     }
 }
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereDistinctMethods {
+    }
+}

package/dist/extensions/where-is-distinct-from.extension.js

@@ -1,6 +1,7 @@
 "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 sql_utils_1 = require("../utils/sql.utils");
@@ -23,6 +24,7 @@ const queryBuilders = [
     typeorm_1.SelectQueryBuilder,
     typeorm_1.UpdateQueryBuilder,
     typeorm_1.DeleteQueryBuilder,
+    SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder,
 ];
 queryBuilders.forEach((builder) => {
     (0, prototype_utils_1.patchPrototype)(builder, extension);

package/dist/extensions/where-is-in.extension.d.ts

@@ -39,29 +39,29 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
          * If you had previously WHERE expression defined,
          * calling this function will override previously set WHERE conditions.
          */
-        whereIsIn(field: string, array?: ArgsType): SelectQueryBuilder<Entity>;
+        whereIsIn(field: string, array?: ArgsType): this;
         /**
          * Adds new AND WHERE IN condition in the query builder.
          */
-        andWhereIsIn(field: string, array?: ArgsType): SelectQueryBuilder<Entity>;
+        andWhereIsIn(field: string, array?: ArgsType): this;
         /**
          * Adds new OR WHERE IN condition in the query builder.
          */
-        orWhereIsIn(field: string, array?: ArgsType): SelectQueryBuilder<Entity>;
+        orWhereIsIn(field: string, array?: ArgsType): this;
         /**
          * Sets WHERE NOT IN condition in the query builder.
          * If you had previously WHERE expression defined,
          * calling this function will override previously set WHERE conditions.
          */
-        whereIsNotIn(field: string, array?: ArgsType): SelectQueryBuilder<Entity>;
+        whereIsNotIn(field: string, array?: ArgsType): this;
         /**
          * Adds new AND WHERE NOT IN condition in the query builder.
          */
-        andWhereIsNotIn(field: string, array?: ArgsType): SelectQueryBuilder<Entity>;
+        andWhereIsNotIn(field: string, array?: ArgsType): this;
         /**
          * Adds new OR WHERE NOT IN condition in the query builder.
          */
-        orWhereIsNotIn(field: string, array?: ArgsType): SelectQueryBuilder<Entity>;
+        orWhereIsNotIn(field: string, array?: ArgsType): this;
     }
 }
 declare module 'typeorm/query-builder/UpdateQueryBuilder' {
@@ -128,3 +128,35 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
         orWhereIsNotIn(field: string, array?: ArgsType): DeleteQueryBuilder<Entity>;
     }
 }
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> {
+        /**
+         * Sets WHERE IN condition in the query builder.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         */
+        whereIsIn(field: string, array?: ArgsType): SoftDeleteQueryBuilder<Entity>;
+        /**
+         * Adds new AND WHERE IN condition in the query builder.
+         */
+        andWhereIsIn(field: string, array?: ArgsType): SoftDeleteQueryBuilder<Entity>;
+        /**
+         * Adds new OR WHERE IN condition in the query builder.
+         */
+        orWhereIsIn(field: string, array?: ArgsType): SoftDeleteQueryBuilder<Entity>;
+        /**
+         * Sets WHERE NOT IN condition in the query builder.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         */
+        whereIsNotIn(field: string, array?: ArgsType): SoftDeleteQueryBuilder<Entity>;
+        /**
+         * Adds new AND WHERE NOT IN condition in the query builder.
+         */
+        andWhereIsNotIn(field: string, array?: ArgsType): SoftDeleteQueryBuilder<Entity>;
+        /**
+         * Adds new OR WHERE NOT IN condition in the query builder.
+         */
+        orWhereIsNotIn(field: string, array?: ArgsType): SoftDeleteQueryBuilder<Entity>;
+    }
+}

package/dist/extensions/where-is-in.extension.js

@@ -1,6 +1,7 @@
 "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 where_utils_1 = require("../utils/where.utils");
 // patching
@@ -30,6 +31,7 @@ const queryBuilders = [
     typeorm_1.SelectQueryBuilder,
     typeorm_1.UpdateQueryBuilder,
     typeorm_1.DeleteQueryBuilder,
+    SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder,
 ];
 queryBuilders.forEach((builder) => {
     (0, prototype_utils_1.patchPrototype)(builder, extension);

package/dist/extensions/where-json.extension.d.ts

@@ -53,3 +53,7 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
     interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereJsonMethods {
     }
 }
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereJsonMethods {
+    }
+}

package/dist/extensions/where-json.extension.js

@@ -1,6 +1,7 @@
 "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 sql_utils_1 = require("../utils/sql.utils");
@@ -26,6 +27,7 @@ const queryBuilders = [
     typeorm_1.SelectQueryBuilder,
     typeorm_1.UpdateQueryBuilder,
     typeorm_1.DeleteQueryBuilder,
+    SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder,
 ];
 queryBuilders.forEach((builder) => {
     (0, prototype_utils_1.patchPrototype)(builder, extension);

package/dist/extensions/where-relation-exists.extension.d.ts

@@ -19,17 +19,17 @@ type RelatedCondition<Related extends ObjectLiteral> = (subQuery: SelectQueryBui
  */
 export interface WhereRelationExistsMethods<Entity extends ObjectLiteral> {
     /** Sets `WHERE EXISTS (…)` over the relation, replacing the WHERE conditions set before. */
-    whereRelationExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
+    whereRelationExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity, this>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
     /** Adds `AND EXISTS (…)` over the relation. */
-    andWhereRelationExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
+    andWhereRelationExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity, this>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
     /** Adds `OR EXISTS (…)` over the relation. */
-    orWhereRelationExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
+    orWhereRelationExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity, this>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
     /** Sets `WHERE NOT EXISTS (…)` over the relation, replacing the WHERE conditions set before. */
-    whereRelationNotExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
+    whereRelationNotExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity, this>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
     /** Adds `AND NOT EXISTS (…)` over the relation. */
-    andWhereRelationNotExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
+    andWhereRelationNotExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity, this>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
     /** Adds `OR NOT EXISTS (…)` over the relation. */
-    orWhereRelationNotExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
+    orWhereRelationNotExists<Related extends ObjectLiteral, Type extends ObjectLiteral = TypedRoot<Entity, this>>(relation: RelationSelection<Type, Related>, alias: string, where?: RelatedCondition<Related>): this;
 }
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
     interface SelectQueryBuilder<Entity extends ObjectLiteral> extends WhereRelationExistsMethods<Entity> {

package/dist/helpers.d.ts

@@ -1,2 +1,7 @@
 export * from './utils/table.utils';
+export * from './decorators/generated-column.decorator';
 export { escapeLikePattern } from './utils/search.utils';
+export { COCKROACHDB_RESERVED_KEY_WORDS, findBareReservedQualifiers, POSTGRES_RESERVED_KEY_WORDS, } from './utils/reserved-qualifier.utils';
+export type { ReservedQualifier } from './utils/reserved-qualifier.utils';
+export { disableReservedQualifierGuard, enableReservedQualifierGuard, ReservedQualifierError, } from './utils/reserved-qualifier-guard.utils';
+export type { ReservedQualifierGuardOptions } from './utils/reserved-qualifier-guard.utils';

package/dist/helpers.js

@@ -14,10 +14,19 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.escapeLikePattern = void 0;
+exports.ReservedQualifierError = exports.enableReservedQualifierGuard = exports.disableReservedQualifierGuard = exports.POSTGRES_RESERVED_KEY_WORDS = exports.findBareReservedQualifiers = exports.COCKROACHDB_RESERVED_KEY_WORDS = exports.escapeLikePattern = void 0;
 // Side-effect-free entry point: `typeorm-extensions/helpers`.
-// Exports helpers (tableHelper, escapeLikePattern) only and patches nothing; importing the package root
-// (`typeorm-extensions`) installs every QueryBuilder extension.
+// Exports helpers (tableHelper, escapeLikePattern, the reserved qualifier guard, @GeneratedColumn) only and patches nothing on import;
+// importing the package root (`typeorm-extensions`) installs every QueryBuilder extension.
 __exportStar(require("./utils/table.utils"), exports);
+__exportStar(require("./decorators/generated-column.decorator"), exports);
 var search_utils_1 = require("./utils/search.utils");
 Object.defineProperty(exports, "escapeLikePattern", { enumerable: true, get: function () { return search_utils_1.escapeLikePattern; } });
+var reserved_qualifier_utils_1 = require("./utils/reserved-qualifier.utils");
+Object.defineProperty(exports, "COCKROACHDB_RESERVED_KEY_WORDS", { enumerable: true, get: function () { return reserved_qualifier_utils_1.COCKROACHDB_RESERVED_KEY_WORDS; } });
+Object.defineProperty(exports, "findBareReservedQualifiers", { enumerable: true, get: function () { return reserved_qualifier_utils_1.findBareReservedQualifiers; } });
+Object.defineProperty(exports, "POSTGRES_RESERVED_KEY_WORDS", { enumerable: true, get: function () { return reserved_qualifier_utils_1.POSTGRES_RESERVED_KEY_WORDS; } });
+var reserved_qualifier_guard_utils_1 = require("./utils/reserved-qualifier-guard.utils");
+Object.defineProperty(exports, "disableReservedQualifierGuard", { enumerable: true, get: function () { return reserved_qualifier_guard_utils_1.disableReservedQualifierGuard; } });
+Object.defineProperty(exports, "enableReservedQualifierGuard", { enumerable: true, get: function () { return reserved_qualifier_guard_utils_1.enableReservedQualifierGuard; } });
+Object.defineProperty(exports, "ReservedQualifierError", { enumerable: true, get: function () { return reserved_qualifier_guard_utils_1.ReservedQualifierError; } });

package/dist/index.d.ts

@@ -6,3 +6,7 @@ export type { Json } from './types/modules/proxy-callback.types';
 export type { TypedRoot, WithTypedRoot } from './types/modules/typed-root.types';
 export * from './utils/table.utils';
 export { escapeLikePattern } from './utils/search.utils';
+export { COCKROACHDB_RESERVED_KEY_WORDS, findBareReservedQualifiers, POSTGRES_RESERVED_KEY_WORDS, } from './utils/reserved-qualifier.utils';
+export type { ReservedQualifier } from './utils/reserved-qualifier.utils';
+export { disableReservedQualifierGuard, enableReservedQualifierGuard, ReservedQualifierError, } from './utils/reserved-qualifier-guard.utils';
+export type { ReservedQualifierGuardOptions } from './utils/reserved-qualifier-guard.utils';

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.escapeLikePattern = void 0;
+exports.ReservedQualifierError = exports.enableReservedQualifierGuard = exports.disableReservedQualifierGuard = exports.POSTGRES_RESERVED_KEY_WORDS = exports.findBareReservedQualifiers = exports.COCKROACHDB_RESERVED_KEY_WORDS = exports.escapeLikePattern = void 0;
 __exportStar(require("./extensions"), exports);
 __exportStar(require("./decorators"), exports);
 __exportStar(require("./types/interfaces"), exports);
@@ -22,3 +22,11 @@ __exportStar(require("./types/extensions"), exports);
 __exportStar(require("./utils/table.utils"), exports);
 var search_utils_1 = require("./utils/search.utils");
 Object.defineProperty(exports, "escapeLikePattern", { enumerable: true, get: function () { return search_utils_1.escapeLikePattern; } });
+var reserved_qualifier_utils_1 = require("./utils/reserved-qualifier.utils");
+Object.defineProperty(exports, "COCKROACHDB_RESERVED_KEY_WORDS", { enumerable: true, get: function () { return reserved_qualifier_utils_1.COCKROACHDB_RESERVED_KEY_WORDS; } });
+Object.defineProperty(exports, "findBareReservedQualifiers", { enumerable: true, get: function () { return reserved_qualifier_utils_1.findBareReservedQualifiers; } });
+Object.defineProperty(exports, "POSTGRES_RESERVED_KEY_WORDS", { enumerable: true, get: function () { return reserved_qualifier_utils_1.POSTGRES_RESERVED_KEY_WORDS; } });
+var reserved_qualifier_guard_utils_1 = require("./utils/reserved-qualifier-guard.utils");
+Object.defineProperty(exports, "disableReservedQualifierGuard", { enumerable: true, get: function () { return reserved_qualifier_guard_utils_1.disableReservedQualifierGuard; } });
+Object.defineProperty(exports, "enableReservedQualifierGuard", { enumerable: true, get: function () { return reserved_qualifier_guard_utils_1.enableReservedQualifierGuard; } });
+Object.defineProperty(exports, "ReservedQualifierError", { enumerable: true, get: function () { return reserved_qualifier_guard_utils_1.ReservedQualifierError; } });

package/dist/types/extensions/cursor-pagination.types.d.ts

@@ -1,4 +1,5 @@
 import type { CursorOrderParam } from '../interfaces/cursor-pagination.interface';
+import type { OrderType } from '../interfaces/ordering.interface';
 export type GetManyWithCursorOptions<Entity> = {
     /**
      * Columns that order the rows, e.g. `[{ field: 'createdAt', direction: 'DESC' }]`.
@@ -18,4 +19,8 @@ export interface ListWithCursor<Entity> {
      * keyset query loads `pageSize + 1` rows, so it needs no total. Equivalent to `nextCursor !== null`.
      */
     hasMore: boolean;
+    /** The page size used: the `pageSize` given, rounded down, or `10` when it was missing or below 1. */
+    pageSize: number;
+    /** The ORDER BY the page was read in: the `orderBy` columns, then the primary key columns not among them. */
+    orderBy: OrderType[];
 }

package/dist/types/extensions/get-many-with-totals.types.d.ts

@@ -18,6 +18,10 @@ export type GetRawManyWithTotalsOptions = Omit<GetManyWithTotalsOptions, 'useTak
 export interface ListWithTotals<Entity> {
     list: Entity[];
     total: number | null;
+    /** The page read, 1-based: the `page` given, or `1` when it was missing or below 1. `null` with `loadAll`. */
+    page: number | null;
+    /** The page size used: the `pageSize` given, or `10` when it was missing or below 1. `null` with `loadAll`. */
+    pageSize: number | null;
     limit: number | null;
     offset: number | null;
     /**

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

@@ -10,4 +10,5 @@ export * from './search.types';
 export * from './typed-having.types';
 export * from './union.types';
 export * from './join-lateral.types';
+export * from './typed-join-and-map.types';
 export * from './query-returning.types';

package/dist/types/extensions/index.js

@@ -26,4 +26,5 @@ __exportStar(require("./search.types"), exports);
 __exportStar(require("./typed-having.types"), exports);
 __exportStar(require("./union.types"), exports);
 __exportStar(require("./join-lateral.types"), exports);
+__exportStar(require("./typed-join-and-map.types"), exports);
 __exportStar(require("./query-returning.types"), exports);

package/dist/types/extensions/typed-join-and-map.types.d.ts

@@ -0,0 +1,6 @@
+import type { SelectQueryBuilder } from 'typeorm';
+/**
+ * What a map join joins, as TypeORM's `leftJoinAndMapOne` and the others take it: an entity class or name, a
+ * relation (`'user.photos'`), a table name, or a factory that builds a subquery on the query builder it is given.
+ */
+export type JoinAndMapTarget = Function | string | ((qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>);

package/dist/types/extensions/typed-join-and-map.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,17 +1,19 @@
 import type { ObjectLiteral } from 'typeorm';
-declare const typedRoot: unique symbol;
 declare class TypedRootMark<Root> {
-    [typedRoot]?(): Root;
+    __typedRoot?(): Root;
 }
 /**
- * The entity type of a builder whose typed callbacks take another root, set with `typed<Root>()`: the entity
- * with an optional symbol method that only types carry. Entities loaded with it are plain entities.
+ * A query builder whose typed callbacks take another root, as `typed<Root>()` returns it:
+ * `WithTypedRoot<SelectQueryBuilder<Entity>, Root>`, the builder with an optional `__typedRoot` method that only
+ * types carry. A builder of a marked entity, `SelectQueryBuilder<WithTypedRoot<Entity, Root>>`, takes the root too.
  */
-export type WithTypedRoot<Entity, Root extends ObjectLiteral> = Entity & TypedRootMark<Root>;
+export type WithTypedRoot<Marked, Root extends ObjectLiteral> = Marked & TypedRootMark<Root>;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type BuilderRoot<Builder> = '__typedRoot' extends keyof Builder ? Builder extends TypedRootMark<infer Root> ? Root extends ObjectLiteral ? Root : never : never : never;
+type EntityRoot<Entity> = '__typedRoot' extends keyof Entity ? IsAny<Entity['__typedRoot' & keyof Entity]> extends true ? Entity : Entity extends TypedRootMark<infer Root> ? Root extends ObjectLiteral ? Root : Entity : Entity : Entity;
 /**
- * The root of a builder's typed callbacks: the one set with `typed<Root>()`, or else its entity. The key check
- * comes first: without `strictNullChecks` an entity with an index signature (`ObjectLiteral`) matches the
- * optional mark too, and its root would be inferred as `unknown`.
+ * The root of a builder's typed callbacks: the one set with `typed<Root>()` on the builder (`Builder`, which the
+ * typed methods pass as `this`) or on its entity, or else the entity.
  */
-export type TypedRoot<Entity> = typeof typedRoot extends keyof Entity ? Entity extends TypedRootMark<infer Root> ? Root extends ObjectLiteral ? Root : Entity : Entity : Entity;
+export type TypedRoot<Entity, Builder = unknown> = [BuilderRoot<Builder>] extends [never] ? EntityRoot<Entity> : BuilderRoot<Builder>;
 export {};

package/dist/utils/pagination.utils.d.ts

@@ -2,4 +2,6 @@ import { PaginationFilter } from "../types/interfaces/pagination.interface";
 export declare const getLimitAndOffset: ({ page, pageSize }: PaginationFilter) => {
     limit: number;
     offset: number;
+    page: number;
+    pageSize: number;
 };

package/dist/utils/pagination.utils.js

@@ -11,6 +11,6 @@ const getLimitAndOffset = ({ page, pageSize }) => {
     }
     const offset = (page >= 1 ? page - 1 : 0) * pageSize;
     const limit = pageSize;
-    return { limit, offset };
+    return { limit, offset, page, pageSize };
 };
 exports.getLimitAndOffset = getLimitAndOffset;

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

@@ -1,6 +1,8 @@
+import { QueryBuilder } from 'typeorm';
 import type { ObjectLiteral, WhereExpressionBuilder } from 'typeorm';
 import type { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata';
 import type { KeyProxyCallback } from '../types/modules/proxy-callback.types';
+import type { OrderType } from '../types/interfaces/ordering.interface';
 import { JsonPathSqlOptions } from './json-path.utils';
 /** Replaces placeholders of `deferColumnKey` in SQL built by `builder`, through the aliases it has by then. */
 export declare function resolveDeferredKeys(builder: WhereExpressionBuilder, statement: string): string;
@@ -54,8 +56,15 @@ export declare function getTypedSingleColumnKey<Type extends ObjectLiteral>(buil
  * Without quotes it is `alias.propertyPath` (`user.name`, `images.url`, `p.address.city`),
  * which TypeORM maps to the column itself. With `useQuotes` it is the quoted database column
  * (`"t"."ticket_status"`), since TypeORM doesn't map quoted keys. An alias of the query without
- * metadata (a subquery or a CTE in FROM or a join) is quoted unless `useQuotes` is `false`:
- * TypeORM leaves its keys as written, and PostgreSQL folds an unquoted `cte.firstName` to `firstname`.
+ * metadata (a subquery or a CTE in FROM or a join), or one the query still doesn't have when the SQL
+ * is built, is quoted unless `useQuotes` is `false`: TypeORM leaves its keys as written, and
+ * PostgreSQL folds an unquoted `cte.firstName` to `firstname`.
  * Strings are kept as is.
  */
 export declare function getTypedSelectionKey<Type extends ObjectLiteral>(builder: WhereExpressionBuilder, selection: KeyProxyCallback<Type> | string, useQuotes?: boolean, columnsFor?: string): string | string[];
+/**
+ * The ORDER BY a query is built with, in the order it was applied. `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.
+ */
+export declare function getAppliedOrderBy<Entity extends ObjectLiteral>(builder: QueryBuilder<Entity>): OrderType[];

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypedSelectionKey = exports.getTypedSingleColumnKey = exports.isTypedJsonPath = exports.getTypedColumnKey = exports.toFieldSql = exports.findFieldColumn = exports.getColumnDatabaseName = exports.resolveDeferredKeys = void 0;
+exports.getAppliedOrderBy = exports.getTypedSelectionKey = exports.getTypedSingleColumnKey = exports.isTypedJsonPath = exports.getTypedColumnKey = exports.toFieldSql = exports.findFieldColumn = exports.getColumnDatabaseName = exports.resolveDeferredKeys = void 0;
 const typeorm_1 = require("typeorm");
 const QueryExpressionMap_1 = require("typeorm/query-builder/QueryExpressionMap");
 const proxy_key_utils_1 = require("./proxy-key.utils");
@@ -70,12 +70,13 @@ function deferColumnKey(aliasName, separator, name) {
  *   quoted without an entity;
  * - an unquoted one (select, order, group by, distinct without `useQuotes`): `alias.property` on an alias with an
  *   entity, which TypeORM maps and reads as a column of the entity; quoted on an alias without one (a subquery, a
- *   CTE), as on an alias known at the call; as written on an unknown alias.
+ *   CTE), as on an alias known at the call, and on an alias the query never has, which only raw SQL adds (a LATERAL
+ *   subquery in the condition of a raw join): TypeORM can't map it, and PostgreSQL would fold it to lower case.
  */
 function toDeferredKeySql(alias, aliasName, separator, name, escape) {
     const metadata = (alias === null || alias === void 0 ? void 0 : alias.hasMetadata) ? alias.metadata : undefined;
     if (separator === DEFERRED_UNQUOTED) {
-        return metadata || !alias ? `${aliasName}.${name}` : `${escape(aliasName)}.${escape(name)}`;
+        return metadata ? `${aliasName}.${name}` : `${escape(aliasName)}.${escape(name)}`;
     }
     const column = metadata && (separator === DEFERRED_FIELD ? findColumn(metadata, name) : metadata.findColumnWithPropertyPath(name));
     const columnName = column && !column.isVirtualProperty ? column.databaseName : name;
@@ -403,8 +404,9 @@ function isAliasWithoutMetadata(queryBuilder, aliasName) {
  * Without quotes it is `alias.propertyPath` (`user.name`, `images.url`, `p.address.city`),
  * which TypeORM maps to the column itself. With `useQuotes` it is the quoted database column
  * (`"t"."ticket_status"`), since TypeORM doesn't map quoted keys. An alias of the query without
- * metadata (a subquery or a CTE in FROM or a join) is quoted unless `useQuotes` is `false`:
- * TypeORM leaves its keys as written, and PostgreSQL folds an unquoted `cte.firstName` to `firstname`.
+ * metadata (a subquery or a CTE in FROM or a join), or one the query still doesn't have when the SQL
+ * is built, is quoted unless `useQuotes` is `false`: TypeORM leaves its keys as written, and
+ * PostgreSQL folds an unquoted `cte.firstName` to `firstname`.
  * Strings are kept as is.
  */
 function getTypedSelectionKey(builder, selection, useQuotes, columnsFor) {
@@ -440,3 +442,18 @@ function getTypedSelectionKey(builder, selection, useQuotes, columnsFor) {
     return Array.isArray(keyHolder) ? keyHolder.map(toKey) : toKey(keyHolder);
 }
 exports.getTypedSelectionKey = getTypedSelectionKey;
+/**
+ * The ORDER BY a query is built with, in the order it was applied. `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.
+ */
+function getAppliedOrderBy(builder) {
+    var _a;
+    return Object.entries((_a = builder.expressionMap.allOrderBys) !== null && _a !== void 0 ? _a : {}).map(([key, value]) => {
+        const selector = resolveDeferredKeys(builder, key);
+        return typeof value === 'string'
+            ? { selector, order: value }
+            : { selector, order: value.order, nulls: value.nulls };
+    });
+}
+exports.getAppliedOrderBy = getAppliedOrderBy;

package/dist/utils/reserved-qualifier-guard.utils.d.ts

@@ -0,0 +1,36 @@
+import { ReservedQualifier } from './reserved-qualifier.utils';
+/** The SQL of a query names a reserved word as a qualifier without quotes; see `enableReservedQualifierGuard`. */
+export declare class ReservedQualifierError extends Error {
+    /** The SQL of the query, as the driver gets it. */
+    readonly sql: string;
+    /** Each reserved word used as a qualifier, in the order of the SQL. */
+    readonly qualifiers: ReservedQualifier[];
+    constructor(sql: string, qualifiers: ReservedQualifier[]);
+}
+type GuardWordsOption = {
+    /**
+     * The words to report, instead of the default list of the database (`POSTGRES_RESERVED_KEY_WORDS`,
+     * `COCKROACHDB_RESERVED_KEY_WORDS` on CockroachDB). Spread a default list to extend it.
+     */
+    words?: readonly string[];
+};
+export type ReservedQualifierGuardOptions = GuardWordsOption & ({
+    /** `'throw'` (the default): the query rejects with a `ReservedQualifierError` before it runs. */
+    mode?: 'throw';
+} | {
+    /** `'warn'`: the query runs, and the error is passed to `onViolation`. */
+    mode: 'warn';
+    /** Reports the error the query would throw in `'throw'` mode; `console.warn` by default. */
+    onViolation?: (violation: ReservedQualifierError) => void;
+});
+/**
+ * Checks the SQL of every query builder on PostgreSQL and CockroachDB for a reserved word used as a qualifier
+ * without quotes, such as `order."userId"` or `user.id` (`findBareReservedQualifiers`), before the query runs.
+ * TypeORM quotes the aliases it writes, so such a word comes from SQL written by hand, which PostgreSQL rejects.
+ *
+ * Off by default. A second call replaces the options. Other databases aren't checked.
+ */
+export declare function enableReservedQualifierGuard(options?: ReservedQualifierGuardOptions): void;
+/** Turns the check of `enableReservedQualifierGuard` off. */
+export declare function disableReservedQualifierGuard(): void;
+export {};