typeorm-extensions 1.3.1 → 1.3.4

package/README.md

@@ -42,8 +42,8 @@ const query = myDataSource
     name: user.name,
     email: user.email,
   ]))
-  .whereTyped(user => user.name, 'ILIKE', { search: 'John' })
-  .andWhereTyped(user => user.metadata, ` ->> 'jsonField' =`, { value: 'some-value' })
+  .whereTyped(user => user.name, 'ILIKE', 'John')
+  .andWhereTyped(user => user.metadata, ` ->> 'jsonField' =`, 'some-value')
   // Order by type-safe own and relation properties
   .orderByTyped(user => user.images.url, 'ASC', 'NULLS LAST')
   // Use pagination as simple as that

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

@@ -1,2 +1,8 @@
-import './declarations/get-many-with-totals.declaration';
 import './pagination.extension';
+import { PaginationFilter } from '../types/interfaces/pagination.interface';
+import type { GetManyWithTotalsOptions, ListWithTotals } from '../types/extensions';
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity> {
+        getManyWithTotals(paginationFilter: PaginationFilter, options?: GetManyWithTotalsOptions): Promise<ListWithTotals<Entity>>;
+    }
+}

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

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("./declarations/get-many-with-totals.declaration");
+require("./pagination.extension");
 const SelectQueryBuilder_1 = require("typeorm/query-builder/SelectQueryBuilder");
 const pagination_utils_1 = require("../utils/pagination.utils");
