typeorm-extensions 1.3.2 → 1.3.5

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.js

@@ -19,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.js

@@ -30,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,4 +1,3 @@
-import { SelectQueryBuilder } from 'typeorm';
 import { PaginationFilter } from '../types/interfaces/pagination.interface';
 import { ObjectLiteral } from 'typeorm';
 import { ApplyPaginationOptions } from '../types/extensions/pagination.types';
@@ -7,4 +6,3 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
         applyPaginationFilter(paginationFilter: PaginationFilter, options?: ApplyPaginationOptions): SelectQueryBuilder<Entity>;
     }
 }
-export declare const SelectQB: typeof SelectQueryBuilder;

package/dist/extensions/pagination.extension.js

@@ -1,9 +1,7 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SelectQB = void 0;
 /* eslint-disable @typescript-eslint/no-explicit-any */
-const typeorm_1 = require("typeorm");
+const SelectQueryBuilder_1 = require("typeorm/query-builder/SelectQueryBuilder");
 const constants_1 = require("../constants");
 const pagination_utils_1 = require("../utils/pagination.utils");
 const prototype_utils_1 = require("../utils/prototype.utils");
@@ -15,9 +13,7 @@ const extension = {
         },
     },
 };
-(0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
-console.log('After patching:', ((_a = typeorm_1.SelectQueryBuilder.prototype.applyPaginationFilter) === null || _a === void 0 ? void 0 : _a.name) || 'not patched');
-exports.SelectQB = typeorm_1.SelectQueryBuilder;
+(0, prototype_utils_1.patchPrototype)(SelectQueryBuilder_1.SelectQueryBuilder, extension);
 // implementation
 function applyPaginationFilter(builder, paginationFilter, options) {
     const { useTakeAndSkip = constants_1.defaultUseTakeAndSkip } = options || {};

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

@@ -28,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.js

@@ -13,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

@@ -7,28 +7,28 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
          * Creates SELECT query.
          * Replaces all previous selections if they exist.
          */
-        selectTyped<Type extends ObjectLiteral = Entity>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string): SelectQueryBuilder<Entity>;
+        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): SelectQueryBuilder<Entity>;
+        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>>): SelectQueryBuilder<Entity>;
+        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): SelectQueryBuilder<Entity>;
+        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): SelectQueryBuilder<Entity>;
+        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>>): SelectQueryBuilder<Entity>;
+        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

@@ -6,26 +6,30 @@ 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.extension.d.ts

@@ -9,17 +9,17 @@ declare module 'typeorm/query-builder/WhereExpressionBuilder' {
          * 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?: ObjectLiteral, options?: TypedWhereOptions): this;
+        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?: ObjectLiteral, options?: TypedWhereOptions): this;
+        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?: ObjectLiteral, options?: TypedWhereOptions): this;
+        orWhereTyped<Type extends ObjectLiteral>(subQuery: (proxy: Type) => ProxyColumnValueType, conditions: string, parameters?: unknown, options?: TypedWhereOptions): this;
     }
 }
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
@@ -30,17 +30,17 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
          * 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?: ObjectLiteral, options?: TypedWhereOptions): this;
+        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?: ObjectLiteral, options?: TypedWhereOptions): this;
+        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?: ObjectLiteral, options?: TypedWhereOptions): this;
+        orWhereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, conditions: string, parameters?: unknown, options?: TypedWhereOptions): this;
     }
 }
 declare module 'typeorm/query-builder/UpdateQueryBuilder' {
@@ -51,17 +51,17 @@ declare module 'typeorm/query-builder/UpdateQueryBuilder' {
          * 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?: ObjectLiteral, options?: TypedWhereOptions): this;
+        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?: ObjectLiteral, options?: TypedWhereOptions): this;
+        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?: ObjectLiteral, options?: TypedWhereOptions): this;
+        orWhereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, conditions: string, parameters?: unknown, options?: TypedWhereOptions): this;
     }
 }
 declare module 'typeorm/query-builder/DeleteQueryBuilder' {
@@ -72,16 +72,16 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
          * 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?: ObjectLiteral, options?: TypedWhereOptions): this;
+        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?: ObjectLiteral, options?: TypedWhereOptions): this;
+        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?: ObjectLiteral, options?: TypedWhereOptions): this;
+        orWhereTyped<Type extends ObjectLiteral = Entity>(where: (proxy: Type) => ProxyColumnValueType, conditions: string, parameters?: unknown, options?: TypedWhereOptions): this;
     }
 }

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

@@ -1,6 +1,6 @@
 import type { WhereExpressionBuilder } from 'typeorm';
 import type { WhereMethods } from '../types/extensions/where.types';
 export declare function getValuePlaceholder<T>(value: T, paramName?: string): string;
-export declare function attachWhere<QB extends WhereExpressionBuilder>(builder: QB, method: WhereMethods, field: string, conditions: string, value?: unknown, options?: {
+export declare function attachWhere<QB extends WhereExpressionBuilder>(builder: QB, method: WhereMethods, field: string, conditions: string, params?: unknown, options?: {
     addValue?: boolean;
 }): QB;

package/dist/utils/where.utils.js

@@ -12,22 +12,29 @@ function getValuePlaceholder(value, paramName) {
     return `:${paramName}`;
 }
 exports.getValuePlaceholder = getValuePlaceholder;
-function attachWhere(builder, method, field, conditions, value, options) {
+function attachWhere(builder, method, field, conditions, params, options) {
     const { addValue = true } = 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;
+        const hasParams = typeof params !== 'undefined';
+        if (addValue && hasParams) {
+            // pick first value from params object or pass as is
+            const firstValue = params !== null && typeof params === 'object' && !Array.isArray(params)
+                ? Object.values(params)[0]
+                : params;
+            // 0, false, '' are valid values like any other
+            // null, undefined and NaN are equal to NULL
+            const valueIsValid = firstValue !== undefined &&
+                (typeof firstValue === 'number' ? !isNaN(firstValue) : true);
             const paramName = valueIsValid
                 ? (0, sql_utils_1.createUniqueParameterName)(method)
                 : undefined;
-            const params = paramName && valueIsValid ? { [paramName]: firstValue } : undefined;
+            const queryParams = paramName && valueIsValid ? { [paramName]: firstValue } : undefined;
             const valuePlaceholder = getValuePlaceholder(firstValue, paramName);
-            return builder[method](`${field} ${conditions} ${valuePlaceholder}`, params);
+            return builder[method](`${field} ${conditions} ${valuePlaceholder}`, queryParams);
         }
         else {
-            return builder[method](`${field} ${conditions}`, value);
+            return builder[method](`${field} ${conditions}`, params);
         }
     }
     return builder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typeorm-extensions",
-  "version": "1.3.2",
+  "version": "1.3.5",
   "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",