@warlock.js/cascade 1.0.3 → 1.0.5

package/cjs/aggregate/aggregate.js

@@ -1,680 +0,0 @@
-'use strict';var reinforcements=require('@mongez/reinforcements'),logger=require('@warlock.js/logger'),mongodb=require('mongodb'),modelEvents=require('../model/model-events.js'),query=require('../query/query.js'),DeselectPipeline=require('./DeselectPipeline.js'),GroupByPipeline=require('./GroupByPipeline.js'),LimitPipeline=require('./LimitPipeline.js'),LookupPipeline=require('./LookupPipeline.js'),OrWherePipeline=require('./OrWherePipeline.js'),SelectPipeline=require('./SelectPipeline.js'),SkipPipeline=require('./SkipPipeline.js'),SortByPipeline=require('./SortByPipeline.js'),SortPipeline=require('./SortPipeline.js'),SortRandomPipeline=require('./SortRandomPipeline.js'),UnwindPipeline=require('./UnwindPipeline.js'),WhereExpression=require('./WhereExpression.js'),WherePipeline=require('./WherePipeline.js'),expressions=require('./expressions.js'),parsePipelines=require('./parsePipelines.js');class Aggregate {
-    collection;
-    /**
-     * Collection pipelines
-     */
-    pipelines = [];
-    /**
-     * Aggregate events
-     */
-    static _events = new modelEvents.ModelEvents();
-    /**
-     * Query manager
-     */
-    query = query.query;
-    /**
-     * Constructor
-     */
-    constructor(collection) {
-        this.collection = collection;
-        // get the events instance
-        const events = Aggregate._events;
-        Aggregate._events.trigger("fetching", this);
-        events.collection = collection;
-    }
-    /**
-     * Get the events instance
-     */
-    static events() {
-        return Aggregate._events;
-    }
-    /**
-     * Sort by the given column
-     */
-    sort(column, direction = "asc") {
-        return this.pipeline(new SortPipeline.SortPipeline(column, direction));
-    }
-    /**
-     * @alias sort
-     */
-    orderBy(column, direction = "asc") {
-        return this.sort(column, direction);
-    }
-    /**
-     * Order by descending
-     */
-    sortByDesc(column) {
-        return this.sort(column, "desc");
-    }
-    /**
-     * Order by descending
-     */
-    orderByDesc(column) {
-        return this.sort(column, "desc");
-    }
-    /**
-     * Sort by multiple columns
-     */
-    sortBy(columns) {
-        return this.pipeline(new SortByPipeline.SortByPipeline(columns));
-    }
-    /**
-     * Sort randomly
-     */
-    random(limit) {
-        if (!limit) {
-            // get limit pipeline
-            const limitPipeline = this.pipelines.find(pipeline => pipeline.name === "limit");
-            if (limitPipeline) {
-                limit = limitPipeline.getData();
-            }
-            if (!limit) {
-                throw new Error("You must provide a limit when using random() or use limit() pipeline");
-            }
-        }
-        // order by random in mongodb using $sample
-        return this.pipeline(new SortRandomPipeline.SortRandomPipeline(limit));
-    }
-    /**
-     * Order by latest created records
-     */
-    latest(column = "createdAt") {
-        return this.sort(column, "desc");
-    }
-    /**
-     * Order by oldest created records
-     */
-    oldest(column = "createdAt") {
-        return this.sort(column, "asc");
-    }
-    groupBy(...args) {
-        const [groupBy_id, groupByData] = args;
-        if (groupBy_id instanceof GroupByPipeline.GroupByPipeline) {
-            return this.pipeline(groupBy_id);
-        }
-        return this.pipeline(new GroupByPipeline.GroupByPipeline(groupBy_id, groupByData));
-    }
-    /**
-     * Group by year
-     */
-    groupByYear(column, groupByData) {
-        return this.groupBy({
-            year: expressions.year(expressions.$agg.columnName(column)),
-        }, groupByData);
-    }
-    /**
-     * Group by month and year
-     */
-    groupByMonthAndYear(column, groupByData) {
-        column = expressions.$agg.columnName(column);
-        return this.groupBy({
-            year: expressions.year(column),
-            month: expressions.month(column),
-        }, groupByData);
-    }
-    /**
-     * Group by month only
-     */
-    groupByMonth(column, groupByData) {
-        column = expressions.$agg.columnName(column);
-        return this.groupBy({
-            month: expressions.month(column),
-        }, groupByData);
-    }
-    /**
-     * Group by day, month and year
-     */
-    groupByDate(column, groupByData) {
-        column = expressions.$agg.columnName(column);
-        return this.groupBy({
-            year: expressions.year(column),
-            month: expressions.month(column),
-            day: expressions.dayOfMonth(column),
-        }, groupByData);
-    }
-    /**
-     * Group by week and year
-     */
-    groupByWeek(column, groupByData) {
-        column = expressions.$agg.columnName(column);
-        return this.groupBy({
-            year: expressions.year(column),
-            week: expressions.week(column),
-        }, groupByData);
-    }
-    /**
-     * Group by day only
-     */
-    groupByDayOfMonth(column, groupByData) {
-        column = expressions.$agg.columnName(column);
-        return this.groupBy({
-            day: expressions.dayOfMonth(column),
-        }, groupByData);
-    }
-    /**
-     * Pluck only the given column
-     */
-    async pluck(column) {
-        return await this.select([column]).get(record => reinforcements.get(record, column));
-    }
-    /**
-     * Get average of the given column
-     */
-    async avg(column) {
-        const document = await this.groupBy(null, {
-            avg: expressions.$agg.avg(column),
-        }).first(document => document);
-        return document?.avg || 0;
-    }
-    /**
-     * {@alias} avg
-     */
-    average(column) {
-        return this.avg(column);
-    }
-    /**
-     * Sum values of the given column
-     */
-    async sum(column) {
-        const document = await this.groupBy(null, {
-            sum: expressions.$agg.sum(column),
-        }).first(document => document);
-        return document?.sum || 0;
-    }
-    /**
-     * Get minimum value of the given column
-     */
-    async min(column) {
-        const document = await this.groupBy(null, {
-            min: expressions.$agg.min(column),
-        }).first(document => document);
-        return document?.min || 0;
-    }
-    /**
-     * Get maximum value of the given column
-     */
-    async max(column) {
-        const document = await this.groupBy(null, {
-            max: expressions.$agg.max(column),
-        }).first(document => document);
-        return document?.max || 0;
-    }
-    /**
-     * Get distinct value for the given column using aggregation
-     */
-    async distinct(column) {
-        return (await this.groupBy(null, {
-            // use addToSet to get unique values
-            [column]: expressions.$agg.addToSet(column),
-        })
-            .select([column])
-            .get(data => data[column]));
-    }
-    /**
-     * {@alias} distinct
-     */
-    unique(column) {
-        return this.distinct(column);
-    }
-    /**
-     * Get distinct values that are not empty
-     */
-    async distinctHeavy(column) {
-        return await this.whereNotNull(column).distinct(column);
-    }
-    /**
-     * {@alias} distinctHeavy
-     */
-    async uniqueHeavy(column) {
-        return await this.distinctHeavy(column);
-    }
-    /**
-     * Get values list of the given column
-     */
-    async values(column) {
-        return (await this.groupBy(null, {
-            values: expressions.$agg.push(column),
-        })
-            .select(["values"])
-            .get(data => data.values));
-    }
-    /**
-     * Limit the number of results
-     */
-    limit(limit) {
-        return this.pipeline(new LimitPipeline.LimitPipeline(limit));
-    }
-    /**
-     * Skip the given number of results
-     */
-    skip(skip) {
-        return this.pipeline(new SkipPipeline.SkipPipeline(skip));
-    }
-    select(...columns) {
-        if (columns.length === 1 && Array.isArray(columns[0])) {
-            columns = columns[0];
-        }
-        return this.pipeline(new SelectPipeline.SelectPipeline(columns));
-    }
-    /**
-     * Deselect the given columns
-     */
-    deselect(columns) {
-        return this.pipeline(new DeselectPipeline.DeselectPipeline(columns));
-    }
-    /**
-     * Unwind/Extract the given column
-     */
-    unwind(column, options) {
-        return this.pipeline(new UnwindPipeline.UnwindPipeline(column, options));
-    }
-    where(...args) {
-        return this.pipeline(new WherePipeline.WherePipeline(WhereExpression.WhereExpression.parse.apply(null, args)));
-    }
-    /**
-     * Add comparison between two or more columns
-     */
-    whereColumns(column1, operator, ...otherColumns) {
-        const mongoOperator = WhereExpression.toOperator(operator) || operator;
-        return this.where(expressions.$agg.expr({
-            [mongoOperator]: [
-                expressions.$agg.columnName(column1),
-                ...otherColumns.map(column => expressions.$agg.columnName(column)),
-            ],
-        }));
-    }
-    orWhere(column) {
-        return this.pipeline(new OrWherePipeline.OrWherePipeline(column));
-    }
-    /**
-     * Perform a text search
-     * Please note that this method will add the `match` stage to the beginning of the pipeline
-     * Also it will add `score` field to the result automatically
-     *
-     * @warning This method will not work if the collection is not indexed for text search
-     */
-    textSearch(query, moreFilters) {
-        this.pipelines.unshift({
-            $match: {
-                $text: { $search: query },
-                ...moreFilters,
-            },
-        });
-        this.addField("score", { $meta: "textScore" });
-        return this;
-    }
-    /**
-     * Where null
-     */
-    whereNull(column) {
-        return this.where(column, null);
-    }
-    /**
-     * Where not null
-     */
-    whereNotNull(column) {
-        return this.where(column, "!=", null);
-    }
-    /**
-     * Where like operator
-     */
-    whereLike(column, value) {
-        return this.where(column, "like", value);
-    }
-    /**
-     * Where not like operator
-     */
-    whereNotLike(column, value) {
-        return this.where(column, "notLike", value);
-    }
-    /**
-     * Where column starts with the given value
-     */
-    whereStartsWith(column, value) {
-        return this.where(column, "startsWith", value);
-    }
-    /**
-     * Where column not starts with the given value
-     */
-    whereNotStartsWith(column, value) {
-        return this.where(column, "notStartsWith", value);
-    }
-    /**
-     * Where column ends with the given value
-     */
-    whereEndsWith(column, value) {
-        return this.where(column, "endsWith", value);
-    }
-    /**
-     * Where column not ends with the given value
-     */
-    whereNotEndsWith(column, value) {
-        return this.where(column, "notEndsWith", value);
-    }
-    /**
-     * Where between operator
-     */
-    whereBetween(column, value) {
-        return this.where(column, "between", value);
-    }
-    /**
-     * Where date between operator
-     */
-    whereDateBetween(column, value) {
-        return this.where(column, "between", value);
-    }
-    /**
-     * Where date not between operator
-     */
-    whereDateNotBetween(column, value) {
-        return this.where(column, "notBetween", value);
-    }
-    /**
-     * Where not between operator
-     */
-    whereNotBetween(column, value) {
-        return this.where(column, "notBetween", value);
-    }
-    /**
-     * Where exists operator
-     */
-    whereExists(column) {
-        return this.where(column, "exists", true);
-    }
-    /**
-     * Where not exists operator
-     */
-    whereNotExists(column) {
-        return this.where(column, "exists", false);
-    }
-    whereSize(...args) {
-        // first we need to project the column to get the size
-        const [column, operator, columnSize] = args;
-        this.project({
-            [column + "_size"]: {
-                $size: expressions.$agg.columnName(column),
-            },
-        });
-        // then we can use the size operator
-        this.where(column + "_size", operator, columnSize);
-        // now we need to deselect the column size
-        // this.project({
-        //   [column + "_size"]: 0,
-        // });
-        return this;
-    }
-    /**
-     * Add project pipeline
-     *
-     */
-    project(data) {
-        return this.addPipeline({
-            $project: data,
-        });
-    }
-    /**
-     * Where in operator
-     * If value is a string, it will be treated as a column name
-     */
-    whereIn(column, values) {
-        return this.where(column, "in", values);
-    }
-    /**
-     * Where not in operator
-     * If value is a string, it will be treated as a column name
-     */
-    whereNotIn(column, values) {
-        return this.where(column, "notIn", values);
-    }
-    /**
-     * // TODO: Make a proper implementation
-     * Where location near
-     */
-    whereNear(column, value, _distance) {
-        return this.where(column, "near", value);
-    }
-    /**
-     * // TODO: Make a proper implementation
-     * Get nearby location between the given min and max distance
-     */
-    async whereNearByIn(column, value, _minDistance, _maxDistance) {
-        return this.where(column, value);
-    }
-    /**
-     * Lookup the given collection
-     */
-    lookup(options) {
-        this.pipeline(new LookupPipeline.LookupPipeline(options));
-        if (options.single && options.as) {
-            const as = options.as;
-            this.addField(as, expressions.last(as));
-        }
-        return this;
-    }
-    /**
-     * Add field to the pipeline
-     */
-    addField(field, value) {
-        return this.addPipeline({
-            $addFields: {
-                [field]: value,
-            },
-        });
-    }
-    /**
-     * Add fields to the pipeline
-     */
-    addFields(fields) {
-        return this.addPipeline({
-            $addFields: fields,
-        });
-    }
-    /**
-     * Get new pipeline instance
-     */
-    pipeline(...pipelines) {
-        this.pipelines.push(...pipelines);
-        return this;
-    }
-    /**
-     * Unshift pipeline to the beginning of the pipelines
-     */
-    unshiftPipelines(pipelines) {
-        this.pipelines.unshift(...pipelines);
-        return this;
-    }
-    /**
-     * Add mongodb plain stage
-     */
-    addPipeline(pipeline) {
-        this.pipelines.push(pipeline);
-        return this;
-    }
-    /**
-     * Add mongodb plain stages
-     */
-    addPipelines(pipelines) {
-        this.pipelines.push(...pipelines);
-        return this;
-    }
-    /**
-     * Get pipelines
-     */
-    getPipelines() {
-        return this.pipelines;
-    }
-    /**
-     * Get only first result
-     */
-    async first(mapData) {
-        const results = await this.limit(1).get(mapData);
-        return results[0];
-    }
-    /**
-     * Get last result
-     */
-    async last(filters) {
-        if (filters) {
-            this.where(filters);
-        }
-        const results = await this.orderByDesc("id").limit(1).get();
-        return results[0];
-    }
-    /**
-     * Delete records
-     */
-    async delete() {
-        const ids = await (await this.select(["_id"]).pluck("_id")).map(_id => new mongodb.ObjectId(_id));
-        Aggregate._events.trigger("deleting", this);
-        return await query.query.delete(this.collection, {
-            _id: ids,
-        });
-    }
-    /**
-     * Get the data
-     */
-    async get(mapData) {
-        const records = await this.execute();
-        return mapData ? records.map(mapData) : records;
-    }
-    /**
-     * Chunk documents based on the given limit
-     */
-    async chunk(limit, callback, mapData) {
-        const totalDocuments = await this.clone().count();
-        const totalPages = Math.ceil(totalDocuments / limit);
-        for (let page = 1; page <= totalPages; page++) {
-            const results = await this.clone().paginate(page, limit, mapData);
-            const { documents, paginationInfo } = results;
-            const output = await callback(documents, paginationInfo);
-            if (output === false)
-                break;
-        }
-    }
-    /**
-     * Paginate records based on the given filter
-     */
-    async paginate(page = 1, limit = 15, mapData) {
-        const totalDocumentsQuery = this.parse();
-        this.skip((page - 1) * limit).limit(limit);
-        const records = await this.get(mapData);
-        this.pipelines = totalDocumentsQuery;
-        const totalDocuments = await this.count();
-        const result = {
-            documents: records,
-            paginationInfo: {
-                limit,
-                page,
-                result: records.length,
-                total: totalDocuments,
-                pages: Math.ceil(totalDocuments / limit),
-            },
-        };
-        return result;
-    }
-    /**
-     * Explain the query
-     */
-    async explain() {
-        return (await this.query.aggregate(this.collection, this.parse(), {
-            explain: true,
-        })).explain();
-    }
-    /**
-     * Update the given data
-     */
-    async update(data) {
-        try {
-            const query = [];
-            const filters = {};
-            this.parse().forEach(pipeline => {
-                if (pipeline.$match) {
-                    Object.assign(filters, pipeline.$match);
-                }
-                else {
-                    query.push(pipeline);
-                }
-            });
-            Aggregate._events.trigger("updating", this);
-            const results = await this.query.updateMany(this.collection, filters, [
-                ...query,
-                {
-                    $set: WhereExpression.parseValuesInObject(data),
-                },
-            ]);
-            return results.modifiedCount;
-        }
-        catch (error) {
-            logger.log.error("database", "aggregate.update", error);
-            throw error;
-        }
-    }
-    /**
-     * Unset the given columns
-     */
-    async unset(...columns) {
-        try {
-            const query = [];
-            const filters = {};
-            this.parse().forEach(pipeline => {
-                if (pipeline.$match) {
-                    Object.assign(filters, pipeline.$match);
-                }
-                else {
-                    query.push(pipeline);
-                }
-            });
-            Aggregate._events.trigger("updating", this);
-            const results = await this.query.updateMany(this.collection, filters, [
-                ...query,
-                {
-                    $unset: columns,
-                },
-            ]);
-            return results.modifiedCount;
-        }
-        catch (error) {
-            logger.log.error("database", "aggregate.unset", error);
-            console.log(error);
-            throw error;
-        }
-    }
-    /**
-     * Execute the query
-     */
-    async execute() {
-        const results = (await this.query.aggregate(this.collection, this.parse())).toArray();
-        return results;
-    }
-    /**
-     * Count the results
-     */
-    async count() {
-        this.groupBy(null, {
-            total: expressions.count(),
-        });
-        const results = await this.execute();
-        return reinforcements.get(results, "0.total", 0);
-    }
-    /**
-     * Parse pipelines
-     */
-    parse() {
-        return parsePipelines.parsePipelines(this.pipelines);
-    }
-    /**
-     * Reset the pipeline
-     */
-    reset() {
-        this.pipelines = [];
-        return this;
-    }
-    /**
-     * Clone the aggregate class
-     */
-    clone() {
-        const aggregate = new this.constructor(this.collection);
-        aggregate.pipelines = this.pipelines.slice();
-        return aggregate;
-    }
-}exports.Aggregate=Aggregate;//# sourceMappingURL=aggregate.js.map