@graphql-inspector/core 0.0.0-canary.02a53c5 → 0.0.0-canary.0f79587

package/README.md

@@ -36,17 +36,17 @@ import {
   Change,
   InvalidDocument,
   SimilarMap,
-  SchemaCoverage,
-} from '@graphql-inspector/core';
+  SchemaCoverage
+} from '@graphql-inspector/core'
 
 // diff
-const changes: Change[] = diff(schemaA, schemaB);
+const changes: Change[] = diff(schemaA, schemaB)
 // validate
-const invalid: InvalidDocument[] = validate(documentsGlob, schema);
+const invalid: InvalidDocument[] = validate(documentsGlob, schema)
 // similar
-const similar: SimilarMap = similar(schema, typename, threshold);
+const similar: SimilarMap = similar(schema, typename, threshold)
 // coverage
-const schemaCoverage: SchemaCoverage = coverage(schema, documents);
+const schemaCoverage: SchemaCoverage = coverage(schema, documents)
 // ...
 ```
 

package/diff/index.d.ts

@@ -5,4 +5,5 @@ import * as rules from './rules';
 export * from './rules/types';
 export declare const DiffRule: typeof rules;
 export * from './onComplete/types';
-export declare function diff(oldSchema: GraphQLSchema, newSchema: GraphQLSchema, rules?: Rule[]): Change[];
+export type { UsageHandler } from './rules/consider-usage';
+export declare function diff(oldSchema: GraphQLSchema, newSchema: GraphQLSchema, rules?: Rule[], config?: rules.ConsiderUsageConfig): Promise<Change[]>;

package/diff/rules/config.d.ts

@@ -0,0 +1,2 @@
+import { ConsiderUsageConfig } from './consider-usage';
+export declare type Config = ConsiderUsageConfig;

package/diff/rules/consider-usage.d.ts

@@ -0,0 +1,29 @@
+import { Rule } from './types';
+export declare type UsageHandler = (input: Array<{
+    type: string;
+    field?: string;
+    argument?: string;
+}>) => Promise<boolean[]>;
+export interface ConsiderUsageConfig {
+    /**
+     * Checks if it's safe to introduce a breaking change on a field
+     *
+     * Because the function is async and resolves to a boolean value
+     * you can add pretty much anything here, many different conditions or
+     * even any source of data.
+     *
+     * In the CLI we use a GraphQL endpoint with a query
+     * that checks the usage and returns stats like:
+     * min/max count and min/max precentage
+     * So we know when to allow for a breaking change.
+     *
+     * Because it returns a boolean,
+     * we can't attach any data or even customize a message of an api change.
+     * This is the first iteration, we're going to improve it soon.
+     *
+     * true - NON_BREAKING
+     * false - BREAKING
+     */
+    checkUsage?: UsageHandler;
+}
+export declare const considerUsage: Rule<ConsiderUsageConfig>;

package/diff/rules/index.d.ts

@@ -1,3 +1,5 @@
 export * from './dangerous-breaking';
 export * from './suppress-removal-of-deprecated-field';
 export * from './ignore-description-changes';
+export * from './consider-usage';
+export * from './safe-unreachable';

package/diff/rules/safe-unreachable.d.ts

@@ -0,0 +1,2 @@
+import { Rule } from './types';
+export declare const safeUnreachable: Rule;

package/diff/rules/types.d.ts

@@ -1,7 +1,8 @@
 import { GraphQLSchema } from 'graphql';
 import { Change } from '../changes/change';
-export declare type Rule = (input: {
+export declare type Rule<TConfig = any> = (input: {
     changes: Change[];
     oldSchema: GraphQLSchema;
     newSchema: GraphQLSchema;
-}) => Change[];
+    config: TConfig;
+}) => Change[] | Promise<Change[]>;

package/index.d.ts

@@ -1,4 +1,4 @@
-export { diff, DiffRule, Rule, CompletionArgs, CompletionHandler } from './diff';
+export { diff, DiffRule, Rule, CompletionArgs, CompletionHandler, UsageHandler, } from './diff';
 export { validate, InvalidDocument } from './validate';
 export { similar, SimilarMap } from './similar';
 export * from './coverage';

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

@@ -2,9 +2,12 @@
 
 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');
-require('object-inspect');
 
 function keyMap(list, keyFn) {
     return list.reduce((map, item) => {
@@ -17,7 +20,21 @@ function isEqual(a, 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;
             }
         }
@@ -32,7 +49,7 @@ 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);
@@ -75,6 +92,20 @@ function compareLists(oldList, newList, callbacks) {
     };
 }
 
+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) {
     if (!graphql.isWrappingType(oldType) && !graphql.isWrappingType(newType)) {
         return oldType.toString() === newType.toString();
@@ -98,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;
@@ -117,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);
@@ -152,7 +183,7 @@ function findDeprecatedUsages(schema, ast) {
         },
         Field(node) {
             const fieldDef = typeInfo.getFieldDef();
-            if (fieldDef && fieldDef.isDeprecated) {
+            if (fieldDef && isDeprecated(fieldDef)) {
                 const parentType = typeInfo.getParentType();
                 if (parentType) {
                     const reason = fieldDef.deprecationReason;
@@ -162,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;
@@ -187,6 +218,75 @@ function removeDirectives(node, directiveNames) {
     }
     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
@@ -473,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}' ${value.isDeprecated ? '(deprecated) ' : ''}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('.'),
     };
 }
@@ -556,7 +656,7 @@ function changesInEnum(oldEnum, newEnum, addChange) {
                     addChange(enumValueDeprecationReasonChanged(newEnum, oldValue, newValue));
                 }
             }
-        }
+        },
     });
 }
 
@@ -596,6 +696,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: {
@@ -603,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('.'),
     };
 }
@@ -656,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('.'),
     };
 }
@@ -757,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('.'),
     };
 }
@@ -865,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.`,
@@ -876,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('.'),
     };
 }
