@graphql-inspector/core 4.0.2 → 4.0.3

package/cjs/diff/changes/field.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldArgumentRemoved = exports.fieldArgumentAdded = exports.fieldTypeChanged = exports.fieldDeprecationReasonRemoved = exports.fieldDeprecationReasonAdded = exports.fieldDeprecationReasonChanged = exports.fieldDeprecationRemoved = exports.fieldDeprecationAdded = exports.fieldDescriptionRemoved = exports.fieldDescriptionAdded = exports.fieldDescriptionChanged = exports.fieldAdded = exports.fieldRemoved = void 0;
+const graphql_1 = require("graphql");
+const graphql_js_1 = require("../../utils/graphql.js");
+const is_deprecated_js_1 = require("../../utils/is-deprecated.js");
+const change_js_1 = require("./change.js");
+function fieldRemoved(type, field) {
+    const entity = (0, graphql_1.isInterfaceType)(type) ? 'interface' : 'object type';
+    return {
+        criticality: {
+            level: change_js_1.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: change_js_1.ChangeType.FieldRemoved,
+        message: `Field '${field.name}' ${(0, is_deprecated_js_1.isDeprecated)(field) ? '(deprecated) ' : ''}was removed from ${entity} '${type.name}'`,
+        path: [type.name, field.name].join('.'),
+    };
+}
+exports.fieldRemoved = fieldRemoved;
+function fieldAdded(type, field) {
+    const entity = (0, graphql_1.isInterfaceType)(type) ? 'interface' : 'object type';
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.FieldAdded,
+        message: `Field '${field.name}' was added to ${entity} '${type.name}'`,
+        path: [type.name, field.name].join('.'),
+    };
+}
+exports.fieldAdded = fieldAdded;
+function fieldDescriptionChanged(type, oldField, newField) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.FieldDescriptionChanged,
+        message: `Field '${type.name}.${oldField.name}' description changed from '${oldField.description}' to '${newField.description}'`,
+        path: [type.name, oldField.name].join('.'),
+    };
+}
+exports.fieldDescriptionChanged = fieldDescriptionChanged;
+function fieldDescriptionAdded(type, field) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.FieldDescriptionAdded,
+        message: `Field '${type.name}.${field.name}' has description '${field.description}'`,
+        path: [type.name, field.name].join('.'),
+    };
+}
+exports.fieldDescriptionAdded = fieldDescriptionAdded;
+function fieldDescriptionRemoved(type, field) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.FieldDescriptionRemoved,
+        message: `Description was removed from field '${type.name}.${field.name}'`,
+        path: [type.name, field.name].join('.'),
+    };
+}
+exports.fieldDescriptionRemoved = fieldDescriptionRemoved;
+function fieldDeprecationAdded(type, field) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.FieldDeprecationAdded,
+        message: `Field '${type.name}.${field.name}' is deprecated`,
+        path: [type.name, field.name].join('.'),
+    };
+}
+exports.fieldDeprecationAdded = fieldDeprecationAdded;
+function fieldDeprecationRemoved(type, field) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.Dangerous,
+        },
+        type: change_js_1.ChangeType.FieldDeprecationRemoved,
+        message: `Field '${type.name}.${field.name}' is no longer deprecated`,
+        path: [type.name, field.name].join('.'),
+    };
+}
+exports.fieldDeprecationRemoved = fieldDeprecationRemoved;
+function fieldDeprecationReasonChanged(type, oldField, newField) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.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('.'),
+    };
+}
+exports.fieldDeprecationReasonChanged = fieldDeprecationReasonChanged;
+function fieldDeprecationReasonAdded(type, field) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.FieldDeprecationReasonAdded,
+        message: `Field '${type.name}.${field.name}' has deprecation reason '${field.deprecationReason}'`,
+        path: [type.name, field.name].join('.'),
+    };
+}
+exports.fieldDeprecationReasonAdded = fieldDeprecationReasonAdded;
+function fieldDeprecationReasonRemoved(type, field) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.FieldDeprecationReasonRemoved,
+        message: `Deprecation reason was removed from field '${type.name}.${field.name}'`,
+        path: [type.name, field.name].join('.'),
+    };
+}
+exports.fieldDeprecationReasonRemoved = fieldDeprecationReasonRemoved;
+function fieldTypeChanged(type, oldField, newField) {
+    return {
+        criticality: {
+            level: (0, graphql_js_1.safeChangeForField)(oldField.type, newField.type)
+                ? change_js_1.CriticalityLevel.NonBreaking
+                : change_js_1.CriticalityLevel.Breaking,
+        },
+        type: change_js_1.ChangeType.FieldTypeChanged,
+        message: `Field '${type}.${oldField.name}' changed type from '${oldField.type}' to '${newField.type}'`,
+        path: [type.name, oldField.name].join('.'),
+    };
+}
+exports.fieldTypeChanged = fieldTypeChanged;
+function fieldArgumentAdded(type, field, arg) {
+    const isBreaking = (0, graphql_1.isNonNullType)(arg.type) && typeof arg.defaultValue === 'undefined';
+    const defaultValueMsg = typeof arg.defaultValue === 'undefined' ? ' ' : ' (with default value) ';
+    return {
+        criticality: isBreaking
+            ? {
+                level: change_js_1.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: change_js_1.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: change_js_1.ChangeType.FieldArgumentAdded,
+        message: `Argument '${arg.name}: ${arg.type}'${defaultValueMsg}added to field '${type.name}.${field.name}'`,
+        path: [type.name, field.name, arg.name].join('.'),
+    };
+}
+exports.fieldArgumentAdded = fieldArgumentAdded;
+function fieldArgumentRemoved(type, field, arg) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.Breaking,
+            reason: `Removing a field argument is a breaking change because it will cause existing queries that use this argument to error.`,
+        },
+        type: change_js_1.ChangeType.FieldArgumentRemoved,
+        message: `Argument '${arg.name}: ${arg.type}' was removed from field '${type.name}.${field.name}'`,
+        path: [type.name, field.name, arg.name].join('.'),
+    };
+}
+exports.fieldArgumentRemoved = fieldArgumentRemoved;