-require("./pagination.extension");
 const prototype_utils_1 = require("../utils/prototype.utils");
 // patching
 const extension = {
@@ -20,13 +19,10 @@ async function getManyWithTotals(builder, paginationFilter, options) {
     const { limit, offset } = loadAll
         ? { limit: null, offset: null }
         : (0, pagination_utils_1.getLimitAndOffset)(paginationFilter);
-    const requests = [];
+    const requests = [null, []];
     if (!disableTotalsCalculation) {
         requests[0] = await builder.getCount();
     }
-    else {
-        requests[0] = null;
-    }
     if (loadAll) {
         requests[1] = await builder.getMany();
     }

package/dist/extensions/order.extension.d.ts

@@ -1 +1,8 @@
-import './declarations/order.declaration';
+import type { OrderParam, OrderFilter } from '../types/interfaces/ordering.interface';
+import type { ApplyOrderOptions } from '../types/extensions/order.types';
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity> {
+        applyOrder<OrderEntity>(orderBy: OrderParam<OrderEntity>, options?: ApplyOrderOptions): SelectQueryBuilder<Entity>;
+        applyOrderFilter<OrderEntity>(orderFilter: OrderFilter<OrderEntity>, options?: ApplyOrderOptions): SelectQueryBuilder<Entity>;
+    }
+}

package/dist/extensions/order.extension.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable @typescript-eslint/no-explicit-any */
-require("./declarations/order.declaration");
 const SelectQueryBuilder_1 = require("typeorm/query-builder/SelectQueryBuilder");
 const constants_1 = require("../constants");
 const common_utils_1 = require("../utils/common.utils");
@@ -31,18 +30,23 @@ const alwaysAliasWhiteList = [
 ];
 function getOrderOption(orderBy, defaultAlias, options) {
     const { useDoubleQuotes = constants_1.defaultUseDoubleQuotes, alias: customAlias, alwaysAliasFields = alwaysAliasWhiteList, } = options !== null && options !== void 0 ? options : {};
-    const { field, direction = constants_1.defaultOrderDirection, nulls: nullsOrder = constants_1.defaultNullsOrder, } = orderBy;
-    const alias = customAlias !== null && customAlias !== void 0 ? customAlias : (alwaysAliasFields.includes(field) ? defaultAlias : undefined);
+    const { field, direction, isReversed, nulls: nullsOrder, tableAlias: otherTableAlias, } = orderBy;
+    const alias = otherTableAlias || customAlias ||
+        (alwaysAliasFields.includes(field) ? defaultAlias : undefined);
     const identifier = new identifier_utils_1.Identifier(field, alias, useDoubleQuotes);
     const selector = identifier.fieldIdentifier();
-    const order = typeof direction === 'number'
-        ? direction === -1
-            ? 'DESC'
-            : 'ASC'
-        : direction.toUpperCase();
-    const nulls = nullsOrder && /first|last/i.test(nullsOrder)
+    const order = typeof isReversed === 'boolean' && (0, common_utils_1.isNil)(direction)
+        ? (isReversed ? 'DESC' : 'ASC')
+        : typeof direction === 'boolean'
+            ? (direction ? 'ASC' : 'DESC')
+            : typeof direction === 'number'
+                ? (direction === -1 ? 'DESC' : 'ASC')
+                : typeof direction === 'string' && /asc|desc/i.test(direction)
+                    ? direction.toUpperCase()
+                    : constants_1.defaultOrderDirection;
+    const nulls = typeof nullsOrder === 'string' && /first|last/i.test(nullsOrder)
         ? `NULLS ${nullsOrder.toUpperCase()}`
-        : undefined;
+        : constants_1.defaultNullsOrder;
     return {
         selector,
         order,

package/dist/extensions/pagination.extension.d.ts

@@ -1 +1,8 @@
-import './declarations/pagination.declaration';
+import { PaginationFilter } from '../types/interfaces/pagination.interface';
+import { ObjectLiteral } from 'typeorm';
+import { ApplyPaginationOptions } from '../types/extensions/pagination.types';
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> {
+        applyPaginationFilter(paginationFilter: PaginationFilter, options?: ApplyPaginationOptions): SelectQueryBuilder<Entity>;
+    }
+}

package/dist/extensions/pagination.extension.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable @typescript-eslint/no-explicit-any */
-require("./declarations/pagination.declaration");
 const SelectQueryBuilder_1 = require("typeorm/query-builder/SelectQueryBuilder");
 const constants_1 = require("../constants");
 const pagination_utils_1 = require("../utils/pagination.utils");

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

@@ -1 +1,14 @@
-import '../../declarations/typed/typed-distinct.declaration';
+import { ObjectLiteral } from 'typeorm';
+import { KeyProxyCallback } from '../../../types/modules/proxy-callback.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>;
+        /**
+         * Sets the distinct on clause for Postgres.
+         */
+        distinctOnTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, distinctOn: KeyProxyCallback<Type>): SelectQueryBuilder<Entity>;
+    }
+}

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("../../declarations/typed/typed-distinct.declaration");
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
 // patching and implementation

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

@@ -1 +1,10 @@
-import '../../declarations/typed/typed-joins.declaration';
+import { ObjectLiteral } from 'typeorm';
+import { RelationalKeyProxyCallback } from '../../../types/modules/proxy-callback.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>;
+    }
+}

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("../../declarations/typed/typed-joins.declaration");
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
 // patching
@@ -29,6 +28,6 @@ typeorm_1.SelectQueryBuilder.prototype.innerJoinAndSelectTyped = function (selec
     return this;
 };
 function addJoin(query, method, selection, alias, condition, parameters) {
-    const key = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(selection, query.alias);
+    const key = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(selection, query.alias, false);
     return query[method](key, alias, condition, parameters);
 }

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

@@ -1 +1,17 @@
-import '../../declarations/typed/typed-order-by.declaration';
+import { ObjectLiteral } from 'typeorm';
+import { ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import { KeyHolder } from '../../../utils/proxy-key.utils';
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> {
+        /**
+         * 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.
+         */
+        orderByTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: (proxy: Type) => ProxyColumnValueType | KeyHolder, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST'): SelectQueryBuilder<Entity>;
+        /**
+         * Adds ORDER BY condition in the query builder.
+         */
+        addOrderByTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: (proxy: Type) => ProxyColumnValueType | KeyHolder, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST'): SelectQueryBuilder<Entity>;
+    }
+}

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("../../declarations/typed/typed-order-by.declaration");
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
 // patching and implementation
