@graphql-inspector/core 4.0.2 → 4.0.3

package/esm/diff/changes/field.js

@@ -0,0 +1,150 @@
+import { isInterfaceType, isNonNullType, } from 'graphql';
+import { safeChangeForField } from '../../utils/graphql.js';
+import { isDeprecated } from '../../utils/is-deprecated.js';
+import { ChangeType, CriticalityLevel } from './change.js';
+export 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}' ${isDeprecated(field) ? '(deprecated) ' : ''}was removed from ${entity} '${type.name}'`,
+        path: [type.name, field.name].join('.'),
+    };
+}
+export 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('.'),
+    };
+}
+export 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('.'),
+    };
+}
+export 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('.'),
+    };
+}
+export 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('.'),
+    };
+}
+export 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('.'),
+    };
+}
+export 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('.'),
+    };
+}
+export 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('.'),
+    };
+}
+export 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('.'),
+    };
+}
+export 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('.'),
+    };
+}
+export 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('.'),
+    };
+}
+export function fieldArgumentAdded(type, field, arg) {
+    const isBreaking = isNonNullType(arg.type) && typeof arg.defaultValue === 'undefined';
+    const defaultValueMsg = typeof arg.defaultValue === 'undefined' ? ' ' : ' (with default value) ';
+    return {
+        criticality: isBreaking
+            ? {
+                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}'${defaultValueMsg}added to field '${type.name}.${field.name}'`,
+        path: [type.name, field.name, arg.name].join('.'),
+    };
+}
+export 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('.'),
+    };
+}

package/esm/diff/changes/input.js

@@ -0,0 +1,88 @@
+import { isNonNullType } from 'graphql';
+import { safeChangeForInputValue } from '../../utils/graphql.js';
+import { isDeprecated } from '../../utils/is-deprecated.js';
+import { safeString } from '../../utils/string.js';
+import { ChangeType, CriticalityLevel } from './change.js';
+export 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}' ${isDeprecated(field) ? '(deprecated) ' : ''}was removed from input object type '${input.name}'`,
+        path: [input.name, field.name].join('.'),
+    };
+}
+export function inputFieldAdded(input, field) {
+    return {
+        criticality: isNonNullType(field.type)
+            ? {
+                level: CriticalityLevel.Breaking,
+                reason: 'Adding a required input field to an existing input object type is a breaking change because it will cause existing uses of this input object type to error.',
+            }
+            : {
+                level: CriticalityLevel.Dangerous,
+            },
+        type: ChangeType.InputFieldAdded,
+        message: `Input field '${field.name}' was added to input object type '${input.name}'`,
+        path: [input.name, field.name].join('.'),
+    };
+}
+export 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('.'),
+    };
+}
+export 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('.'),
+    };
+}
+export 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('.'),
+    };
+}
+export function inputFieldDefaultValueChanged(input, oldField, newField) {
+    return {
+        criticality: {
+            level: CriticalityLevel.Dangerous,
+            reason: 'Changing the default value for an argument may change the runtime behavior of a field if it was never provided.',
+        },
+        type: ChangeType.InputFieldDefaultValueChanged,
+        message: `Input field '${input.name}.${oldField.name}' default value changed from '${safeString(oldField.defaultValue)}' to '${safeString(newField.defaultValue)}'`,
+        path: [input.name, oldField.name].join('.'),
+    };
+}
+export 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('.'),
+    };
+}

package/esm/diff/changes/object.js

@@ -0,0 +1,23 @@
+import { ChangeType, CriticalityLevel } from './change.js';
+export 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,
+    };
+}
+export 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,
+    };
+}

package/esm/diff/changes/schema.js

@@ -0,0 +1,34 @@
+import { ChangeType, CriticalityLevel } from './change.js';
+export 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}'`,
+    };
+}
+export 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}'`,
+    };
+}
+export 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}'`,
+    };
+}

package/esm/diff/changes/type.js

