@graphql-inspector/core 4.0.2 → 4.0.3

package/cjs/utils/graphql.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReachableTypes = exports.removeDirectives = exports.removeFieldIfDirectives = exports.findDeprecatedUsages = exports.isForIntrospection = exports.isPrimitive = exports.getTypePrefix = exports.getKind = exports.safeChangeForInputValue = exports.safeChangeForField = void 0;
+const graphql_1 = require("graphql");
+const is_deprecated_js_1 = require("./is-deprecated.js");
+function safeChangeForField(oldType, newType) {
+    if (!(0, graphql_1.isWrappingType)(oldType) && !(0, graphql_1.isWrappingType)(newType)) {
+        return oldType.toString() === newType.toString();
+    }
+    if ((0, graphql_1.isNonNullType)(newType)) {
+        const ofType = (0, graphql_1.isNonNullType)(oldType) ? oldType.ofType : oldType;
+        return safeChangeForField(ofType, newType.ofType);
+    }
+    if ((0, graphql_1.isListType)(oldType)) {
+        return (((0, graphql_1.isListType)(newType) && safeChangeForField(oldType.ofType, newType.ofType)) ||
+            ((0, graphql_1.isNonNullType)(newType) && safeChangeForField(oldType, newType.ofType)));
+    }
+    return false;
+}
+exports.safeChangeForField = safeChangeForField;
+function safeChangeForInputValue(oldType, newType) {
+    if (!(0, graphql_1.isWrappingType)(oldType) && !(0, graphql_1.isWrappingType)(newType)) {
+        return oldType.toString() === newType.toString();
+    }
+    if ((0, graphql_1.isListType)(oldType) && (0, graphql_1.isListType)(newType)) {
+        return safeChangeForInputValue(oldType.ofType, newType.ofType);
+    }
+    if ((0, graphql_1.isNonNullType)(oldType)) {
+        const ofType = (0, graphql_1.isNonNullType)(newType) ? newType.ofType : newType;
+        return safeChangeForInputValue(oldType.ofType, ofType);
+    }
+    return false;
+}
+exports.safeChangeForInputValue = safeChangeForInputValue;
+function getKind(type) {
+    const node = type.astNode;
+    return (node === null || node === void 0 ? void 0 : node.kind) || '';
+}
+exports.getKind = getKind;
+function getTypePrefix(type) {
+    const kind = getKind(type);
+    const kindsMap = {
+        [graphql_1.Kind.SCALAR_TYPE_DEFINITION]: 'scalar',
+        [graphql_1.Kind.OBJECT_TYPE_DEFINITION]: 'type',
+        [graphql_1.Kind.INTERFACE_TYPE_DEFINITION]: 'interface',
+        [graphql_1.Kind.UNION_TYPE_DEFINITION]: 'union',
+        [graphql_1.Kind.ENUM_TYPE_DEFINITION]: 'enum',
+        [graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION]: 'input',
+    };
+    return kindsMap[kind.toString()];
+}
+exports.getTypePrefix = getTypePrefix;
+function isPrimitive(type) {
+    return ['String', 'Int', 'Float', 'Boolean', 'ID'].includes(typeof type === 'string' ? type : type.name);
+}
+exports.isPrimitive = isPrimitive;
+function isForIntrospection(type) {
+    return [
+        '__Schema',
+        '__Type',
+        '__TypeKind',
+        '__Field',
+        '__InputValue',
+        '__EnumValue',
+        '__Directive',
+        '__DirectiveLocation',
+    ].includes(typeof type === 'string' ? type : type.name);
+}
+exports.isForIntrospection = isForIntrospection;
+function findDeprecatedUsages(schema, ast) {
+    const errors = [];
+    const typeInfo = new graphql_1.TypeInfo(schema);
+    (0, graphql_1.visit)(ast, (0, graphql_1.visitWithTypeInfo)(typeInfo, {
+        Argument(node) {
+            const argument = typeInfo.getArgument();
+            if (argument) {
+                const reason = argument.deprecationReason;
+                if (reason) {
+                    const fieldDef = typeInfo.getFieldDef();
+                    if (fieldDef) {
+                        errors.push(new graphql_1.GraphQLError(`The argument '${argument === null || argument === void 0 ? void 0 : argument.name}' of '${fieldDef.name}' is deprecated. ${reason}`, [node]));
+                    }
+                }
+            }
+        },
+        Field(node) {
+            const fieldDef = typeInfo.getFieldDef();
+            if (fieldDef && (0, is_deprecated_js_1.isDeprecated)(fieldDef)) {
+                const parentType = typeInfo.getParentType();
+                if (parentType) {
+                    const reason = fieldDef.deprecationReason;
+                    errors.push(new graphql_1.GraphQLError(`The field '${parentType.name}.${fieldDef.name}' is deprecated.${reason ? ' ' + reason : ''}`, [node]));
+                }
+            }
+        },
+        EnumValue(node) {
+            const enumVal = typeInfo.getEnumValue();
+            if (enumVal && (0, is_deprecated_js_1.isDeprecated)(enumVal)) {
+                const type = (0, graphql_1.getNamedType)(typeInfo.getInputType());
+                if (type) {
+                    const reason = enumVal.deprecationReason;
+                    errors.push(new graphql_1.GraphQLError(`The enum value '${type.name}.${enumVal.name}' is deprecated.${reason ? ' ' + reason : ''}`, [node]));
+                }
+            }
+        },
+    }));
+    return errors;
+}
+exports.findDeprecatedUsages = findDeprecatedUsages;
+function removeFieldIfDirectives(node, directiveNames) {
+    var _a;
+    if ((_a = node.directives) === null || _a === void 0 ? void 0 : _a.some(d => directiveNames.includes(d.name.value))) {
+        return null;
+    }
+    return node;
+}
+exports.removeFieldIfDirectives = removeFieldIfDirectives;
+function removeDirectives(node, directiveNames) {
+    if (node.directives) {
+        return Object.assign(Object.assign({}, node), { directives: node.directives.filter(d => !directiveNames.includes(d.name.value)) });
+    }
+    return node;
+}
+exports.removeDirectives = removeDirectives;
+function getReachableTypes(schema) {
+    const reachableTypes = new Set();
+    const collect = (type) => {
+        const typeName = type.name;
+        if (reachableTypes.has(typeName)) {
+            return;
+        }
+        reachableTypes.add(typeName);
+        if ((0, graphql_1.isScalarType)(type)) {
+            return;
+        }
+        if ((0, graphql_1.isInterfaceType)(type) || (0, graphql_1.isObjectType)(type)) {
+            if ((0, graphql_1.isInterfaceType)(type)) {
+                const { objects, interfaces } = schema.getImplementations(type);
+                for (const child of objects) {
+                    collect(child);
+                }
+                for (const child of interfaces) {
+                    collect(child);
+                }
+            }
+            const fields = type.getFields();
+            for (const fieldName in fields) {
+                const field = fields[fieldName];
+                collect(resolveOutputType(field.type));
+                const args = field.args;
+                for (const argName in args) {
+                    const arg = args[argName];
+                    collect(resolveInputType(arg.type));
+                }
+            }
+        }
+        else if ((0, graphql_1.isUnionType)(type)) {
+            const types = type.getTypes();
+            for (const child of types) {
+                collect(child);
+            }
+        }
+        else if ((0, graphql_1.isInputObjectType)(type)) {
+            const fields = type.getFields();
+            for (const fieldName in fields) {
+                const field = fields[fieldName];
+                collect(resolveInputType(field.type));
+            }
+        }
+    };
+    for (const type of [
+        schema.getQueryType(),
+        schema.getMutationType(),
+        schema.getSubscriptionType(),
+    ]) {
+        if (type) {
+            collect(type);
+        }
+    }
+    return reachableTypes;
+}
+exports.getReachableTypes = getReachableTypes;
+function resolveOutputType(output) {
+    if ((0, graphql_1.isListType)(output) || (0, graphql_1.isNonNullType)(output)) {
+        return resolveOutputType(output.ofType);
+    }
+    return output;
+}
+function resolveInputType(input) {
+    if ((0, graphql_1.isListType)(input) || (0, graphql_1.isNonNullType)(input)) {
+        return resolveInputType(input.ofType);
+    }
+    return input;
+}