@@ -14,12 +13,12 @@ typeorm_1.SelectQueryBuilder.prototype.orderByTyped = function (selection, order
     }
     return this;
 };
-typeorm_1.SelectQueryBuilder.prototype.addOrderByTyped = function (selection, order, nulls) {
+typeorm_1.SelectQueryBuilder.prototype.addOrderByTyped = function (selection, order, nulls, useDoubleQuotes) {
     if (selection instanceof proxy_key_utils_1.KeyHolder) {
         return this.addOrderBy(selection.toSql(), order, nulls);
     }
     if (typeof selection === 'function') {
-        const key = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(selection, this.alias);
+        const key = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(selection, this.alias, useDoubleQuotes);
         return this.addOrderBy(key, order, nulls);
     }
     return this;

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

@@ -1 +1,34 @@
-import '../../declarations/typed/typed-select.declaration';
+import { ObjectLiteral } from 'typeorm';
+import { KeyProxyCallback } from '../../../types/modules/proxy-callback.types';
+import { KeyHolder } from '../../../utils/proxy-key.utils';
+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, useDoubleQuotes?: boolean): SelectQueryBuilder<Entity>;
+        /**
+         * Creates SELECT query and selects given data.
+         * Replaces all previous selections if they exist.
+         */
+        selectTyped(this: SelectQueryBuilder<Entity>, selection: string | KeyHolder, selectionAliasName?: string, useDoubleQuotes?: boolean): SelectQueryBuilder<Entity>;
+        /**
+         * 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>>, useDoubleQuotes?: boolean): SelectQueryBuilder<Entity>;
+        /**
+         * Adds new selection to the SELECT query.
+         */
+        addSelectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useDoubleQuotes?: boolean): SelectQueryBuilder<Entity>;
+        /**
+         * Adds new selection to the SELECT query.
+         */
+        addSelectTyped(this: SelectQueryBuilder<Entity>, selection: string | KeyHolder, selectionAliasName?: string, useDoubleQuotes?: boolean): SelectQueryBuilder<Entity>;
+        /**
+         * Adds new selection to the SELECT query.
+         */
+        addSelectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useDoubleQuotes?: boolean): SelectQueryBuilder<Entity>;
+    }
+}

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