package/cjs/diff/changes/input.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputFieldTypeChanged = exports.inputFieldDefaultValueChanged = exports.inputFieldDescriptionChanged = exports.inputFieldDescriptionRemoved = exports.inputFieldDescriptionAdded = exports.inputFieldAdded = exports.inputFieldRemoved = void 0;
+const graphql_1 = require("graphql");
+const graphql_js_1 = require("../../utils/graphql.js");
+const is_deprecated_js_1 = require("../../utils/is-deprecated.js");
+const string_js_1 = require("../../utils/string.js");
+const change_js_1 = require("./change.js");
+function inputFieldRemoved(input, field) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.Breaking,
+            reason: 'Removing an input field will cause existing queries that use this input field to error.',
+        },
+        type: change_js_1.ChangeType.InputFieldRemoved,
+        message: `Input field '${field.name}' ${(0, is_deprecated_js_1.isDeprecated)(field) ? '(deprecated) ' : ''}was removed from input object type '${input.name}'`,
+        path: [input.name, field.name].join('.'),
+    };
+}
+exports.inputFieldRemoved = inputFieldRemoved;
+function inputFieldAdded(input, field) {
+    return {
+        criticality: (0, graphql_1.isNonNullType)(field.type)
+            ? {
+                level: change_js_1.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: change_js_1.CriticalityLevel.Dangerous,
+            },
+        type: change_js_1.ChangeType.InputFieldAdded,
+        message: `Input field '${field.name}' was added to input object type '${input.name}'`,
+        path: [input.name, field.name].join('.'),
+    };
+}
+exports.inputFieldAdded = inputFieldAdded;
+function inputFieldDescriptionAdded(type, field) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.InputFieldDescriptionAdded,
+        message: `Input field '${type.name}.${field.name}' has description '${field.description}'`,
+        path: [type.name, field.name].join('.'),
+    };
+}
+exports.inputFieldDescriptionAdded = inputFieldDescriptionAdded;
+function inputFieldDescriptionRemoved(type, field) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.InputFieldDescriptionRemoved,
+        message: `Description was removed from input field '${type.name}.${field.name}'`,
+        path: [type.name, field.name].join('.'),
+    };
+}
+exports.inputFieldDescriptionRemoved = inputFieldDescriptionRemoved;
+function inputFieldDescriptionChanged(input, oldField, newField) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.InputFieldDescriptionChanged,
+        message: `Input field '${input.name}.${oldField.name}' description changed from '${oldField.description}' to '${newField.description}'`,
+        path: [input.name, oldField.name].join('.'),
+    };
+}
+exports.inputFieldDescriptionChanged = inputFieldDescriptionChanged;
+function inputFieldDefaultValueChanged(input, oldField, newField) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.Dangerous,
+            reason: 'Changing the default value for an argument may change the runtime behavior of a field if it was never provided.',
+        },
+        type: change_js_1.ChangeType.InputFieldDefaultValueChanged,
+        message: `Input field '${input.name}.${oldField.name}' default value changed from '${(0, string_js_1.safeString)(oldField.defaultValue)}' to '${(0, string_js_1.safeString)(newField.defaultValue)}'`,
+        path: [input.name, oldField.name].join('.'),
+    };
+}
+exports.inputFieldDefaultValueChanged = inputFieldDefaultValueChanged;
+function inputFieldTypeChanged(input, oldField, newField) {
+    return {
+        criticality: (0, graphql_js_1.safeChangeForInputValue)(oldField.type, newField.type)
+            ? {
+                level: change_js_1.CriticalityLevel.NonBreaking,
+                reason: 'Changing an input field from non-null to null is considered non-breaking.',
+            }
+            : {
+                level: change_js_1.CriticalityLevel.Breaking,
+                reason: 'Changing the type of an input field can cause existing queries that use this field to error.',
+            },
+        type: change_js_1.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('.'),
+    };
+}
+exports.inputFieldTypeChanged = inputFieldTypeChanged;