@@ -0,0 +1,63 @@
+import { getKind } from '../../utils/graphql.js';
+import { ChangeType, CriticalityLevel } from './change.js';
+export function typeRemoved(type) {
+    return {
+        criticality: {
+            level: CriticalityLevel.Breaking,
+        },
+        type: ChangeType.TypeRemoved,
+        message: `Type '${type.name}' was removed`,
+        path: type.name,
+    };
+}
+export function typeAdded(type) {
+    return {
+        criticality: {
+            level: CriticalityLevel.NonBreaking,
+        },
+        type: ChangeType.TypeAdded,
+        message: `Type '${type.name}' was added`,
+        path: type.name,
+    };
+}
+export 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,
+    };
+}
+export 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,
+    };
+}
+export 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,
+    };
+}
+export function typeDescriptionAdded(type) {
+    return {
+        criticality: {
+            level: CriticalityLevel.NonBreaking,
+        },
+        type: ChangeType.TypeDescriptionAdded,
+        message: `Object type '${type.name}' has description '${type.description}'`,
+        path: type.name,
+    };
+}

package/esm/diff/changes/union.js

@@ -0,0 +1,23 @@
+import { ChangeType, CriticalityLevel } from './change.js';
+export 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,
+    };
+}
+export 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,
+    };
+}

package/esm/diff/directive.js

@@ -0,0 +1,37 @@
+import { compareLists, diffArrays, isNotEqual } from '../utils/compare.js';
+import { directiveArgumentAdded, directiveArgumentDefaultValueChanged, directiveArgumentDescriptionChanged, directiveArgumentRemoved, directiveArgumentTypeChanged, directiveDescriptionChanged, directiveLocationAdded, directiveLocationRemoved, } from './changes/directive.js';
+export function changesInDirective(oldDirective, newDirective, addChange) {
+    if (isNotEqual(oldDirective.description, newDirective.description)) {
+        addChange(directiveDescriptionChanged(oldDirective, newDirective));
+    }
+    const locations = {
+        added: diffArrays(newDirective.locations, oldDirective.locations),
+        removed: diffArrays(oldDirective.locations, newDirective.locations),
+    };
+    // locations added
+    locations.added.forEach(location => addChange(directiveLocationAdded(newDirective, location)));
+    // locations removed
+    locations.removed.forEach(location => addChange(directiveLocationRemoved(oldDirective, location)));
+    compareLists(oldDirective.args, newDirective.args, {
+        onAdded(arg) {
+            addChange(directiveArgumentAdded(newDirective, arg));
+        },
+        onRemoved(arg) {
+            addChange(directiveArgumentRemoved(oldDirective, arg));
+        },
+        onMutual(arg) {
+            changesInDirectiveArgument(oldDirective, arg.oldVersion, arg.newVersion, addChange);
+        },
+    });
+}
+function changesInDirectiveArgument(directive, oldArg, newArg, addChange) {
+    if (isNotEqual(oldArg.description, newArg.description)) {
+        addChange(directiveArgumentDescriptionChanged(directive, oldArg, newArg));
+    }
+    if (isNotEqual(oldArg.defaultValue, newArg.defaultValue)) {
+        addChange(directiveArgumentDefaultValueChanged(directive, oldArg, newArg));
+    }
+    if (isNotEqual(oldArg.type.toString(), newArg.type.toString())) {
+        addChange(directiveArgumentTypeChanged(directive, oldArg, newArg));
+    }
+}

package/esm/diff/enum.js

@@ -0,0 +1,30 @@
+import { compareLists, isNotEqual, isVoid } from '../utils/compare.js';
+import { enumValueAdded, enumValueDeprecationReasonAdded, enumValueDeprecationReasonChanged, enumValueDeprecationReasonRemoved, enumValueDescriptionChanged, enumValueRemoved, } from './changes/enum.js';
+export function changesInEnum(oldEnum, newEnum, addChange) {
+    compareLists(oldEnum.getValues(), newEnum.getValues(), {
+        onAdded(value) {
+            addChange(enumValueAdded(newEnum, value));
+        },
+        onRemoved(value) {
+            addChange(enumValueRemoved(oldEnum, value));
+        },
+        onMutual(value) {
+            const oldValue = value.oldVersion;
+            const newValue = value.newVersion;
+            if (isNotEqual(oldValue.description, newValue.description)) {
+                addChange(enumValueDescriptionChanged(newEnum, oldValue, newValue));
+            }
+            if (isNotEqual(oldValue.deprecationReason, newValue.deprecationReason)) {
+                if (isVoid(oldValue.deprecationReason)) {
+                    addChange(enumValueDeprecationReasonAdded(newEnum, oldValue, newValue));
+                }
+                else if (isVoid(newValue.deprecationReason)) {
+                    addChange(enumValueDeprecationReasonRemoved(newEnum, oldValue, newValue));
+                }
+                else {
+                    addChange(enumValueDeprecationReasonChanged(newEnum, oldValue, newValue));
+                }
+            }
+        },
+    });
+}

