graphql-anywhere/lib/graphql.js

Run GraphQL queries with no schema and just one resolver

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.merge = exports.graphql = void 0;
var apollo_utilities_1 = require("apollo-utilities");
function graphql(resolver, document, rootValue, contextValue, variableValues, execOptions) {
    if (variableValues === void 0) { variableValues = {}; }
    if (execOptions === void 0) { execOptions = {}; }
    var mainDefinition = (0, apollo_utilities_1.getMainDefinition)(document);
    var fragments = (0, apollo_utilities_1.getFragmentDefinitions)(document);
    var fragmentMap = (0, apollo_utilities_1.createFragmentMap)(fragments);
    var resultMapper = execOptions.resultMapper;
    var fragmentMatcher = execOptions.fragmentMatcher || (function () { return true; });
    var execContext = {
        fragmentMap: fragmentMap,
        contextValue: contextValue,
        variableValues: variableValues,
        resultMapper: resultMapper,
        resolver: resolver,
        fragmentMatcher: fragmentMatcher,
    };
    return executeSelectionSet(mainDefinition.selectionSet, rootValue, execContext);
}
exports.graphql = graphql;
function executeSelectionSet(selectionSet, rootValue, execContext) {
    var fragmentMap = execContext.fragmentMap, contextValue = execContext.contextValue, variables = execContext.variableValues;
    var result = {};
    selectionSet.selections.forEach(function (selection) {
        if (variables && !(0, apollo_utilities_1.shouldInclude)(selection, variables)) {
            return;
        }
        if ((0, apollo_utilities_1.isField)(selection)) {
            var fieldResult = executeField(selection, rootValue, execContext);
            var resultFieldKey = (0, apollo_utilities_1.resultKeyNameFromField)(selection);
            if (fieldResult !== undefined) {
                if (result[resultFieldKey] === undefined) {
                    result[resultFieldKey] = fieldResult;
                }
                else {
                    merge(result[resultFieldKey], fieldResult);
                }
            }
        }
        else {
            var fragment = void 0;
            if ((0, apollo_utilities_1.isInlineFragment)(selection)) {
                fragment = selection;
            }
            else {
                fragment = fragmentMap[selection.name.value];
                if (!fragment) {
                    throw new Error("No fragment named ".concat(selection.name.value));
                }
            }
            var typeCondition = fragment.typeCondition.name.value;
            if (execContext.fragmentMatcher(rootValue, typeCondition, contextValue)) {
                var fragmentResult = executeSelectionSet(fragment.selectionSet, rootValue, execContext);
                merge(result, fragmentResult);
            }
        }
    });
    if (execContext.resultMapper) {
        return execContext.resultMapper(result, rootValue);
    }
    return result;
}
function executeField(field, rootValue, execContext) {
    var variables = execContext.variableValues, contextValue = execContext.contextValue, resolver = execContext.resolver;
    var fieldName = field.name.value;
    var args = (0, apollo_utilities_1.argumentsObjectFromField)(field, variables);
    var info = {
        isLeaf: !field.selectionSet,
        resultKey: (0, apollo_utilities_1.resultKeyNameFromField)(field),
        directives: (0, apollo_utilities_1.getDirectiveInfoFromField)(field, variables),
        field: field,
    };
    var result = resolver(fieldName, rootValue, args, contextValue, info);
    if (!field.selectionSet) {
        return result;
    }
    if (result == null) {
        return result;
    }
    if (Array.isArray(result)) {
        return executeSubSelectedArray(field, result, execContext);
    }
    return executeSelectionSet(field.selectionSet, result, execContext);
}
function executeSubSelectedArray(field, result, execContext) {
    return result.map(function (item) {
        if (item === null) {
            return null;
        }
        if (Array.isArray(item)) {
            return executeSubSelectedArray(field, item, execContext);
        }
        return executeSelectionSet(field.selectionSet, item, execContext);
    });
}
var hasOwn = Object.prototype.hasOwnProperty;
function merge(dest, src) {
    if (src !== null && typeof src === 'object') {
        Object.keys(src).forEach(function (key) {
            var srcVal = src[key];
            if (!hasOwn.call(dest, key)) {
                dest[key] = srcVal;
            }
            else {
                merge(dest[key], srcVal);
            }
        });
    }
}
exports.merge = merge;
//# sourceMappingURL=graphql.js.map