typeorm-extensions 1.2.3 → 1.2.5

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

@@ -0,0 +1,56 @@
+"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/{src/extensions/typed/typeorm.types.ts → dist/extensions/typed/typeorm.types.d.ts}

@@ -1,30 +1,17 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 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 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;
+    [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;
-
+    [Key in keyof Type]: NonRelationColumnsType<Type[Key], Key>;
+}[keyof Type] & string;
 export type EntityOnlyWithRelations<Entity extends ObjectLiteral> = {
-	[Key in RelationPropertyNames<Entity>]: Entity[Key];
+    [Key in RelationPropertyNames<Entity>]: Entity[Key];
 };
-
 export type EntityWithoutRelations<Entity extends ObjectLiteral> = {
-	[Key in NonRelationPropertyNames<Entity>]: Entity[Key];
+    [Key in NonRelationPropertyNames<Entity>]: Entity[Key];
 };

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

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

package/{src/index.ts → dist/index.d.ts}

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

package/dist/index.js

@@ -0,0 +1,18 @@
+"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("./extensions"), exports);
+__exportStar(require("./types/interfaces"), exports);

package/dist/types/interfaces/index.js

@@ -0,0 +1,18 @@
+"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("./ordering.interface"), exports);
+__exportStar(require("./pagination.interface"), exports);

package/{src/types/interfaces/ordering.interface.ts → dist/types/interfaces/ordering.interface.d.ts}

@@ -1,21 +1,16 @@
 import { NonFunctionPropertyNames } from "../util-types";
-
 export type OrderDirection = 'asc' | 'desc' | 'ASC' | 'DESC';
-
 export type NullsOrder = 'first' | 'last' | 'FIRST' | 'LAST';
-
 export type OrderParam<Entity> = {
-  field: NonFunctionPropertyNames<Required<Entity>> | string;
-  direction?: OrderDirection;
-  nulls?: NullsOrder;
+    field: NonFunctionPropertyNames<Required<Entity>> | string;
+    direction?: OrderDirection;
+    nulls?: NullsOrder;
 };
-
 export type OrderType = {
-	selector: string;
-  order: 'ASC' | 'DESC';
-  nulls?: 'NULLS FIRST' | 'NULLS LAST';
+    selector: string;
+    order: 'ASC' | 'DESC';
+    nulls?: 'NULLS FIRST' | 'NULLS LAST';
 };
-
 export interface OrderFilter<Entity> {
-  orderBy?: Array<OrderParam<Entity>>;
+    orderBy?: Array<OrderParam<Entity>>;
 }

package/dist/types/interfaces/ordering.interface.js

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

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

@@ -0,0 +1,6 @@
+export type PageSize = number;
+export type PageNumber = number;
+export interface PaginationFilter {
+    page?: PageNumber;
+    pageSize?: PageSize;
+}

package/dist/types/interfaces/pagination.interface.js

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

package/{src/types/modules/column.types.ts → dist/types/modules/column.types.d.ts}

@@ -1,5 +1,3 @@
 import { ObjectLiteral } from "typeorm";
-
 export type SimpleColumnType = string | number | boolean | Date | null;
-
-export type ColumnValueType = SimpleColumnType | undefined | object | ObjectLiteral;
+export type ColumnValueType = SimpleColumnType | undefined | object | ObjectLiteral;

package/dist/types/modules/column.types.js

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

package/{src/types/modules/proxy-types/proxy-callback.types.ts → dist/types/modules/proxy-types/proxy-callback.types.d.ts}

@@ -1,11 +1,6 @@
 import { ObjectLiteral } from "typeorm";
 import { ColumnValueType } from "../column.types";
 import { EntityOnlyWithRelations, EntityWithoutRelations } from "../relations.types";
-
 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;
+export type RelationalKeyProxyCallback<T extends ObjectLiteral> = (proxy: EntityOnlyWithRelations<T>) => ColumnValueType;
+export type NonRelationalKeyProxyCallback<T extends ObjectLiteral> = (proxy: EntityWithoutRelations<T>) => ColumnValueType;

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

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

package/dist/types/modules/relations.types.d.ts

@@ -0,0 +1,16 @@
+import { BaseEntity, ObjectLiteral } from 'typeorm';
+import { SimpleColumnType } from './column.types';
+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];
+};

package/dist/types/modules/relations.types.js

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

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

@@ -0,0 +1,7 @@
+export type FunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T] & string;
+export type NonFunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? never : K;
+}[keyof T] & string;
+export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;

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

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

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

@@ -0,0 +1 @@
+export declare const isNil: (val: unknown) => boolean;

package/dist/utils/common.utils.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNil = void 0;
+const isNil = (val) => typeof val === 'undefined' || val === null;
+exports.isNil = isNil;

package/dist/utils/identifier.utils.d.ts