package/esm/diff/field.js

@@ -0,0 +1,50 @@
+import { compareLists, isNotEqual, isVoid } from '../utils/compare.js';
+import { isDeprecated } from '../utils/is-deprecated.js';
+import { changesInArgument } from './argument.js';
+import { fieldArgumentAdded, fieldArgumentRemoved, fieldDeprecationAdded, fieldDeprecationReasonAdded, fieldDeprecationReasonChanged, fieldDeprecationReasonRemoved, fieldDeprecationRemoved, fieldDescriptionAdded, fieldDescriptionChanged, fieldDescriptionRemoved, fieldTypeChanged, } from './changes/field.js';
+export function changesInField(type, oldField, newField, addChange) {
+    if (isNotEqual(oldField.description, newField.description)) {
+        if (isVoid(oldField.description)) {
+            addChange(fieldDescriptionAdded(type, newField));
+        }
+        else if (isVoid(newField.description)) {
+            addChange(fieldDescriptionRemoved(type, oldField));
+        }
+        else {
+            addChange(fieldDescriptionChanged(type, oldField, newField));
+        }
+    }
+    if (isNotEqual(isDeprecated(oldField), isDeprecated(newField))) {
+        if (isDeprecated(newField)) {
+            addChange(fieldDeprecationAdded(type, newField));
+        }
+        else {
+            addChange(fieldDeprecationRemoved(type, oldField));
+        }
+    }
+    if (isNotEqual(oldField.deprecationReason, newField.deprecationReason)) {
+        if (isVoid(oldField.deprecationReason)) {
+            addChange(fieldDeprecationReasonAdded(type, newField));
+        }
+        else if (isVoid(newField.deprecationReason)) {
+            addChange(fieldDeprecationReasonRemoved(type, oldField));
+        }
+        else {
+            addChange(fieldDeprecationReasonChanged(type, oldField, newField));
+        }
+    }
+    if (isNotEqual(oldField.type.toString(), newField.type.toString())) {
+        addChange(fieldTypeChanged(type, oldField, newField));
+    }
+    compareLists(oldField.args, newField.args, {
+        onAdded(arg) {
+            addChange(fieldArgumentAdded(type, newField, arg));
+        },
+        onRemoved(arg) {
+            addChange(fieldArgumentRemoved(type, oldField, arg));
+        },
+        onMutual(arg) {
+            changesInArgument(type, oldField, arg.oldVersion, arg.newVersion, addChange);
+        },
+    });
+}

package/esm/diff/index.js

@@ -0,0 +1,18 @@
+import { __awaiter } from "tslib";
+import * as rules from './rules/index.js';
+import { diffSchema } from './schema.js';
+export * from './rules/types.js';
+export const DiffRule = rules;
+export * from './onComplete/types.js';
+export function diff(oldSchema, newSchema, rules = [], config) {
+    const changes = diffSchema(oldSchema, newSchema);
+    return rules.reduce((prev, rule) => __awaiter(this, void 0, void 0, function* () {
+        const prevChanges = yield prev;
+        return rule({
+            changes: prevChanges,
+            oldSchema,
+            newSchema,
+            config,
+        });
+    }), Promise.resolve(changes));
+}

package/esm/diff/input.js

