typeorm-extensions 1.2.6 → 1.3.1

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

@@ -1,33 +1,49 @@
 "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 queryBuilders = [
-    typeorm_1.SelectQueryBuilder,
-    typeorm_1.UpdateQueryBuilder,
-    typeorm_1.DeleteQueryBuilder,
-];
+const prototype_utils_1 = require("../../../utils/prototype.utils");
+const where_utils_1 = require("../../../utils/where.utils");
+// patching
 const extension = {
     prototype: {
-        whereTyped: function (where, conditions, parameters, options) {
-            return attachWhere(this, 'where', where, conditions, parameters, options);
+        whereTyped: function (where, operator, parameters, options) {
+            return attachTypedWhere(this, 'where', where, operator, parameters, options);
         },
-        andWhereTyped: function (where, conditions, parameters, options) {
-            return attachWhere(this, 'andWhere', where, conditions, parameters, options);
+        andWhereTyped: function (where, operator, parameters, options) {
+            return attachTypedWhere(this, 'andWhere', where, operator, parameters, options);
         },
-        orWhereTyped: function (where, conditions, parameters, options) {
-            return attachWhere(this, 'orWhere', where, conditions, parameters, options);
+        orWhereTyped: function (where, operator, parameters, options) {
+            return attachTypedWhere(this, 'orWhere', where, operator, parameters, options);
         },
     },
 };
+const queryBuilders = [
+    typeorm_1.SelectQueryBuilder,
+    typeorm_1.UpdateQueryBuilder,
+    typeorm_1.DeleteQueryBuilder,
+];
 queryBuilders.forEach((builder) => {
-    Object.assign(builder, extension);
+    (0, prototype_utils_1.patchPrototype)(builder, extension);
 });
-function attachWhere(builder, method, where, conditions, parameters, options) {
+// implementation
+function attachTypedWhere(builder, method, where, conditions, parameters, options) {
+    const { useDoubleQuotes, addValue = true } = options || {};
     if (typeof where === 'function') {
-        const key = (0, proxy_key_utils_1.getSqlKey)(where, builder.alias, options === null || options === void 0 ? void 0 : options.useDoubleQuotes);
-        // .andWhere(`"table"."column"   IN (:...values)`, { values: ['value'] })
-        return builder[method](`${key} ${conditions}`, parameters);
+        const alias = builder.alias;
+        const key = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(where, alias, useDoubleQuotes);
+        if (Array.isArray(key)) {
+            for (const k of key) {
+                builder = (0, where_utils_1.attachWhere)(builder, method, k, conditions, parameters, {
+                    addValue,
+                });
+            }
+            return builder;
+        }
+        return (0, where_utils_1.attachWhere)(builder, method, key, conditions, parameters, {
+            addValue,
+        });
     }
     return builder;
 }

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

@@ -0,0 +1 @@
+import './declarations/where-is-in.daclaration';

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

@@ -0,0 +1,52 @@
+"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");
+// patching
+const extension = {
+    prototype: {
+        whereIsIn: function (field, array) {
+            return attachWhereIsIn(this, 'where', field, 'IN', array);
+        },
+        andWhereIsIn: function (field, array) {
+            return attachWhereIsIn(this, 'andWhere', field, 'IN', array);
+        },
+        orWhereIsIn: function (field, array) {
+            return attachWhereIsIn(this, 'orWhere', field, 'IN', array);
+        },
+        whereIsNotIn: function (field, array) {
+            return attachWhereIsIn(this, 'where', field, 'NOT IN', array);
+        },
+        andWhereIsNotIn: function (field, array) {
+            return attachWhereIsIn(this, 'andWhere', field, 'NOT IN', array);
+        },
+        orWhereIsNotIn: function (field, array) {
+            return attachWhereIsIn(this, 'orWhere', field, 'NOT IN', array);
+        },
+    },
+};
+const queryBuilders = [
+    typeorm_1.SelectQueryBuilder,
+    typeorm_1.UpdateQueryBuilder,
+    typeorm_1.DeleteQueryBuilder,
+];
+queryBuilders.forEach((builder) => {
+    (0, prototype_utils_1.patchPrototype)(builder, extension);
+});
+// implementation
+function attachWhereIsIn(builder, method, field, operator, array) {
+    if (method && typeof field === 'string' && typeof operator === 'string') {
+        if (!(array === null || array === void 0 ? void 0 : array.length)) {
+            // if the array is empty, we can use a simple condition
+            // IN (empty array) => FALSE
+            // NOT IN (empty array) => TRUE
+            return builder[method](operator === 'IN' ? 'FALSE' : 'TRUE');
+        }
+        return (0, where_utils_1.attachWhere)(builder, method, field, operator, { value: array }, {
+            addValue: true,
+        });
+    }
+    return builder;
+}

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from './extensions';
 export * from './types/interfaces';
+export * from './types/extensions';

package/dist/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./extensions"), exports);
 __exportStar(require("./types/interfaces"), exports);
+__exportStar(require("./types/extensions"), exports);

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

@@ -0,0 +1,10 @@
+export type GetManyWithTotalsOptions = {
+    disableTotalsCalculation?: boolean;
+    loadAll?: boolean;
+};
+export interface ListWithTotals<Entity> {
+    list: Entity[];
+    total: number | null;
+    limit: number | null;
+    offset: number | null;
+}

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

@@ -0,0 +1,4 @@
+export * from './pagination.types';
+export * from './order.types';
+export * from './get-many-with-totals.types';
+export * from './where.types';

package/dist/types/extensions/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./pagination.types"), exports);
+__exportStar(require("./order.types"), exports);
+__exportStar(require("./get-many-with-totals.types"), exports);
+__exportStar(require("./where.types"), exports);

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

@@ -0,0 +1,6 @@
+export type ApplyOrderOptions = {
+    useDoubleQuotes?: boolean;
+    alias?: string;
+    alwaysAliasFields?: string[];
+    resetPreviousOrder?: boolean;
+};

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

@@ -0,0 +1,3 @@
+export type ApplyPaginationOptions = {
+    useTakeAndSkip?: boolean;
+};

package/dist/types/extensions/pagination.types.js

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

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

@@ -0,0 +1,7 @@
+export type TypedWhereOptions = {
+    useDoubleQuotes?: boolean;
+    addValue?: boolean;
+};
+export type TypedWhereIsInOptions = {
+    useDoubleQuotes?: boolean;
+};

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

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

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

@@ -0,0 +1,2 @@
+export type WhereMethods = 'where' | 'andWhere' | 'orWhere';
+export type WhereInMethods = 'whereIsIn' | 'andWhereIsIn' | 'orWhereIsIn' | 'whereIsNotIn' | 'andWhereIsNotIn' | 'orWhereIsNotIn';

package/dist/types/extensions/where.types.js

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

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

@@ -1,5 +1,5 @@
 import { NonFunctionPropertyNames } from "../util-types";
-export type OrderDirection = 'asc' | 'desc' | 'ASC' | 'DESC';
+export type OrderDirection = 'asc' | 'desc' | 'ASC' | 'DESC' | 1 | -1;
 export type NullsOrder = 'first' | 'last' | 'FIRST' | 'LAST';
 export type OrderParam<Entity> = {
     field: NonFunctionPropertyNames<Required<Entity>> | string;

package/dist/types/modules/proxy-callback.types.d.ts

@@ -0,0 +1,7 @@
+import { ObjectLiteral } from "typeorm";
+import { EntityOnlyWithRelations, EntityWithoutRelations } from "./relations.types";
+import { ColumnValueType } from "./column.types";
+export type ProxyColumnValueType = ColumnValueType | ':value';
+export type KeyProxyCallback<T extends ObjectLiteral> = (proxy: T) => ProxyColumnValueType | Array<ProxyColumnValueType>;
+export type RelationalKeyProxyCallback<T extends ObjectLiteral> = (proxy: EntityOnlyWithRelations<T>) => ProxyColumnValueType;
+export type NonRelationalKeyProxyCallback<T extends ObjectLiteral> = (proxy: EntityWithoutRelations<T>) => ProxyColumnValueType;

package/dist/types/modules/proxy-callback.types.js

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

package/dist/types/util-types/index.d.ts

@@ -1,3 +1,4 @@
+export type ArgsType = unknown[];
 export type FunctionPropertyNames<T> = {
     [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
 }[keyof T] & string;

package/dist/types/util-types/index.js

@@ -1,2 +1,3 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/common.utils.d.ts

@@ -1 +1,2 @@
 export declare const isNil: (val: unknown) => boolean;
+export declare function randomString(length?: number): string;

package/dist/utils/common.utils.js

@@ -1,5 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNil = void 0;
+exports.randomString = exports.isNil = void 0;
 const isNil = (val) => typeof val === 'undefined' || val === null;
 exports.isNil = isNil;
+function randomString(length = 21) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        const index = Math.floor(Math.random() * chars.length);
+        result += chars.charAt(index);
+    }
+    return result;
+}
+exports.randomString = randomString;

package/dist/utils/prototype.utils.d.ts

@@ -0,0 +1,5 @@
+export declare function patchPrototype<T extends {
+    prototype: any;
+}, S extends {
+    prototype: any;
+}>(target: T, source: S): void;

package/dist/utils/prototype.utils.js

@@ -0,0 +1,10 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchPrototype = void 0;
+function patchPrototype(target, source) {
+    for (const method in Object.keys(source.prototype)) {
+        target.prototype[method] = source.prototype[method];
+    }
+}
+exports.patchPrototype = patchPrototype;

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

@@ -1,13 +1,15 @@
 import { ObjectLiteral } from 'typeorm';
-import { KeyProxyCallback } from '../types/modules/proxy-types/proxy-callback.types';
+import { KeyProxyCallback } from '../types/modules/proxy-callback.types';
 export declare class KeyHolder {
-    keys: string[];
-    constructor(keys?: string[]);
+    private _keys;
+    constructor(_keys?: string[]);
     toSql(length?: number, addDobleQuotes?: boolean): string;
     toString(length?: number): string;
     valueOf(): string;
     [Symbol.toPrimitive](): string;
-    add(key: string | symbol): this;
+    getKeys(): string[];
+    push(key: string | symbol): this;
+    unshift(key: string | symbol): this;
 }
 export declare class TypedProxy {
     static defaultHandler: {};
@@ -19,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 getSqlKey: <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, addDobleQuotes?: boolean) => string | string[];

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

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSqlKey = exports.getKey = exports.getKeyHolder = exports.KeyProxy = exports.TypedProxy = exports.KeyHolder = void 0;
+exports.getSqlKeyFromProxyCallback = exports.getKey = exports.getKeyHolder = exports.KeyProxy = exports.TypedProxy = exports.KeyHolder = void 0;
 const sql_utils_1 = require("./sql.utils");
 class KeyHolder {
-    constructor(keys = []) {
-        this.keys = keys;
-        this.keys = [...keys];
+    constructor(_keys = []) {
+        this._keys = _keys;
+        this._keys = [..._keys];
     }
     toSql(length = 2, addDobleQuotes = true) {
         const string = this.toString(length);
@@ -13,7 +13,7 @@ class KeyHolder {
         return sql;
     }
     toString(length = 2) {
-        const keys = this.keys.slice(0, length);
+        const keys = this._keys.slice(0, length);
         const string = keys.join('.');
         return string;
     }
@@ -23,11 +23,22 @@ class KeyHolder {
     [Symbol.toPrimitive]() {
         return this.toString();
     }
-    add(key) {
+    getKeys() {
+        return this._keys.slice();
+    }
+    push(key) {
+        if (typeof key !== 'symbol' &&
+            !Object.getOwnPropertyNames(this).includes(key) && // check of getOwnPropertyNames(this) is questionable
+            !Object.getOwnPropertyNames(KeyHolder.prototype).includes(key)) {
+            this._keys.push(key);
+        }
+        return this;
+    }
+    unshift(key) {
         if (typeof key !== 'symbol' &&
             !Object.getOwnPropertyNames(this).includes(key) && // check of getOwnPropertyNames(this) is questionable
             !Object.getOwnPropertyNames(KeyHolder.prototype).includes(key)) {
-            this.keys.push(key);
+            this._keys.unshift(key);
         }
         return this;
     }
@@ -53,8 +64,8 @@ KeyProxy.defaultHandler = {
             return value;
         }
         // for each key create new independent layer of KeyProxy
-        const newKeyHolder = new KeyHolder(target.keys).add(key);
-        const newLayer = TypedProxy.create(newKeyHolder, KeyProxy.defaultHandler);
+        const newKeyHolder = new KeyHolder(target.getKeys());
+        const newLayer = TypedProxy.create(newKeyHolder.push(key), KeyProxy.defaultHandler);
         return newLayer;
     },
 };
@@ -75,26 +86,26 @@ const getKey = (callback) => {
     return keyHolder.toString();
 };
 exports.getKey = getKey;
-const getSqlKey = (callback, addPrefix, addDobleQuotes = true) => {
+const getSqlKeyFromProxyCallback = (callback, addPrefix, addDobleQuotes = true) => {
     if (typeof callback === 'string')
         return callback;
     const keyHolder = (0, exports.getKeyHolder)(callback);
     if (Array.isArray(keyHolder)) {
-        return keyHolder.map((holder) => (0, exports.getSqlKey)(holder, addPrefix));
+        return keyHolder.map((holder) => (0, exports.getSqlKeyFromProxyCallback)(holder, addPrefix));
     }
     // if select is like this: (proxy) => proxy.relation.column
-    if (keyHolder.keys.length > 1) {
+    if (keyHolder.getKeys().length > 1) {
         // return unchanged
         return keyHolder.toSql(undefined, addDobleQuotes);
     }
     // 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.keys.unshift(addPrefix);
+        keyHolder.unshift(addPrefix);
     }
     return keyHolder.toSql(undefined, addDobleQuotes);
 };
-exports.getSqlKey = getSqlKey;
+exports.getSqlKeyFromProxyCallback = getSqlKeyFromProxyCallback;
 // example of typed select
 // const key = getSqlKey<UserEntity>((proxy) => proxy.sessions);
 // console.log(key);

package/dist/utils/sql.utils.d.ts

@@ -3,3 +3,4 @@ export declare const wrapWithDoubleQoutes: (str: string) => string;
 export declare const wrapWithBackQoutes: (str: string) => string;
 export declare const stringToSQLIdentifier: (str: string, driver?: DatabaseType) => string;
 export declare const stringToSQLValue: (str: string) => string;
+export declare const createUniqueParameterName: (prefix?: string) => string;

package/dist/utils/sql.utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringToSQLValue = exports.stringToSQLIdentifier = exports.wrapWithBackQoutes = exports.wrapWithDoubleQoutes = void 0;
+exports.createUniqueParameterName = exports.stringToSQLValue = exports.stringToSQLIdentifier = exports.wrapWithBackQoutes = exports.wrapWithDoubleQoutes = void 0;
+const common_utils_1 = require("./common.utils");
 const wrapWithDoubleQoutes = (str) => str.includes('"') ? str : `"${str}"`;
 exports.wrapWithDoubleQoutes = wrapWithDoubleQoutes;
 const wrapWithBackQoutes = (str) => str.includes('`') ? str : '`' + str + '`';
@@ -16,3 +17,8 @@ const stringToSQLIdentifier = (str, driver) => str.includes('.')
 exports.stringToSQLIdentifier = stringToSQLIdentifier;
 const stringToSQLValue = (str) => `'${str}'`;
 exports.stringToSQLValue = stringToSQLValue;
+const createUniqueParameterName = (prefix) => {
+    const uniqueCode = (0, common_utils_1.randomString)(5);
+    return `${prefix || 'param'}_${uniqueCode}`;
+};
+exports.createUniqueParameterName = createUniqueParameterName;

package/dist/utils/where.utils.d.ts

@@ -0,0 +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?: {
+    addValue?: boolean;
+}): QB;

package/dist/utils/where.utils.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachWhere = exports.getValuePlaceholder = void 0;
+const sql_utils_1 = require("./sql.utils");
+function getValuePlaceholder(value, paramName) {
+    if (value === undefined || value === null || paramName === undefined) {
+        return 'NULL';
+    }
+    if (Array.isArray(value)) {
+        return `(:...${paramName})`;
+    }
+    return `:${paramName}`;
+}
+exports.getValuePlaceholder = getValuePlaceholder;
+function attachWhere(builder, method, field, conditions, value, 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 paramName = valueIsValid
+                ? (0, sql_utils_1.createUniqueParameterName)(method)
+                : undefined;
+            const params = paramName && valueIsValid ? { [paramName]: firstValue } : undefined;
+            const valuePlaceholder = getValuePlaceholder(firstValue, paramName);
+            return builder[method](`${field} ${conditions} ${valuePlaceholder}`, params);
+        }
+        else {
+            return builder[method](`${field} ${conditions}`, value);
+        }
+    }
+    return builder;
+}
+exports.attachWhere = attachWhere;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "typeorm-extensions",
-  "version": "1.2.6",
+  "version": "1.3.1",
   "description": "typeorm commonly used extensions",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",
   "files": ["dist", "LICENSE", "README.md", "package.json"],
-  "type": "module",
+  "type": "commonjs",
   "homepage": "https://koenigstag.github.io/typeorm-extensions/",
   "repository": {
     "type": "git",
@@ -14,7 +14,7 @@
   "scripts": {
     "build": "tsc -p .",
     "lint": "eslint . --ext .ts",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test-nest-build": "cd test/nest_v11 && npm install && npm run build"
   },
   "keywords": [
     "typeorm",

package/dist/extensions/ordering.extension.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOrderOption = void 0;
-const SelectQueryBuilder_1 = require("typeorm/query-builder/SelectQueryBuilder");
-const constants_1 = require("../constants");
-const common_utils_1 = require("../utils/common.utils");
-const identifier_utils_1 = require("../utils/identifier.utils");
-const alwaysAliasWhiteList = [
-    'id',
-    'createdAt',
-    'created_at',
-    'updatedAt',
-    'updated_at',
-    'deletedAt',
-    'deleted_at',
-];
-SelectQueryBuilder_1.SelectQueryBuilder.prototype.applyOrder = function (orderBy, options) {
-    const { resetPreviousOrder = false } = options !== null && options !== void 0 ? options : {};
-    const orderOption = (0, exports.getOrderOption)(orderBy, this.alias, options);
-    const query = resetPreviousOrder ? this.orderBy() : this;
-    return query.addOrderBy(orderOption.selector, orderOption.order, orderOption.nulls);
-};
-SelectQueryBuilder_1.SelectQueryBuilder.prototype.applyOrderFilter = function (orderFilter, options) {
-    if (!(0, common_utils_1.isNil)(orderFilter === null || orderFilter === void 0 ? void 0 : orderFilter.orderBy)) {
-        return orderFilter.orderBy.reduce((acc, order, index) => acc.applyOrder(order, {
-            ...options,
-            resetPreviousOrder: index === 0 ? options === null || options === void 0 ? void 0 : options.resetPreviousOrder : false,
-        }), this);
-    }
-    return this;
-};
-const 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 identifier = new identifier_utils_1.Identifier(field, alias, useDoubleQuotes);
-    const selector = identifier.fieldIdentifier();
-    const order = direction.toUpperCase();
-    const nulls = nullsOrder
-        ? `NULLS ${nullsOrder.toUpperCase()}`
-        : undefined;
-    return {
-        selector,
-        order,
-        nulls,
-    };
-};
-exports.getOrderOption = getOrderOption;

package/dist/extensions/typed/typeorm-querybuilder.types.d.ts

@@ -1,22 +0,0 @@
-import { ObjectLiteral } from 'typeorm';
-import { ColumnValueType, EntityOnlyWithRelations, EntityWithoutRelations } from './typeorm.types';
-export declare class KeyHolder {
-    keys: string[];
-    constructor(keys?: string[]);
-    toSql(length?: number, addDobleQuotes?: boolean): string;
-    toString(length?: number): string;
-    valueOf(): string;
-    [Symbol.toPrimitive](): string;
-    add(key: string | symbol): this;
-}
-export declare class TypedProxy {
-    static defaultHandler: {};
-    static create<T extends ObjectLiteral>(obj: object, handler?: {}): T;
-}
-export declare class KeyProxy {
-    static defaultHandler: ProxyHandler<KeyHolder>;
-    static create<T extends ObjectLiteral>(): T;
-}
-export type KeyProxyCallback<T extends ObjectLiteral> = (proxy: T) => ColumnValueType | Array<ColumnValueType>;
-export type RelationalKeyProxyCallback<T extends ObjectLiteral> = (proxy: EntityOnlyWithRelations<T>) => ColumnValueType;
-export type NonRelationalKeyProxyCallback<T extends ObjectLiteral> = (proxy: EntityWithoutRelations<T>) => ColumnValueType;

package/dist/extensions/typed/typeorm-querybuilder.types.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeyProxy = exports.TypedProxy = exports.KeyHolder = void 0;
-class KeyHolder {
-    constructor(keys = []) {
-        this.keys = keys;
-        this.keys = [...keys];
-    }
-    toSql(length = 2, addDobleQuotes = true) {
-        const string = this.toString(length);
-        const sql = addDobleQuotes ? `"${string.replace(/\./g, '"."')}"` : string;
-        return sql;
-    }
-    toString(length = 2) {
-        const keys = this.keys.slice(0, length);
-        const string = keys.join('.');
-        return string;
-    }
-    valueOf() {
-        return this.toString();
-    }
-    [Symbol.toPrimitive]() {
-        return this.toString();
-    }
-    add(key) {
-        if (typeof key !== 'symbol' &&
-            !Object.getOwnPropertyNames(this).includes(key) && // check of getOwnPropertyNames(this) is questionable
-            !Object.getOwnPropertyNames(KeyHolder.prototype).includes(key)) {
-            this.keys.push(key);
-        }
-        return this;
-    }
-}
-exports.KeyHolder = KeyHolder;
-class TypedProxy {
-    static create(obj, handler = TypedProxy.defaultHandler) {
-        return new Proxy(obj, handler);
-    }
-}
-exports.TypedProxy = TypedProxy;
-TypedProxy.defaultHandler = {};
-class KeyProxy {
-    static create() {
-        return TypedProxy.create(new KeyHolder(), KeyProxy.defaultHandler);
-    }
-}
-exports.KeyProxy = KeyProxy;
-KeyProxy.defaultHandler = {
-    get(target, key, receiver) {
-        var _a;
-        // for each key create new independent layer of KeyProxy
-        const newKeyHolder = new KeyHolder(target.keys).add(key);
-        const newLayer = TypedProxy.create(newKeyHolder, KeyProxy.defaultHandler);
-        return (_a = Reflect.get(target, key, receiver)) !== null && _a !== void 0 ? _a : newLayer;
-    },
-};

package/dist/extensions/typed/typeorm.types.d.ts

@@ -1,17 +0,0 @@
-import { BaseEntity, ObjectLiteral } from 'typeorm';
-export type SimpleColumnType = string | number | boolean | Date | null;
-export type ColumnValueType = SimpleColumnType | undefined | object | ObjectLiteral | ':value';
-export type RelationColumnsType<ColumnType, Key> = ColumnType extends SimpleColumnType | ((...args: any[]) => any) ? never : ColumnType extends BaseEntity | BaseEntity[] | ObjectLiteral | ObjectLiteral[] ? Key : never;
-export type NonRelationColumnsType<ColumnType, Key> = ColumnType extends SimpleColumnType ? Key : never;
-export type RelationPropertyNames<Type> = {
-    [Key in keyof Type]: RelationColumnsType<Type[Key], Key>;
-}[keyof Type] & string;
-export type NonRelationPropertyNames<Type> = {
-    [Key in keyof Type]: NonRelationColumnsType<Type[Key], Key>;
-}[keyof Type] & string;
-export type EntityOnlyWithRelations<Entity extends ObjectLiteral> = {
-    [Key in RelationPropertyNames<Entity>]: Entity[Key];
-};
-export type EntityWithoutRelations<Entity extends ObjectLiteral> = {
-    [Key in NonRelationPropertyNames<Entity>]: Entity[Key];
-};