popurelate/lib/optimizer/reorder.js

Easily populate and filter documents using data from related collections.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.reorderPipelines = void 0;
const is_1 = require("./is");
const recompose_1 = require("./recompose");
const deps_1 = require("./deps");
const { recalculateDependencies } = deps_1.deps;
const reorderPipelines = (pipelines, startingIndexBackwards, finder, helper) => {
    let lastAffectedIndex = -1;
    for (let i = startingIndexBackwards - 1; i >= 0; --i) {
        const me = pipelines[i];
        if (!me.useOptimizer || me.removable)
            continue;
        // let lastBeneficialIndex = i;
        let lastPrefferedIndex = i;
        for (let j = i + 1; j < pipelines.length; j++) {
            const secondary = pipelines[j];
            if (!secondary.useOptimizer || secondary.removable)
                continue;
            const cannotMove = me.pipelineIdsDepenedOnMe.has(secondary.id) ||
                me.sameSettersWith.has(secondary.id);
            if (cannotMove)
                break;
            if (isBeneficialToMoveAfter(me, secondary, helper)) {
                // lastBeneficialIndex = j;
                lastPrefferedIndex = j;
                continue;
            }
            const third = finFirstNonRemovable(pipelines, j + 1);
            const canBeJoined = !third
                ? false
                : recompose_1.canBeMerged(secondary, third, finder);
            if (!canBeJoined) {
                const preffered = isPreferredToMoveAfter(me, secondary, helper);
                if (preffered)
                    lastPrefferedIndex = j;
            }
        }
        if (lastPrefferedIndex !== i) {
            reorderPipelineAfter(pipelines, i, lastPrefferedIndex);
            lastAffectedIndex = i;
            recalculateDependencies(pipelines, finder, helper);
        }
    }
    return lastAffectedIndex;
};
exports.reorderPipelines = reorderPipelines;
const reorderPipelineAfter = (pipelines, from, after) => {
    if (after <= from) {
        throw new Error("cannot move before");
    }
    const element = pipelines[from];
    pipelines.splice(from, 1);
    pipelines.splice(after, 0, element);
};
const finFirstNonRemovable = (pipelines, from) => {
    for (let i = from; i < pipelines.length; ++i) {
        const pip = pipelines[i];
        if (!pip.removable)
            return pip;
    }
    return null;
};
const isBeneficialToMoveAfter = (me, after, helper) => {
    const is = helper.pipelineIs;
    if (is.populate(me.pipeline)) {
        if (is.countLike(after.pipeline))
            return false;
        if (is.changingDocCount(after.pipeline))
            return true;
        if (is.project(after.pipeline))
            return true;
        return false;
    }
    if (is.sort(me.pipeline)) {
        if (is.countLike(after.pipeline))
            return false;
        if (is.changingDocCount(after.pipeline))
            return true;
        return false;
    }
    return false;
};
const isPreferredToMoveAfter = (me, after, helper) => {
    const is = helper.pipelineIs;
    const type1 = is_1.getPipelineType(me.pipeline, is);
    const type2 = is_1.getPipelineType(after.pipeline, is);
    if (type1 === null || type2 === null)
        return false;
    const ind1 = sortedPrefferedOrder.indexOf(type1);
    const ind2 = sortedPrefferedOrder.indexOf(type2);
    if (ind1 === -1 || ind2 === -1)
        return false;
    return ind1 > ind2;
};
const sortedPrefferedOrder = [
    "query",
    "project",
    "addFields",
    "sort",
    "populate",
];