package/cjs/utils/is-deprecated.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDeprecated = void 0;
+function isDeprecated(fieldOrEnumValue) {
+    var _a, _b;
+    if ('isDeprecated' in fieldOrEnumValue) {
+        return fieldOrEnumValue['isDeprecated'];
+    }
+    if (fieldOrEnumValue.deprecationReason != null) {
+        return true;
+    }
+    if ((_b = (_a = fieldOrEnumValue.astNode) === null || _a === void 0 ? void 0 : _a.directives) === null || _b === void 0 ? void 0 : _b.some(directive => directive.name.value === 'deprecated')) {
+        return true;
+    }
+    return false;
+}
+exports.isDeprecated = isDeprecated;

package/cjs/utils/path.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePath = void 0;
+function parsePath(path) {
+    return path.split('.');
+}
+exports.parsePath = parsePath;

package/cjs/utils/string.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeString = exports.findBestMatch = void 0;
+const tslib_1 = require("tslib");
+const object_inspect_1 = tslib_1.__importDefault(require("object-inspect"));
+function compareTwoStrings(str1, str2) {
+    if (!str1.length && !str2.length)
+        return 1;
+    if (!str1.length || !str2.length)
+        return 0;
+    if (str1.toUpperCase() === str2.toUpperCase())
+        return 1;
+    if (str1.length === 1 && str2.length === 1)
+        return 0;
+    const pairs1 = wordLetterPairs(str1);
+    const pairs2 = wordLetterPairs(str2);
+    const union = pairs1.length + pairs2.length;
+    let intersection = 0;
+    pairs1.forEach(pair1 => {
+        for (let i = 0, pair2; (pair2 = pairs2[i]); i++) {
+            if (pair1 !== pair2)
+                continue;
+            intersection++;
+            pairs2.splice(i, 1);
+            break;
+        }
+    });
+    return (intersection * 2) / union;
+}
+function findBestMatch(mainString, targetStrings) {
+    if (!areArgsValid(mainString, targetStrings))
+        throw new Error('Bad arguments: First argument should be a string, second should be an array of strings');
+    const ratings = targetStrings.map(target => ({
+        target,
+        rating: compareTwoStrings(mainString, target.value),
+    }));
+    const bestMatch = Array.from(ratings).sort((a, b) => b.rating - a.rating)[0];
+    return { ratings, bestMatch };
+}
+exports.findBestMatch = findBestMatch;
+function flattenDeep(arr) {
+    return Array.isArray(arr) ? arr.reduce((a, b) => a.concat(flattenDeep(b)), []) : [arr];
+}
+function areArgsValid(mainString, targetStrings) {
+    if (typeof mainString !== 'string')
+        return false;
+    if (!Array.isArray(targetStrings))
+        return false;
+    if (!targetStrings.length)
+        return false;
+    if (targetStrings.find(s => typeof s.value !== 'string'))
+        return false;
+    return true;
+}
+function letterPairs(str) {
+    const pairs = [];
+    for (let i = 0, max = str.length - 1; i < max; i++)
+        pairs[i] = str.substring(i, i + 2);
+    return pairs;
+}
+function wordLetterPairs(str) {
+    const pairs = str.toUpperCase().split(' ').map(letterPairs);
+    return flattenDeep(pairs);
+}
+function safeString(obj) {
+    return (0, object_inspect_1.default)(obj)
+        .replace(/\[Object: null prototype\] /g, '')
+        .replace(/(^')|('$)/g, '');
+}
+exports.safeString = safeString;