@@ -1,32 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("../../declarations/typed/typed-select.declaration");
 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 extension = {
     prototype: {
-        selectTyped(selection, selectionAliasName) {
-            return attachSelectMethod(this, 'select', selection, selectionAliasName);
+        selectTyped(selection, selectionAliasName, useDoubleQuotes) {
+            return attachSelectMethod(this, 'select', selection, typeof selectionAliasName === 'string' ? selectionAliasName : undefined, typeof selectionAliasName === 'boolean'
+                ? selectionAliasName
+                : useDoubleQuotes);
         },
-        addSelectTyped(selection, selectionAliasName) {
-            return attachSelectMethod(this, 'addSelect', selection, selectionAliasName);
+        addSelectTyped(selection, selectionAliasName, useDoubleQuotes) {
+            return attachSelectMethod(this, 'addSelect', selection, typeof selectionAliasName === 'string' ? selectionAliasName : undefined, typeof selectionAliasName === 'boolean'
+                ? selectionAliasName
+                : useDoubleQuotes);
         },
     },
 };
 (0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
 // implementation
-const attachSelectMethod = (query, method, selection, selectionAliasName) => {
+const attachSelectMethod = (query, method, selection, selectionAliasName, useDoubleQuotes) => {
     if (selection instanceof proxy_key_utils_1.KeyHolder) {
-        return query[method](selection.toSql(), selectionAliasName);
+        return query[method](selection.toSql(undefined, useDoubleQuotes), selectionAliasName);
     }
     if (Array.isArray(selection)) {
-        const arrayOfKeys = selection.map((select) => (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(select, query.alias));
+        const arrayOfKeys = selection.map((select) => (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(select, query.alias, useDoubleQuotes));
         return query[method](arrayOfKeys);
     }
     else if (typeof selection === 'function') {
-        const keyArrayOrSingleKey = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(selection, query.alias);
+        const keyArrayOrSingleKey = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(selection, query.alias, useDoubleQuotes);
         if (Array.isArray(keyArrayOrSingleKey)) {
             return query[method](keyArrayOrSingleKey);
         }

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

@@ -1,2 +1,133 @@
-import '../../declarations/typed/typed-where-is-in.declaration';
 import '../../where-is-in.extension';
+import { ObjectLiteral } from 'typeorm';
+import { ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import { ArgsType } from '../../../types/util-types';
+import { TypedWhereIsInOptions } from '../../../types/extensions/typed-where.types';
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder {
+        /**
+         * Sets WHERE IN condition in the query builder.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         */
+        whereIsInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new AND WHERE IN condition in the query builder.
+         */
+        andWhereIsInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new OR WHERE IN condition in the query builder.
+         */
+        orWhereIsInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): 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.
+         */
+        whereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new AND WHERE NOT IN condition in the query builder.
+         */
+        andWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new OR WHERE NOT IN condition in the query builder.
+         */
+        orWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<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.
+         */
+        whereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new AND WHERE IN condition in the query builder.
+         */
+        andWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new OR WHERE IN condition in the query builder.
+         */
+        orWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): 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.
+         */
+        whereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new AND WHERE NOT IN condition in the query builder.
+         */
+        andWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new OR WHERE NOT IN condition in the query builder.
+         */
+        orWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<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.
+         */
+        whereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new AND WHERE IN condition in the query builder.
+         */
+        andWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new OR WHERE IN condition in the query builder.
+         */
+        orWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): 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.
+         */
+        whereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new AND WHERE NOT IN condition in the query builder.
+         */
+        andWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new OR WHERE NOT IN condition in the query builder.
+         */
+        orWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<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.
+         */
+        whereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new AND WHERE IN condition in the query builder.
+         */
+        andWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new OR WHERE IN condition in the query builder.
+         */
+        orWhereIsInTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): 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.
+         */
+        whereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new AND WHERE NOT IN condition in the query builder.
+         */
+        andWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+        /**
+         * Adds new OR WHERE NOT IN condition in the query builder.
+         */
+        orWhereIsNotInTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, array?: ArgsType, options?: TypedWhereIsInOptions): this;
+    }
+}

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("../../declarations/typed/typed-where-is-in.declaration");
 require("../../where-is-in.extension");
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");

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

@@ -1 +1,87 @@
-import '../../declarations/typed/typed-where.declaration';
+import { ObjectLiteral } from 'typeorm';
+import { ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import { TypedWhereOptions } from '../../../types/extensions/typed-where.types';
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder {
+        /**
+         * Sets WHERE condition in the query builder.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         * Additionally you can add parameters used in where expression.
+         */
+        whereTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, conditions: string, parameters?: unknown, options?: TypedWhereOptions): this;
+        /**
+         * Adds new AND WHERE condition in the query builder.
+         * Additionally you can add parameters used in where expression.
+         */
+        andWhereTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, conditions: string, parameters?: unknown, options?: TypedWhereOptions): this;
+        /**
+         * Adds new OR WHERE condition in the query builder.
+         * Additionally you can add parameters used in where expression.
+         */
+        orWhereTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, conditions: string, parameters?: unknown, options?: TypedWhereOptions): this;
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity> {
+        /**
+         * Sets WHERE condition in the query builder.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         * Additionally you can add parameters used in where expression.
+         */
+        whereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, conditions: string, parameters?: unknown, options?: TypedWhereOptions): this;
+        /**
+         * Adds new AND WHERE condition in the query builder.
+         * Additionally you can add parameters used in where expression.
+         */
+        andWhereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, conditions: string, parameters?: unknown, options?: TypedWhereOptions): this;
+        /**
+         * Adds new OR WHERE condition in the query builder.
+         * Additionally you can add parameters used in where expression.
+         */
+        orWhereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, conditions: string, parameters?: unknown, options?: TypedWhereOptions): this;
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<Entity> {
+        /**
+         * Sets WHERE condition in the query builder.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         * Additionally you can add parameters used in where expression.
+         */
+        whereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, conditions: string, parameters?: unknown, options?: TypedWhereOptions): this;
+        /**
+         * Adds new AND WHERE condition in the query builder.
+         * Additionally you can add parameters used in where expression.
+         */
+        andWhereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, conditions: string, parameters?: unknown, options?: TypedWhereOptions): this;
+        /**
+         * Adds new OR WHERE condition in the query builder.
+         * Additionally you can add parameters used in where expression.
+         */
+        orWhereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, conditions: string, parameters?: unknown, options?: TypedWhereOptions): this;
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<Entity> {
+        /**
+         * Sets WHERE condition in the query builder.
+         * If you had previously WHERE expression defined,
+         * calling this function will override previously set WHERE conditions.
+         * Additionally you can add parameters used in where expression.
+         */
+        whereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, conditions: string, parameters?: unknown, options?: TypedWhereOptions): this;
+        /**
+         * Adds new AND WHERE condition in the query builder.
+         * Additionally you can add parameters used in where expression.
+         */
+        andWhereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, conditions: string, parameters?: unknown, options?: TypedWhereOptions): this;
+        /**
+         * Adds new OR WHERE condition in the query builder.
+         * Additionally you can add parameters used in where expression.
+         */
+        orWhereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, conditions: string, parameters?: unknown, options?: TypedWhereOptions): this;
+    }
+}

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("../../declarations/typed/typed-where.declaration");
 const typeorm_1 = require("typeorm");
 const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");

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

