@graphql-inspector/core 3.1.4 → 3.4.0

package/{dist/index.js → index.js}

@@ -8,6 +8,7 @@ const tslib = require('tslib');
 const graphql = require('graphql');
 const inspect = _interopDefault(require('object-inspect'));
 const dependencyGraph = require('dependency-graph');
+const parser = require('graphql/language/parser');
 
 function keyMap(list, keyFn) {
     return list.reduce((map, item) => {
@@ -49,7 +50,7 @@ function isVoid(a) {
     return typeof a === 'undefined' || a === null;
 }
 function diffArrays(a, b) {
-    return a.filter((c) => !b.some((d) => isEqual(d, c)));
+    return a.filter(c => !b.some(d => isEqual(d, c)));
 }
 function compareLists(oldList, newList, callbacks) {
     const oldMap = keyMap(oldList, ({ name }) => name);
@@ -100,7 +101,7 @@ function isDeprecated(fieldOrEnumValue) {
     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')) {
+    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;
@@ -115,8 +116,7 @@ function safeChangeForField(oldType, newType) {
         return safeChangeForField(ofType, newType.ofType);
     }
     if (graphql.isListType(oldType)) {
-        return ((graphql.isListType(newType) &&
-            safeChangeForField(oldType.ofType, newType.ofType)) ||
+        return ((graphql.isListType(newType) && safeChangeForField(oldType.ofType, newType.ofType)) ||
             (graphql.isNonNullType(newType) && safeChangeForField(oldType, newType.ofType)));
     }
     return false;
@@ -129,7 +129,7 @@ function safeChangeForInputValue(oldType, newType) {
         return safeChangeForInputValue(oldType.ofType, newType.ofType);
     }
     if (graphql.isNonNullType(oldType)) {
-        const ofType = graphql.isNonNullType(newType) ? newType : newType;
+        const ofType = graphql.isNonNullType(newType) ? newType.ofType : newType;
         return safeChangeForInputValue(oldType.ofType, ofType);
     }
     return false;
@@ -151,7 +151,7 @@ function getTypePrefix(type) {
     return kindsMap[kind.toString()];
 }
 function isPrimitive(type) {
-    return (['String', 'Int', 'Float', 'Boolean', 'ID'].indexOf(typeof type === 'string' ? type : type.name) !== -1);
+    return ['String', 'Int', 'Float', 'Boolean', 'ID'].indexOf(typeof type === 'string' ? type : type.name) !== -1;
 }
 function isForIntrospection(type) {
     return ([
@@ -176,7 +176,9 @@ function findDeprecatedUsages(schema, ast) {
                 if (reason) {
                     const fieldDef = typeInfo.getFieldDef();
                     if (fieldDef) {
-                        errors.push(new graphql.GraphQLError(`The argument '${argument === null || argument === void 0 ? void 0 : argument.name}' of '${fieldDef.name}' is deprecated. ${reason}`, [node]));
+                        errors.push(new graphql.GraphQLError(`The argument '${argument === null || argument === void 0 ? void 0 : argument.name}' of '${fieldDef.name}' is deprecated. ${reason}`, [
+                            node,
+                        ]));
                     }
                 }
             }
@@ -206,7 +208,7 @@ function findDeprecatedUsages(schema, ast) {
 }
 function removeFieldIfDirectives(node, directiveNames) {
     if (node.directives) {
-        if (node.directives.some((d) => directiveNames.indexOf(d.name.value) !== -1)) {
+        if (node.directives.some(d => directiveNames.indexOf(d.name.value) !== -1)) {
             return null;
         }
     }
@@ -214,7 +216,7 @@ function removeFieldIfDirectives(node, directiveNames) {
 }
 function removeDirectives(node, directiveNames) {
     if (node.directives) {
-        return Object.assign(Object.assign({}, node), { directives: node.directives.filter((d) => directiveNames.indexOf(d.name.value) === -1) });
+        return Object.assign(Object.assign({}, node), { directives: node.directives.filter(d => directiveNames.indexOf(d.name.value) === -1) });
     }
     return node;
 }
@@ -264,11 +266,7 @@ function getReachableTypes(schema) {
             }
         }
     };
-    for (const type of [
-        schema.getQueryType(),
-        schema.getMutationType(),
-        schema.getSubscriptionType(),
-    ]) {
+    for (const type of [schema.getQueryType(), schema.getMutationType(), schema.getSubscriptionType()]) {
         if (type) {
             collect(type);
         }
@@ -508,9 +506,7 @@ function directiveLocationRemoved(directive, location) {
 function directiveArgumentAdded(directive, arg) {
     return {
         criticality: {
-            level: graphql.isNonNullType(arg.type)
-                ? exports.CriticalityLevel.Breaking
-                : exports.CriticalityLevel.NonBreaking,
+            level: graphql.isNonNullType(arg.type) ? exports.CriticalityLevel.Breaking : exports.CriticalityLevel.NonBreaking,
         },
         type: exports.ChangeType.DirectiveArgumentAdded,
         message: `Argument '${arg.name}' was added to directive '${directive.name}'`,
@@ -696,6 +692,70 @@ function changesInUnion(oldUnion, newUnion, addChange) {
     });
 }
 
+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 };
+}
+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 inspect(obj)
+        .replace(/\[Object\: null prototype\] /g, '')
+        .replace(/(^')|('$)/g, '');
+}
+
 function inputFieldRemoved(input, field) {
     return {
         criticality: {
@@ -703,7 +763,7 @@ function inputFieldRemoved(input, field) {
             reason: 'Removing an input field will cause existing queries that use this input field to error.',
         },
         type: exports.ChangeType.InputFieldRemoved,
-        message: `Input field '${field.name}' was removed from input object type '${input.name}'`,
+        message: `Input field '${field.name}' ${isDeprecated(field) ? '(deprecated) ' : ''}was removed from input object type '${input.name}'`,
         path: [input.name, field.name].join('.'),
     };
 }
@@ -756,10 +816,10 @@ function inputFieldDefaultValueChanged(input, oldField, newField) {
     return {
         criticality: {
             level: exports.CriticalityLevel.Dangerous,
-            reason: 'Changing the default value for an argument may change the runtime behaviour of a field if it was never provided.',
+            reason: 'Changing the default value for an argument may change the runtime behavior of a field if it was never provided.',
         },
         type: exports.ChangeType.InputFieldDefaultValueChanged,
-        message: `Input field '${input.name}.${oldField.name}' default value changed from '${oldField.defaultValue}' to '${newField.defaultValue}'`,
+        message: `Input field '${input.name}.${oldField.name}' default value changed from '${safeString(oldField.defaultValue)}' to '${safeString(newField.defaultValue)}'`,
         path: [input.name, oldField.name].join('.'),
     };
 }
@@ -808,14 +868,12 @@ function changesInInputField(input, oldField, newField, addChange) {
         }
     }
     if (isNotEqual(oldField.defaultValue, newField.defaultValue)) {
-        if (Array.isArray(oldField.defaultValue) &&
-            Array.isArray(newField.defaultValue)) {
+        if (Array.isArray(oldField.defaultValue) && Array.isArray(newField.defaultValue)) {
             if (diffArrays(oldField.defaultValue, newField.defaultValue).length > 0) {
                 addChange(inputFieldDefaultValueChanged(input, oldField, newField));
             }
         }
-        else if (JSON.stringify(oldField.defaultValue) !==
-            JSON.stringify(newField.defaultValue)) {
+        else if (JSON.stringify(oldField.defaultValue) !== JSON.stringify(newField.defaultValue)) {
             addChange(inputFieldDefaultValueChanged(input, oldField, newField));
         }
     }
@@ -965,8 +1023,10 @@ function fieldTypeChanged(type, oldField, newField) {
     };
 }
 function fieldArgumentAdded(type, field, arg) {
+    const isBreaking = graphql.isNonNullType(arg.type) && typeof arg.defaultValue === 'undefined';
+    const defaultValueMsg = typeof arg.defaultValue !== 'undefined' ? ' (with default value) ' : ' ';
     return {
-        criticality: graphql.isNonNullType(arg.type)
+        criticality: isBreaking
             ? {
                 level: exports.CriticalityLevel.Breaking,
                 reason: `Adding a required argument to an existing field is a breaking change because it will cause existing uses of this field to error.`,
@@ -976,7 +1036,7 @@ function fieldArgumentAdded(type, field, arg) {
                 reason: `Adding a new argument to an existing field may involve a change in resolve function logic that potentially may cause some side effects.`,
             },
         type: exports.ChangeType.FieldArgumentAdded,
-        message: `Argument '${arg.name}: ${arg.type}' added to field '${type.name}.${field.name}'`,
+        message: `Argument '${arg.name}: ${arg.type}'${defaultValueMsg}added to field '${type.name}.${field.name}'`,
         path: [type.name, field.name, arg.name].join('.'),
     };
 }
@@ -992,70 +1052,6 @@ function fieldArgumentRemoved(type, field, arg) {
     };
 }
 
-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 };
-}
-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 inspect(obj).replace(/\[Object\: null prototype\] /g, '');
-}
-
 function fieldArgumentDescriptionChanged(type, field, oldArg, newArg) {
     return {
         criticality: {
@@ -1101,15 +1097,13 @@ function changesInArgument(type, field, oldArg, newArg, addChange) {
         addChange(fieldArgumentDescriptionChanged(type, field, oldArg, newArg));
     }
     if (isNotEqual(oldArg.defaultValue, newArg.defaultValue)) {
-        if (Array.isArray(oldArg.defaultValue) &&
-            Array.isArray(newArg.defaultValue)) {
+        if (Array.isArray(oldArg.defaultValue) && Array.isArray(newArg.defaultValue)) {
             const diff = diffArrays(oldArg.defaultValue, newArg.defaultValue);
             if (diff.length > 0) {
                 addChange(fieldArgumentDefaultChanged(type, field, oldArg, newArg));
             }
         }
-        else if (JSON.stringify(oldArg.defaultValue) !==
-            JSON.stringify(newArg.defaultValue)) {
+        else if (JSON.stringify(oldArg.defaultValue) !== JSON.stringify(newArg.defaultValue)) {
             addChange(fieldArgumentDefaultChanged(type, field, oldArg, newArg));
         }
     }
@@ -1214,9 +1208,9 @@ function changesInDirective(oldDirective, newDirective, addChange) {
         removed: diffArrays(oldDirective.locations, newDirective.locations),
     };
     // locations added
-    locations.added.forEach((location) => addChange(directiveLocationAdded(newDirective, location)));
+    locations.added.forEach(location => addChange(directiveLocationAdded(newDirective, location)));
     // locations removed
-    locations.removed.forEach((location) => addChange(directiveLocationRemoved(oldDirective, location)));
+    locations.removed.forEach(location => addChange(directiveLocationRemoved(oldDirective, location)));
     compareLists(oldDirective.args, newDirective.args, {
         onAdded(arg) {
             addChange(directiveArgumentAdded(newDirective, arg));
@@ -1247,7 +1241,7 @@ function diffSchema(oldSchema, newSchema) {
         changes.push(change);
     }
     changesInSchema(oldSchema, newSchema, addChange);
-    compareLists(Object.values(oldSchema.getTypeMap()).filter((t) => !isPrimitive(t)), Object.values(newSchema.getTypeMap()).filter((t) => !isPrimitive(t)), {
+    compareLists(Object.values(oldSchema.getTypeMap()).filter(t => !isPrimitive(t)), Object.values(newSchema.getTypeMap()).filter(t => !isPrimitive(t)), {
         onAdded(type) {
             addChange(typeAdded(type));
         },
@@ -1332,7 +1326,7 @@ function changesInType(oldType, newType, addChange) {
 }
 
 const dangerousBreaking = ({ changes }) => {
-    return changes.map((change) => {
+    return changes.map(change => {
         if (change.criticality.level === exports.CriticalityLevel.Dangerous) {
             return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: exports.CriticalityLevel.Breaking }) });
         }
@@ -1344,8 +1338,8 @@ function parsePath(path) {
     return path.split('.');
 }
 
-const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, }) => {
-    return changes.map((change) => {
+const suppressRemovalOfDeprecatedField = ({ changes, oldSchema }) => {
+    return changes.map(change => {
         if (change.type === exports.ChangeType.FieldRemoved &&
             change.criticality.level === exports.CriticalityLevel.Breaking &&
             change.path) {
@@ -1370,6 +1364,18 @@ const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, }) => {
                 }
             }
         }
+        if (change.type === exports.ChangeType.InputFieldRemoved &&
+            change.criticality.level === exports.CriticalityLevel.Breaking &&
+            change.path) {
+            const [inputName, inputItem] = parsePath(change.path);
+            const type = oldSchema.getType(inputName);
+            if (graphql.isInputObjectType(type)) {
+                const item = type.getFields()[inputItem];
+                if (item && isDeprecated(item)) {
+                    return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: exports.CriticalityLevel.Dangerous }) });
+                }
+            }
+        }
         return change;
     });
 };
@@ -1388,15 +1394,15 @@ const descriptionChangeTypes = [
     exports.ChangeType.TypeDescriptionChanged,
 ];
 const ignoreDescriptionChanges = ({ changes }) => {
-    return changes.filter((change) => descriptionChangeTypes.indexOf(change.type) === -1);
+    return changes.filter(change => descriptionChangeTypes.indexOf(change.type) === -1);
 };
 
-const considerUsage = ({ changes, config, }) => tslib.__awaiter(void 0, void 0, void 0, function* () {
+const considerUsage = ({ changes, config }) => tslib.__awaiter(void 0, void 0, void 0, function* () {
     if (!config) {
         throw new Error(`considerUsage rule is missing config`);
     }
     const collectedBreakingField = [];
-    changes.forEach((change) => {
+    changes.forEach(change => {
         if (change.criticality.level === exports.CriticalityLevel.Breaking && change.path) {
             const [typeName, fieldName, argumentName] = parsePath(change.path);
             collectedBreakingField.push({
@@ -1413,11 +1419,11 @@ const considerUsage = ({ changes, config, }) => tslib.__awaiter(void 0, void 0,
     const suppressedPaths = collectedBreakingField
         .filter((_, i) => usageList[i] === true)
         .map(({ type, field, argument }) => [type, field, argument].filter(Boolean).join('.'));
-    return changes.map((change) => {
+    return changes.map(change => {
         // Turns those "safe to break" changes into "dangerous"
         if (change.criticality.level === exports.CriticalityLevel.Breaking &&
             change.path &&
-            suppressedPaths.some((p) => change.path.startsWith(p))) {
+            suppressedPaths.some(p => change.path.startsWith(p))) {
             return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: exports.CriticalityLevel.Dangerous }), message: `${change.message} (non-breaking based on usage)` });
         }
         return change;
@@ -1426,7 +1432,7 @@ const considerUsage = ({ changes, config, }) => tslib.__awaiter(void 0, void 0,
 
 const safeUnreachable = ({ changes, oldSchema }) => {
     const reachable = getReachableTypes(oldSchema);
-    return changes.map((change) => {
+    return changes.map(change => {
         if (change.criticality.level === exports.CriticalityLevel.Breaking && change.path) {
             const [typeName] = parsePath(change.path);
             if (!reachable.has(typeName)) {
@@ -1533,7 +1539,7 @@ function calculateDepth({ node, currentDepth, maxDepth, getFragment, }) {
             return 1 + maxInnerDepth;
         }
         case graphql.Kind.SELECTION_SET: {
-            return Math.max(...node.selections.map((selection) => {
+            return Math.max(...node.selections.map(selection => {
                 return calculateDepth({
                     node: selection,
                     currentDepth: currentDepth,
@@ -1543,7 +1549,7 @@ function calculateDepth({ node, currentDepth, maxDepth, getFragment, }) {
             }));
         }
         case graphql.Kind.DOCUMENT: {
-            return Math.max(...node.definitions.map((def) => {
+            return Math.max(...node.definitions.map(def => {
                 return calculateDepth({
                     node: def,
                     currentDepth: currentDepth,
@@ -1555,7 +1561,7 @@ function calculateDepth({ node, currentDepth, maxDepth, getFragment, }) {
         case graphql.Kind.OPERATION_DEFINITION:
         case graphql.Kind.INLINE_FRAGMENT:
         case graphql.Kind.FRAGMENT_DEFINITION: {
-            return Math.max(...node.selectionSet.selections.map((selection) => {
+            return Math.max(...node.selectionSet.selections.map(selection => {
                 return calculateDepth({
                     node: selection,
                     currentDepth,
@@ -1576,13 +1582,26 @@ function calculateDepth({ node, currentDepth, maxDepth, getFragment, }) {
         }
     }
 }
+function countDepth(node, parentDepth, getFragmentReference) {
+    let depth = parentDepth;
+    if ('selectionSet' in node && node.selectionSet) {
+        for (let child of node.selectionSet.selections) {
+            depth = Math.max(depth, countDepth(child, parentDepth + 1, getFragmentReference));
+        }
+    }
+    if (node.kind == graphql.Kind.FRAGMENT_SPREAD) {
+        const fragment = getFragmentReference(node.name.value);
+        if (fragment) {
+            depth = Math.max(depth, countDepth(fragment, parentDepth + 1, getFragmentReference));
+        }
+    }
+    return depth;
+}
 
 function transformDocumentWithApollo(doc, { keepClientFields }) {
     return graphql.visit(doc, {
         Field(node) {
-            return keepClientFields
-                ? removeDirectives(node, ['client'])
-                : removeFieldIfDirectives(node, ['client']);
+            return keepClientFields ? removeDirectives(node, ['client']) : removeFieldIfDirectives(node, ['client']);
         },
     });
 }
@@ -1592,6 +1611,116 @@ function transformSchemaWithApollo(schema) {
     `));
 }
 
+function validateAliasCount({ source, doc, maxAliasCount, fragmentGraph, }) {
+    const getFragmentByFragmentName = (fragmentName) => fragmentGraph.getNodeData(fragmentName);
+    for (const definition of doc.definitions) {
+        if (definition.kind !== graphql.Kind.OPERATION_DEFINITION) {
+            continue;
+        }
+        const aliasCount = countAliases(definition, getFragmentByFragmentName);
+        if (aliasCount > maxAliasCount) {
+            return new graphql.GraphQLError(`Too many aliases (${aliasCount}). Maximum allowed is ${maxAliasCount}`, [definition], source, definition.loc && definition.loc.start ? [definition.loc.start] : undefined);
+        }
+    }
+}
+function countAliases(node, getFragmentByName) {
+    let aliases = 0;
+    if ('alias' in node && node.alias) {
+        ++aliases;
+    }
+    if ('selectionSet' in node && node.selectionSet) {
+        for (let child of node.selectionSet.selections) {
+            aliases += countAliases(child, getFragmentByName);
+        }
+    }
+    else if (node.kind === graphql.Kind.FRAGMENT_SPREAD) {
+        const fragmentNode = getFragmentByName(node.name.value);
+        if (fragmentNode) {
+            aliases += countAliases(fragmentNode, getFragmentByName);
+        }
+    }
+    return aliases;
+}
+
+function validateDirectiveCount({ source, doc, maxDirectiveCount, fragmentGraph, }) {
+    const getFragmentByFragmentName = (fragmentName) => fragmentGraph.getNodeData(fragmentName);
+    for (const definition of doc.definitions) {
+        if (definition.kind !== graphql.Kind.OPERATION_DEFINITION) {
+            continue;
+        }
+        const directiveCount = countDirectives(definition, getFragmentByFragmentName);
+        if (directiveCount > maxDirectiveCount) {
+            return new graphql.GraphQLError(`Too many directives (${directiveCount}). Maximum allowed is ${maxDirectiveCount}`, [definition], source, definition.loc && definition.loc.start ? [definition.loc.start] : undefined);
+        }
+    }
+}
+function countDirectives(node, getFragmentByName) {
+    let directives = 0;
+    if (node.directives) {
+        directives += node.directives.length;
+    }
+    if ('selectionSet' in node && node.selectionSet) {
+        for (let child of node.selectionSet.selections) {
+            directives += countDirectives(child, getFragmentByName);
+        }
+    }
+    if (node.kind == graphql.Kind.FRAGMENT_SPREAD) {
+        const fragment = getFragmentByName(node.name.value);
+        if (fragment) {
+            directives += countDirectives(fragment, getFragmentByName);
+        }
+    }
+    return directives;
+}
+
+class ParserWithLexer extends parser.Parser {
+    constructor(source, options) {
+        super(source, options);
+        this.__tokenCount = 0;
+        const lexer = this._lexer;
+        this._lexer = new Proxy(lexer, {
+            get: (target, prop, receiver) => {
+                if (prop === 'advance') {
+                    return () => {
+                        const token = target.advance();
+                        if (token.kind !== graphql.TokenKind.EOF) {
+                            this.__tokenCount++;
+                        }
+                        return token;
+                    };
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+        });
+    }
+    get tokenCount() {
+        return this.__tokenCount;
+    }
+}
+function calculateTokenCount(args) {
+    const parser = new ParserWithLexer(args.source);
+    const document = parser.parseDocument();
+    let { tokenCount } = parser;
+    graphql.visit(document, {
+        FragmentSpread(node) {
+            const fragmentSource = args.getReferencedFragmentSource(node.name.value);
+            if (fragmentSource) {
+                tokenCount += calculateTokenCount({
+                    source: fragmentSource,
+                    getReferencedFragmentSource: args.getReferencedFragmentSource,
+                });
+            }
+        },
+    });
+    return tokenCount;
+}
+function validateTokenCount(args) {
+    const tokenCount = calculateTokenCount(args);
+    if (tokenCount > args.maxTokenCount) {
+        return new graphql.GraphQLError(`Query exceeds maximum token count of ${args.maxTokenCount} (actual: ${tokenCount})`, args.document, args.source, args.document.loc && args.document.loc.start ? [args.document.loc.start] : undefined);
+    }
+}
+
 function validate(schema, sources, options) {
     const config = Object.assign({ strictDeprecated: true, strictFragments: true, keepClientFields: false, apollo: false }, options);
     const invalidDocuments = [];
@@ -1601,43 +1730,41 @@ function validate(schema, sources, options) {
     const fragments = [];
     const fragmentNames = [];
     const graph = new dependencyGraph.DepGraph({ circular: true });
-    documents.forEach((doc) => {
-        doc.fragments.forEach((fragment) => {
+    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) => {
+    fragments.forEach(fragment => {
         const depends = extractFragments(graphql.print(fragment.node));
         if (depends) {
-            depends.forEach((name) => {
+            depends.forEach(name => {
                 graph.addDependency(fragment.node.name.value, name);
             });
         }
     });
     documents
         // since we include fragments, validate only operations
-        .filter((doc) => doc.hasOperations)
-        .forEach((doc) => {
+        .filter(doc => doc.hasOperations)
+        .forEach(doc => {
         const docWithOperations = {
             kind: graphql.Kind.DOCUMENT,
-            definitions: doc.operations.map((d) => d.node),
+            definitions: doc.operations.map(d => d.node),
         };
         const extractedFragments = (extractFragments(graphql.print(docWithOperations)) || [])
             // resolve all nested fragments
-            .map((fragmentName) => resolveFragment(graph.getNodeData(fragmentName), graph))
+            .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);
+            .filter((def, i, all) => all.findIndex(item => item.name.value === def.name.value) === i);
         const merged = {
             kind: graphql.Kind.DOCUMENT,
             definitions: [...docWithOperations.definitions, ...extractedFragments],
         };
-        let transformedSchema = config.apollo
-            ? transformSchemaWithApollo(schema)
-            : schema;
+        let transformedSchema = config.apollo ? transformSchemaWithApollo(schema) : schema;
         const transformedDoc = config.apollo
             ? transformDocumentWithApollo(merged, {
                 keepClientFields: config.keepClientFields,
@@ -1655,12 +1782,41 @@ function validate(schema, sources, options) {
                 errors.push(depthError);
             }
         }
-        const deprecated = config.strictDeprecated
-            ? findDeprecatedUsages(transformedSchema, transformedDoc)
-            : [];
-        const duplicatedFragments = config.strictFragments
-            ? findDuplicatedFragments(fragmentNames)
-            : [];
+        if (config.maxAliasCount) {
+            const aliasError = validateAliasCount({
+                source: doc.source,
+                doc: transformedDoc,
+                maxAliasCount: config.maxAliasCount,
+                fragmentGraph: graph,
+            });
+            if (aliasError) {
+                errors.push(aliasError);
+            }
+        }
+        if (config.maxDirectiveCount) {
+            const directiveError = validateDirectiveCount({
+                source: doc.source,
+                doc: transformedDoc,
+                maxDirectiveCount: config.maxDirectiveCount,
+                fragmentGraph: graph,
+            });
+            if (directiveError) {
+                errors.push(directiveError);
+            }
+        }
+        if (config.maxTokenCount) {
+            const tokenCountError = validateTokenCount({
+                source: doc.source,
+                document: transformedDoc,
+                maxTokenCount: config.maxTokenCount,
+                getReferencedFragmentSource: fragmentName => graphql.print(graph.getNodeData(fragmentName)),
+            });
+            if (tokenCountError) {
+                errors.push(tokenCountError);
+            }
+        }
+        const deprecated = config.strictDeprecated ? findDeprecatedUsages(transformedSchema, transformedDoc) : [];
+        const duplicatedFragments = config.strictFragments ? findDuplicatedFragments(fragmentNames) : [];
         if (sumLengths(errors, duplicatedFragments, deprecated) > 0) {
             invalidDocuments.push({
                 source: doc.source,
@@ -1674,7 +1830,7 @@ function validate(schema, sources, options) {
 function findDuplicatedFragments(fragmentNames) {
     return fragmentNames
         .filter((name, i, all) => all.indexOf(name) !== i)
-        .map((name) => new graphql.GraphQLError(`Name of '${name}' fragment is not unique`));
+        .map(name => new graphql.GraphQLError(`Name of '${name}' fragment is not unique`));
 }
 //
 // PostInfo -> AuthorInfo
@@ -1683,13 +1839,10 @@ function findDuplicatedFragments(fragmentNames) {
 function resolveFragment(fragment, graph) {
     return graph
         .dependenciesOf(fragment.name.value)
-        .reduce((list, current) => [
-        ...list,
-        ...resolveFragment(graph.getNodeData(current), graph),
-    ], [fragment]);
+        .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('...', ''));
+    return (document.match(/[\.]{3}[a-z0-9\_]+\b/gi) || []).map(name => name.replace('...', ''));
 }
 function sumLengths(...arrays) {
     return arrays.reduce((sum, { length }) => sum + length, 0);
@@ -1698,20 +1851,19 @@ function sumLengths(...arrays) {
 function similar(schema, typeName, threshold = 0.4) {
     const typeMap = schema.getTypeMap();
     const targets = Object.keys(schema.getTypeMap())
-        .filter((name) => !isPrimitive(name) && !isForIntrospection(name))
-        .map((name) => ({
+        .filter(name => !isPrimitive(name) && !isForIntrospection(name))
+        .map(name => ({
         typeId: name,
         value: stripType(typeMap[name]),
     }));
     const results = {};
-    if (typeof typeName !== 'undefined' &&
-        !targets.some((t) => t.typeId === typeName)) {
+    if (typeof typeName !== 'undefined' && !targets.some(t => t.typeId === typeName)) {
         throw new Error(`Type '${typeName}' doesn't exist`);
     }
-    (typeName ? [{ typeId: typeName, value: '' }] : targets).forEach((source) => {
+    (typeName ? [{ typeId: typeName, value: '' }] : targets).forEach(source => {
         const sourceType = schema.getType(source.typeId);
-        const matchWith = targets.filter((target) => schema.getType(target.typeId).astNode.kind ===
-            sourceType.astNode.kind && target.typeId !== source.typeId);
+        const matchWith = targets.filter(target => schema.getType(target.typeId).astNode.kind === sourceType.astNode.kind &&
+            target.typeId !== source.typeId);
         if (matchWith.length > 0) {
             const found = similarTo(sourceType, matchWith, threshold);
             if (found) {
@@ -1722,7 +1874,7 @@ function similar(schema, typeName, threshold = 0.4) {
     return results;
 }
 function similarTo(type, targets, threshold) {
-    const types = targets.filter((target) => target.typeId !== type.name);
+    const types = targets.filter(target => target.typeId !== type.name);
     const result = findBestMatch(stripType(type), types);
     if (result.bestMatch.rating < threshold) {
         return;
@@ -1730,7 +1882,7 @@ function similarTo(type, targets, threshold) {
     return {
         bestMatch: result.bestMatch,
         ratings: result.ratings
-            .filter((r) => r.rating >= threshold && r.target !== result.bestMatch.target)
+            .filter(r => r.rating >= threshold && r.target !== result.bestMatch.target)
             .sort((a, b) => a.rating - b.rating)
             .reverse(),
     };
@@ -1742,7 +1894,7 @@ function stripType(type) {
         .replace(/\}$/g, '')
         .trim()
         .split('\n')
-        .map((s) => s.trim())
+        .map(s => s.trim())
         .sort((a, b) => a.localeCompare(b))
         .join(' ');
 }
@@ -1754,7 +1906,7 @@ function coverage(schema, sources) {
     };
     const typeMap = schema.getTypeMap();
     const typeInfo = new graphql.TypeInfo(schema);
-    const visitor = (source) => ({
+    const visitor = source => ({
         Field(node) {
             const fieldDef = typeInfo.getFieldDef();
             const parent = typeInfo.getParentType();
@@ -1772,20 +1924,14 @@ function coverage(schema, sources) {
                 typeCoverage.hits++;
                 fieldCoverage.hits++;
                 if (node.loc) {
-                    fieldCoverage.locations[sourceName] = [
-                        node.loc,
-                        ...(locations || []),
-                    ];
+                    fieldCoverage.locations[sourceName] = [node.loc, ...(locations || [])];
                 }
                 if (node.arguments) {
                     for (const argNode of node.arguments) {
                         const argCoverage = fieldCoverage.children[argNode.name.value];
                         argCoverage.hits++;
                         if (argNode.loc) {
-                            argCoverage.locations[sourceName] = [
-                                argNode.loc,
-                                ...(argCoverage.locations[sourceName] || []),
-                            ];
+                            argCoverage.locations[sourceName] = [argNode.loc, ...(argCoverage.locations[sourceName] || [])];
                         }
                     }
                 }
@@ -1823,17 +1969,39 @@ function coverage(schema, sources) {
     const documents = coverage.sources.map(readDocument);
     documents.forEach((doc, i) => {
         const source = coverage.sources[i];
-        doc.operations.forEach((op) => {
+        doc.operations.forEach(op => {
             graphql.visit(op.node, graphql.visitWithTypeInfo(typeInfo, visitor(source)));
         });
-        doc.fragments.forEach((fr) => {
+        doc.fragments.forEach(fr => {
             graphql.visit(fr.node, graphql.visitWithTypeInfo(typeInfo, visitor(source)));
         });
     });
     return coverage;
 }
 
+function calculateOperationComplexity(node, config, getFragmentByName, depth = 0) {
+    let cost = config.scalarCost;
+    if ('selectionSet' in node && node.selectionSet) {
+        cost = config.objectCost;
+        for (let child of node.selectionSet.selections) {
+            cost += config.depthCostFactor * calculateOperationComplexity(child, config, getFragmentByName, depth + 1);
+        }
+    }
+    if (node.kind == graphql.Kind.FRAGMENT_SPREAD) {
+        const fragment = getFragmentByName(node.name.value);
+        if (fragment) {
+            cost += config.depthCostFactor * calculateOperationComplexity(fragment, config, getFragmentByName, depth + 1);
+        }
+    }
+    return cost;
+}
+
 exports.DiffRule = DiffRule;
+exports.calculateOperationComplexity = calculateOperationComplexity;
+exports.calculateTokenCount = calculateTokenCount;
+exports.countAliases = countAliases;
+exports.countDepth = countDepth;
+exports.countDirectives = countDirectives;
 exports.coverage = coverage;
 exports.diff = diff;
 exports.getTypePrefix = getTypePrefix;