package/cjs/validate/alias-count.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countAliases = exports.validateAliasCount = void 0;
+const graphql_1 = require("graphql");
+function validateAliasCount({ source, doc, maxAliasCount, fragmentGraph, }) {
+    var _a;
+    const getFragmentByFragmentName = (fragmentName) => fragmentGraph.getNodeData(fragmentName);
+    for (const definition of doc.definitions) {
+        if (definition.kind !== graphql_1.Kind.OPERATION_DEFINITION) {
+            continue;
+        }
+        const aliasCount = countAliases(definition, getFragmentByFragmentName);
+        if (aliasCount > maxAliasCount) {
+            return new graphql_1.GraphQLError(`Too many aliases (${aliasCount}). Maximum allowed is ${maxAliasCount}`, [definition], source, ((_a = definition.loc) === null || _a === void 0 ? void 0 : _a.start) ? [definition.loc.start] : undefined);
+        }
+    }
+}
+exports.validateAliasCount = validateAliasCount;
+function countAliases(node, getFragmentByName) {
+    let aliases = 0;
+    if ('alias' in node && node.alias) {
+        ++aliases;
+    }
+    if ('selectionSet' in node && node.selectionSet) {
+        for (const child of node.selectionSet.selections) {
+            aliases += countAliases(child, getFragmentByName);
+        }
+    }
+    else if (node.kind === graphql_1.Kind.FRAGMENT_SPREAD) {
+        const fragmentNode = getFragmentByName(node.name.value);
+        if (fragmentNode) {
+            aliases += countAliases(fragmentNode, getFragmentByName);
+        }
+    }
+    return aliases;
+}
+exports.countAliases = countAliases;

