@graphql-tools/executor/esm/execution/buildExecutionPlan.js

Fork of GraphQL.js' execute function

import { AccumulatorMap } from './AccumulatorMap.js';
import { getBySet } from './getBySet.js';
import { isSameSet } from './isSameSet.js';
export function buildExecutionPlan(originalGroupedFieldSet, parentDeferUsages = new Set()) {
    const groupedFieldSet = new Map();
    const newGroupedFieldSets = new Map();
    for (const [responseKey, fieldGroup] of originalGroupedFieldSet) {
        const filteredDeferUsageSet = getFilteredDeferUsageSet(fieldGroup);
        if (isSameSet(filteredDeferUsageSet, parentDeferUsages)) {
            groupedFieldSet.set(responseKey, fieldGroup);
            continue;
        }
        let newGroupedFieldSet = getBySet(newGroupedFieldSets, filteredDeferUsageSet);
        if (newGroupedFieldSet === undefined) {
            newGroupedFieldSet = new Map();
            newGroupedFieldSets.set(filteredDeferUsageSet, newGroupedFieldSet);
        }
        newGroupedFieldSet.set(responseKey, fieldGroup);
    }
    return {
        groupedFieldSet,
        newGroupedFieldSets,
    };
}
function getFilteredDeferUsageSet(fieldGroup) {
    const filteredDeferUsageSet = new Set();
    for (const fieldDetails of fieldGroup) {
        const deferUsage = fieldDetails.deferUsage;
        if (deferUsage === undefined) {
            filteredDeferUsageSet.clear();
            return filteredDeferUsageSet;
        }
        filteredDeferUsageSet.add(deferUsage);
    }
    for (const deferUsage of filteredDeferUsageSet) {
        let parentDeferUsage = deferUsage.parentDeferUsage;
        while (parentDeferUsage !== undefined) {
            if (filteredDeferUsageSet.has(parentDeferUsage)) {
                filteredDeferUsageSet.delete(deferUsage);
                break;
            }
            parentDeferUsage = parentDeferUsage.parentDeferUsage;
        }
    }
    return filteredDeferUsageSet;
}
export function buildBranchingExecutionPlan(originalGroupedFieldSet, parentDeferUsages = new Set()) {
    const groupedFieldSet = new AccumulatorMap();
    const newGroupedFieldSets = new Map();
    for (const [responseKey, fieldGroup] of originalGroupedFieldSet) {
        for (const fieldDetails of fieldGroup) {
            const deferUsage = fieldDetails.deferUsage;
            const deferUsageSet = deferUsage === undefined ? new Set() : new Set([deferUsage]);
            if (isSameSet(parentDeferUsages, deferUsageSet)) {
                groupedFieldSet.add(responseKey, fieldDetails);
            }
            else {
                let newGroupedFieldSet = getBySet(newGroupedFieldSets, deferUsageSet);
                if (newGroupedFieldSet === undefined) {
                    newGroupedFieldSet = new AccumulatorMap();
                    newGroupedFieldSets.set(deferUsageSet, newGroupedFieldSet);
                }
                newGroupedFieldSet.add(responseKey, fieldDetails);
            }
        }
    }
    return {
        groupedFieldSet,
        newGroupedFieldSets,
    };
}