@dharapvj/typeorm-simple-query-parser/lib/RequestQueryParser.js

TypeORM Query Parser

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.RequestQueryParser = void 0;
const class_validator_1 = require("class-validator");
class RequestQueryParser {
    parseLimit() {
        return Number(this.limit);
    }
    getPage() {
        return Number(this.page);
    }
    parseSort() {
        if (class_validator_1.isEmpty(this.sortByDesc) && class_validator_1.isEmpty(this.sortByAsc)) {
            return [];
        }
        const list = {};
        if (!class_validator_1.isEmpty(this.sortByDesc)) {
            const sortByDesc = this.sortByDesc.split(',');
            sortByDesc.forEach((field) => {
                list[field] = 'DESC';
            });
        }
        if (!class_validator_1.isEmpty(this.sortByAsc)) {
            const sortByAsc = this.sortByAsc.split(',');
            sortByAsc.forEach((field) => {
                list[field] = 'ASC';
            });
        }
        return list;
    }
    parseRelations() {
        if (class_validator_1.isEmpty(this.relations) && class_validator_1.isEmpty(this.relations)) {
            return [];
        }
        return this.relations.split(',');
    }
    parseFilters(or = false) {
        const filters = or ? this.filterByOr : this.filter;
        const parsedFilters = [];
        for (const filter in filters) {
            const myObj = filters[filter];
            let value = null;
            let operator = 'eq';
            let not = false;
            if (typeof myObj === 'string' || myObj instanceof String) {
                value = myObj;
            }
            if (typeof myObj === 'object') {
                operator = Object.keys(myObj)[0];
                value = myObj[operator];
                if (typeof value === 'string' || value instanceof String) {
                    value = value;
                }
                else {
                    operator = Object.keys(myObj)[0];
                    const operatorValues = myObj[operator];
                    const isNot = Object.keys(operatorValues)[0];
                    not = Boolean(isNot);
                    value = operatorValues[isNot];
                }
            }
            parsedFilters.push({ column: filter, operator: operator, not: not, value: value });
        }
        return parsedFilters;
    }
    parseFiltersByOr() {
        return this.parseFilters(true);
    }
    parseScopes() {
        if (class_validator_1.isEmpty(this.scopes)) {
            return [];
        }
        return this.scopes;
    }
    getAll() {
        return {
            take: this.parseLimit(),
            skip: (this.getPage() - 1) * this.parseLimit(),
            order: this.parseSort(),
            relations: this.parseRelations(),
            filters: this.parseFilters(),
            filtersByOr: this.parseFiltersByOr(),
            scopes: this.parseScopes(),
        };
    }
}
exports.RequestQueryParser = RequestQueryParser;