@warlock.js/core 1.0.20 → 1.0.22

package/cjs/repositories/repository-listing.js

@@ -0,0 +1,796 @@
+'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