package/cjs/validate/complexity.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateOperationComplexity = exports.validateComplexity = void 0;
+const graphql_1 = require("graphql");
+function validateComplexity({ source, doc, maxComplexityScore, config, fragmentGraph, }) {
+    var _a;
+    const getFragmentByFragmentName = (fragmentName) => fragmentGraph.getNodeData(fragmentName);
+    for (const definition of doc.definitions) {
+        if (definition.kind !== graphql_1.Kind.OPERATION_DEFINITION) {
+            continue;
+        }
+        const complexityScore = calculateOperationComplexity(definition, config, getFragmentByFragmentName);
+        if (complexityScore > maxComplexityScore) {
+            return new graphql_1.GraphQLError(`Too high complexity score (${complexityScore}). Maximum allowed is ${maxComplexityScore}`, [definition], source, ((_a = definition.loc) === null || _a === void 0 ? void 0 : _a.start) ? [definition.loc.start] : undefined);
+        }
+    }
+}
+exports.validateComplexity = validateComplexity;
+function calculateOperationComplexity(node, config, getFragmentByName, depth = 0) {
+    let cost = config.scalarCost;
+    if ('selectionSet' in node && node.selectionSet) {
+        cost = config.objectCost;
+        for (const child of node.selectionSet.selections) {
+            cost +=
+                config.depthCostFactor *
+                    calculateOperationComplexity(child, config, getFragmentByName, depth + 1);
+        }
+    }
+    if (node.kind == graphql_1.Kind.FRAGMENT_SPREAD) {
+        const fragment = getFragmentByName(node.name.value);
+        if (fragment) {
+            cost +=
+                config.depthCostFactor *
+                    calculateOperationComplexity(fragment, config, getFragmentByName, depth + 1);
+        }
+    }
+    return cost;
+}
+exports.calculateOperationComplexity = calculateOperationComplexity;

package/cjs/validate/directive-count.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countDirectives = exports.validateDirectiveCount = void 0;
+const graphql_1 = require("graphql");
+function validateDirectiveCount({ source, doc, maxDirectiveCount, fragmentGraph, }) {
+    var _a;
+    const getFragmentByFragmentName = (fragmentName) => fragmentGraph.getNodeData(fragmentName);
+    for (const definition of doc.definitions) {
+        if (definition.kind !== graphql_1.Kind.OPERATION_DEFINITION) {
+            continue;
+        }
+        const directiveCount = countDirectives(definition, getFragmentByFragmentName);
+        if (directiveCount > maxDirectiveCount) {
+            return new graphql_1.GraphQLError(`Too many directives (${directiveCount}). Maximum allowed is ${maxDirectiveCount}`, [definition], source, ((_a = definition.loc) === null || _a === void 0 ? void 0 : _a.start) ? [definition.loc.start] : undefined);
+        }
+    }
+}
+exports.validateDirectiveCount = validateDirectiveCount;
+function countDirectives(node, getFragmentByName) {
+    let directives = 0;
+    if (node.directives) {
+        directives += node.directives.length;
+    }
+    if ('selectionSet' in node && node.selectionSet) {
+        for (const child of node.selectionSet.selections) {
+            directives += countDirectives(child, getFragmentByName);
+        }
+    }
+    if (node.kind == graphql_1.Kind.FRAGMENT_SPREAD) {
+        const fragment = getFragmentByName(node.name.value);
+        if (fragment) {
+            directives += countDirectives(fragment, getFragmentByName);
+        }
+    }
+    return directives;
+}
+exports.countDirectives = countDirectives;