@@ -0,0 +1,15 @@
+export declare class Identifier {
+    readonly field: string;
+    readonly alias?: string | undefined;
+    private readonly useDoubleQuotes?;
+    private readonly useAlias;
+    constructor(field: string, alias?: string | undefined, useDoubleQuotes?: boolean | undefined);
+    fieldAsAlias(): string;
+    fieldIdentifier(): string;
+    get aliasSql(): string | undefined;
+    get fieldSql(): string;
+    private calcUseAlias;
+    static fieldToSql(field: string, useDoubleQuotes?: boolean): string;
+    static aliasToSql(alias: string | undefined, useDoubleQuotes?: boolean): string | undefined;
+    static toIdentifier(value: string, useDoubleQuotes?: boolean): string;
+}

package/dist/utils/identifier.utils.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Identifier = void 0;
+const sql_utils_1 = require("./sql.utils");
+class Identifier {
+    constructor(field, alias, useDoubleQuotes) {
+        this.field = field;
+        this.alias = alias;
+        this.useDoubleQuotes = useDoubleQuotes;
+        this.useAlias = this.calcUseAlias();
+    }
+    fieldAsAlias() {
+        if (this.useAlias) {
+            return `${this.fieldSql} AS ${this.aliasSql}`;
+        }
+        return this.fieldSql;
+    }
+    fieldIdentifier() {
+        if (this.useAlias) {
+            return `${this.aliasSql}.${this.fieldSql}`;
+        }
+        return this.fieldSql;
+    }
+    get aliasSql() {
+        return Identifier.aliasToSql(this.alias, this.useDoubleQuotes);
+    }
+    get fieldSql() {
+        return Identifier.fieldToSql(this.field, this.useDoubleQuotes);
+    }
+    /* PRIVATE */
+    calcUseAlias() {
+        return !!this.alias && !this.field.includes('.');
+    }
+    /* STATIC */
+    static fieldToSql(field, useDoubleQuotes) {
+        return this.toIdentifier(field, useDoubleQuotes);
+    }
+    static aliasToSql(alias, useDoubleQuotes) {
+        return alias ? this.toIdentifier(alias, useDoubleQuotes) : undefined;
+    }
+    static toIdentifier(value, useDoubleQuotes) {
+        return useDoubleQuotes ? (0, sql_utils_1.stringToSQLIdentifier)(value) : value;
+    }
+}
+exports.Identifier = Identifier;

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

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

package/dist/utils/pagination.utils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLimitAndOffset = void 0;
+const constants_1 = require("../constants");
+const getLimitAndOffset = ({ page, pageSize }) => {
+    if (!page || page < 1) {
+        page = 1;
+    }
+    if (!pageSize || pageSize < 1) {
+        pageSize = constants_1.defaultPageSize;
+    }
+    const offset = (page >= 1 ? page - 1 : 0) * pageSize;
+    const limit = pageSize;
+    return { limit, offset };
+};
+exports.getLimitAndOffset = getLimitAndOffset;

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

@@ -0,0 +1,22 @@
+import { ObjectLiteral } from 'typeorm';
+import { KeyProxyCallback } from '../types/modules/proxy-types/proxy-callback.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 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[];

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSqlKey = 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];
+    }
+    toSql(length = 2, addDobleQuotes = true) {
+        const string = this.toString(length);
+        const sql = addDobleQuotes ? (0, sql_utils_1.stringToSQLIdentifier)(string) : 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) {
+        const value = Reflect.get(target, key, receiver);
+        if (value) {
+            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);
+        return newLayer;
+    },
+};
+const getKeyHolder = (callback) => {
+    if (typeof callback !== 'function') {
+        if (callback instanceof KeyHolder) {
+            return callback;
+        }
+    }
+    const keyHolder = callback(KeyProxy.create());
+    return keyHolder;
+};
+exports.getKeyHolder = getKeyHolder;
+const getKey = (callback) => {
+    if (typeof callback === 'string')
+        return callback;
+    const keyHolder = (0, exports.getKeyHolder)(callback);
+    return keyHolder.toString();
+};
+exports.getKey = getKey;
+const getSqlKey = (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));
+    }
+    // if select is like this: (proxy) => proxy.relation.column
+    if (keyHolder.keys.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);
+    }
+    return keyHolder.toSql(undefined, addDobleQuotes);
+};
+exports.getSqlKey = getSqlKey;
+// example of typed select
+// const key = getSqlKey<UserEntity>((proxy) => proxy.sessions);
+// console.log(key);

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

@@ -0,0 +1,5 @@
+import { DatabaseType } from 'typeorm';
+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;