@@ -0,0 +1,43 @@
+import { compareLists, diffArrays, isNotEqual, isVoid } from '../utils/compare.js';
+import { inputFieldAdded, inputFieldDefaultValueChanged, inputFieldDescriptionAdded, inputFieldDescriptionChanged, inputFieldDescriptionRemoved, inputFieldRemoved, inputFieldTypeChanged, } from './changes/input.js';
+export function changesInInputObject(oldInput, newInput, addChange) {
+    const oldFields = oldInput.getFields();
+    const newFields = newInput.getFields();
+    compareLists(Object.values(oldFields), Object.values(newFields), {
+        onAdded(field) {
+            addChange(inputFieldAdded(newInput, field));
+        },
+        onRemoved(field) {
+            addChange(inputFieldRemoved(oldInput, field));
+        },
+        onMutual(field) {
+            changesInInputField(oldInput, field.oldVersion, field.newVersion, addChange);
+        },
+    });
+}
+function changesInInputField(input, oldField, newField, addChange) {
+    if (isNotEqual(oldField.description, newField.description)) {
+        if (isVoid(oldField.description)) {
+            addChange(inputFieldDescriptionAdded(input, newField));
+        }
+        else if (isVoid(newField.description)) {
+            addChange(inputFieldDescriptionRemoved(input, oldField));
+        }
+        else {
+            addChange(inputFieldDescriptionChanged(input, oldField, newField));
+        }
+    }
+    if (isNotEqual(oldField.defaultValue, newField.defaultValue)) {
+        if (Array.isArray(oldField.defaultValue) && Array.isArray(newField.defaultValue)) {
+            if (diffArrays(oldField.defaultValue, newField.defaultValue).length > 0) {
+                addChange(inputFieldDefaultValueChanged(input, oldField, newField));
+            }
+        }
+        else if (JSON.stringify(oldField.defaultValue) !== JSON.stringify(newField.defaultValue)) {
+            addChange(inputFieldDefaultValueChanged(input, oldField, newField));
+        }
+    }
+    if (isNotEqual(oldField.type.toString(), newField.type.toString())) {
+        addChange(inputFieldTypeChanged(input, oldField, newField));
+    }
+}

package/esm/diff/interface.js

@@ -0,0 +1,16 @@
+import { compareLists } from '../utils/compare.js';
+import { fieldAdded, fieldRemoved } from './changes/field.js';
+import { changesInField } from './field.js';
+export function changesInInterface(oldInterface, newInterface, addChange) {
+    compareLists(Object.values(oldInterface.getFields()), Object.values(newInterface.getFields()), {
+        onAdded(field) {
+            addChange(fieldAdded(newInterface, field));
+        },
+        onRemoved(field) {
+            addChange(fieldRemoved(oldInterface, field));
+        },
+        onMutual(field) {
+            changesInField(oldInterface, field.oldVersion, field.newVersion, addChange);
+        },
+    });
+}

package/esm/diff/object.js

@@ -0,0 +1,29 @@
+import { compareLists } from '../utils/compare.js';
+import { fieldAdded, fieldRemoved } from './changes/field.js';
+import { objectTypeInterfaceAdded, objectTypeInterfaceRemoved } from './changes/object.js';
+import { changesInField } from './field.js';
+export function changesInObject(oldType, newType, addChange) {
+    const oldInterfaces = oldType.getInterfaces();
+    const newInterfaces = newType.getInterfaces();
+    const oldFields = oldType.getFields();
+    const newFields = newType.getFields();
+    compareLists(oldInterfaces, newInterfaces, {
+        onAdded(i) {
+            addChange(objectTypeInterfaceAdded(i, newType));
+        },
+        onRemoved(i) {
+            addChange(objectTypeInterfaceRemoved(i, oldType));
+        },
+    });
+    compareLists(Object.values(oldFields), Object.values(newFields), {
+        onAdded(f) {
+            addChange(fieldAdded(newType, f));
+        },
+        onRemoved(f) {
+            addChange(fieldRemoved(oldType, f));
+        },
+        onMutual(f) {
+            changesInField(oldType, f.oldVersion, f.newVersion, addChange);
+        },
+    });
+}

package/esm/diff/rules/consider-usage.js

@@ -0,0 +1,35 @@
+import { __awaiter } from "tslib";
+import { parsePath } from '../../utils/path.js';
+import { CriticalityLevel } from './../changes/change.js';
+export const considerUsage = ({ changes, config }) => __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 === 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 === 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: CriticalityLevel.Dangerous }), message: `${change.message} (non-breaking based on usage)` });
+        }
+        return change;
+    });
+});

package/esm/diff/rules/dangerous-breaking.js

@@ -0,0 +1,9 @@
+import { CriticalityLevel } from './../changes/change.js';
+export const dangerousBreaking = ({ changes }) => {
+    return changes.map(change => {
+        if (change.criticality.level === CriticalityLevel.Dangerous) {
+            return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: CriticalityLevel.Breaking }) });
+        }
+        return change;
+    });
+};