@graphql-inspector/core 4.0.2 → 4.0.3

package/cjs/ast/document.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDocument = void 0;
+const graphql_1 = require("graphql");
+function readDocument(source) {
+    const result = {
+        source,
+        fragments: [],
+        operations: [],
+        hasFragments: false,
+        hasOperations: false,
+    };
+    const documentNode = (0, graphql_1.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;
+}
+exports.readDocument = readDocument;
+function isOperation(node) {
+    return node.kind === graphql_1.Kind.OPERATION_DEFINITION;
+}
+function isFragment(node) {
+    return node.kind === graphql_1.Kind.FRAGMENT_DEFINITION;
+}

package/cjs/coverage/index.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coverage = void 0;
+const graphql_1 = require("graphql");
+const document_js_1 = require("../ast/document.js");
+const graphql_js_1 = require("../utils/graphql.js");
+function coverage(schema, sources) {
+    const coverage = {
+        sources,
+        types: {},
+        stats: {
+            numTypes: 0,
+            numTypesCoveredFully: 0,
+            numTypesCovered: 0,
+            numFields: 0,
+            numFiledsCovered: 0,
+        },
+    };
+    const typeMap = schema.getTypeMap();
+    const typeInfo = new graphql_1.TypeInfo(schema);
+    const visitor = source => ({
+        Field(node) {
+            const fieldDef = typeInfo.getFieldDef();
+            const parent = typeInfo.getParentType();
+            if ((parent === null || parent === void 0 ? void 0 : parent.name) &&
+                !(0, graphql_js_1.isForIntrospection)(parent.name) &&
+                (fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.name) &&
+                fieldDef.name !== '__typename' &&
+                fieldDef.name !== '__schema') {
+                const sourceName = source.name;
+                const typeCoverage = coverage.types[parent.name];
+                const fieldCoverage = typeCoverage.children[fieldDef.name];
+                const locations = fieldCoverage.locations[sourceName];
+                typeCoverage.hits++;
+                fieldCoverage.hits++;
+                if (node.loc) {
+                    fieldCoverage.locations[sourceName] = [node.loc, ...(locations || [])];
+                }
+                if (node.arguments) {
+                    for (const argNode of node.arguments) {
+                        const argCoverage = fieldCoverage.children[argNode.name.value];
+                        argCoverage.hits++;
+                        if (argNode.loc) {
+                            argCoverage.locations[sourceName] = [
+                                argNode.loc,
+                                ...(argCoverage.locations[sourceName] || []),
+                            ];
+                        }
+                    }
+                }
+            }
+        },
+    });
+    for (const typename in typeMap) {
+        if (!(0, graphql_js_1.isForIntrospection)(typename) && !(0, graphql_js_1.isPrimitive)(typename)) {
+            const type = typeMap[typename];
+            if ((0, graphql_1.isObjectType)(type) || (0, graphql_1.isInterfaceType)(type)) {
+                const typeCoverage = {
+                    hits: 0,
+                    fieldsCount: 0,
+                    fieldsCountCovered: 0,
+                    type,
+                    children: {},
+                };
+                const fieldMap = type.getFields();
+                for (const fieldname in fieldMap) {
+                    const field = fieldMap[fieldname];
+                    typeCoverage.children[field.name] = {
+                        hits: 0,
+                        fieldsCount: 0,
+                        fieldsCountCovered: 0,
+                        locations: {},
+                        children: {},
+                    };
+                    for (const arg of field.args) {
+                        typeCoverage.children[field.name].children[arg.name] = {
+                            hits: 0,
+                            fieldsCount: 0,
+                            fieldsCountCovered: 0,
+                            locations: {},
+                        };
+                    }
+                }
+                coverage.types[type.name] = typeCoverage;
+            }
+        }
+    }
+    const documents = coverage.sources.map(document_js_1.readDocument);
+    documents.forEach((doc, i) => {
+        const source = coverage.sources[i];
+        doc.operations.forEach(op => {
+            (0, graphql_1.visit)(op.node, (0, graphql_1.visitWithTypeInfo)(typeInfo, visitor(source)));
+        });
+        doc.fragments.forEach(fr => {
+            (0, graphql_1.visit)(fr.node, (0, graphql_1.visitWithTypeInfo)(typeInfo, visitor(source)));
+        });
+    });
+    for (const key in coverage.types) {
+        const me = coverage.types[key];
+        processStats(me);
+        coverage.stats.numTypes++;
+        if (me.fieldsCountCovered > 0)
+            coverage.stats.numTypesCovered++;
+        if (me.fieldsCount == me.fieldsCountCovered)
+            coverage.stats.numTypesCoveredFully++;
+        coverage.stats.numFields += me.fieldsCount;
+        coverage.stats.numFiledsCovered += me.fieldsCountCovered;
+    }
+    return coverage;
+}
+exports.coverage = coverage;
+function processStats(me) {
+    const children = me.children;
+    if (children) {
+        for (const k in children) {
+            const ch = children[k];
+            if (ch.children !== undefined) {
+                processStats(ch);
+                me.fieldsCount += ch.fieldsCount;
+                me.fieldsCountCovered += ch.fieldsCountCovered;
+            }
+            me.fieldsCount++;
+            if (ch.hits > 0) {
+                me.fieldsCountCovered++;
+            }
+        }
+    }
+}

package/cjs/coverage/output/json.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outputJSON = void 0;
+function outputJSON(coverage) {
+    return JSON.stringify(coverage, null, 2);
+}
+exports.outputJSON = outputJSON;

package/cjs/diff/argument.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changesInArgument = void 0;
+const compare_js_1 = require("../utils/compare.js");
+const argument_js_1 = require("./changes/argument.js");
+function changesInArgument(type, field, oldArg, newArg, addChange) {
+    if ((0, compare_js_1.isNotEqual)(oldArg.description, newArg.description)) {
+        addChange((0, argument_js_1.fieldArgumentDescriptionChanged)(type, field, oldArg, newArg));
+    }
+    if ((0, compare_js_1.isNotEqual)(oldArg.defaultValue, newArg.defaultValue)) {
+        if (Array.isArray(oldArg.defaultValue) && Array.isArray(newArg.defaultValue)) {
+            const diff = (0, compare_js_1.diffArrays)(oldArg.defaultValue, newArg.defaultValue);
+            if (diff.length > 0) {
+                addChange((0, argument_js_1.fieldArgumentDefaultChanged)(type, field, oldArg, newArg));
+            }
+        }
+        else if (JSON.stringify(oldArg.defaultValue) !== JSON.stringify(newArg.defaultValue)) {
+            addChange((0, argument_js_1.fieldArgumentDefaultChanged)(type, field, oldArg, newArg));
+        }
+    }
+    if ((0, compare_js_1.isNotEqual)(oldArg.type.toString(), newArg.type.toString())) {
+        addChange((0, argument_js_1.fieldArgumentTypeChanged)(type, field, oldArg, newArg));
+    }
+}
+exports.changesInArgument = changesInArgument;

package/cjs/diff/changes/argument.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldArgumentTypeChanged = exports.fieldArgumentDefaultChanged = exports.fieldArgumentDescriptionChanged = void 0;
+const graphql_js_1 = require("../../utils/graphql.js");
+const string_js_1 = require("../../utils/string.js");
+const change_js_1 = require("./change.js");
+function fieldArgumentDescriptionChanged(type, field, oldArg, newArg) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.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('.'),
+    };
+}
+exports.fieldArgumentDescriptionChanged = fieldArgumentDescriptionChanged;
+function fieldArgumentDefaultChanged(type, field, oldArg, newArg) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.Dangerous,
+            reason: 'Changing the default value for an argument may change the runtime behaviour of a field if it was never provided.',
+        },
+        type: change_js_1.ChangeType.FieldArgumentDefaultChanged,
+        message: typeof oldArg.defaultValue === 'undefined'
+            ? `Default value '${(0, string_js_1.safeString)(newArg.defaultValue)}' was added to argument '${newArg.name}' on field '${type.name}.${field.name}'`
+            : `Default value for argument '${newArg.name}' on field '${type.name}.${field.name}' changed from '${(0, string_js_1.safeString)(oldArg.defaultValue)}' to '${(0, string_js_1.safeString)(newArg.defaultValue)}'`,
+        path: [type.name, field.name, oldArg.name].join('.'),
+    };
+}
+exports.fieldArgumentDefaultChanged = fieldArgumentDefaultChanged;
+function fieldArgumentTypeChanged(type, field, oldArg, newArg) {
+    return {
+        criticality: (0, graphql_js_1.safeChangeForInputValue)(oldArg.type, newArg.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 a field's argument can cause existing queries that use this argument to error.`,
+            },
+        type: change_js_1.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('.'),
+    };
+}
+exports.fieldArgumentTypeChanged = fieldArgumentTypeChanged;