@@ -1 +1,130 @@
-import './declarations/where-is-in.daclaration';
+import { ObjectLiteral } from 'typeorm';
+import { ArgsType } from '../types/util-types';
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder {
+        /**
+         * 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): this;
+        /**
+         * Adds new AND WHERE IN condition in the query builder.
+         */
+        andWhereIsIn(field: string, array?: ArgsType): this;
+        /**
+         * Adds new OR WHERE IN condition in the query builder.
+         */
+        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): this;
+        /**
+         * Adds new AND WHERE NOT IN condition in the query builder.
+         */
+        andWhereIsNotIn(field: string, array?: ArgsType): this;
+        /**
+         * Adds new OR WHERE NOT IN condition in the query builder.
+         */
+        orWhereIsNotIn(field: string, array?: ArgsType): this;
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<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): SelectQueryBuilder<Entity>;
+        /**
+         * Adds new AND WHERE IN condition in the query builder.
+         */
+        andWhereIsIn(field: string, array?: ArgsType): SelectQueryBuilder<Entity>;
+        /**
+         * Adds new OR WHERE IN condition in the query builder.
+         */
+        orWhereIsIn(field: string, array?: ArgsType): SelectQueryBuilder<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): SelectQueryBuilder<Entity>;
+        /**
+         * Adds new AND WHERE NOT IN condition in the query builder.
+         */
+        andWhereIsNotIn(field: string, array?: ArgsType): SelectQueryBuilder<Entity>;
+        /**
+         * Adds new OR WHERE NOT IN condition in the query builder.
+         */
+        orWhereIsNotIn(field: string, array?: ArgsType): SelectQueryBuilder<Entity>;
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<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): UpdateQueryBuilder<Entity>;
+        /**
+         * Adds new AND WHERE IN condition in the query builder.
+         */
+        andWhereIsIn(field: string, array?: ArgsType): UpdateQueryBuilder<Entity>;
+        /**
+         * Adds new OR WHERE IN condition in the query builder.
+         */
+        orWhereIsIn(field: string, array?: ArgsType): UpdateQueryBuilder<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): UpdateQueryBuilder<Entity>;
+        /**
+         * Adds new AND WHERE NOT IN condition in the query builder.
+         */
+        andWhereIsNotIn(field: string, array?: ArgsType): UpdateQueryBuilder<Entity>;
+        /**
+         * Adds new OR WHERE NOT IN condition in the query builder.
+         */
+        orWhereIsNotIn(field: string, array?: ArgsType): UpdateQueryBuilder<Entity>;
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<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): DeleteQueryBuilder<Entity>;
+        /**
+         * Adds new AND WHERE IN condition in the query builder.
+         */
+        andWhereIsIn(field: string, array?: ArgsType): DeleteQueryBuilder<Entity>;
+        /**
+         * Adds new OR WHERE IN condition in the query builder.
+         */
+        orWhereIsIn(field: string, array?: ArgsType): DeleteQueryBuilder<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): DeleteQueryBuilder<Entity>;
+        /**
+         * Adds new AND WHERE NOT IN condition in the query builder.
+         */
+        andWhereIsNotIn(field: string, array?: ArgsType): DeleteQueryBuilder<Entity>;
+        /**
+         * Adds new OR WHERE NOT IN condition in the query builder.
+         */
+        orWhereIsNotIn(field: string, array?: ArgsType): DeleteQueryBuilder<Entity>;
+    }
+}

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("./declarations/where-is-in.daclaration");
 const typeorm_1 = require("typeorm");
 const prototype_utils_1 = require("../utils/prototype.utils");
 const where_utils_1 = require("../utils/where.utils");

