@graphql-inspector/core 0.0.0-canary.da4bdcc → 0.0.0-canary.e88122e

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

@@ -2,15 +2,39 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+const tslib = require('tslib');
 const graphql = require('graphql');
+const inspect = _interopDefault(require('object-inspect'));
 const dependencyGraph = require('dependency-graph');
 
+function keyMap(list, keyFn) {
+    return list.reduce((map, item) => {
+        map[keyFn(item)] = item;
+        return map;
+    }, Object.create(null));
+}
 function isEqual(a, b) {
     if (Array.isArray(a) && Array.isArray(b)) {
         if (a.length !== b.length)
             return false;
         for (var index = 0; index < a.length; index++) {
-            if (a[index] !== b[index]) {
+            if (!isEqual(a[index], b[index])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (a && b && typeof a === 'object' && typeof b === 'object') {
+        const aRecord = a;
+        const bRecord = b;
+        const aKeys = Object.keys(aRecord);
+        const bKeys = Object.keys(bRecord);
+        if (aKeys.length !== bKeys.length)
+            return false;
+        for (const key of aKeys) {
+            if (!isEqual(aRecord[key], bRecord[key])) {
                 return false;
             }
         }
@@ -24,12 +48,62 @@ function isNotEqual(a, b) {
 function isVoid(a) {
     return typeof a === 'undefined' || a === null;
 }
-
 function diffArrays(a, b) {
-    return a.filter(c => !b.some(d => d === c));
+    return a.filter((c) => !b.some((d) => isEqual(d, c)));
+}
+function compareLists(oldList, newList, callbacks) {
+    const oldMap = keyMap(oldList, ({ name }) => name);
+    const newMap = keyMap(newList, ({ name }) => name);
+    const added = [];
+    const removed = [];
+    const mutual = [];
+    for (const oldItem of oldList) {
+        const newItem = newMap[oldItem.name];
+        if (newItem === undefined) {
+            removed.push(oldItem);
+        }
+        else {
+            mutual.push({
+                newVersion: newItem,
+                oldVersion: oldItem,
+            });
+        }
+    }
+    for (const newItem of newList) {
+        if (oldMap[newItem.name] === undefined) {
+            added.push(newItem);
+        }
+    }
+    if (callbacks) {
+        if (callbacks.onAdded) {
+            added.forEach(callbacks.onAdded);
+        }
+        if (callbacks.onRemoved) {
+            removed.forEach(callbacks.onRemoved);
+        }
+        if (callbacks.onMutual) {
+            mutual.forEach(callbacks.onMutual);
+        }
+    }
+    return {
+        added,
+        removed,
+        mutual,
+    };
 }
-function unionArrays(a, b) {
-    return a.filter(c => b.some(d => d === c));
+
+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;
 }
 
 function safeChangeForField(oldType, newType) {
@@ -55,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;
@@ -74,7 +148,7 @@ function getTypePrefix(type) {
         [graphql.Kind.ENUM_TYPE_DEFINITION]: 'enum',
         [graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION]: 'input',
     };
-    return kindsMap[kind];
+    return kindsMap[kind.toString()];
 }
 function isPrimitive(type) {
     return (['String', 'Int', 'Float', 'Boolean', 'ID'].indexOf(typeof type === 'string' ? type : type.name) !== -1);
@@ -95,9 +169,21 @@ function findDeprecatedUsages(schema, ast) {
     const errors = [];
     const typeInfo = new graphql.TypeInfo(schema);
     graphql.visit(ast, graphql.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.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 && fieldDef.isDeprecated) {
+            if (fieldDef && isDeprecated(fieldDef)) {
                 const parentType = typeInfo.getParentType();
                 if (parentType) {
                     const reason = fieldDef.deprecationReason;
@@ -107,7 +193,7 @@ function findDeprecatedUsages(schema, ast) {
         },
         EnumValue(node) {
             const enumVal = typeInfo.getEnumValue();
-            if (enumVal && enumVal.isDeprecated) {
+            if (enumVal && isDeprecated(enumVal)) {
                 const type = graphql.getNamedType(typeInfo.getInputType());
                 if (type) {
                     const reason = enumVal.deprecationReason;
@@ -120,7 +206,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;
         }
     }
@@ -128,10 +214,79 @@ 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;
 }
+function getReachableTypes(schema) {
+    const reachableTypes = new Set();
+    const collect = (type) => {
+        const typeName = type.name;
+        if (reachableTypes.has(typeName)) {
+            return;
+        }
+        reachableTypes.add(typeName);
+        if (graphql.isScalarType(type)) {
+            return;
+        }
+        else if (graphql.isInterfaceType(type) || graphql.isObjectType(type)) {
+            if (graphql.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 (graphql.isUnionType(type)) {
+            const types = type.getTypes();
+            for (const child of types) {
+                collect(child);
+            }
+        }
+        else if (graphql.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;
+}
+function resolveOutputType(output) {
+    if (graphql.isListType(output) || graphql.isNonNullType(output)) {
+        return resolveOutputType(output.ofType);
+    }
+    return output;
+}
+function resolveInputType(input) {
+    if (graphql.isListType(input) || graphql.isNonNullType(input)) {
+        return resolveInputType(input.ofType);
+    }
+    return input;
+}
 
 (function (ChangeType) {
     // Argument
@@ -154,6 +309,8 @@ function removeDirectives(node, directiveNames) {
     ChangeType["EnumValueAdded"] = "ENUM_VALUE_ADDED";
     ChangeType["EnumValueDescriptionChanged"] = "ENUM_VALUE_DESCRIPTION_CHANGED";
     ChangeType["EnumValueDeprecationReasonChanged"] = "ENUM_VALUE_DEPRECATION_REASON_CHANGED";
+    ChangeType["EnumValueDeprecationReasonAdded"] = "ENUM_VALUE_DEPRECATION_REASON_ADDED";
+    ChangeType["EnumValueDeprecationReasonRemoved"] = "ENUM_VALUE_DEPRECATION_REASON_REMOVED";
     // Field
     ChangeType["FieldRemoved"] = "FIELD_REMOVED";
     ChangeType["FieldAdded"] = "FIELD_ADDED";
@@ -416,7 +573,7 @@ function enumValueRemoved(oldEnum, value) {
             reason: `Removing an enum value will cause existing queries that use this enum value to error.`,
         },
         type: exports.ChangeType.EnumValueRemoved,
-        message: `Enum value '${value.name}' was removed from enum '${oldEnum.name}'`,
+        message: `Enum value '${value.name}' ${isDeprecated(value) ? '(deprecated) ' : ''}was removed from enum '${oldEnum.name}'`,
         path: [oldEnum.name, value.name].join('.'),
     };
 }
@@ -448,35 +605,59 @@ function enumValueDeprecationReasonChanged(newEnum, oldValue, newValue) {
         criticality: {
             level: exports.CriticalityLevel.NonBreaking,
         },
-        type: exports.ChangeType.EnumValueDescriptionChanged,
-        message: oldValue.deprecationReason
-            ? `Enum value '${newEnum.name}.${newValue.name}' deprecation reason changed from '${oldValue.deprecationReason}' to '${newValue.deprecationReason}'`
-            : `Enum value '${newEnum.name}.${newValue.name}' was deprecated with reason '${newValue.deprecationReason}'`,
+        type: exports.ChangeType.EnumValueDeprecationReasonChanged,
+        message: `Enum value '${newEnum.name}.${newValue.name}' deprecation reason changed from '${oldValue.deprecationReason}' to '${newValue.deprecationReason}'`,
+        path: [newEnum.name, oldValue.name].join('.'),
+    };
+}
+function enumValueDeprecationReasonAdded(newEnum, oldValue, newValue) {
+    return {
+        criticality: {
+            level: exports.CriticalityLevel.NonBreaking,
+        },
+        type: exports.ChangeType.EnumValueDeprecationReasonAdded,
+        message: `Enum value '${newEnum.name}.${newValue.name}' was deprecated with reason '${newValue.deprecationReason}'`,
+        path: [newEnum.name, oldValue.name].join('.'),
+    };
+}
+function enumValueDeprecationReasonRemoved(newEnum, oldValue, newValue) {
+    return {
+        criticality: {
+            level: exports.CriticalityLevel.NonBreaking,
+        },
+        type: exports.ChangeType.EnumValueDeprecationReasonRemoved,
+        message: `Deprecation reason was removed from enum value '${newEnum.name}.${newValue.name}'`,
         path: [newEnum.name, oldValue.name].join('.'),
     };
 }
 
-function changesInEnum(oldEnum, newEnum) {
-    const changes = [];
-    const oldNames = oldEnum.getValues().map(v => v.name);
-    const newNames = newEnum.getValues().map(v => v.name);
-    const added = diffArrays(newNames, oldNames).map(name => newEnum.getValue(name));
-    const removed = diffArrays(oldNames, newNames).map(name => oldEnum.getValue(name));
-    const common = unionArrays(oldNames, newNames).map(name => ({
-        oldValue: oldEnum.getValue(name),
-        newValue: newEnum.getValue(name),
-    }));
-    changes.push(...added.map(v => enumValueAdded(newEnum, v)));
-    changes.push(...removed.map(v => enumValueRemoved(oldEnum, v)));
-    common.forEach(({ oldValue, newValue }) => {
-        if (isNotEqual(oldValue.description, newValue.description)) {
-            changes.push(enumValueDescriptionChanged(newEnum, oldValue, newValue));
-        }
-        if (isNotEqual(oldValue.deprecationReason, newValue.deprecationReason)) {
-            changes.push(enumValueDeprecationReasonChanged(newEnum, oldValue, newValue));
-        }
+function changesInEnum(oldEnum, newEnum, addChange) {
+    compareLists(oldEnum.getValues(), newEnum.getValues(), {
+        onAdded(value) {
+            addChange(enumValueAdded(newEnum, value));
+        },
+        onRemoved(value) {
+            addChange(enumValueRemoved(oldEnum, value));
+        },
+        onMutual(value) {
+            const oldValue = value.oldVersion;
+            const newValue = value.newVersion;
+            if (isNotEqual(oldValue.description, newValue.description)) {
+                addChange(enumValueDescriptionChanged(newEnum, oldValue, newValue));
+            }
+            if (isNotEqual(oldValue.deprecationReason, newValue.deprecationReason)) {
+                if (isVoid(oldValue.deprecationReason)) {
+                    addChange(enumValueDeprecationReasonAdded(newEnum, oldValue, newValue));
+                }
+                else if (isVoid(newValue.deprecationReason)) {
+                    addChange(enumValueDeprecationReasonRemoved(newEnum, oldValue, newValue));
+                }
+                else {
+                    addChange(enumValueDeprecationReasonChanged(newEnum, oldValue, newValue));
+                }
+            }
+        },
     });
-    return changes;
 }
 
 function unionMemberRemoved(union, type) {
@@ -502,17 +683,81 @@ function unionMemberAdded(union, type) {
     };
 }
 
-function changesInUnion(oldUnion, newUnion) {
-    const changes = [];
+function changesInUnion(oldUnion, newUnion, addChange) {
     const oldTypes = oldUnion.getTypes();
     const newTypes = newUnion.getTypes();
-    const oldTypenames = oldTypes.map(t => t.name);
-    const newTypenames = newTypes.map(t => t.name);
-    const added = diffArrays(newTypenames, oldTypenames).map(name => newTypes.find(t => t.name === name));
-    const removed = diffArrays(oldTypenames, newTypenames).map(name => oldTypes.find(t => t.name === name));
-    changes.push(...added.map(type => unionMemberAdded(newUnion, type)));
-    changes.push(...removed.map(type => unionMemberRemoved(oldUnion, type)));
-    return changes;
+    compareLists(oldTypes, newTypes, {
+        onAdded(t) {
+            addChange(unionMemberAdded(newUnion, t));
+        },
+        onRemoved(t) {
+            addChange(unionMemberRemoved(oldUnion, t));
+        },
+    });
+}
+
+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) {
@@ -522,7 +767,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('.'),
     };
 }
@@ -531,7 +776,7 @@ function inputFieldAdded(input, field) {
         criticality: graphql.isNonNullType(field.type)
             ? {
                 level: exports.CriticalityLevel.Breaking,
-                reason: 'Adding a possible type to Unions may break existing clients that were not programming defensively against a new possible type.',
+                reason: 'Adding a required input field to an existing input object type is a breaking change because it will cause existing uses of this input object type to error.',
             }
             : {
                 level: exports.CriticalityLevel.Dangerous,
@@ -575,10 +820,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('.'),
     };
 }
@@ -599,55 +844,48 @@ function inputFieldTypeChanged(input, oldField, newField) {
     };
 }
 
-function changesInInputObject(oldInput, newInput) {
-    const changes = [];
+function changesInInputObject(oldInput, newInput, addChange) {
     const oldFields = oldInput.getFields();
     const newFields = newInput.getFields();
-    const oldNames = Object.keys(oldFields).map(name => oldFields[name].name);
-    const newNames = Object.keys(newFields).map(name => newFields[name].name);
-    const added = diffArrays(newNames, oldNames).map(name => newFields[name]);
-    const removed = diffArrays(oldNames, newNames).map(name => oldFields[name]);
-    const common = unionArrays(oldNames, newNames).map(name => ({
-        inOld: oldFields[name],
-        inNew: newFields[name],
-    }));
-    common.forEach(({ inOld, inNew }) => {
-        changes.push(...changesInInputField(oldInput, inOld, inNew));
+    compareLists(Object.values(oldFields), Object.values(newFields), {
+        onAdded(field) {
+            addChange(inputFieldAdded(newInput, field));
+        },
+        onRemoved(field) {
+            addChange(inputFieldRemoved(oldInput, field));
+        },
+        onMutual(field) {
+            changesInInputField(oldInput, field.oldVersion, field.newVersion, addChange);
+        },
     });
-    changes.push(...added.map(field => inputFieldAdded(newInput, field)));
-    changes.push(...removed.map(field => inputFieldRemoved(oldInput, field)));
-    return changes;
 }
-function changesInInputField(input, oldField, newField) {
-    const changes = [];
+function changesInInputField(input, oldField, newField, addChange) {
     if (isNotEqual(oldField.description, newField.description)) {
         if (isVoid(oldField.description)) {
-            changes.push(inputFieldDescriptionAdded(input, newField));
+            addChange(inputFieldDescriptionAdded(input, newField));
         }
         else if (isVoid(newField.description)) {
-            changes.push(inputFieldDescriptionRemoved(input, oldField));
+            addChange(inputFieldDescriptionRemoved(input, oldField));
         }
         else {
-            changes.push(inputFieldDescriptionChanged(input, oldField, newField));
+            addChange(inputFieldDescriptionChanged(input, oldField, newField));
         }
     }
     if (isNotEqual(oldField.defaultValue, newField.defaultValue)) {
         if (Array.isArray(oldField.defaultValue) &&
             Array.isArray(newField.defaultValue)) {
             if (diffArrays(oldField.defaultValue, newField.defaultValue).length > 0) {
-                changes.push(inputFieldDefaultValueChanged(input, oldField, newField));
+                addChange(inputFieldDefaultValueChanged(input, oldField, newField));
             }
         }
         else if (JSON.stringify(oldField.defaultValue) !==
             JSON.stringify(newField.defaultValue)) {
-            changes.push(inputFieldDefaultValueChanged(input, oldField, newField));
+            addChange(inputFieldDefaultValueChanged(input, oldField, newField));
         }
     }
     if (isNotEqual(oldField.type.toString(), newField.type.toString())) {
-        changes.push(inputFieldTypeChanged(input, oldField, newField));
+        addChange(inputFieldTypeChanged(input, oldField, newField));
     }
-    // TODO: diff directives
-    return changes;
 }
 
 function objectTypeInterfaceAdded(iface, type) {
@@ -683,7 +921,7 @@ function fieldRemoved(type, field) {
                 : `Removing a field is a breaking change. It is preferable to deprecate the field before removing it.`,
         },
         type: exports.ChangeType.FieldRemoved,
-        message: `Field '${field.name}' ${field.isDeprecated ? '(deprecated) ' : ''}was removed from ${entity} '${type.name}'`,
+        message: `Field '${field.name}' ${isDeprecated(field) ? '(deprecated) ' : ''}was removed from ${entity} '${type.name}'`,
         path: [type.name, field.name].join('.'),
     };
 }
@@ -791,8 +1029,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.`,
@@ -802,7 +1042,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('.'),
     };
 }
@@ -836,8 +1076,8 @@ function fieldArgumentDefaultChanged(type, field, oldArg, newArg) {
         },
         type: exports.ChangeType.FieldArgumentDefaultChanged,
         message: typeof oldArg.defaultValue === 'undefined'
-            ? `Default value '${newArg.defaultValue}' was added to argument '${newArg.name}' on field '${type.name}.${field.name}'`
-            : `Default value for argument '${newArg.name}' on field '${type.name}.${field.name}' changed from '${oldArg.defaultValue}' to '${newArg.defaultValue}'`,
+            ? `Default value '${safeString(newArg.defaultValue)}' was added to argument '${newArg.name}' on field '${type.name}.${field.name}'`
+            : `Default value for argument '${newArg.name}' on field '${type.name}.${field.name}' changed from '${safeString(oldArg.defaultValue)}' to '${safeString(newArg.defaultValue)}'`,
         path: [type.name, field.name, oldArg.name].join('.'),
     };
 }
@@ -858,340 +1098,256 @@ function fieldArgumentTypeChanged(type, field, oldArg, newArg) {
     };
 }
 
-function changesInArgument(type, field, oldArg, newArg) {
-    const changes = [];
+function changesInArgument(type, field, oldArg, newArg, addChange) {
     if (isNotEqual(oldArg.description, newArg.description)) {
-        changes.push(fieldArgumentDescriptionChanged(type, field, oldArg, newArg));
+        addChange(fieldArgumentDescriptionChanged(type, field, oldArg, newArg));
     }
     if (isNotEqual(oldArg.defaultValue, newArg.defaultValue)) {
         if (Array.isArray(oldArg.defaultValue) &&
             Array.isArray(newArg.defaultValue)) {
             const diff = diffArrays(oldArg.defaultValue, newArg.defaultValue);
             if (diff.length > 0) {
-                changes.push(fieldArgumentDefaultChanged(type, field, oldArg, newArg));
+                addChange(fieldArgumentDefaultChanged(type, field, oldArg, newArg));
             }
         }
         else if (JSON.stringify(oldArg.defaultValue) !==
             JSON.stringify(newArg.defaultValue)) {
-            changes.push(fieldArgumentDefaultChanged(type, field, oldArg, newArg));
+            addChange(fieldArgumentDefaultChanged(type, field, oldArg, newArg));
         }
     }
     if (isNotEqual(oldArg.type.toString(), newArg.type.toString())) {
-        changes.push(fieldArgumentTypeChanged(type, field, oldArg, newArg));
+        addChange(fieldArgumentTypeChanged(type, field, oldArg, newArg));
     }
-    return changes;
 }
 
-function changesInField(type, oldField, newField) {
-    const changes = [];
+function changesInField(type, oldField, newField, addChange) {
     if (isNotEqual(oldField.description, newField.description)) {
         if (isVoid(oldField.description)) {
-            changes.push(fieldDescriptionAdded(type, newField));
+            addChange(fieldDescriptionAdded(type, newField));
         }
         else if (isVoid(newField.description)) {
-            changes.push(fieldDescriptionRemoved(type, oldField));
+            addChange(fieldDescriptionRemoved(type, oldField));
         }
         else {
-            changes.push(fieldDescriptionChanged(type, oldField, newField));
+            addChange(fieldDescriptionChanged(type, oldField, newField));
         }
     }
-    if (isNotEqual(oldField.isDeprecated, newField.isDeprecated)) {
-        if (newField.isDeprecated) {
-            changes.push(fieldDeprecationAdded(type, newField));
+    if (isNotEqual(isDeprecated(oldField), isDeprecated(newField))) {
+        if (isDeprecated(newField)) {
+            addChange(fieldDeprecationAdded(type, newField));
         }
         else {
-            changes.push(fieldDeprecationRemoved(type, oldField));
+            addChange(fieldDeprecationRemoved(type, oldField));
         }
     }
     if (isNotEqual(oldField.deprecationReason, newField.deprecationReason)) {
         if (isVoid(oldField.deprecationReason)) {
-            changes.push(fieldDeprecationReasonAdded(type, newField));
+            addChange(fieldDeprecationReasonAdded(type, newField));
         }
         else if (isVoid(newField.deprecationReason)) {
-            changes.push(fieldDeprecationReasonRemoved(type, oldField));
+            addChange(fieldDeprecationReasonRemoved(type, oldField));
         }
         else {
-            changes.push(fieldDeprecationReasonChanged(type, oldField, newField));
+            addChange(fieldDeprecationReasonChanged(type, oldField, newField));
         }
     }
     if (isNotEqual(oldField.type.toString(), newField.type.toString())) {
-        changes.push(fieldTypeChanged(type, oldField, newField));
+        addChange(fieldTypeChanged(type, oldField, newField));
     }
-    const oldArgs = oldField.args;
-    const newArgs = newField.args;
-    const oldNames = oldArgs.map(a => a.name);
-    const newNames = newArgs.map(a => a.name);
-    const added = diffArrays(newNames, oldNames).map(name => newArgs.find(a => a.name === name));
-    const removed = diffArrays(oldNames, newNames).map(name => oldArgs.find(a => a.name === name));
-    const common = unionArrays(oldNames, newNames).map(name => ({
-        inOld: oldArgs.find(a => a.name === name),
-        inNew: newArgs.find(a => a.name === name),
-    }));
-    common.forEach(({ inOld, inNew }) => {
-        changes.push(...changesInArgument(type, oldField, inOld, inNew));
+    compareLists(oldField.args, newField.args, {
+        onAdded(arg) {
+            addChange(fieldArgumentAdded(type, newField, arg));
+        },
+        onRemoved(arg) {
+            addChange(fieldArgumentRemoved(type, oldField, arg));
+        },
+        onMutual(arg) {
+            changesInArgument(type, oldField, arg.oldVersion, arg.newVersion, addChange);
+        },
     });
-    changes.push(...added.map(arg => fieldArgumentAdded(type, newField, arg)));
-    changes.push(...removed.map(arg => fieldArgumentRemoved(type, oldField, arg)));
-    return changes;
 }
 
-function changesInObject(oldType, newType) {
-    const changes = [];
-    // Interfaces
-    changes.push(...addedInterfaces(oldType, newType));
-    changes.push(...removedInterfaces(oldType, newType));
-    // Fields
-    changes.push(...addedFields(oldType, newType));
-    changes.push(...removedFields(oldType, newType));
-    changedFields(oldType, newType).forEach(({ inOld, inNew }) => {
-        changes.push(...changesInField(oldType, inOld, inNew));
-    });
-    return changes;
-}
-function addedInterfaces(oldType, newType) {
+function changesInObject(oldType, newType, addChange) {
     const oldInterfaces = oldType.getInterfaces();
     const newInterfaces = newType.getInterfaces();
-    const oldNames = oldInterfaces.map(i => i.name);
-    const newNames = newInterfaces.map(i => i.name);
-    return diffArrays(newNames, oldNames)
-        .map(name => newInterfaces.find(i => i.name === name))
-        .map(i => objectTypeInterfaceAdded(i, newType));
-}
-function removedInterfaces(oldType, newType) {
-    const oldInterfaces = oldType.getInterfaces();
-    const newInterfaces = newType.getInterfaces();
-    const oldNames = oldInterfaces.map(i => i.name);
-    const newNames = newInterfaces.map(i => i.name);
-    return diffArrays(oldNames, newNames)
-        .map(name => oldInterfaces.find(i => i.name === name))
-        .map(i => objectTypeInterfaceRemoved(i, newType));
-}
-function addedFields(oldType, newType) {
-    const oldFields = oldType.getFields();
-    const newFields = newType.getFields();
-    const oldNames = Object.keys(oldFields);
-    const newNames = Object.keys(newFields);
-    return diffArrays(newNames, oldNames)
-        .map(name => newFields[name])
-        .map(f => fieldAdded(newType, f));
-}
-function removedFields(oldType, newType) {
-    const oldFields = oldType.getFields();
-    const newFields = newType.getFields();
-    const oldNames = Object.keys(oldFields);
-    const newNames = Object.keys(newFields);
-    return diffArrays(oldNames, newNames)
-        .map(name => oldFields[name])
-        .map(f => fieldRemoved(oldType, f));
-}
-function changedFields(oldType, newType) {
     const oldFields = oldType.getFields();
     const newFields = newType.getFields();
-    const oldNames = Object.keys(oldFields);
-    const newNames = Object.keys(newFields);
-    return unionArrays(oldNames, newNames).map(name => ({
-        inOld: oldFields[name],
-        inNew: newFields[name],
-    }));
+    compareLists(oldInterfaces, newInterfaces, {
+        onAdded(i) {
+            addChange(objectTypeInterfaceAdded(i, newType));
+        },
+        onRemoved(i) {
+            addChange(objectTypeInterfaceRemoved(i, oldType));
+        },
+    });
+    compareLists(Object.values(oldFields), Object.values(newFields), {
+        onAdded(f) {
+            addChange(fieldAdded(newType, f));
+        },
+        onRemoved(f) {
+            addChange(fieldRemoved(oldType, f));
+        },
+        onMutual(f) {
+            changesInField(oldType, f.oldVersion, f.newVersion, addChange);
+        },
+    });
 }
 
-function changesInInterface(oldInterface, newInterface) {
-    const changes = [];
-    changes.push(...addedFields$1(oldInterface, newInterface));
-    changes.push(...removedFields$1(oldInterface, newInterface));
-    changedFields$1(oldInterface, newInterface).forEach(({ inOld, inNew }) => {
-        changes.push(...changesInField(oldInterface, inOld, inNew));
+function changesInInterface(oldInterface, newInterface, addChange) {
+    compareLists(Object.values(oldInterface.getFields()), Object.values(newInterface.getFields()), {
+        onAdded(field) {
+            addChange(fieldAdded(newInterface, field));
+        },
+        onRemoved(field) {
+            addChange(fieldRemoved(oldInterface, field));
+        },
+        onMutual(field) {
+            changesInField(oldInterface, field.oldVersion, field.newVersion, addChange);
+        },
     });
-    return changes;
-}
-function addedFields$1(oldInterface, newInterface) {
-    const oldFields = oldInterface.getFields();
-    const newFields = newInterface.getFields();
-    const oldNames = Object.keys(oldFields);
-    const newNames = Object.keys(newFields);
-    return diffArrays(newNames, oldNames)
-        .map(name => newFields[name])
-        .map(f => fieldAdded(newInterface, f));
-}
-function removedFields$1(oldInterface, newInterface) {
-    const oldFields = oldInterface.getFields();
-    const newFields = newInterface.getFields();
-    const oldNames = Object.keys(oldFields);
-    const newNames = Object.keys(newFields);
-    return diffArrays(oldNames, newNames)
-        .map(name => oldFields[name])
-        .map(f => fieldRemoved(oldInterface, f));
-}
-function changedFields$1(oldInterface, newInterface) {
-    const oldFields = oldInterface.getFields();
-    const newFields = newInterface.getFields();
-    const oldNames = Object.keys(oldFields);
-    const newNames = Object.keys(newFields);
-    return unionArrays(oldNames, newNames).map(name => ({
-        inOld: oldFields[name],
-        inNew: newFields[name],
-    }));
 }
 
-function changesInDirective(oldDirective, newDirective) {
-    const changes = [];
+function changesInDirective(oldDirective, newDirective, addChange) {
     if (isNotEqual(oldDirective.description, newDirective.description)) {
-        changes.push(directiveDescriptionChanged(oldDirective, newDirective));
+        addChange(directiveDescriptionChanged(oldDirective, newDirective));
     }
+    const locations = {
+        added: diffArrays(newDirective.locations, oldDirective.locations),
+        removed: diffArrays(oldDirective.locations, newDirective.locations),
+    };
     // locations added
-    changes.push(...diffArrays(newDirective.locations, oldDirective.locations).map(location => directiveLocationAdded(newDirective, location)));
+    locations.added.forEach((location) => addChange(directiveLocationAdded(newDirective, location)));
     // locations removed
-    changes.push(...diffArrays(oldDirective.locations, newDirective.locations).map(location => directiveLocationRemoved(oldDirective, location)));
-    const oldNames = oldDirective.args.map(a => a.name);
-    const newNames = newDirective.args.map(a => a.name);
-    // arguments added
-    changes.push(...diffArrays(newNames, oldNames).map(name => directiveArgumentAdded(newDirective, newDirective.args.find(a => a.name === name))));
-    // arguments removed
-    changes.push(...diffArrays(oldNames, newNames).map(name => directiveArgumentRemoved(oldDirective, oldDirective.args.find(a => a.name === name))));
-    // common arguments
-    unionArrays(oldNames, newNames).forEach(name => {
-        const oldArg = oldDirective.args.find(a => a.name === name);
-        const newArg = newDirective.args.find(a => a.name === name);
-        changes.push(...changesInDirectiveArgument(oldDirective, oldArg, newArg));
+    locations.removed.forEach((location) => addChange(directiveLocationRemoved(oldDirective, location)));
+    compareLists(oldDirective.args, newDirective.args, {
+        onAdded(arg) {
+            addChange(directiveArgumentAdded(newDirective, arg));
+        },
+        onRemoved(arg) {
+            addChange(directiveArgumentRemoved(oldDirective, arg));
+        },
+        onMutual(arg) {
+            changesInDirectiveArgument(oldDirective, arg.oldVersion, arg.newVersion, addChange);
+        },
     });
-    return changes;
 }
-function changesInDirectiveArgument(directive, oldArg, newArg) {
-    const changes = [];
+function changesInDirectiveArgument(directive, oldArg, newArg, addChange) {
     if (isNotEqual(oldArg.description, newArg.description)) {
-        changes.push(directiveArgumentDescriptionChanged(directive, oldArg, newArg));
+        addChange(directiveArgumentDescriptionChanged(directive, oldArg, newArg));
     }
     if (isNotEqual(oldArg.defaultValue, newArg.defaultValue)) {
-        changes.push(directiveArgumentDefaultValueChanged(directive, oldArg, newArg));
+        addChange(directiveArgumentDefaultValueChanged(directive, oldArg, newArg));
     }
     if (isNotEqual(oldArg.type.toString(), newArg.type.toString())) {
-        changes.push(directiveArgumentTypeChanged(directive, oldArg, newArg));
+        addChange(directiveArgumentTypeChanged(directive, oldArg, newArg));
     }
-    return changes;
 }
 
 function diffSchema(oldSchema, newSchema) {
     const changes = [];
-    const types = diffTypes(oldSchema, newSchema);
-    const directives = diffDirectives(oldSchema, newSchema);
-    // Added and removed types
-    changes.push(...types.added.map(typeAdded));
-    changes.push(...types.removed.map(typeRemoved));
-    // Added and removed directives
-    changes.push(...directives.added.map(directiveAdded));
-    changes.push(...directives.removed.map(directiveRemoved));
-    // Changes in Schema
-    changes.push(...changesInSchema(oldSchema, newSchema));
-    // Changes in Type
-    types.common.forEach(({ inOld, inNew }) => {
-        changes.push(...changesInType(inOld, inNew));
+    function addChange(change) {
+        changes.push(change);
+    }
+    changesInSchema(oldSchema, newSchema, addChange);
+    compareLists(Object.values(oldSchema.getTypeMap()).filter((t) => !isPrimitive(t)), Object.values(newSchema.getTypeMap()).filter((t) => !isPrimitive(t)), {
+        onAdded(type) {
+            addChange(typeAdded(type));
+        },
+        onRemoved(type) {
+            addChange(typeRemoved(type));
+        },
+        onMutual(type) {
+            changesInType(type.oldVersion, type.newVersion, addChange);
+        },
     });
-    // Changes in Directives
-    directives.common.forEach(({ inOld, inNew }) => {
-        changes.push(...changesInDirective(inOld, inNew));
+    compareLists(oldSchema.getDirectives(), newSchema.getDirectives(), {
+        onAdded(directive) {
+            addChange(directiveAdded(directive));
+        },
+        onRemoved(directive) {
+            addChange(directiveRemoved(directive));
+        },
+        onMutual(directive) {
+            changesInDirective(directive.oldVersion, directive.newVersion, addChange);
+        },
     });
     return changes;
 }
-function diffTypes(oldSchema, newSchema) {
-    const oldTypeMap = oldSchema.getTypeMap();
-    const newTypeMap = newSchema.getTypeMap();
-    const oldTypenames = Object.keys(oldTypeMap).filter(name => !isPrimitive(name));
-    const newTypenames = Object.keys(newTypeMap).filter(name => !isPrimitive(name));
-    const added = diffArrays(newTypenames, oldTypenames).map(name => newTypeMap[name]);
-    const removed = diffArrays(oldTypenames, newTypenames).map(name => oldTypeMap[name]);
-    const common = unionArrays(oldTypenames, newTypenames).map(name => ({
-        inOld: oldTypeMap[name],
-        inNew: newTypeMap[name],
-    }));
-    return {
-        added,
-        removed,
-        common,
+function changesInSchema(oldSchema, newSchema, addChange) {
+    var _a, _b, _c, _d, _e, _f;
+    const defaultNames = {
+        query: 'Query',
+        mutation: 'Mutation',
+        subscription: 'Subscription',
     };
-}
-function diffDirectives(oldSchema, newSchema) {
-    const oldDirectives = oldSchema.getDirectives();
-    const newDirectives = newSchema.getDirectives();
-    const oldNames = oldDirectives.map(d => d.name);
-    const newNames = newDirectives.map(d => d.name);
-    const added = diffArrays(newNames, oldNames).map(name => newDirectives.find(d => d.name === name));
-    const removed = diffArrays(oldNames, newNames).map(name => oldDirectives.find(d => d.name === name));
-    const common = unionArrays(oldNames, newNames).map(name => ({
-        inOld: oldDirectives.find(d => d.name === name),
-        inNew: newDirectives.find(d => d.name === name),
-    }));
-    return {
-        added,
-        removed,
-        common,
-    };
-}
-function changesInSchema(oldSchema, newSchema) {
-    const changes = [];
     const oldRoot = {
-        query: (oldSchema.getQueryType() || {}).name,
-        mutation: (oldSchema.getMutationType() || {}).name,
-        subscription: (oldSchema.getSubscriptionType() || {})
-            .name,
+        query: (_a = (oldSchema.getQueryType() || {}).name) !== null && _a !== void 0 ? _a : defaultNames.query,
+        mutation: (_b = (oldSchema.getMutationType() || {}).name) !== null && _b !== void 0 ? _b : defaultNames.mutation,
+        subscription: (_c = (oldSchema.getSubscriptionType() || {}).name) !== null && _c !== void 0 ? _c : defaultNames.subscription,
     };
     const newRoot = {
-        query: (newSchema.getQueryType() || {}).name,
-        mutation: (newSchema.getMutationType() || {}).name,
-        subscription: (newSchema.getSubscriptionType() || {})
-            .name,
+        query: (_d = (newSchema.getQueryType() || {}).name) !== null && _d !== void 0 ? _d : defaultNames.query,
+        mutation: (_e = (newSchema.getMutationType() || {}).name) !== null && _e !== void 0 ? _e : defaultNames.mutation,
+        subscription: (_f = (newSchema.getSubscriptionType() || {}).name) !== null && _f !== void 0 ? _f : defaultNames.subscription,
     };
     if (isNotEqual(oldRoot.query, newRoot.query)) {
-        changes.push(schemaQueryTypeChanged(oldSchema, newSchema));
+        addChange(schemaQueryTypeChanged(oldSchema, newSchema));
     }
     if (isNotEqual(oldRoot.mutation, newRoot.mutation)) {
-        changes.push(schemaMutationTypeChanged(oldSchema, newSchema));
+        addChange(schemaMutationTypeChanged(oldSchema, newSchema));
     }
     if (isNotEqual(oldRoot.subscription, newRoot.subscription)) {
-        changes.push(schemaSubscriptionTypeChanged(oldSchema, newSchema));
+        addChange(schemaSubscriptionTypeChanged(oldSchema, newSchema));
     }
-    return changes;
 }
-function changesInType(oldType, newType) {
-    let changes = [];
+function changesInType(oldType, newType, addChange) {
     if (graphql.isEnumType(oldType) && graphql.isEnumType(newType)) {
-        changes = changesInEnum(oldType, newType);
+        changesInEnum(oldType, newType, addChange);
     }
     else if (graphql.isUnionType(oldType) && graphql.isUnionType(newType)) {
-        changes = changesInUnion(oldType, newType);
+        changesInUnion(oldType, newType, addChange);
     }
     else if (graphql.isInputObjectType(oldType) && graphql.isInputObjectType(newType)) {
-        changes = changesInInputObject(oldType, newType);
+        changesInInputObject(oldType, newType, addChange);
     }
     else if (graphql.isObjectType(oldType) && graphql.isObjectType(newType)) {
-        changes = changesInObject(oldType, newType);
+        changesInObject(oldType, newType, addChange);
     }
     else if (graphql.isInterfaceType(oldType) && graphql.isInterfaceType(newType)) {
-        changes = changesInInterface(oldType, newType);
+        changesInInterface(oldType, newType, addChange);
     }
     else if (graphql.isScalarType(oldType) && graphql.isScalarType(newType)) ;
     else {
-        changes = [typeKindChanged(oldType, newType)];
+        addChange(typeKindChanged(oldType, newType));
     }
     if (isNotEqual(oldType.description, newType.description)) {
         if (isVoid(oldType.description)) {
-            changes.push(typeDescriptionAdded(newType));
+            addChange(typeDescriptionAdded(newType));
         }
         else if (isVoid(newType.description)) {
-            changes.push(typeDescriptionRemoved(oldType));
+            addChange(typeDescriptionRemoved(oldType));
         }
         else {
-            changes.push(typeDescriptionChanged(oldType, newType));
+            addChange(typeDescriptionChanged(oldType, newType));
         }
     }
-    return changes;
 }
 
+const dangerousBreaking = ({ changes }) => {
+    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 }) });
+        }
+        return change;
+    });
+};
+
 function parsePath(path) {
     return path.split('.');
 }
 
 const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, }) => {
-    return changes.map(change => {
+    return changes.map((change) => {
         if (change.type === exports.ChangeType.FieldRemoved &&
             change.criticality.level === exports.CriticalityLevel.Breaking &&
             change.path) {
@@ -1199,7 +1355,31 @@ const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, }) => {
             const type = oldSchema.getType(typeName);
             if (graphql.isObjectType(type) || graphql.isInterfaceType(type)) {
                 const field = type.getFields()[fieldName];
-                if (field.isDeprecated) {
+                if (isDeprecated(field)) {
+                    return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: exports.CriticalityLevel.Dangerous }) });
+                }
+            }
+        }
+        if (change.type === exports.ChangeType.EnumValueRemoved &&
+            change.criticality.level === exports.CriticalityLevel.Breaking &&
+            change.path) {
+            const [enumName, enumItem] = parsePath(change.path);
+            const type = oldSchema.getType(enumName);
+            if (graphql.isEnumType(type)) {
+                const item = type.getValue(enumItem);
+                if (item && isDeprecated(item)) {
+                    return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: exports.CriticalityLevel.Dangerous }) });
+                }
+            }
+        }
+        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 }) });
                 }
             }
@@ -1222,23 +1402,76 @@ 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* () {
+    if (!config) {
+        throw new Error(`considerUsage rule is missing config`);
+    }
+    const collectedBreakingField = [];
+    changes.forEach((change) => {
+        if (change.criticality.level === exports.CriticalityLevel.Breaking && change.path) {
+            const [typeName, fieldName, argumentName] = parsePath(change.path);
+            collectedBreakingField.push({
+                type: typeName,
+                field: fieldName,
+                argument: argumentName,
+            });
+        }
+    });
+    // True if safe to break, false otherwise
+    const usageList = yield config.checkUsage(collectedBreakingField);
+    // turns an array of booleans into an array of `Type.Field` strings
+    // includes only those that are safe to break the api
+    const suppressedPaths = collectedBreakingField
+        .filter((_, i) => usageList[i] === true)
+        .map(({ type, field, argument }) => [type, field, argument].filter(Boolean).join('.'));
+    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))) {
+            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;
+    });
+});
+
+const safeUnreachable = ({ changes, oldSchema }) => {
+    const reachable = getReachableTypes(oldSchema);
+    return changes.map((change) => {
+        if (change.criticality.level === exports.CriticalityLevel.Breaking && change.path) {
+            const [typeName] = parsePath(change.path);
+            if (!reachable.has(typeName)) {
+                return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: exports.CriticalityLevel.NonBreaking }), message: 'Unreachable from root' });
+            }
+        }
+        return change;
+    });
 };
 
 const rules = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    dangerousBreaking: dangerousBreaking,
     suppressRemovalOfDeprecatedField: suppressRemovalOfDeprecatedField,
-    ignoreDescriptionChanges: ignoreDescriptionChanges
+    ignoreDescriptionChanges: ignoreDescriptionChanges,
+    considerUsage: considerUsage,
+    safeUnreachable: safeUnreachable
 });
 
 const DiffRule = rules;
-function diff(oldSchema, newSchema, rules = []) {
+function diff(oldSchema, newSchema, rules = [], config) {
     const changes = diffSchema(oldSchema, newSchema);
-    return rules.reduce((prev, rule) => rule({
-        changes: prev,
-        oldSchema,
-        newSchema,
-    }), changes);
+    return rules.reduce((prev, rule) => tslib.__awaiter(this, void 0, void 0, function* () {
+        const prevChanges = yield prev;
+        return rule({
+            changes: prevChanges,
+            oldSchema,
+            newSchema,
+            config,
+        });
+    }), Promise.resolve(changes));
 }
 
 function readDocument(source) {
@@ -1314,7 +1547,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,
@@ -1324,7 +1557,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,
@@ -1336,7 +1569,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,
@@ -1382,41 +1615,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: 'Document',
-            definitions: doc.operations.map(d => d.node),
+            kind: graphql.Kind.DOCUMENT,
+            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: 'Document',
+            kind: graphql.Kind.DOCUMENT,
             definitions: [...docWithOperations.definitions, ...extractedFragments],
         };
-        const transformedSchema = config.apollo
+        let transformedSchema = config.apollo
             ? transformSchemaWithApollo(schema)
             : schema;
         const transformedDoc = config.apollo
@@ -1437,7 +1670,7 @@ function validate(schema, sources, options) {
             }
         }
         const deprecated = config.strictDeprecated
-            ? findDeprecatedUsages(transformedSchema, graphql.parse(doc.source.body))
+            ? findDeprecatedUsages(transformedSchema, transformedDoc)
             : [];
         const duplicatedFragments = config.strictFragments
             ? findDuplicatedFragments(fragmentNames)
@@ -1455,7 +1688,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
@@ -1470,92 +1703,28 @@ function resolveFragment(fragment, 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);
 }
 
-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 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)) {
+        !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 ===
+        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);
@@ -1567,7 +1736,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;
@@ -1575,7 +1744,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(),
     };
@@ -1587,7 +1756,7 @@ function stripType(type) {
         .replace(/\}$/g, '')
         .trim()
         .split('\n')
-        .map(s => s.trim())
+        .map((s) => s.trim())
         .sort((a, b) => a.localeCompare(b))
         .join(' ');
 }
@@ -1599,7 +1768,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();
@@ -1610,10 +1779,30 @@ function coverage(schema, sources) {
                 fieldDef.name &&
                 fieldDef.name !== '__typename' &&
                 fieldDef.name !== '__schema') {
-                const locations = coverage.types[parent.name].children[fieldDef.name].locations[source.name];
-                coverage.types[parent.name].hits++;
-                coverage.types[parent.name].children[fieldDef.name].locations[source.name] = [node.loc].concat(locations || []);
-                coverage.types[parent.name].children[fieldDef.name].hits++;
+                const sourceName = source.name;
+                const typeCoverage = coverage.types[parent.name];
+                const fieldCoverage = typeCoverage.children[fieldDef.name];
+                const locations = fieldCoverage.locations[sourceName];
+                typeCoverage.hits++;
+                fieldCoverage.hits++;
+                if (node.loc) {
+                    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] || []),
+                            ];
+                        }
+                    }
+                }
             }
         },
     });
@@ -1632,7 +1821,14 @@ function coverage(schema, sources) {
                     typeCoverage.children[field.name] = {
                         hits: 0,
                         locations: {},
+                        children: {},
                     };
+                    for (const arg of field.args) {
+                        typeCoverage.children[field.name].children[arg.name] = {
+                            hits: 0,
+                            locations: {},
+                        };
+                    }
                 }
                 coverage.types[type.name] = typeCoverage;
             }
@@ -1641,10 +1837,10 @@ 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)));
         });
     });
@@ -1657,4 +1853,3 @@ exports.diff = diff;
 exports.getTypePrefix = getTypePrefix;
 exports.similar = similar;
 exports.validate = validate;
-//# sourceMappingURL=index.cjs.js.map