package/cjs/diff/changes/object.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectTypeInterfaceRemoved = exports.objectTypeInterfaceAdded = void 0;
+const change_js_1 = require("./change.js");
+function objectTypeInterfaceAdded(iface, type) {
+    return {
+        criticality: {
+            level: change_js_1.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: change_js_1.ChangeType.ObjectTypeInterfaceAdded,
+        message: `'${type.name}' object implements '${iface.name}' interface`,
+        path: type.name,
+    };
+}
+exports.objectTypeInterfaceAdded = objectTypeInterfaceAdded;
+function objectTypeInterfaceRemoved(iface, type) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.Breaking,
+            reason: 'Removing an interface from an object type can cause existing queries that use this in a fragment spread to error.',
+        },
+        type: change_js_1.ChangeType.ObjectTypeInterfaceRemoved,
+        message: `'${type.name}' object type no longer implements '${iface.name}' interface`,
+        path: type.name,
+    };
+}
+exports.objectTypeInterfaceRemoved = objectTypeInterfaceRemoved;

package/cjs/diff/changes/schema.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaSubscriptionTypeChanged = exports.schemaMutationTypeChanged = exports.schemaQueryTypeChanged = void 0;
+const change_js_1 = require("./change.js");
+function schemaQueryTypeChanged(oldSchema, newSchema) {
+    const oldName = (oldSchema.getQueryType() || {}).name || 'unknown';
+    const newName = (newSchema.getQueryType() || {}).name || 'unknown';
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.Breaking,
+        },
+        type: change_js_1.ChangeType.SchemaQueryTypeChanged,
+        message: `Schema query root has changed from '${oldName}' to '${newName}'`,
+    };
+}
+exports.schemaQueryTypeChanged = schemaQueryTypeChanged;
+function schemaMutationTypeChanged(oldSchema, newSchema) {
+    const oldName = (oldSchema.getMutationType() || {}).name || 'unknown';
+    const newName = (newSchema.getMutationType() || {}).name || 'unknown';
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.Breaking,
+        },
+        type: change_js_1.ChangeType.SchemaMutationTypeChanged,
+        message: `Schema mutation root has changed from '${oldName}' to '${newName}'`,
+    };
+}
+exports.schemaMutationTypeChanged = schemaMutationTypeChanged;
+function schemaSubscriptionTypeChanged(oldSchema, newSchema) {
+    const oldName = (oldSchema.getSubscriptionType() || {}).name || 'unknown';
+    const newName = (newSchema.getSubscriptionType() || {}).name || 'unknown';
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.Breaking,
+        },
+        type: change_js_1.ChangeType.SchemaSubscriptionTypeChanged,
+        message: `Schema subscription root has changed from '${oldName}' to '${newName}'`,
+    };
+}
+exports.schemaSubscriptionTypeChanged = schemaSubscriptionTypeChanged;