package/cjs/validate/index.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = void 0;
+const dependency_graph_1 = require("dependency-graph");
+const graphql_1 = require("graphql");
+const document_js_1 = require("../ast/document.js");
+const apollo_js_1 = require("../utils/apollo.js");
+const graphql_js_1 = require("../utils/graphql.js");
+const alias_count_js_1 = require("./alias-count.js");
+const directive_count_js_1 = require("./directive-count.js");
+const query_depth_js_1 = require("./query-depth.js");
+const token_count_js_1 = require("./token-count.js");
+function validate(schema, sources, options) {
+    const config = Object.assign({ strictDeprecated: true, strictFragments: true, keepClientFields: false, apollo: false }, options);
+    const invalidDocuments = [];
+    // read documents
+    const documents = sources.map(document_js_1.readDocument);
+    // keep all named fragments
+    const fragments = [];
+    const fragmentNames = [];
+    const graph = new dependency_graph_1.DepGraph({ circular: true });
+    documents.forEach(doc => {
+        doc.fragments.forEach(fragment => {
+            fragmentNames.push(fragment.node.name.value);
+            fragments.push(fragment);
+            graph.addNode(fragment.node.name.value, fragment.node);
+        });
+    });
+    fragments.forEach(fragment => {
+        const depends = extractFragments((0, graphql_1.print)(fragment.node));
+        if (depends) {
+            depends.forEach(name => {
+                graph.addDependency(fragment.node.name.value, name);
+            });
+        }
+    });
+    documents
+        // since we include fragments, validate only operations
+        .filter(doc => doc.hasOperations)
+        .forEach(doc => {
+        const docWithOperations = {
+            kind: graphql_1.Kind.DOCUMENT,
+            definitions: doc.operations.map(d => d.node),
+        };
+        const extractedFragments = (extractFragments((0, graphql_1.print)(docWithOperations)) || [])
+            // resolve all nested fragments
+            .map(fragmentName => resolveFragment(graph.getNodeData(fragmentName), graph))
+            // flatten arrays
+            .reduce((list, current) => list.concat(current), [])
+            // remove duplicates
+            .filter((def, i, all) => all.findIndex(item => item.name.value === def.name.value) === i);
+        const merged = {
+            kind: graphql_1.Kind.DOCUMENT,
+            definitions: [...docWithOperations.definitions, ...extractedFragments],
+        };
+        const transformedSchema = config.apollo ? (0, apollo_js_1.transformSchemaWithApollo)(schema) : schema;
+        const transformedDoc = config.apollo
+            ? (0, apollo_js_1.transformDocumentWithApollo)(merged, {
+                keepClientFields: config.keepClientFields,
+            })
+            : merged;
+        const errors = (0, graphql_1.validate)(transformedSchema, transformedDoc) || [];
+        if (config.maxDepth) {
+            const depthError = (0, query_depth_js_1.validateQueryDepth)({
+                source: doc.source,
+                doc: transformedDoc,
+                maxDepth: config.maxDepth,
+                fragmentGraph: graph,
+            });
+            if (depthError) {
+                errors.push(depthError);
+            }
+        }
+        if (config.maxAliasCount) {
+            const aliasError = (0, alias_count_js_1.validateAliasCount)({
+                source: doc.source,
+                doc: transformedDoc,
+                maxAliasCount: config.maxAliasCount,
+                fragmentGraph: graph,
+            });
+            if (aliasError) {
+                errors.push(aliasError);
+            }
+        }
+        if (config.maxDirectiveCount) {
+            const directiveError = (0, directive_count_js_1.validateDirectiveCount)({
+                source: doc.source,
+                doc: transformedDoc,
+                maxDirectiveCount: config.maxDirectiveCount,
+                fragmentGraph: graph,
+            });
+            if (directiveError) {
+                errors.push(directiveError);
+            }
+        }
+        if (config.maxTokenCount) {
+            const tokenCountError = (0, token_count_js_1.validateTokenCount)({
+                source: doc.source,
+                document: transformedDoc,
+                maxTokenCount: config.maxTokenCount,
+                getReferencedFragmentSource: fragmentName => (0, graphql_1.print)(graph.getNodeData(fragmentName)),
+            });
+            if (tokenCountError) {
+                errors.push(tokenCountError);
+            }
+        }
+        const deprecated = config.strictDeprecated
+            ? (0, graphql_js_1.findDeprecatedUsages)(transformedSchema, transformedDoc)
+            : [];
+        const duplicatedFragments = config.strictFragments
+            ? findDuplicatedFragments(fragmentNames)
+            : [];
+        if (sumLengths(errors, duplicatedFragments, deprecated) > 0) {
+            invalidDocuments.push({
+                source: doc.source,
+                errors: [...errors, ...duplicatedFragments],
+                deprecated,
+            });
+        }
+    });
+    return invalidDocuments;
+}
+exports.validate = validate;
+function findDuplicatedFragments(fragmentNames) {
+    return fragmentNames
+        .filter((name, i, all) => all.indexOf(name) !== i)
+        .map(name => new graphql_1.GraphQLError(`Name of '${name}' fragment is not unique`));
+}
+//
+// PostInfo -> AuthorInfo
+// AuthorInfo -> None
+//
+function resolveFragment(fragment, graph) {
+    return graph
+        .dependenciesOf(fragment.name.value)
+        .reduce((list, current) => [...list, ...resolveFragment(graph.getNodeData(current), graph)], [fragment]);
+}
+function extractFragments(document) {
+    return (document.match(/[.]{3}[a-z0-9_]+\b/gi) || []).map(name => name.replace('...', ''));
+}
+function sumLengths(...arrays) {
+    return arrays.reduce((sum, { length }) => sum + length, 0);
+}

