@graphql-inspector/core 0.0.0-canary.f71f99b → 0.0.0-canary.fec2df4

package/index.esm.js

@@ -1,1681 +0,0 @@
-import { Kind, TypeInfo, visit, visitWithTypeInfo, GraphQLError, getNamedType, isWrappingType, isListType, isNonNullType, isInterfaceType, isEnumType, isUnionType, isInputObjectType, isObjectType, isScalarType, parse, extendSchema, print, validate as validate$1, printType } from 'graphql';
-import { DepGraph } from 'dependency-graph';
-
-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]) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return a === b || (!a && !b);
-}
-function isNotEqual(a, b) {
-  return !isEqual(a, b);
-}
-function isVoid(a) {
-  return typeof a === 'undefined' || a === null;
-}
-
-function diffArrays(a, b) {
-    return a.filter((c) => !b.some((d) => d === c));
-}
-function unionArrays(a, b) {
-    return a.filter((c) => b.some((d) => d === c));
-}
-
-function safeChangeForField(oldType, newType) {
-    if (!isWrappingType(oldType) && !isWrappingType(newType)) {
-        return oldType.toString() === newType.toString();
-    }
-    if (isNonNullType(newType)) {
-        const ofType = isNonNullType(oldType) ? oldType.ofType : oldType;
-        return safeChangeForField(ofType, newType.ofType);
-    }
-    if (isListType(oldType)) {
-        return ((isListType(newType) &&
-            safeChangeForField(oldType.ofType, newType.ofType)) ||
-            (isNonNullType(newType) && safeChangeForField(oldType, newType.ofType)));
-    }
-    return false;
-}
-function safeChangeForInputValue(oldType, newType) {
-    if (!isWrappingType(oldType) && !isWrappingType(newType)) {
-        return oldType.toString() === newType.toString();
-    }
-    if (isListType(oldType) && isListType(newType)) {
-        return safeChangeForInputValue(oldType.ofType, newType.ofType);
-    }
-    if (isNonNullType(oldType)) {
-        const ofType = isNonNullType(newType) ? newType : newType;
-        return safeChangeForInputValue(oldType.ofType, ofType);
-    }
-    return false;
-}
-function getKind(type) {
-    const node = type.astNode;
-    return (node && node.kind) || '';
-}
-function getTypePrefix(type) {
-    const kind = getKind(type);
-    const kindsMap = {
-        [Kind.SCALAR_TYPE_DEFINITION]: 'scalar',
-        [Kind.OBJECT_TYPE_DEFINITION]: 'type',
-        [Kind.INTERFACE_TYPE_DEFINITION]: 'interface',
-        [Kind.UNION_TYPE_DEFINITION]: 'union',
-        [Kind.ENUM_TYPE_DEFINITION]: 'enum',
-        [Kind.INPUT_OBJECT_TYPE_DEFINITION]: 'input',
-    };
-    return kindsMap[kind];
-}
-function isPrimitive(type) {
-    return (['String', 'Int', 'Float', 'Boolean', 'ID'].indexOf(typeof type === 'string' ? type : type.name) !== -1);
-}
-function isForIntrospection(type) {
-    return ([
-        '__Schema',
-        '__Type',
-        '__TypeKind',
-        '__Field',
-        '__InputValue',
-        '__EnumValue',
-        '__Directive',
-        '__DirectiveLocation',
-    ].indexOf(typeof type === 'string' ? type : type.name) !== -1);
-}
-function findDeprecatedUsages(schema, ast) {
-    const errors = [];
-    const typeInfo = new TypeInfo(schema);
-    visit(ast, visitWithTypeInfo(typeInfo, {
-        Field(node) {
-            const fieldDef = typeInfo.getFieldDef();
-            if (fieldDef && fieldDef.isDeprecated) {
-                const parentType = typeInfo.getParentType();
-                if (parentType) {
-                    const reason = fieldDef.deprecationReason;
-                    errors.push(new GraphQLError(`The field '${parentType.name}.${fieldDef.name}' is deprecated.${reason ? ' ' + reason : ''}`, [node]));
-                }
-            }
-        },
-        EnumValue(node) {
-            const enumVal = typeInfo.getEnumValue();
-            if (enumVal && enumVal.isDeprecated) {
-                const type = getNamedType(typeInfo.getInputType());
-                if (type) {
-                    const reason = enumVal.deprecationReason;
-                    errors.push(new GraphQLError(`The enum value '${type.name}.${enumVal.name}' is deprecated.${reason ? ' ' + reason : ''}`, [node]));
-                }
-            }
-        },
-    }));
-    return errors;
-}
-function removeFieldIfDirectives(node, directiveNames) {
-    if (node.directives) {
-        if (node.directives.some((d) => directiveNames.indexOf(d.name.value) !== -1)) {
-            return null;
-        }
-    }
-    return node;
-}
-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 node;
-}
-
-var ChangeType;
-(function (ChangeType) {
-    // Argument
-    ChangeType["FieldArgumentDescriptionChanged"] = "FIELD_ARGUMENT_DESCRIPTION_CHANGED";
-    ChangeType["FieldArgumentDefaultChanged"] = "FIELD_ARGUMENT_DEFAULT_CHANGED";
-    ChangeType["FieldArgumentTypeChanged"] = "FIELD_ARGUMENT_TYPE_CHANGED";
-    // Directive
-    ChangeType["DirectiveRemoved"] = "DIRECTIVE_REMOVED";
-    ChangeType["DirectiveAdded"] = "DIRECTIVE_ADDED";
-    ChangeType["DirectiveDescriptionChanged"] = "DIRECTIVE_DESCRIPTION_CHANGED";
-    ChangeType["DirectiveLocationAdded"] = "DIRECTIVE_LOCATION_ADDED";
-    ChangeType["DirectiveLocationRemoved"] = "DIRECTIVE_LOCATION_REMOVED";
-    ChangeType["DirectiveArgumentAdded"] = "DIRECTIVE_ARGUMENT_ADDED";
-    ChangeType["DirectiveArgumentRemoved"] = "DIRECTIVE_ARGUMENT_REMOVED";
-    ChangeType["DirectiveArgumentDescriptionChanged"] = "DIRECTIVE_ARGUMENT_DESCRIPTION_CHANGED";
-    ChangeType["DirectiveArgumentDefaultValueChanged"] = "DIRECTIVE_ARGUMENT_DEFAULT_VALUE_CHANGED";
-    ChangeType["DirectiveArgumentTypeChanged"] = "DIRECTIVE_ARGUMENT_TYPE_CHANGED";
-    // Enum
-    ChangeType["EnumValueRemoved"] = "ENUM_VALUE_REMOVED";
-    ChangeType["EnumValueAdded"] = "ENUM_VALUE_ADDED";
-    ChangeType["EnumValueDescriptionChanged"] = "ENUM_VALUE_DESCRIPTION_CHANGED";
-    ChangeType["EnumValueDeprecationReasonChanged"] = "ENUM_VALUE_DEPRECATION_REASON_CHANGED";
-    // Field
-    ChangeType["FieldRemoved"] = "FIELD_REMOVED";
-    ChangeType["FieldAdded"] = "FIELD_ADDED";
-    ChangeType["FieldDescriptionChanged"] = "FIELD_DESCRIPTION_CHANGED";
-    ChangeType["FieldDescriptionAdded"] = "FIELD_DESCRIPTION_ADDED";
-    ChangeType["FieldDescriptionRemoved"] = "FIELD_DESCRIPTION_REMOVED";
-    ChangeType["FieldDeprecationAdded"] = "FIELD_DEPRECATION_ADDED";
-    ChangeType["FieldDeprecationRemoved"] = "FIELD_DEPRECATION_REMOVED";
-    ChangeType["FieldDeprecationReasonChanged"] = "FIELD_DEPRECATION_REASON_CHANGED";
-    ChangeType["FieldDeprecationReasonAdded"] = "FIELD_DEPRECATION_REASON_ADDED";
-    ChangeType["FieldDeprecationReasonRemoved"] = "FIELD_DEPRECATION_REASON_REMOVED";
-    ChangeType["FieldTypeChanged"] = "FIELD_TYPE_CHANGED";
-    ChangeType["FieldArgumentAdded"] = "FIELD_ARGUMENT_ADDED";
-    ChangeType["FieldArgumentRemoved"] = "FIELD_ARGUMENT_REMOVED";
-    // Input
-    ChangeType["InputFieldRemoved"] = "INPUT_FIELD_REMOVED";
-    ChangeType["InputFieldAdded"] = "INPUT_FIELD_ADDED";
-    ChangeType["InputFieldDescriptionAdded"] = "INPUT_FIELD_DESCRIPTION_ADDED";
-    ChangeType["InputFieldDescriptionRemoved"] = "INPUT_FIELD_DESCRIPTION_REMOVED";
-    ChangeType["InputFieldDescriptionChanged"] = "INPUT_FIELD_DESCRIPTION_CHANGED";
-    ChangeType["InputFieldDefaultValueChanged"] = "INPUT_FIELD_DEFAULT_VALUE_CHANGED";
-    ChangeType["InputFieldTypeChanged"] = "INPUT_FIELD_TYPE_CHANGED";
-    // Type
-    ChangeType["ObjectTypeInterfaceAdded"] = "OBJECT_TYPE_INTERFACE_ADDED";
-    ChangeType["ObjectTypeInterfaceRemoved"] = "OBJECT_TYPE_INTERFACE_REMOVED";
-    // Schema
-    ChangeType["SchemaQueryTypeChanged"] = "SCHEMA_QUERY_TYPE_CHANGED";
-    ChangeType["SchemaMutationTypeChanged"] = "SCHEMA_MUTATION_TYPE_CHANGED";
-    ChangeType["SchemaSubscriptionTypeChanged"] = "SCHEMA_SUBSCRIPTION_TYPE_CHANGED";
-    // Type
-    ChangeType["TypeRemoved"] = "TYPE_REMOVED";
-    ChangeType["TypeAdded"] = "TYPE_ADDED";
-    ChangeType["TypeKindChanged"] = "TYPE_KIND_CHANGED";
-    ChangeType["TypeDescriptionChanged"] = "TYPE_DESCRIPTION_CHANGED";
-    // TODO
-    ChangeType["TypeDescriptionRemoved"] = "TYPE_DESCRIPTION_REMOVED";
-    // TODO
-    ChangeType["TypeDescriptionAdded"] = "TYPE_DESCRIPTION_ADDED";
-    // Union
-    ChangeType["UnionMemberRemoved"] = "UNION_MEMBER_REMOVED";
-    ChangeType["UnionMemberAdded"] = "UNION_MEMBER_ADDED";
-})(ChangeType || (ChangeType = {}));
-var CriticalityLevel;
-(function (CriticalityLevel) {
-    CriticalityLevel["Breaking"] = "BREAKING";
-    CriticalityLevel["NonBreaking"] = "NON_BREAKING";
-    CriticalityLevel["Dangerous"] = "DANGEROUS";
-})(CriticalityLevel || (CriticalityLevel = {}));
-
-function schemaQueryTypeChanged(oldSchema, newSchema) {
-  const oldName = (oldSchema.getQueryType() || {}).name || 'unknown';
-  const newName = (newSchema.getQueryType() || {}).name || 'unknown';
-  return {
-    criticality: {
-      level: CriticalityLevel.Breaking,
-    },
-    type: ChangeType.SchemaQueryTypeChanged,
-    message: `Schema query root has changed from '${oldName}' to '${newName}'`,
-  };
-}
-function schemaMutationTypeChanged(oldSchema, newSchema) {
-  const oldName = (oldSchema.getMutationType() || {}).name || 'unknown';
-  const newName = (newSchema.getMutationType() || {}).name || 'unknown';
-  return {
-    criticality: {
-      level: CriticalityLevel.Breaking,
-    },
-    type: ChangeType.SchemaMutationTypeChanged,
-    message: `Schema mutation root has changed from '${oldName}' to '${newName}'`,
-  };
-}
-function schemaSubscriptionTypeChanged(oldSchema, newSchema) {
-  const oldName = (oldSchema.getSubscriptionType() || {}).name || 'unknown';
-  const newName = (newSchema.getSubscriptionType() || {}).name || 'unknown';
-  return {
-    criticality: {
-      level: CriticalityLevel.Breaking,
-    },
-    type: ChangeType.SchemaSubscriptionTypeChanged,
-    message: `Schema subscription root has changed from '${oldName}' to '${newName}'`,
-  };
-}
-
-function typeRemoved(type) {
-    return {
-        criticality: {
-            level: CriticalityLevel.Breaking,
-        },
-        type: ChangeType.TypeRemoved,
-        message: `Type '${type.name}' was removed`,
-        path: type.name,
-    };
-}
-function typeAdded(type) {
-    return {
-        criticality: {
-            level: CriticalityLevel.NonBreaking,
-        },
-        type: ChangeType.TypeAdded,
-        message: `Type '${type.name}' was added`,
-        path: type.name,
-    };
-}
-function typeKindChanged(oldType, newType) {
-    return {
-        criticality: {
-            level: CriticalityLevel.Breaking,
-            reason: `Changing the kind of a type is a breaking change because it can cause existing queries to error. For example, turning an object type to a scalar type would break queries that define a selection set for this type.`,
-        },
-        type: ChangeType.TypeKindChanged,
-        message: `'${oldType.name}' kind changed from '${getKind(oldType)}' to '${getKind(newType)}'`,
-        path: oldType.name,
-    };
-}
-function typeDescriptionChanged(oldType, newType) {
-    return {
-        criticality: {
-            level: CriticalityLevel.NonBreaking,
-        },
-        type: ChangeType.TypeDescriptionChanged,
-        message: `Description '${oldType.description}' on type '${oldType.name}' has changed to '${newType.description}'`,
-        path: oldType.name,
-    };
-}
-function typeDescriptionRemoved(type) {
-    return {
-        criticality: {
-            level: CriticalityLevel.NonBreaking,
-        },
-        type: ChangeType.TypeDescriptionRemoved,
-        message: `Description '${type.description}' was removed from object type '${type.name}'`,
-        path: type.name,
-    };
-}
-function typeDescriptionAdded(type) {
-    return {
-        criticality: {
-            level: CriticalityLevel.NonBreaking,
-        },
-        type: ChangeType.TypeDescriptionAdded,
-        message: `Object type '${type.name}' has description '${type.description}'`,
-        path: type.name,
-    };
-}
-
-function directiveRemoved(directive) {
-  return {
-    criticality: {
-      level: CriticalityLevel.Breaking,
-    },
-    type: ChangeType.DirectiveRemoved,
-    message: `Directive '${directive.name}' was removed`,
-    path: `@${directive.name}`,
-  };
-}
-function directiveAdded(directive) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.DirectiveAdded,
-    message: `Directive '${directive.name}' was added`,
-    path: `@${directive.name}`,
-  };
-}
-function directiveDescriptionChanged(oldDirective, newDirective) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.DirectiveDescriptionChanged,
-    message: `Directive '${oldDirective.name}' description changed from '${oldDirective.description}' to '${newDirective.description}'`,
-    path: `@${oldDirective.name}`,
-  };
-}
-function directiveLocationAdded(directive, location) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.DirectiveLocationAdded,
-    message: `Location '${location}' was added to directive '${directive.name}'`,
-    path: `@${directive.name}`,
-  };
-}
-function directiveLocationRemoved(directive, location) {
-  return {
-    criticality: {
-      level: CriticalityLevel.Breaking,
-    },
-    type: ChangeType.DirectiveLocationRemoved,
-    message: `Location '${location}' was removed from directive '${directive.name}'`,
-    path: `@${directive.name}`,
-  };
-}
-function directiveArgumentAdded(directive, arg) {
-  return {
-    criticality: {
-      level: isNonNullType(arg.type)
-        ? CriticalityLevel.Breaking
-        : CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.DirectiveArgumentAdded,
-    message: `Argument '${arg.name}' was added to directive '${directive.name}'`,
-    path: `@${directive.name}`,
-  };
-}
-function directiveArgumentRemoved(directive, arg) {
-  return {
-    criticality: {
-      level: CriticalityLevel.Breaking,
-    },
-    type: ChangeType.DirectiveArgumentRemoved,
-    message: `Argument '${arg.name}' was removed from directive '${directive.name}'`,
-    path: `@${directive.name}.${arg.name}`,
-  };
-}
-function directiveArgumentDescriptionChanged(directive, oldArg, newArg) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.DirectiveArgumentDescriptionChanged,
-    message: `Description for argument '${oldArg.name}' on directive '${directive.name}' changed from '${oldArg.description}' to '${newArg.description}'`,
-    path: `@${directive.name}.${oldArg.name}`,
-  };
-}
-function directiveArgumentDefaultValueChanged(
-  directive,
-  oldArg,
-  newArg,
-) {
-  return {
-    criticality: {
-      level: CriticalityLevel.Dangerous,
-      reason:
-        'Changing the default value for an argument may change the runtime behaviour of a field if it was never provided.',
-    },
-    type: ChangeType.DirectiveArgumentDefaultValueChanged,
-    message:
-      typeof oldArg.defaultValue === 'undefined'
-        ? `Default value '${newArg.defaultValue}' was added to argument '${newArg.name}' on directive '${directive.name}'`
-        : `Default value for argument '${oldArg.name}' on directive '${directive.name}' changed from '${oldArg.defaultValue}' to '${newArg.defaultValue}'`,
-    path: `@${directive.name}.${oldArg.name}`,
-  };
-}
-function directiveArgumentTypeChanged(directive, oldArg, newArg) {
-  return {
-    criticality: safeChangeForInputValue(oldArg.type, newArg.type)
-      ? {
-          level: CriticalityLevel.NonBreaking,
-          reason:
-            'Changing an input field from non-null to null is considered non-breaking.',
-        }
-      : {
-          level: CriticalityLevel.Breaking,
-        },
-    type: ChangeType.DirectiveArgumentTypeChanged,
-    message: `Type for argument '${oldArg.name}' on directive '${directive.name}' changed from '${oldArg.type}' to '${newArg.type}'`,
-    path: `@${directive.name}.${oldArg.name}`,
-  };
-}
-
-function enumValueRemoved(oldEnum, value) {
-  return {
-    criticality: {
-      level: CriticalityLevel.Breaking,
-      reason: `Removing an enum value will cause existing queries that use this enum value to error.`,
-    },
-    type: ChangeType.EnumValueRemoved,
-    message: `Enum value '${value.name}' was removed from enum '${oldEnum.name}'`,
-    path: [oldEnum.name, value.name].join('.'),
-  };
-}
-function enumValueAdded(newEnum, value) {
-  return {
-    criticality: {
-      level: CriticalityLevel.Dangerous,
-      reason: `Adding an enum value may break existing clients that were not programming defensively against an added case when querying an enum.`,
-    },
-    type: ChangeType.EnumValueAdded,
-    message: `Enum value '${value.name}' was added to enum '${newEnum.name}'`,
-    path: [newEnum.name, value.name].join('.'),
-  };
-}
-function enumValueDescriptionChanged(newEnum, oldValue, newValue) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.EnumValueDescriptionChanged,
-    message:
-      typeof oldValue.description === 'undefined'
-        ? `Description '${newValue.description}' was added to enum value '${newEnum.name}.${newValue.name}'`
-        : `Description for enum value '${newEnum.name}.${newValue.name}' changed from '${oldValue.description}' to '${newValue.description}'`,
-    path: [newEnum.name, oldValue.name].join('.'),
-  };
-}
-function enumValueDeprecationReasonChanged(newEnum, oldValue, newValue) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: 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}'`,
-    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));
-        }
-    });
-    return changes;
-}
-
-function unionMemberRemoved(union, type) {
-  return {
-    criticality: {
-      level: CriticalityLevel.Breaking,
-      reason:
-        'Removing a union member from a union can cause existing queries that use this union member in a fragment spread to error.',
-    },
-    type: ChangeType.UnionMemberRemoved,
-    message: `Member '${type.name}' was removed from Union type '${union.name}'`,
-    path: union.name,
-  };
-}
-function unionMemberAdded(union, type) {
-  return {
-    criticality: {
-      level: CriticalityLevel.Dangerous,
-      reason:
-        'Adding a possible type to Unions may break existing clients that were not programming defensively against a new possible type.',
-    },
-    type: ChangeType.UnionMemberAdded,
-    message: `Member '${type.name}' was added to Union type '${union.name}'`,
-    path: union.name,
-  };
-}
-
-function changesInUnion(oldUnion, newUnion) {
-    const changes = [];
-    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;
-}
-
-function inputFieldRemoved(input, field) {
-  return {
-    criticality: {
-      level: CriticalityLevel.Breaking,
-      reason:
-        'Removing an input field will cause existing queries that use this input field to error.',
-    },
-    type: ChangeType.InputFieldRemoved,
-    message: `Input field '${field.name}' was removed from input object type '${input.name}'`,
-    path: [input.name, field.name].join('.'),
-  };
-}
-function inputFieldAdded(input, field) {
-  return {
-    criticality: isNonNullType(field.type)
-      ? {
-          level: CriticalityLevel.Breaking,
-          reason:
-            'Adding a possible type to Unions may break existing clients that were not programming defensively against a new possible type.',
-        }
-      : {
-          level: CriticalityLevel.Dangerous,
-        },
-    type: ChangeType.InputFieldAdded,
-    message: `Input field '${field.name}' was added to input object type '${input.name}'`,
-    path: [input.name, field.name].join('.'),
-  };
-}
-function inputFieldDescriptionAdded(type, field) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.InputFieldDescriptionAdded,
-    message: `Input field '${type.name}.${field.name}' has description '${field.description}'`,
-    path: [type.name, field.name].join('.'),
-  };
-}
-function inputFieldDescriptionRemoved(type, field) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.InputFieldDescriptionRemoved,
-    message: `Description was removed from input field '${type.name}.${field.name}'`,
-    path: [type.name, field.name].join('.'),
-  };
-}
-function inputFieldDescriptionChanged(input, oldField, newField) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.InputFieldDescriptionChanged,
-    message: `Input field '${input.name}.${oldField.name}' description changed from '${oldField.description}' to '${newField.description}'`,
-    path: [input.name, oldField.name].join('.'),
-  };
-}
-function inputFieldDefaultValueChanged(input, oldField, newField) {
-  return {
-    criticality: {
-      level: CriticalityLevel.Dangerous,
-      reason:
-        'Changing the default value for an argument may change the runtime behaviour of a field if it was never provided.',
-    },
-    type: ChangeType.InputFieldDefaultValueChanged,
-    message: `Input field '${input.name}.${oldField.name}' default value changed from '${oldField.defaultValue}' to '${newField.defaultValue}'`,
-    path: [input.name, oldField.name].join('.'),
-  };
-}
-function inputFieldTypeChanged(input, oldField, newField) {
-  return {
-    criticality: safeChangeForInputValue(oldField.type, newField.type)
-      ? {
-          level: CriticalityLevel.NonBreaking,
-          reason:
-            'Changing an input field from non-null to null is considered non-breaking.',
-        }
-      : {
-          level: CriticalityLevel.Breaking,
-          reason:
-            'Changing the type of an input field can cause existing queries that use this field to error.',
-        },
-    type: ChangeType.InputFieldTypeChanged,
-    message: `Input field '${input.name}.${
-      oldField.name
-    }' changed type from '${oldField.type.toString()}' to '${newField.type.toString()}'`,
-    path: [input.name, oldField.name].join('.'),
-  };
-}
-
-function changesInInputObject(oldInput, newInput) {
-    const changes = [];
-    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));
-    });
-    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 = [];
-    if (isNotEqual(oldField.description, newField.description)) {
-        if (isVoid(oldField.description)) {
-            changes.push(inputFieldDescriptionAdded(input, newField));
-        }
-        else if (isVoid(newField.description)) {
-            changes.push(inputFieldDescriptionRemoved(input, oldField));
-        }
-        else {
-            changes.push(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));
-            }
-        }
-        else if (JSON.stringify(oldField.defaultValue) !==
-            JSON.stringify(newField.defaultValue)) {
-            changes.push(inputFieldDefaultValueChanged(input, oldField, newField));
-        }
-    }
-    if (isNotEqual(oldField.type.toString(), newField.type.toString())) {
-        changes.push(inputFieldTypeChanged(input, oldField, newField));
-    }
-    // TODO: diff directives
-    return changes;
-}
-
-function objectTypeInterfaceAdded(iface, type) {
-  return {
-    criticality: {
-      level: CriticalityLevel.Dangerous,
-      reason:
-        'Adding an interface to an object type may break existing clients that were not programming defensively against a new possible type.',
-    },
-    type: ChangeType.ObjectTypeInterfaceAdded,
-    message: `'${type.name}' object implements '${iface.name}' interface`,
-    path: type.name,
-  };
-}
-function objectTypeInterfaceRemoved(iface, type) {
-  return {
-    criticality: {
-      level: CriticalityLevel.Breaking,
-      reason:
-        'Removing an interface from an object type can cause existing queries that use this in a fragment spread to error.',
-    },
-    type: ChangeType.ObjectTypeInterfaceRemoved,
-    message: `'${type.name}' object type no longer implements '${iface.name}' interface`,
-    path: type.name,
-  };
-}
-
-function fieldRemoved(type, field) {
-  const entity = isInterfaceType(type) ? 'interface' : 'object type';
-  return {
-    criticality: {
-      level: CriticalityLevel.Breaking,
-      reason: field.deprecationReason
-        ? `Removing a deprecated field is a breaking change. Before removing it, you may want to look at the field's usage to see the impact of removing the field.`
-        : `Removing a field is a breaking change. It is preferable to deprecate the field before removing it.`,
-    },
-    type: ChangeType.FieldRemoved,
-    message: `Field '${field.name}' ${
-      field.isDeprecated ? '(deprecated) ' : ''
-    }was removed from ${entity} '${type.name}'`,
-    path: [type.name, field.name].join('.'),
-  };
-}
-function fieldAdded(type, field) {
-  const entity = isInterfaceType(type) ? 'interface' : 'object type';
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.FieldAdded,
-    message: `Field '${field.name}' was added to ${entity} '${type.name}'`,
-    path: [type.name, field.name].join('.'),
-  };
-}
-function fieldDescriptionChanged(type, oldField, newField) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.FieldDescriptionChanged,
-    message: `Field '${type.name}.${oldField.name}' description changed from '${oldField.description}' to '${newField.description}'`,
-    path: [type.name, oldField.name].join('.'),
-  };
-}
-function fieldDescriptionAdded(type, field) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.FieldDescriptionAdded,
-    message: `Field '${type.name}.${field.name}' has description '${field.description}'`,
-    path: [type.name, field.name].join('.'),
-  };
-}
-function fieldDescriptionRemoved(type, field) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.FieldDescriptionRemoved,
-    message: `Description was removed from field '${type.name}.${field.name}'`,
-    path: [type.name, field.name].join('.'),
-  };
-}
-function fieldDeprecationAdded(type, field) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.FieldDeprecationAdded,
-    message: `Field '${type.name}.${field.name}' is deprecated`,
-    path: [type.name, field.name].join('.'),
-  };
-}
-function fieldDeprecationRemoved(type, field) {
-  return {
-    criticality: {
-      level: CriticalityLevel.Dangerous,
-    },
-    type: ChangeType.FieldDeprecationRemoved,
-    message: `Field '${type.name}.${field.name}' is no longer deprecated`,
-    path: [type.name, field.name].join('.'),
-  };
-}
-function fieldDeprecationReasonChanged(type, oldField, newField) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.FieldDeprecationReasonChanged,
-    message: `Deprecation reason on field '${type.name}.${newField.name}' has changed from '${oldField.deprecationReason}' to '${newField.deprecationReason}'`,
-    path: [type.name, oldField.name].join('.'),
-  };
-}
-function fieldDeprecationReasonAdded(type, field) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.FieldDeprecationReasonAdded,
-    message: `Field '${type.name}.${field.name}' has deprecation reason '${field.deprecationReason}'`,
-    path: [type.name, field.name].join('.'),
-  };
-}
-function fieldDeprecationReasonRemoved(type, field) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.FieldDeprecationReasonRemoved,
-    message: `Deprecation reason was removed from field '${type.name}.${field.name}'`,
-    path: [type.name, field.name].join('.'),
-  };
-}
-function fieldTypeChanged(type, oldField, newField) {
-  return {
-    criticality: {
-      level: safeChangeForField(oldField.type, newField.type)
-        ? CriticalityLevel.NonBreaking
-        : CriticalityLevel.Breaking,
-    },
-    type: ChangeType.FieldTypeChanged,
-    message: `Field '${type}.${oldField.name}' changed type from '${oldField.type}' to '${newField.type}'`,
-    path: [type.name, oldField.name].join('.'),
-  };
-}
-function fieldArgumentAdded(type, field, arg) {
-  return {
-    criticality: isNonNullType(arg.type)
-      ? {
-          level: 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.`,
-        }
-      : {
-          level: CriticalityLevel.Dangerous,
-          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: ChangeType.FieldArgumentAdded,
-    message: `Argument '${arg.name}: ${arg.type}' added to field '${type.name}.${field.name}'`,
-    path: [type.name, field.name, arg.name].join('.'),
-  };
-}
-function fieldArgumentRemoved(type, field, arg) {
-  return {
-    criticality: {
-      level: CriticalityLevel.Breaking,
-      reason: `Removing a field argument is a breaking change because it will cause existing queries that use this argument to error.`,
-    },
-    type: ChangeType.FieldArgumentRemoved,
-    message: `Argument '${arg.name}: ${arg.type}' was removed from field '${type.name}.${field.name}'`,
-    path: [type.name, field.name, arg.name].join('.'),
-  };
-}
-
-function fieldArgumentDescriptionChanged(type, field, oldArg, newArg) {
-  return {
-    criticality: {
-      level: CriticalityLevel.NonBreaking,
-    },
-    type: ChangeType.FieldArgumentDescriptionChanged,
-    message: `Description for argument '${newArg.name}' on field '${type.name}.${field.name}' changed from '${oldArg.description}' to '${newArg.description}'`,
-    path: [type.name, field.name, oldArg.name].join('.'),
-  };
-}
-function fieldArgumentDefaultChanged(type, field, oldArg, newArg) {
-  return {
-    criticality: {
-      level: CriticalityLevel.Dangerous,
-      reason:
-        'Changing the default value for an argument may change the runtime behaviour of a field if it was never provided.',
-    },
-    type: 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}'`,
-    path: [type.name, field.name, oldArg.name].join('.'),
-  };
-}
-function fieldArgumentTypeChanged(type, field, oldArg, newArg) {
-  return {
-    criticality: safeChangeForInputValue(oldArg.type, newArg.type)
-      ? {
-          level: CriticalityLevel.NonBreaking,
-          reason: `Changing an input field from non-null to null is considered non-breaking.`,
-        }
-      : {
-          level: CriticalityLevel.Breaking,
-          reason: `Changing the type of a field's argument can cause existing queries that use this argument to error.`,
-        },
-    type: ChangeType.FieldArgumentTypeChanged,
-    message: `Type for argument '${newArg.name}' on field '${type.name}.${field.name}' changed from '${oldArg.type}' to '${newArg.type}'`,
-    path: [type.name, field.name, oldArg.name].join('.'),
-  };
-}
-
-function changesInArgument(type, field, oldArg, newArg) {
-  const changes = [];
-  if (isNotEqual(oldArg.description, newArg.description)) {
-    changes.push(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));
-      }
-    } else if (
-      JSON.stringify(oldArg.defaultValue) !==
-      JSON.stringify(newArg.defaultValue)
-    ) {
-      changes.push(fieldArgumentDefaultChanged(type, field, oldArg, newArg));
-    }
-  }
-  if (isNotEqual(oldArg.type.toString(), newArg.type.toString())) {
-    changes.push(fieldArgumentTypeChanged(type, field, oldArg, newArg));
-  }
-  return changes;
-}
-
-function changesInField(type, oldField, newField) {
-    const changes = [];
-    if (isNotEqual(oldField.description, newField.description)) {
-        if (isVoid(oldField.description)) {
-            changes.push(fieldDescriptionAdded(type, newField));
-        }
-        else if (isVoid(newField.description)) {
-            changes.push(fieldDescriptionRemoved(type, oldField));
-        }
-        else {
-            changes.push(fieldDescriptionChanged(type, oldField, newField));
-        }
-    }
-    if (isNotEqual(oldField.isDeprecated, newField.isDeprecated)) {
-        if (newField.isDeprecated) {
-            changes.push(fieldDeprecationAdded(type, newField));
-        }
-        else {
-            changes.push(fieldDeprecationRemoved(type, oldField));
-        }
-    }
-    if (isNotEqual(oldField.deprecationReason, newField.deprecationReason)) {
-        if (isVoid(oldField.deprecationReason)) {
-            changes.push(fieldDeprecationReasonAdded(type, newField));
-        }
-        else if (isVoid(newField.deprecationReason)) {
-            changes.push(fieldDeprecationReasonRemoved(type, oldField));
-        }
-        else {
-            changes.push(fieldDeprecationReasonChanged(type, oldField, newField));
-        }
-    }
-    if (isNotEqual(oldField.type.toString(), newField.type.toString())) {
-        changes.push(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));
-    });
-    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) {
-    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],
-    }));
-}
-
-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));
-    });
-    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 = [];
-    if (isNotEqual(oldDirective.description, newDirective.description)) {
-        changes.push(directiveDescriptionChanged(oldDirective, newDirective));
-    }
-    // locations added
-    changes.push(...diffArrays(newDirective.locations, oldDirective.locations).map((location) => 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));
-    });
-    return changes;
-}
-function changesInDirectiveArgument(directive, oldArg, newArg) {
-    const changes = [];
-    if (isNotEqual(oldArg.description, newArg.description)) {
-        changes.push(directiveArgumentDescriptionChanged(directive, oldArg, newArg));
-    }
-    if (isNotEqual(oldArg.defaultValue, newArg.defaultValue)) {
-        changes.push(directiveArgumentDefaultValueChanged(directive, oldArg, newArg));
-    }
-    if (isNotEqual(oldArg.type.toString(), newArg.type.toString())) {
-        changes.push(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));
-    });
-    // Changes in Directives
-    directives.common.forEach(({ inOld, inNew }) => {
-        changes.push(...changesInDirective(inOld, inNew));
-    });
-    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 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,
-    };
-    const newRoot = {
-        query: (newSchema.getQueryType() || {}).name,
-        mutation: (newSchema.getMutationType() || {}).name,
-        subscription: (newSchema.getSubscriptionType() || {})
-            .name,
-    };
-    if (isNotEqual(oldRoot.query, newRoot.query)) {
-        changes.push(schemaQueryTypeChanged(oldSchema, newSchema));
-    }
-    if (isNotEqual(oldRoot.mutation, newRoot.mutation)) {
-        changes.push(schemaMutationTypeChanged(oldSchema, newSchema));
-    }
-    if (isNotEqual(oldRoot.subscription, newRoot.subscription)) {
-        changes.push(schemaSubscriptionTypeChanged(oldSchema, newSchema));
-    }
-    return changes;
-}
-function changesInType(oldType, newType) {
-    let changes = [];
-    if (isEnumType(oldType) && isEnumType(newType)) {
-        changes = changesInEnum(oldType, newType);
-    }
-    else if (isUnionType(oldType) && isUnionType(newType)) {
-        changes = changesInUnion(oldType, newType);
-    }
-    else if (isInputObjectType(oldType) && isInputObjectType(newType)) {
-        changes = changesInInputObject(oldType, newType);
-    }
-    else if (isObjectType(oldType) && isObjectType(newType)) {
-        changes = changesInObject(oldType, newType);
-    }
-    else if (isInterfaceType(oldType) && isInterfaceType(newType)) {
-        changes = changesInInterface(oldType, newType);
-    }
-    else if (isScalarType(oldType) && isScalarType(newType)) ;
-    else {
-        changes = [typeKindChanged(oldType, newType)];
-    }
-    if (isNotEqual(oldType.description, newType.description)) {
-        if (isVoid(oldType.description)) {
-            changes.push(typeDescriptionAdded(newType));
-        }
-        else if (isVoid(newType.description)) {
-            changes.push(typeDescriptionRemoved(oldType));
-        }
-        else {
-            changes.push(typeDescriptionChanged(oldType, newType));
-        }
-    }
-    return changes;
-}
-
-function parsePath(path) {
-  return path.split('.');
-}
-
-const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, }) => {
-    return changes.map((change) => {
-        if (change.type === ChangeType.FieldRemoved &&
-            change.criticality.level === CriticalityLevel.Breaking &&
-            change.path) {
-            const [typeName, fieldName] = parsePath(change.path);
-            const type = oldSchema.getType(typeName);
-            if (isObjectType(type) || isInterfaceType(type)) {
-                const field = type.getFields()[fieldName];
-                if (field.isDeprecated) {
-                    return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: CriticalityLevel.Dangerous }) });
-                }
-            }
-        }
-        return change;
-    });
-};
-
-const descriptionChangeTypes = [
-    ChangeType.FieldArgumentDescriptionChanged,
-    ChangeType.DirectiveDescriptionChanged,
-    ChangeType.DirectiveArgumentDescriptionChanged,
-    ChangeType.EnumValueDescriptionChanged,
-    ChangeType.FieldDescriptionChanged,
-    ChangeType.FieldDescriptionAdded,
-    ChangeType.FieldDescriptionRemoved,
-    ChangeType.InputFieldDescriptionAdded,
-    ChangeType.InputFieldDescriptionRemoved,
-    ChangeType.InputFieldDescriptionChanged,
-    ChangeType.TypeDescriptionChanged,
-];
-const ignoreDescriptionChanges = ({ changes }) => {
-    return changes.filter((change) => descriptionChangeTypes.indexOf(change.type) === -1);
-};
-
-const rules = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  suppressRemovalOfDeprecatedField: suppressRemovalOfDeprecatedField,
-  ignoreDescriptionChanges: ignoreDescriptionChanges
-});
-
-const DiffRule = rules;
-function diff(oldSchema, newSchema, rules = []) {
-  const changes = diffSchema(oldSchema, newSchema);
-  return rules.reduce(
-    (prev, rule) =>
-      rule({
-        changes: prev,
-        oldSchema,
-        newSchema,
-      }),
-    changes,
-  );
-}
-
-function readDocument(source) {
-  const result = {
-    source,
-    fragments: [],
-    operations: [],
-    hasFragments: false,
-    hasOperations: false,
-  };
-  const documentNode = parse(source.body);
-  const filepath = source.name;
-  const definitions = documentNode.definitions || [];
-  definitions.forEach((node) => {
-    if (isOperation(node)) {
-      result.operations.push({
-        node,
-        source: filepath,
-      });
-    } else if (isFragment(node)) {
-      result.fragments.push({
-        node,
-        source: filepath,
-      });
-    }
-  });
-  result.hasFragments = result.fragments.length > 0;
-  result.hasOperations = result.operations.length > 0;
-  return result;
-}
-function isOperation(node) {
-  return node.kind === Kind.OPERATION_DEFINITION;
-}
-function isFragment(node) {
-  return node.kind === Kind.FRAGMENT_DEFINITION;
-}
-
-function validateQueryDepth({ source, doc, maxDepth, fragmentGraph, }) {
-    try {
-        calculateDepth({
-            node: doc,
-            currentDepth: 0,
-            maxDepth,
-            getFragment(name) {
-                return fragmentGraph.getNodeData(name);
-            },
-        });
-    }
-    catch (errorOrNode) {
-        if (errorOrNode instanceof Error) {
-            throw errorOrNode;
-        }
-        const node = errorOrNode;
-        return new GraphQLError(`Query exceeds maximum depth of ${maxDepth}`, node, source, node.loc && node.loc.start ? [node.loc.start] : undefined);
-    }
-}
-function calculateDepth({ node, currentDepth, maxDepth, getFragment, }) {
-    if (maxDepth && currentDepth > maxDepth) {
-        throw node;
-    }
-    switch (node.kind) {
-        case Kind.FIELD: {
-            if (node.name.value.startsWith('__') || !node.selectionSet) {
-                return 0;
-            }
-            const maxInnerDepth = calculateDepth({
-                node: node.selectionSet,
-                currentDepth: currentDepth + 1,
-                maxDepth,
-                getFragment,
-            });
-            return 1 + maxInnerDepth;
-        }
-        case Kind.SELECTION_SET: {
-            return Math.max(...node.selections.map((selection) => {
-                return calculateDepth({
-                    node: selection,
-                    currentDepth: currentDepth,
-                    maxDepth,
-                    getFragment,
-                });
-            }));
-        }
-        case Kind.DOCUMENT: {
-            return Math.max(...node.definitions.map((def) => {
-                return calculateDepth({
-                    node: def,
-                    currentDepth: currentDepth,
-                    maxDepth,
-                    getFragment,
-                });
-            }));
-        }
-        case Kind.OPERATION_DEFINITION:
-        case Kind.INLINE_FRAGMENT:
-        case Kind.FRAGMENT_DEFINITION: {
-            return Math.max(...node.selectionSet.selections.map((selection) => {
-                return calculateDepth({
-                    node: selection,
-                    currentDepth,
-                    maxDepth,
-                    getFragment,
-                });
-            }));
-        }
-        case Kind.FRAGMENT_SPREAD:
-            return calculateDepth({
-                node: getFragment(node.name.value),
-                currentDepth,
-                maxDepth,
-                getFragment,
-            });
-        default: {
-            throw new Error(`Couldn't handle ${node.kind}`);
-        }
-    }
-}
-
-function transformDocumentWithApollo(doc, {keepClientFields}) {
-  return visit(doc, {
-    Field(node) {
-      return keepClientFields
-        ? removeDirectives(node, ['client'])
-        : removeFieldIfDirectives(node, ['client']);
-    },
-  });
-}
-function transformSchemaWithApollo(schema) {
-  return extendSchema(
-    schema,
-    parse(/* GraphQL */ `
-      directive @connection(key: String!, filter: [String]) on FIELD
-    `),
-  );
-}
-
-function validate(schema, sources, options) {
-    const config = Object.assign({ strictDeprecated: true, strictFragments: true, keepClientFields: false, apollo: false }, options);
-    const invalidDocuments = [];
-    // read documents
-    const documents = sources.map(readDocument);
-    // keep all named fragments
-    const fragments = [];
-    const fragmentNames = [];
-    const graph = new DepGraph({ circular: true });
-    documents.forEach((doc) => {
-        doc.fragments.forEach((fragment) => {
-            fragmentNames.push(fragment.node.name.value);
-            fragments.push(fragment);
-            graph.addNode(fragment.node.name.value, fragment.node);
-        });
-    });
-    fragments.forEach((fragment) => {
-        const depends = extractFragments(print(fragment.node));
-        if (depends) {
-            depends.forEach((name) => {
-                graph.addDependency(fragment.node.name.value, name);
-            });
-        }
-    });
-    documents
-        // since we include fragments, validate only operations
-        .filter((doc) => doc.hasOperations)
-        .forEach((doc) => {
-        const docWithOperations = {
-            kind: 'Document',
-            definitions: doc.operations.map((d) => d.node),
-        };
-        const extractedFragments = (extractFragments(print(docWithOperations)) || [])
-            // resolve all nested fragments
-            .map((fragmentName) => resolveFragment(graph.getNodeData(fragmentName), graph))
-            // flatten arrays
-            .reduce((list, current) => list.concat(current), [])
-            // remove duplicates
-            .filter((def, i, all) => all.findIndex((item) => item.name.value === def.name.value) === i);
-        const merged = {
-            kind: 'Document',
-            definitions: [...docWithOperations.definitions, ...extractedFragments],
-        };
-        const transformedSchema = config.apollo
-            ? transformSchemaWithApollo(schema)
-            : schema;
-        const transformedDoc = config.apollo
-            ? transformDocumentWithApollo(merged, {
-                keepClientFields: config.keepClientFields,
-            })
-            : merged;
-        const errors = validate$1(transformedSchema, transformedDoc) || [];
-        if (config.maxDepth) {
-            const depthError = validateQueryDepth({
-                source: doc.source,
-                doc: transformedDoc,
-                maxDepth: config.maxDepth,
-                fragmentGraph: graph,
-            });
-            if (depthError) {
-                errors.push(depthError);
-            }
-        }
-        const deprecated = config.strictDeprecated
-            ? findDeprecatedUsages(transformedSchema, parse(doc.source.body))
-            : [];
-        const duplicatedFragments = config.strictFragments
-            ? findDuplicatedFragments(fragmentNames)
-            : [];
-        if (sumLengths(errors, duplicatedFragments, deprecated) > 0) {
-            invalidDocuments.push({
-                source: doc.source,
-                errors: [...errors, ...duplicatedFragments],
-                deprecated,
-            });
-        }
-    });
-    return invalidDocuments;
-}
-function findDuplicatedFragments(fragmentNames) {
-    return fragmentNames
-        .filter((name, i, all) => all.indexOf(name) !== i)
-        .map((name) => new GraphQLError(`Name of '${name}' fragment is not unique`));
-}
-//
-// PostInfo -> AuthorInfo
-// AuthorInfo -> None
-//
-function resolveFragment(fragment, graph) {
-    return graph
-        .dependenciesOf(fragment.name.value)
-        .reduce((list, current) => [
-        ...list,
-        ...resolveFragment(graph.getNodeData(current), graph),
-    ], [fragment]);
-}
-function extractFragments(document) {
-    return (document.match(/[\.]{3}[a-z0-9\_]+\b/gi) || []).map((name) => name.replace('...', ''));
-}
-function sumLengths(...arrays) {
-    return arrays.reduce((sum, { length }) => sum + length, 0);
-}
-
-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) => ({
-        typeId: name,
-        value: stripType(typeMap[name]),
-    }));
-    const results = {};
-    if (typeof typeName !== 'undefined' &&
-        !targets.some((t) => t.typeId === typeName)) {
-        throw new Error(`Type '${typeName}' doesn't exist`);
-    }
-    (typeName ? [{ typeId: typeName, value: '' }] : targets).forEach((source) => {
-        const sourceType = schema.getType(source.typeId);
-        const matchWith = targets.filter((target) => schema.getType(target.typeId).astNode.kind ===
-            sourceType.astNode.kind && target.typeId !== source.typeId);
-        if (matchWith.length > 0) {
-            const found = similarTo(sourceType, matchWith, threshold);
-            if (found) {
-                results[source.typeId] = found;
-            }
-        }
-    });
-    return results;
-}
-function similarTo(type, targets, threshold) {
-    const types = targets.filter((target) => target.typeId !== type.name);
-    const result = findBestMatch(stripType(type), types);
-    if (result.bestMatch.rating < threshold) {
-        return;
-    }
-    return {
-        bestMatch: result.bestMatch,
-        ratings: result.ratings
-            .filter((r) => r.rating >= threshold && r.target !== result.bestMatch.target)
-            .sort((a, b) => a.rating - b.rating)
-            .reverse(),
-    };
-}
-function stripType(type) {
-    return printType(type)
-        .trim()
-        .replace(/^[a-z]+ [^\{]+\{/g, '')
-        .replace(/\}$/g, '')
-        .trim()
-        .split('\n')
-        .map((s) => s.trim())
-        .sort((a, b) => a.localeCompare(b))
-        .join(' ');
-}
-
-function coverage(schema, sources) {
-    const coverage = {
-        sources,
-        types: {},
-    };
-    const typeMap = schema.getTypeMap();
-    const typeInfo = new TypeInfo(schema);
-    const visitor = (source) => ({
-        Field(node) {
-            const fieldDef = typeInfo.getFieldDef();
-            const parent = typeInfo.getParentType();
-            if (parent &&
-                parent.name &&
-                !isForIntrospection(parent.name) &&
-                fieldDef &&
-                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++;
-            }
-        },
-    });
-    for (const typename in typeMap) {
-        if (!isForIntrospection(typename) && !isPrimitive(typename)) {
-            const type = typeMap[typename];
-            if (isObjectType(type) || isInterfaceType(type)) {
-                const typeCoverage = {
-                    hits: 0,
-                    type,
-                    children: {},
-                };
-                const fieldMap = type.getFields();
-                for (const fieldname in fieldMap) {
-                    const field = fieldMap[fieldname];
-                    typeCoverage.children[field.name] = {
-                        hits: 0,
-                        locations: {},
-                    };
-                }
-                coverage.types[type.name] = typeCoverage;
-            }
-        }
-    }
-    const documents = coverage.sources.map(readDocument);
-    documents.forEach((doc, i) => {
-        const source = coverage.sources[i];
-        doc.operations.forEach((op) => {
-            visit(op.node, visitWithTypeInfo(typeInfo, visitor(source)));
-        });
-        doc.fragments.forEach((fr) => {
-            visit(fr.node, visitWithTypeInfo(typeInfo, visitor(source)));
-        });
-    });
-    return coverage;
-}
-
-export { ChangeType, CriticalityLevel, DiffRule, coverage, diff, getTypePrefix, similar, validate };
-//# sourceMappingURL=index.esm.js.map