package/cjs/diff/changes/type.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeDescriptionAdded = exports.typeDescriptionRemoved = exports.typeDescriptionChanged = exports.typeKindChanged = exports.typeAdded = exports.typeRemoved = void 0;
+const graphql_js_1 = require("../../utils/graphql.js");
+const change_js_1 = require("./change.js");
+function typeRemoved(type) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.Breaking,
+        },
+        type: change_js_1.ChangeType.TypeRemoved,
+        message: `Type '${type.name}' was removed`,
+        path: type.name,
+    };
+}
+exports.typeRemoved = typeRemoved;
+function typeAdded(type) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.TypeAdded,
+        message: `Type '${type.name}' was added`,
+        path: type.name,
+    };
+}
+exports.typeAdded = typeAdded;
+function typeKindChanged(oldType, newType) {
+    return {
+        criticality: {
+            level: change_js_1.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: change_js_1.ChangeType.TypeKindChanged,
+        message: `'${oldType.name}' kind changed from '${(0, graphql_js_1.getKind)(oldType)}' to '${(0, graphql_js_1.getKind)(newType)}'`,
+        path: oldType.name,
+    };
+}
+exports.typeKindChanged = typeKindChanged;
+function typeDescriptionChanged(oldType, newType) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.TypeDescriptionChanged,
+        message: `Description '${oldType.description}' on type '${oldType.name}' has changed to '${newType.description}'`,
+        path: oldType.name,
+    };
+}
+exports.typeDescriptionChanged = typeDescriptionChanged;
+function typeDescriptionRemoved(type) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.TypeDescriptionRemoved,
+        message: `Description '${type.description}' was removed from object type '${type.name}'`,
+        path: type.name,
+    };
+}
+exports.typeDescriptionRemoved = typeDescriptionRemoved;
+function typeDescriptionAdded(type) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.TypeDescriptionAdded,
+        message: `Object type '${type.name}' has description '${type.description}'`,
+        path: type.name,
+    };
+}
+exports.typeDescriptionAdded = typeDescriptionAdded;

package/cjs/diff/changes/union.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unionMemberAdded = exports.unionMemberRemoved = void 0;
+const change_js_1 = require("./change.js");
+function unionMemberRemoved(union, type) {
+    return {
+        criticality: {
+            level: change_js_1.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: change_js_1.ChangeType.UnionMemberRemoved,
+        message: `Member '${type.name}' was removed from Union type '${union.name}'`,
+        path: union.name,
+    };
+}
+exports.unionMemberRemoved = unionMemberRemoved;
+function unionMemberAdded(union, type) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.Dangerous,
+            reason: 'Adding a possible type to Unions may break existing clients that were not programming defensively against a new possible type.',
+        },
+        type: change_js_1.ChangeType.UnionMemberAdded,
+        message: `Member '${type.name}' was added to Union type '${union.name}'`,
+        path: union.name,
+    };
+}
+exports.unionMemberAdded = unionMemberAdded;

package/cjs/diff/directive.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changesInDirective = void 0;
+const compare_js_1 = require("../utils/compare.js");
+const directive_js_1 = require("./changes/directive.js");
+function changesInDirective(oldDirective, newDirective, addChange) {
+    if ((0, compare_js_1.isNotEqual)(oldDirective.description, newDirective.description)) {
+        addChange((0, directive_js_1.directiveDescriptionChanged)(oldDirective, newDirective));
+    }
+    const locations = {
+        added: (0, compare_js_1.diffArrays)(newDirective.locations, oldDirective.locations),
+        removed: (0, compare_js_1.diffArrays)(oldDirective.locations, newDirective.locations),
+    };
+    // locations added
+    locations.added.forEach(location => addChange((0, directive_js_1.directiveLocationAdded)(newDirective, location)));
+    // locations removed
+    locations.removed.forEach(location => addChange((0, directive_js_1.directiveLocationRemoved)(oldDirective, location)));
+    (0, compare_js_1.compareLists)(oldDirective.args, newDirective.args, {
+        onAdded(arg) {
+            addChange((0, directive_js_1.directiveArgumentAdded)(newDirective, arg));
+        },
+        onRemoved(arg) {
+            addChange((0, directive_js_1.directiveArgumentRemoved)(oldDirective, arg));
+        },
+        onMutual(arg) {
+            changesInDirectiveArgument(oldDirective, arg.oldVersion, arg.newVersion, addChange);
+        },
+    });
+}
+exports.changesInDirective = changesInDirective;
+function changesInDirectiveArgument(directive, oldArg, newArg, addChange) {
+    if ((0, compare_js_1.isNotEqual)(oldArg.description, newArg.description)) {
+        addChange((0, directive_js_1.directiveArgumentDescriptionChanged)(directive, oldArg, newArg));
+    }
+    if ((0, compare_js_1.isNotEqual)(oldArg.defaultValue, newArg.defaultValue)) {
+        addChange((0, directive_js_1.directiveArgumentDefaultValueChanged)(directive, oldArg, newArg));
+    }
+    if ((0, compare_js_1.isNotEqual)(oldArg.type.toString(), newArg.type.toString())) {
+        addChange((0, directive_js_1.directiveArgumentTypeChanged)(directive, oldArg, newArg));
+    }
+}

