@warlock.js/core 1.0.9 → 1.0.11

package/cjs/repositories/repository-listing.js

@@ -1,796 +0,0 @@
-'use strict';var reinforcements=require('@mongez/reinforcements'),supportiveIs=require('@mongez/supportive-is'),cascade=require('@warlock.js/cascade'),dayjs=require('dayjs');function _interopDefault(e){return e&&e.__esModule?e:{default:e}}var dayjs__default=/*#__PURE__*/_interopDefault(dayjs);class RepositoryListing {
-    repositoryManager;
-    filterBy;
-    /**
-     * Aggregate query
-     */
-    query;
-    /**
-     * Pagination info
-     *
-     * Returned when the list is paginated
-     */
-    paginationInfo;
-    /**
-     * List options
-     */
-    options = {};
-    /**
-     * Documents list from the query
-     */
-    documents = [];
-    /**
-     * Date time format
-     */
-    dateTimeFormat = "";
-    /**
-     * Date format
-     */
-    dateFormat = "";
-    /**
-     * Constructor
-     */
-    constructor(repositoryManager, filterBy = {}, options) {
-        this.repositoryManager = repositoryManager;
-        this.filterBy = filterBy;
-        //
-        this.prepareOptions(options);
-    }
-    /**
-     * Set date time format
-     */
-    setDateTimeFormat(format) {
-        this.dateTimeFormat = format;
-        return this;
-    }
-    /**
-     * Set date format
-     */
-    setDateFormat(format) {
-        this.dateFormat = format;
-        return this;
-    }
-    /**
-     * Prepare the query
-     */
-    async prepareQuery() {
-        this.query = this.repositoryManager.newQuery();
-        await this.repositoryManager.beforeListing(this.query, this.options);
-        await this.parseFilterBy();
-        await this.repositoryManager.filter(this.query, this.options);
-        if (this.options.select) {
-            this.query.select(this.options.select);
-        }
-        if (this.options.deselect) {
-            this.query.deselect(this.options.deselect);
-        }
-        if (this.options.perform) {
-            this.options.perform(this.query, this.options);
-        }
-        return this.query;
-    }
-    /**
-     * perform listing
-     */
-    async list() {
-        await this.prepareQuery();
-        let orderByOptions = this.repositoryManager.orderBy?.(this.options);
-        if (!orderByOptions) {
-            if (this.options.sortBy && this.options.sortDirection) {
-                orderByOptions = {
-                    [this.options.sortBy]: this.options.sortDirection,
-                };
-            }
-            else if (this.options.orderBy) {
-                orderByOptions = this.options.orderBy;
-            }
-        }
-        this.parseOrderBy(orderByOptions);
-        let records = [];
-        const paginate = this.options.paginate;
-        const limit = Number(this.options.limit);
-        if (paginate) {
-            const { documents, paginationInfo } = await this.query.paginate(Number(this.options.page || 1), Number(limit || this.options.defaultLimit));
-            records = documents;
-            this.paginationInfo = paginationInfo;
-        }
-        else {
-            if (limit) {
-                this.query.limit(limit);
-            }
-            records = await this.query.get();
-        }
-        this.documents = await this.repositoryManager.onList(records);
-    }
-    /**
-     * Chunk the documents by the given callback
-     */
-    async chunk(callback) {
-        await this.prepareQuery();
-        return this.query.chunk(Number(this.option("limit", 15)), callback);
-    }
-    /**
-     * Count records only
-     */
-    async count() {
-        this.query = this.repositoryManager.newQuery();
-        await this.repositoryManager.beforeListing(this.query, this.options);
-        await this.parseFilterBy();
-        await this.repositoryManager.filter(this.query, this.options);
-        if (this.options.select) {
-            this.query.select(this.options.select);
-        }
-        if (this.options.deselect) {
-            this.query.deselect(this.options.deselect);
-        }
-        if (this.options.perform) {
-            this.options.perform(this.query, this.options);
-        }
-        // NO need to order by when counting
-        return await this.query.count();
-    }
-    /**
-     * Check if the list method Has pagination
-     */
-    hasPagination() {
-        return Boolean(this.paginationInfo);
-    }
-    /**
-     * Int filter
-     */
-    intFilter(column, value, columns) {
-        if (column) {
-            this.query.where(column, parseInt(value));
-        }
-        else if (columns) {
-            const columnsAsObject = {};
-            for (const column of columns) {
-                columnsAsObject[column] = parseInt(value);
-            }
-            this.query.orWhere(columnsAsObject);
-        }
-    }
-    /**
-     * float filter
-     */
-    floatFilter(column, value, columns) {
-        if (column) {
-            this.query.where(column, parseFloat(value));
-        }
-        else if (columns) {
-            const columnsAsObject = {};
-            for (const column of columns) {
-                columnsAsObject[column] = parseFloat(value);
-            }
-            this.query.orWhere(columnsAsObject);
-        }
-    }
-    /**
-     * Where operators filter
-     */
-    whereOperatorsFilter(column, value, columns, filterType) {
-        if (column) {
-            this.query.where(column, filterType, value);
-        }
-        else if (columns) {
-            const columnsAsObject = {};
-            for (const column of columns) {
-                columnsAsObject[column] = {
-                    [cascade.toOperator(filterType)]: value,
-                };
-            }
-            this.query.orWhere(columnsAsObject);
-        }
-    }
-    /**
-     * Parse filter by
-     */
-    async parseFilterBy() {
-        // TODO: Use filter maps instead of these tons of if statements
-        // get where operators from WhereOperator type
-        // just get the keys
-        // const filtersKeys = Object.keys(this.filterBy).filter(
-        //   key => this.option(key) !== undefined,
-        // );
-        // for (const filterKey of filtersKeys) {
-        //   const filterValue = this.option(filterKey);
-        //   if (filterValue === undefined) continue;
-        //   const { filterType, columns, column } = this.prepareFilterType(
-        //     filterKey,
-        //     this.filterBy[filterKey],
-        //   );
-        //   if (typeof filterType === "function") {
-        //     await filterType(filterValue, this.query);
-        //     continue;
-        //   }
-        //   // where operators
-        //   if (whereOperators.includes(filterType as WhereOperator)) {
-        //     this.whereOperatorsFilter(
-        //       column,
-        //       filterValue,
-        //       columns,
-        //       filterType as WhereOperator,
-        //     );
-        //     continue;
-        //   }
-        // }
-        for (const optionKey in this.filterBy) {
-            const filterValue = this.option(optionKey);
-            if (filterValue === undefined)
-                continue;
-            const { filterType, columns, column } = this.prepareFilterType(optionKey, this.filterBy[optionKey]);
-            if (typeof filterType === "function") {
-                await filterType(filterValue, this.query, this.options);
-                continue;
-            }
-            // in
-            if (filterType === "in") {
-                const value = this.returnAsArray(filterValue);
-                if (column) {
-                    this.query.whereIn(column, value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = value;
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // where operators
-            if (cascade.whereOperators.includes(filterType)) {
-                if (column) {
-                    this.query.where(column, filterType, filterValue);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        const filterExpression = cascade.WhereExpression.parse.apply(null, [
-                            column,
-                            filterType,
-                            filterValue,
-                        ]);
-                        columnsAsObject[column] = filterExpression[column];
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // bool, boolean
-            if (["bool", "boolean"].includes(filterType)) {
-                const value = filterValue === "0" ? false : Boolean(filterValue);
-                if (column) {
-                    this.query.where(column, value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = value;
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // !int
-            if (filterType === "!int") {
-                if (column) {
-                    this.query.where(column, "!=", parseInt(filterValue));
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $ne: parseInt(filterValue),
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // inInt
-            // int, integer
-            if (["int", "integer"].includes(filterType)) {
-                if (column) {
-                    this.query.where(column, parseInt(filterValue));
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = parseInt(filterValue);
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // int>
-            if (filterType === "int>") {
-                const value = parseInt(filterValue);
-                if (column) {
-                    this.query.where(column, ">", value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $gt: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-            }
-            // int>=
-            if (filterType === "int>=") {
-                const value = parseInt(filterValue);
-                if (column) {
-                    this.query.where(column, ">=", value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $gte: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-            }
-            // int<
-            if (filterType === "int<") {
-                const value = parseInt(filterValue);
-                if (column) {
-                    this.query.where(column, "<", value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $lt: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-            }
-            // int<=
-            if (filterType === "int<=") {
-                const value = parseInt(filterValue);
-                if (column) {
-                    this.query.where(column, "<=", value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $lte: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-            }
-            // inInt
-            if (filterType === "inInt") {
-                const value = this.returnAsArray(filterValue).map((v) => parseInt(v));
-                if (column) {
-                    this.query.whereIn(column, value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $in: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // number
-            if (filterType === "number") {
-                if (column) {
-                    this.query.where(column, Number(filterValue));
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = Number(filterValue);
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // inNumber
-            if (filterType === "inNumber") {
-                const value = this.returnAsArray(filterValue).map((v) => Number(v));
-                if (column) {
-                    this.query.whereIn(column, value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $in: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // float, double
-            if (["float", "double"].includes(filterType)) {
-                const value = this.returnAsArray(filterValue).map((v) => parseFloat(v));
-                if (column) {
-                    this.query.whereIn(column, value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $in: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // date
-            if (filterType === "date") {
-                const value = this.parseDate(filterValue);
-                if (column) {
-                    this.query.where(column, value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = value;
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // date>
-            if (filterType === "date>") {
-                const value = this.parseDate(filterValue);
-                if (column) {
-                    this.query.where(column, ">", value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $gt: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // date>=
-            if (filterType === "date>=") {
-                const value = this.parseDate(filterValue);
-                if (column) {
-                    this.query.where(column, ">=", value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $gte: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // date<
-            if (filterType === "date<") {
-                const value = this.parseDate(filterValue);
-                if (column) {
-                    this.query.where(column, "<", value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $gte: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // date<=
-            if (filterType === "date<=") {
-                const value = this.parseDate(filterValue);
-                if (column) {
-                    this.query.where(column, "<=", value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $gte: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // null
-            if (filterType === "null") {
-                if (column) {
-                    this.query.whereNull(column);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = null;
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // notNull | !null
-            if (["notNull", "!null"].includes(filterType)) {
-                if (column) {
-                    this.query.whereNotNull(column);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $ne: null,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // inDate
-            if (filterType === "inDate") {
-                const value = this.returnAsArray(filterValue).map((v) => this.parseDate(v));
-                if (column) {
-                    this.query.whereIn(column, value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $in: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // dateBetween
-            if (filterType === "dateBetween") {
-                const value = this.returnAsArray(filterValue).map((v) => this.parseDate(v));
-                if (column) {
-                    this.query.whereBetween(column, value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $between: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // dateTime
-            if (filterType === "dateTime") {
-                const value = this.parseDate(filterValue, this.dateTimeFormat);
-                if (column) {
-                    this.query.where(column, value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = value;
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // dateTime>
-            if (filterType === "dateTime>") {
-                const value = this.parseDate(filterValue, this.dateTimeFormat);
-                if (column) {
-                    this.query.where(column, ">", value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $gt: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // dateTime>=
-            if (filterType === "dateTime>=") {
-                const value = this.parseDate(filterValue, this.dateTimeFormat);
-                if (column) {
-                    this.query.where(column, ">=", value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $gte: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // dateTime<
-            if (filterType === "dateTime<") {
-                const value = this.parseDate(filterValue, this.dateTimeFormat);
-                if (column) {
-                    this.query.where(column, "<", value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $gte: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // dateTime<=
-            if (filterType === "dateTime<=") {
-                const value = this.parseDate(filterValue, this.dateTimeFormat);
-                if (column) {
-                    this.query.where(column, "<=", value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $gte: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // inDateTime
-            if (filterType === "inDateTime") {
-                const value = this.returnAsArray(filterValue).map((v) => this.parseDate(v, this.dateTimeFormat));
-                if (column) {
-                    this.query.whereIn(column, value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $in: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-            // dateTimeBetween
-            if (filterType === "dateTimeBetween") {
-                const value = this.returnAsArray(filterValue).map((v) => this.parseDate(v, this.dateTimeFormat));
-                if (column) {
-                    this.query.whereBetween(column, value);
-                }
-                else if (columns) {
-                    const columnsAsObject = {};
-                    for (const column of columns) {
-                        columnsAsObject[column] = {
-                            $between: value,
-                        };
-                    }
-                    this.query.orWhere(columnsAsObject);
-                }
-                continue;
-            }
-        }
-    }
-    /**
-     * Return the given value as a array
-     */
-    returnAsArray(value) {
-        if (!Array.isArray(value)) {
-            if (supportiveIs.isIterable(value) && value.toArray) {
-                return value.toArray();
-            }
-            else {
-                return [value];
-            }
-        }
-        return value;
-    }
-    /**
-     * Sum the value of the given column
-     */
-    sum(column) {
-        return this.query.sum(column);
-    }
-    /**
-     * Prepare filter type
-     */
-    prepareFilterType(optionKey, filterType) {
-        if (Array.isArray(filterType)) {
-            if (filterType.length === 1) {
-                return {
-                    filterType: filterType[0],
-                    column: optionKey,
-                    columns: undefined,
-                };
-            }
-            if (Array.isArray(filterType[1])) {
-                return {
-                    filterType: filterType[0],
-                    column: undefined,
-                    columns: filterType[1],
-                };
-            }
-            else {
-                return {
-                    filterType: filterType[0],
-                    column: filterType[1],
-                    columns: undefined,
-                };
-            }
-        }
-        return {
-            filterType,
-            column: optionKey,
-            columns: undefined,
-        };
-    }
-    /**
-     * Get option's value for the given key
-     */
-    option(key, defaultValue) {
-        return reinforcements.get(this.options, key, defaultValue);
-    }
-    /**
-     * Make order by
-     */
-    parseOrderBy(orderByOptions) {
-        if (!orderByOptions)
-            return;
-        const orderBy = orderByOptions;
-        if (Array.isArray(orderBy)) {
-            const [column, direction] = orderBy;
-            return this.query.orderBy(column, direction);
-        }
-        if (orderBy === "random") {
-            return this.query.random(Number(this.options.limit || this.options.defaultLimit));
-        }
-        this.query.sortBy(orderBy);
-    }
-    /**
-     * Prepare options
-     */
-    prepareOptions(options = {}) {
-        this.paginationInfo = undefined;
-        this.options = {
-            ...options,
-        };
-    }
-    /**
-     * Parse date value
-     */
-    parseDate(value, format = this.dateFormat) {
-        if (value instanceof Date)
-            return value;
-        if (typeof value === "string") {
-            return dayjs__default.default(value, format);
-        }
-        return value;
-    }
-}exports.RepositoryListing=RepositoryListing;//# sourceMappingURL=repository-listing.js.map