package/dist/utils/sql.utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringToSQLValue = exports.stringToSQLIdentifier = exports.wrapWithBackQoutes = exports.wrapWithDoubleQoutes = void 0;
+const wrapWithDoubleQoutes = (str) => str.includes('"') ? str : `"${str}"`;
+exports.wrapWithDoubleQoutes = wrapWithDoubleQoutes;
+const wrapWithBackQoutes = (str) => str.includes('`') ? str : '`' + str + '`';
+exports.wrapWithBackQoutes = wrapWithBackQoutes;
+const stringToSQLIdentifier = (str, driver) => str.includes('.')
+    ? str
+        .split('.')
+        .map((val) => (driver === null || driver === void 0 ? void 0 : driver.includes('mysql'))
+        ? (0, exports.wrapWithBackQoutes)(val)
+        : (0, exports.wrapWithDoubleQoutes)(val))
+        .join('.')
+    : (0, exports.wrapWithDoubleQoutes)(str);
+exports.stringToSQLIdentifier = stringToSQLIdentifier;
+const stringToSQLValue = (str) => `'${str}'`;
+exports.stringToSQLValue = stringToSQLValue;

package/dist/utils/string.utils.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringToSQLValue = exports.stringToSQLIdentifier = exports.wrapWithDblQoutes = void 0;
+const wrapWithDblQoutes = (str) => str.includes('"') ? str : `"${str}"`;
+exports.wrapWithDblQoutes = wrapWithDblQoutes;
+const stringToSQLIdentifier = (str) => str.includes('.')
+    ? str.split('.').map(exports.wrapWithDblQoutes).join('.')
+    : (0, exports.wrapWithDblQoutes)(str);
+exports.stringToSQLIdentifier = stringToSQLIdentifier;
+const stringToSQLValue = (str) => `'${str}'`;
+exports.stringToSQLValue = stringToSQLValue;

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "typeorm-extensions",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "typeorm commonly used extensions",
   "main": "./dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist", "LICENSE", "README.md", "package.json"],
+  "type": "module",
   "repository": {
     "type": "git",
     "url": "https://github.com/koenigstag/typeorm-extensions.git"

package/.eslintignore

@@ -1,2 +0,0 @@
-node_modules
-dist

package/.eslintrc

@@ -1,12 +0,0 @@
-{
-  "root": true,
-  "parser": "@typescript-eslint/parser",
-  "plugins": [
-    "@typescript-eslint"
-  ],
-  "extends": [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/eslint-recommended",
-    "plugin:@typescript-eslint/recommended"
-  ]
-}

package/docs/api_reference/index.html

@@ -1,21 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>API reference / typeorm-extensions</title>
-</head>
-<body>
-  <header>
-    <h1>API Reference</h1>
-  </header>
-
-  <nav>
-    <ul>
-      <li><a href="pagination">Pagination</a></li>
-      <li><a href="order">Order</a></li>
-      <li><a href="typed">Typed Extensions</a></li>
-    </ul>
-  </nav>
-</body>
-</html>

package/docs/api_reference/order/applyOrderFilter.html

@@ -1,77 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>applyOrderFilter / API reference / typeorm-extensions</title>
-</head>
-<body>
-  <header>
-    <h1>applyOrderFilter</h1>
-    
-  </header>
-
-  <nav>
-    <ul>
-      <li><a href="../pagination">Pagination</a></li>
-      <li><a href="../order">Order</a></li>
-      <li><a href="../typed">Typed Extensions</a></li>
-    </ul>
-  </nav>
-
-  <main>
-    <section>
-      <h2>Description</h2>
-      <p>
-        <code>applyOrderFilter</code> is a method that applies order to a query.
-      </p>
-    </section>
-    <section>
-      <h2>Signature</h2>
-      <p>
-        <pre><code>applyOrderFilter(orderFilter: OrderFilter, orderOptions?: ApplyOrderOptions): void</code></pre>
-      </p>
-    </section>
-    <section>
-      <h2>Arguments</h2>
-      <ul>
-        <li>
-          <h3>orderFilter: OrderFilter</h3>
-          <p>The order options to apply to the query.</p>
-          <p>
-            <h4>Properties</h4>
-            <ul>
-              <li>
-                <h5>orderBy: Array< OrderParam ></h5>
-                <p>Order configurations.</p>
-              </li>
-            </ul>
-          </p>
-        </li>
-        <li>
-          <h3>(optional) orderOptions?: ApplyOrderOptions</h3>
-          <p>Additional options to apply to the order filter.</p>
-          <p>
-            <h4>Properties</h4>
-            <ul>
-              <li>
-                <h5>useDoubleQuotes?: boolean</h5>
-                <p>
-                  Whether to wrap the order field with double qoutes (defaults to false).
-                </p>
-              </li>
-              <li>
-                ...TBD...
-              </li>
-            </ul>
-          </p>
-        </li>
-      </ul>
-    </section>
-    <section>
-      <h2>Usage</h2>
-      <pre><code>query.applyOrderFilter({ orderBy: [{ field: 'name', direction: 'asc', nulls: 'last' }] }, { useDoubleQuotes: true })</code></pre>
-    </section>
-  </main>
-</body>
-</html>