package/dist/types/interfaces/ordering.interface.d.ts

@@ -1,14 +1,19 @@
 import { NonFunctionPropertyNames } from "../util-types";
-export type OrderDirection = 'asc' | 'desc' | 'ASC' | 'DESC' | 1 | -1;
+export type OrderDirection = 'asc' | 'desc' | 'ASC' | 'DESC' | 1 | -1 | true | false;
 export type NullsOrder = 'first' | 'last' | 'FIRST' | 'LAST';
 export type OrderParam<Entity> = {
-    field: NonFunctionPropertyNames<Required<Entity>> | string;
+    field: NonFunctionPropertyNames<Required<Entity>>;
+    /** -1 = DESC, false = DESC */
     direction?: OrderDirection;
     nulls?: NullsOrder;
+    /** true = DESC, false = ASC */
+    isReversed?: boolean;
+    /** order by related table */
+    tableAlias?: string;
 };
 export type OrderType = {
     selector: string;
-    order: 'ASC' | 'DESC';
+    order?: 'ASC' | 'DESC';
     nulls?: 'NULLS FIRST' | 'NULLS LAST';
 };
 export interface OrderFilter<Entity> {

package/dist/utils/prototype.utils.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.patchPrototype = void 0;
 function patchPrototype(target, source) {
-    for (const method in Object.keys(source.prototype)) {
+    for (const method of Object.keys(source.prototype)) {
         target.prototype[method] = source.prototype[method];
     }
 }

package/dist/utils/proxy-key.utils.d.ts

@@ -3,7 +3,7 @@ import { KeyProxyCallback } from '../types/modules/proxy-callback.types';
 export declare class KeyHolder {
     private _keys;
     constructor(_keys?: string[]);
-    toSql(length?: number, addDobleQuotes?: boolean): string;
+    toSql(length?: number, useDoubleQuotes?: boolean): string;
     toString(length?: number): string;
     valueOf(): string;
     [Symbol.toPrimitive](): string;
@@ -21,4 +21,4 @@ export declare class KeyProxy {
 }
 export declare const getKeyHolder: <Type extends ObjectLiteral>(callback: KeyHolder | KeyProxyCallback<Type>) => KeyHolder | Array<KeyHolder>;
 export declare const getKey: <Type extends ObjectLiteral>(callback: string | KeyHolder | KeyProxyCallback<Type>) => string;
-export declare const getSqlKeyFromProxyCallback: <Type extends ObjectLiteral>(callback: string | KeyHolder | KeyProxyCallback<Type>, addPrefix?: string, addDobleQuotes?: boolean) => string | string[];
+export declare const getSqlKeyFromProxyCallback: <Type extends ObjectLiteral>(callback: string | KeyHolder | KeyProxyCallback<Type>, addPrefix?: string, useDoubleQuotes?: boolean) => string | string[];

package/dist/utils/proxy-key.utils.js

@@ -7,9 +7,9 @@ class KeyHolder {
         this._keys = _keys;
         this._keys = [..._keys];
     }
-    toSql(length = 2, addDobleQuotes = true) {
+    toSql(length = 2, useDoubleQuotes) {
         const string = this.toString(length);
-        const sql = addDobleQuotes ? (0, sql_utils_1.stringToSQLIdentifier)(string) : string;
+        const sql = useDoubleQuotes ? (0, sql_utils_1.stringToSQLIdentifier)(string) : string;
         return sql;
     }
     toString(length = 2) {
@@ -86,7 +86,7 @@ const getKey = (callback) => {
     return keyHolder.toString();
 };
 exports.getKey = getKey;
-const getSqlKeyFromProxyCallback = (callback, addPrefix, addDobleQuotes = true) => {
+const getSqlKeyFromProxyCallback = (callback, addPrefix, useDoubleQuotes) => {
     if (typeof callback === 'string')
         return callback;
     const keyHolder = (0, exports.getKeyHolder)(callback);
@@ -96,14 +96,14 @@ const getSqlKeyFromProxyCallback = (callback, addPrefix, addDobleQuotes = true)
     // if select is like this: (proxy) => proxy.relation.column
     if (keyHolder.getKeys().length > 1) {
         // return unchanged
-        return keyHolder.toSql(undefined, addDobleQuotes);
+        return keyHolder.toSql(undefined, useDoubleQuotes);
     }
     // else if select is one layer depth like this: (proxy) => proxy.column
     // then add alias before the key
     if (typeof addPrefix === 'string' && addPrefix.length >= 1) {
         keyHolder.unshift(addPrefix);
     }
-    return keyHolder.toSql(undefined, addDobleQuotes);
+    return keyHolder.toSql(undefined, useDoubleQuotes);
 };
 exports.getSqlKeyFromProxyCallback = getSqlKeyFromProxyCallback;
 // example of typed select

package/dist/utils/where.utils.js

@@ -17,8 +17,14 @@ function attachWhere(builder, method, field, conditions, value, options) {
     if (method && typeof field === 'string' && typeof conditions === 'string') {
         field = (0, sql_utils_1.stringToSQLIdentifier)(field);
         if (addValue) {
-            const firstValue = value !== null && typeof value === 'object' ? Object.values(value)[0] : value;
-            const valueIsValid = firstValue !== undefined;
+            // is object (not primitive, null or array)
+            const firstValue = value !== null && typeof value === 'object' && !Array.isArray(value)
+                ? Object.values(value)[0]
+                : value;
+            // 0, false, '' are valid values like any other
+            // null is a valid value, but undefined and NaN are not
+            const valueIsValid = firstValue !== undefined &&
+                (typeof firstValue === 'number' ? !isNaN(firstValue) : true);
             const paramName = valueIsValid
                 ? (0, sql_utils_1.createUniqueParameterName)(method)
                 : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typeorm-extensions",
-  "version": "1.3.1",
+  "version": "1.3.4",
   "description": "typeorm commonly used extensions",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,8 +13,7 @@
   },
   "scripts": {
     "build": "tsc -p .",
-    "lint": "eslint . --ext .ts",
-    "test-nest-build": "cd test/nest_v11 && npm install && npm run build"
+    "lint": "eslint . --ext .ts"
   },
   "keywords": [
     "typeorm",
@@ -25,13 +24,14 @@
   ],
   "author": "koenigstag",
   "license": "ISC",
-  "dependencies": {
-    "typeorm": "^0.3.20"
+  "peerDependencies": {
+    "typeorm": "^0.3.12"
   },
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "^7.1.1",
     "@typescript-eslint/parser": "^7.1.1",
     "eslint": "^8.57.0",
+    "typeorm": "^0.3.12",
     "typescript": "5.3"
   }
 }