package/cjs/diff/enum.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changesInEnum = void 0;
+const compare_js_1 = require("../utils/compare.js");
+const enum_js_1 = require("./changes/enum.js");
+function changesInEnum(oldEnum, newEnum, addChange) {
+    (0, compare_js_1.compareLists)(oldEnum.getValues(), newEnum.getValues(), {
+        onAdded(value) {
+            addChange((0, enum_js_1.enumValueAdded)(newEnum, value));
+        },
+        onRemoved(value) {
+            addChange((0, enum_js_1.enumValueRemoved)(oldEnum, value));
+        },
+        onMutual(value) {
+            const oldValue = value.oldVersion;
+            const newValue = value.newVersion;
+            if ((0, compare_js_1.isNotEqual)(oldValue.description, newValue.description)) {
+                addChange((0, enum_js_1.enumValueDescriptionChanged)(newEnum, oldValue, newValue));
+            }
+            if ((0, compare_js_1.isNotEqual)(oldValue.deprecationReason, newValue.deprecationReason)) {
+                if ((0, compare_js_1.isVoid)(oldValue.deprecationReason)) {
+                    addChange((0, enum_js_1.enumValueDeprecationReasonAdded)(newEnum, oldValue, newValue));
+                }
+                else if ((0, compare_js_1.isVoid)(newValue.deprecationReason)) {
+                    addChange((0, enum_js_1.enumValueDeprecationReasonRemoved)(newEnum, oldValue, newValue));
+                }
+                else {
+                    addChange((0, enum_js_1.enumValueDeprecationReasonChanged)(newEnum, oldValue, newValue));
+                }
+            }
+        },
+    });
+}
+exports.changesInEnum = changesInEnum;

package/cjs/diff/field.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changesInField = void 0;
+const compare_js_1 = require("../utils/compare.js");
+const is_deprecated_js_1 = require("../utils/is-deprecated.js");
+const argument_js_1 = require("./argument.js");
+const field_js_1 = require("./changes/field.js");
+function changesInField(type, oldField, newField, addChange) {
+    if ((0, compare_js_1.isNotEqual)(oldField.description, newField.description)) {
+        if ((0, compare_js_1.isVoid)(oldField.description)) {
+            addChange((0, field_js_1.fieldDescriptionAdded)(type, newField));
+        }
+        else if ((0, compare_js_1.isVoid)(newField.description)) {
+            addChange((0, field_js_1.fieldDescriptionRemoved)(type, oldField));
+        }
+        else {
+            addChange((0, field_js_1.fieldDescriptionChanged)(type, oldField, newField));
+        }
+    }
+    if ((0, compare_js_1.isNotEqual)((0, is_deprecated_js_1.isDeprecated)(oldField), (0, is_deprecated_js_1.isDeprecated)(newField))) {
+        if ((0, is_deprecated_js_1.isDeprecated)(newField)) {
+            addChange((0, field_js_1.fieldDeprecationAdded)(type, newField));
+        }
+        else {
+            addChange((0, field_js_1.fieldDeprecationRemoved)(type, oldField));
+        }
+    }
+    if ((0, compare_js_1.isNotEqual)(oldField.deprecationReason, newField.deprecationReason)) {
+        if ((0, compare_js_1.isVoid)(oldField.deprecationReason)) {
+            addChange((0, field_js_1.fieldDeprecationReasonAdded)(type, newField));
+        }
+        else if ((0, compare_js_1.isVoid)(newField.deprecationReason)) {
+            addChange((0, field_js_1.fieldDeprecationReasonRemoved)(type, oldField));
+        }
+        else {
+            addChange((0, field_js_1.fieldDeprecationReasonChanged)(type, oldField, newField));
+        }
+    }
+    if ((0, compare_js_1.isNotEqual)(oldField.type.toString(), newField.type.toString())) {
+        addChange((0, field_js_1.fieldTypeChanged)(type, oldField, newField));
+    }
+    (0, compare_js_1.compareLists)(oldField.args, newField.args, {
+        onAdded(arg) {
+            addChange((0, field_js_1.fieldArgumentAdded)(type, newField, arg));
+        },
+        onRemoved(arg) {
+            addChange((0, field_js_1.fieldArgumentRemoved)(type, oldField, arg));
+        },
+        onMutual(arg) {
+            (0, argument_js_1.changesInArgument)(type, oldField, arg.oldVersion, arg.newVersion, addChange);
+        },
+    });
+}
+exports.changesInField = changesInField;