package/cjs/validate/query-depth.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countDepth = exports.calculateDepth = exports.validateQueryDepth = void 0;
+const graphql_1 = require("graphql");
+function validateQueryDepth({ source, doc, maxDepth, fragmentGraph, }) {
+    var _a;
+    try {
+        calculateDepth({
+            node: doc,
+            currentDepth: 0,
+            maxDepth,
+            getFragment(name) {
+                return fragmentGraph.getNodeData(name);
+            },
+        });
+    }
+    catch (errorOrNode) {
+        if (errorOrNode instanceof Error) {
+            throw errorOrNode;
+        }
+        const node = errorOrNode;
+        return new graphql_1.GraphQLError(`Query exceeds maximum depth of ${maxDepth}`, node, source, ((_a = node.loc) === null || _a === void 0 ? void 0 : _a.start) ? [node.loc.start] : undefined);
+    }
+}
+exports.validateQueryDepth = validateQueryDepth;
+function calculateDepth({ node, currentDepth, maxDepth, getFragment, }) {
+    if (maxDepth && currentDepth > maxDepth) {
+        throw node;
+    }
+    switch (node.kind) {
+        case graphql_1.Kind.FIELD: {
+            if (node.name.value.startsWith('__') || !node.selectionSet) {
+                return 0;
+            }
+            const maxInnerDepth = calculateDepth({
+                node: node.selectionSet,
+                currentDepth: currentDepth + 1,
+                maxDepth,
+                getFragment,
+            });
+            return 1 + maxInnerDepth;
+        }
+        case graphql_1.Kind.SELECTION_SET: {
+            return Math.max(...node.selections.map(selection => {
+                return calculateDepth({
+                    node: selection,
+                    currentDepth,
+                    maxDepth,
+                    getFragment,
+                });
+            }));
+        }
+        case graphql_1.Kind.DOCUMENT: {
+            return Math.max(...node.definitions.map(def => {
+                return calculateDepth({
+                    node: def,
+                    currentDepth,
+                    maxDepth,
+                    getFragment,
+                });
+            }));
+        }
+        case graphql_1.Kind.OPERATION_DEFINITION:
+        case graphql_1.Kind.INLINE_FRAGMENT:
+        case graphql_1.Kind.FRAGMENT_DEFINITION: {
+            return Math.max(...node.selectionSet.selections.map(selection => {
+                return calculateDepth({
+                    node: selection,
+                    currentDepth,
+                    maxDepth,
+                    getFragment,
+                });
+            }));
+        }
+        case graphql_1.Kind.FRAGMENT_SPREAD:
+            return calculateDepth({
+                node: getFragment(node.name.value),
+                currentDepth,
+                maxDepth,
+                getFragment,
+            });
+        default: {
+            throw new Error(`Couldn't handle ${node.kind}`);
+        }
+    }
+}
+exports.calculateDepth = calculateDepth;
+function countDepth(node, parentDepth, getFragmentReference) {
+    let depth = parentDepth;
+    if ('selectionSet' in node && node.selectionSet) {
+        for (const child of node.selectionSet.selections) {
+            depth = Math.max(depth, countDepth(child, parentDepth + 1, getFragmentReference));
+        }
+    }
+    if (node.kind == graphql_1.Kind.FRAGMENT_SPREAD) {
+        const fragment = getFragmentReference(node.name.value);
+        if (fragment) {
+            depth = Math.max(depth, countDepth(fragment, parentDepth + 1, getFragmentReference));
+        }
+    }
+    return depth;
+}
+exports.countDepth = countDepth;