package/cjs/diff/changes/change.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CriticalityLevel = exports.ChangeType = void 0;
+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";
+    ChangeType["EnumValueDeprecationReasonAdded"] = "ENUM_VALUE_DEPRECATION_REASON_ADDED";
+    ChangeType["EnumValueDeprecationReasonRemoved"] = "ENUM_VALUE_DEPRECATION_REASON_REMOVED";
+    // 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 = exports.ChangeType || (exports.ChangeType = {}));
+var CriticalityLevel;
+(function (CriticalityLevel) {
+    CriticalityLevel["Breaking"] = "BREAKING";
+    CriticalityLevel["NonBreaking"] = "NON_BREAKING";
+    CriticalityLevel["Dangerous"] = "DANGEROUS";
+})(CriticalityLevel = exports.CriticalityLevel || (exports.CriticalityLevel = {}));

package/cjs/diff/changes/directive.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.directiveArgumentTypeChanged = exports.directiveArgumentDefaultValueChanged = exports.directiveArgumentDescriptionChanged = exports.directiveArgumentRemoved = exports.directiveArgumentAdded = exports.directiveLocationRemoved = exports.directiveLocationAdded = exports.directiveDescriptionChanged = exports.directiveAdded = exports.directiveRemoved = void 0;
+const graphql_1 = require("graphql");
+const graphql_js_1 = require("../../utils/graphql.js");
+const change_js_1 = require("./change.js");
+function directiveRemoved(directive) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.Breaking,
+        },
+        type: change_js_1.ChangeType.DirectiveRemoved,
+        message: `Directive '${directive.name}' was removed`,
+        path: `@${directive.name}`,
+    };
+}
+exports.directiveRemoved = directiveRemoved;
+function directiveAdded(directive) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.DirectiveAdded,
+        message: `Directive '${directive.name}' was added`,
+        path: `@${directive.name}`,
+    };
+}
+exports.directiveAdded = directiveAdded;
+function directiveDescriptionChanged(oldDirective, newDirective) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.DirectiveDescriptionChanged,
+        message: `Directive '${oldDirective.name}' description changed from '${oldDirective.description}' to '${newDirective.description}'`,
+        path: `@${oldDirective.name}`,
+    };
+}
+exports.directiveDescriptionChanged = directiveDescriptionChanged;
+function directiveLocationAdded(directive, location) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.DirectiveLocationAdded,
+        message: `Location '${location}' was added to directive '${directive.name}'`,
+        path: `@${directive.name}`,
+    };
+}
+exports.directiveLocationAdded = directiveLocationAdded;
+function directiveLocationRemoved(directive, location) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.Breaking,
+        },
+        type: change_js_1.ChangeType.DirectiveLocationRemoved,
+        message: `Location '${location}' was removed from directive '${directive.name}'`,
+        path: `@${directive.name}`,
+    };
+}
+exports.directiveLocationRemoved = directiveLocationRemoved;
+function directiveArgumentAdded(directive, arg) {
+    return {
+        criticality: {
+            level: (0, graphql_1.isNonNullType)(arg.type) ? change_js_1.CriticalityLevel.Breaking : change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.DirectiveArgumentAdded,
+        message: `Argument '${arg.name}' was added to directive '${directive.name}'`,
+        path: `@${directive.name}`,
+    };
+}
+exports.directiveArgumentAdded = directiveArgumentAdded;
+function directiveArgumentRemoved(directive, arg) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.Breaking,
+        },
+        type: change_js_1.ChangeType.DirectiveArgumentRemoved,
+        message: `Argument '${arg.name}' was removed from directive '${directive.name}'`,
+        path: `@${directive.name}.${arg.name}`,
+    };
+}
+exports.directiveArgumentRemoved = directiveArgumentRemoved;
+function directiveArgumentDescriptionChanged(directive, oldArg, newArg) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.DirectiveArgumentDescriptionChanged,
+        message: `Description for argument '${oldArg.name}' on directive '${directive.name}' changed from '${oldArg.description}' to '${newArg.description}'`,
+        path: `@${directive.name}.${oldArg.name}`,
+    };
+}
+exports.directiveArgumentDescriptionChanged = directiveArgumentDescriptionChanged;
+function directiveArgumentDefaultValueChanged(directive, oldArg, newArg) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.Dangerous,
+            reason: 'Changing the default value for an argument may change the runtime behaviour of a field if it was never provided.',
+        },
+        type: change_js_1.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}`,
+    };
+}
+exports.directiveArgumentDefaultValueChanged = directiveArgumentDefaultValueChanged;
+function directiveArgumentTypeChanged(directive, oldArg, newArg) {
+    return {
+        criticality: (0, graphql_js_1.safeChangeForInputValue)(oldArg.type, newArg.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,
+            },
+        type: change_js_1.ChangeType.DirectiveArgumentTypeChanged,
+        message: `Type for argument '${oldArg.name}' on directive '${directive.name}' changed from '${oldArg.type}' to '${newArg.type}'`,
+        path: `@${directive.name}.${oldArg.name}`,
+    };
+}
+exports.directiveArgumentTypeChanged = directiveArgumentTypeChanged;

package/cjs/diff/changes/enum.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumValueDeprecationReasonRemoved = exports.enumValueDeprecationReasonAdded = exports.enumValueDeprecationReasonChanged = exports.enumValueDescriptionChanged = exports.enumValueAdded = exports.enumValueRemoved = void 0;
+const is_deprecated_js_1 = require("../../utils/is-deprecated.js");
+const change_js_1 = require("./change.js");
+function enumValueRemoved(oldEnum, value) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.Breaking,
+            reason: `Removing an enum value will cause existing queries that use this enum value to error.`,
+        },
+        type: change_js_1.ChangeType.EnumValueRemoved,
+        message: `Enum value '${value.name}' ${(0, is_deprecated_js_1.isDeprecated)(value) ? '(deprecated) ' : ''}was removed from enum '${oldEnum.name}'`,
+        path: [oldEnum.name, value.name].join('.'),
+    };
+}
+exports.enumValueRemoved = enumValueRemoved;
+function enumValueAdded(newEnum, value) {
+    return {
+        criticality: {
+            level: change_js_1.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: change_js_1.ChangeType.EnumValueAdded,
+        message: `Enum value '${value.name}' was added to enum '${newEnum.name}'`,
+        path: [newEnum.name, value.name].join('.'),
+    };
+}
+exports.enumValueAdded = enumValueAdded;
+function enumValueDescriptionChanged(newEnum, oldValue, newValue) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.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('.'),
+    };
+}
+exports.enumValueDescriptionChanged = enumValueDescriptionChanged;
+function enumValueDeprecationReasonChanged(newEnum, oldValue, newValue) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.EnumValueDeprecationReasonChanged,
+        message: `Enum value '${newEnum.name}.${newValue.name}' deprecation reason changed from '${oldValue.deprecationReason}' to '${newValue.deprecationReason}'`,
+        path: [newEnum.name, oldValue.name].join('.'),
+    };
+}
+exports.enumValueDeprecationReasonChanged = enumValueDeprecationReasonChanged;
+function enumValueDeprecationReasonAdded(newEnum, oldValue, newValue) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.EnumValueDeprecationReasonAdded,
+        message: `Enum value '${newEnum.name}.${newValue.name}' was deprecated with reason '${newValue.deprecationReason}'`,
+        path: [newEnum.name, oldValue.name].join('.'),
+    };
+}
+exports.enumValueDeprecationReasonAdded = enumValueDeprecationReasonAdded;
+function enumValueDeprecationReasonRemoved(newEnum, oldValue, newValue) {
+    return {
+        criticality: {
+            level: change_js_1.CriticalityLevel.NonBreaking,
+        },
+        type: change_js_1.ChangeType.EnumValueDeprecationReasonRemoved,
+        message: `Deprecation reason was removed from enum value '${newEnum.name}.${newValue.name}'`,
+        path: [newEnum.name, oldValue.name].join('.'),
+    };
+}
+exports.enumValueDeprecationReasonRemoved = enumValueDeprecationReasonRemoved;