package/cjs/diff/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diff = exports.DiffRule = void 0;
+const tslib_1 = require("tslib");
+const rules = tslib_1.__importStar(require("./rules/index.js"));
+const schema_js_1 = require("./schema.js");
+tslib_1.__exportStar(require("./rules/types.js"), exports);
+exports.DiffRule = rules;
+tslib_1.__exportStar(require("./onComplete/types.js"), exports);
+function diff(oldSchema, newSchema, rules = [], config) {
+    const changes = (0, schema_js_1.diffSchema)(oldSchema, newSchema);
+    return rules.reduce((prev, rule) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const prevChanges = yield prev;
+        return rule({
+            changes: prevChanges,
+            oldSchema,
+            newSchema,
+            config,
+        });
+    }), Promise.resolve(changes));
+}
+exports.diff = diff;

package/cjs/diff/input.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changesInInputObject = void 0;
+const compare_js_1 = require("../utils/compare.js");
+const input_js_1 = require("./changes/input.js");
+function changesInInputObject(oldInput, newInput, addChange) {
+    const oldFields = oldInput.getFields();
+    const newFields = newInput.getFields();
+    (0, compare_js_1.compareLists)(Object.values(oldFields), Object.values(newFields), {
+        onAdded(field) {
+            addChange((0, input_js_1.inputFieldAdded)(newInput, field));
+        },
+        onRemoved(field) {
+            addChange((0, input_js_1.inputFieldRemoved)(oldInput, field));
+        },
+        onMutual(field) {
+            changesInInputField(oldInput, field.oldVersion, field.newVersion, addChange);
+        },
+    });
+}
+exports.changesInInputObject = changesInInputObject;
+function changesInInputField(input, oldField, newField, addChange) {
+    if ((0, compare_js_1.isNotEqual)(oldField.description, newField.description)) {
+        if ((0, compare_js_1.isVoid)(oldField.description)) {
+            addChange((0, input_js_1.inputFieldDescriptionAdded)(input, newField));
+        }
+        else if ((0, compare_js_1.isVoid)(newField.description)) {
+            addChange((0, input_js_1.inputFieldDescriptionRemoved)(input, oldField));
+        }
+        else {
+            addChange((0, input_js_1.inputFieldDescriptionChanged)(input, oldField, newField));
+        }
+    }
+    if ((0, compare_js_1.isNotEqual)(oldField.defaultValue, newField.defaultValue)) {
+        if (Array.isArray(oldField.defaultValue) && Array.isArray(newField.defaultValue)) {
+            if ((0, compare_js_1.diffArrays)(oldField.defaultValue, newField.defaultValue).length > 0) {
+                addChange((0, input_js_1.inputFieldDefaultValueChanged)(input, oldField, newField));
+            }
+        }
+        else if (JSON.stringify(oldField.defaultValue) !== JSON.stringify(newField.defaultValue)) {
+            addChange((0, input_js_1.inputFieldDefaultValueChanged)(input, oldField, newField));
+        }
+    }
+    if ((0, compare_js_1.isNotEqual)(oldField.type.toString(), newField.type.toString())) {
+        addChange((0, input_js_1.inputFieldTypeChanged)(input, oldField, newField));
+    }
+}

package/cjs/diff/interface.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changesInInterface = void 0;
+const compare_js_1 = require("../utils/compare.js");
+const field_js_1 = require("./changes/field.js");
+const field_js_2 = require("./field.js");
+function changesInInterface(oldInterface, newInterface, addChange) {
+    (0, compare_js_1.compareLists)(Object.values(oldInterface.getFields()), Object.values(newInterface.getFields()), {
+        onAdded(field) {
+            addChange((0, field_js_1.fieldAdded)(newInterface, field));
+        },
+        onRemoved(field) {
+            addChange((0, field_js_1.fieldRemoved)(oldInterface, field));
+        },
+        onMutual(field) {
+            (0, field_js_2.changesInField)(oldInterface, field.oldVersion, field.newVersion, addChange);
+        },
+    });
+}
+exports.changesInInterface = changesInInterface;