@@ -910,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('.'),
     };
 }
@@ -966,8 +1132,8 @@ function changesInField(type, oldField, newField, addChange) {
             addChange(fieldDescriptionChanged(type, oldField, newField));
         }
     }
-    if (isNotEqual(oldField.isDeprecated, newField.isDeprecated)) {
-        if (newField.isDeprecated) {
+    if (isNotEqual(isDeprecated(oldField), isDeprecated(newField))) {
+        if (isDeprecated(newField)) {
             addChange(fieldDeprecationAdded(type, newField));
         }
         else {
@@ -997,7 +1163,7 @@ function changesInField(type, oldField, newField, addChange) {
         },
         onMutual(arg) {
             changesInArgument(type, oldField, arg.oldVersion, arg.newVersion, addChange);
-        }
+        },
     });
 }
 
@@ -1108,17 +1274,21 @@ function diffSchema(oldSchema, newSchema) {
     return changes;
 }
 function changesInSchema(oldSchema, newSchema, addChange) {
+    var _a, _b, _c, _d, _e, _f;
+    const defaultNames = {
+        query: 'Query',
+        mutation: 'Mutation',
+        subscription: 'Subscription',
+    };
     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)) {
         addChange(schemaQueryTypeChanged(oldSchema, newSchema));
@@ -1185,7 +1355,7 @@ 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 }) });
                 }
             }
@@ -1197,7 +1367,19 @@ const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, }) => {
             const type = oldSchema.getType(enumName);
             if (graphql.isEnumType(type)) {
                 const item = type.getValue(enumItem);
-                if (item && item.isDeprecated) {
+                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 }) });
                 }
             }
@@ -1223,21 +1405,73 @@ const ignoreDescriptionChanges = ({ changes }) => {
     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) {
@@ -1401,7 +1635,7 @@ function validate(schema, sources, options) {
         .filter((doc) => doc.hasOperations)
         .forEach((doc) => {
         const docWithOperations = {
-            kind: 'Document',
+            kind: graphql.Kind.DOCUMENT,
             definitions: doc.operations.map((d) => d.node),
         };
         const extractedFragments = (extractFragments(graphql.print(docWithOperations)) || [])
@@ -1412,7 +1646,7 @@ function validate(schema, sources, options) {
             // remove duplicates
             .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],
         };
         let transformedSchema = config.apollo
@@ -1475,67 +1709,6 @@ 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())
@@ -1680,4 +1853,3 @@ exports.diff = diff;
 exports.getTypePrefix = getTypePrefix;
 exports.similar = similar;
 exports.validate = validate;
-//# sourceMappingURL=index.cjs.js.map