@graphql-inspector/core 4.0.2 → 4.0.3

package/cjs/validate/token-count.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTokenCount = exports.calculateTokenCount = void 0;
+const graphql_1 = require("graphql");
+const parser_js_1 = require("graphql/language/parser.js");
+class ParserWithLexer extends parser_js_1.Parser {
+    get tokenCount() {
+        return this.__tokenCount;
+    }
+    constructor(source, options) {
+        super(source, options);
+        this.__tokenCount = 0;
+        const lexer = this._lexer;
+        this._lexer = new Proxy(lexer, {
+            get: (target, prop, receiver) => {
+                if (prop === 'advance') {
+                    return () => {
+                        const token = target.advance();
+                        if (token.kind !== graphql_1.TokenKind.EOF) {
+                            this.__tokenCount++;
+                        }
+                        return token;
+                    };
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+        });
+    }
+}
+function calculateTokenCount(args) {
+    const parser = new ParserWithLexer(args.source);
+    const document = parser.parseDocument();
+    let { tokenCount } = parser;
+    (0, graphql_1.visit)(document, {
+        FragmentSpread(node) {
+            const fragmentSource = args.getReferencedFragmentSource(node.name.value);
+            if (fragmentSource) {
+                tokenCount += calculateTokenCount({
+                    source: fragmentSource,
+                    getReferencedFragmentSource: args.getReferencedFragmentSource,
+                });
+            }
+        },
+    });
+    return tokenCount;
+}
+exports.calculateTokenCount = calculateTokenCount;
+function validateTokenCount(args) {
+    var _a;
+    const tokenCount = calculateTokenCount(args);
+    if (tokenCount > args.maxTokenCount) {
+        return new graphql_1.GraphQLError(`Query exceeds maximum token count of ${args.maxTokenCount} (actual: ${tokenCount})`, args.document, args.source, ((_a = args.document.loc) === null || _a === void 0 ? void 0 : _a.start) ? [args.document.loc.start] : undefined);
+    }
+}
+exports.validateTokenCount = validateTokenCount;

package/esm/ast/document.js

@@ -0,0 +1,36 @@
+import { Kind, parse, } from 'graphql';
+export 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;
+}

package/esm/coverage/index.js

@@ -0,0 +1,124 @@
+import { isInterfaceType, isObjectType, TypeInfo, visit, visitWithTypeInfo, } from 'graphql';
+import { readDocument } from '../ast/document.js';
+import { isForIntrospection, isPrimitive } from '../utils/graphql.js';
+export 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 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) &&
+                !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 (!isForIntrospection(typename) && !isPrimitive(typename)) {
+            const type = typeMap[typename];
+            if (isObjectType(type) || 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(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)));
+        });
+    });
+    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;
+}
+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/esm/coverage/output/json.js

@@ -0,0 +1,3 @@
+export function outputJSON(coverage) {
+    return JSON.stringify(coverage, null, 2);
+}

package/esm/diff/argument.js

@@ -0,0 +1,21 @@
+import { diffArrays, isNotEqual } from '../utils/compare.js';
+import { fieldArgumentDefaultChanged, fieldArgumentDescriptionChanged, fieldArgumentTypeChanged, } from './changes/argument.js';
+export function changesInArgument(type, field, oldArg, newArg, addChange) {
+    if (isNotEqual(oldArg.description, newArg.description)) {
+        addChange(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) {
+                addChange(fieldArgumentDefaultChanged(type, field, oldArg, newArg));
+            }
+        }
+        else if (JSON.stringify(oldArg.defaultValue) !== JSON.stringify(newArg.defaultValue)) {
+            addChange(fieldArgumentDefaultChanged(type, field, oldArg, newArg));
+        }
+    }
+    if (isNotEqual(oldArg.type.toString(), newArg.type.toString())) {
+        addChange(fieldArgumentTypeChanged(type, field, oldArg, newArg));
+    }
+}

package/esm/diff/changes/argument.js

@@ -0,0 +1,42 @@
+import { safeChangeForInputValue } from '../../utils/graphql.js';
+import { safeString } from '../../utils/string.js';
+import { ChangeType, CriticalityLevel } from './change.js';
+export 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('.'),
+    };
+}
+export 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 '${safeString(newArg.defaultValue)}' was added to argument '${newArg.name}' on field '${type.name}.${field.name}'`
+            : `Default value for argument '${newArg.name}' on field '${type.name}.${field.name}' changed from '${safeString(oldArg.defaultValue)}' to '${safeString(newArg.defaultValue)}'`,
+        path: [type.name, field.name, oldArg.name].join('.'),
+    };
+}
+export 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('.'),
+    };
+}

package/esm/diff/changes/change.js

@@ -0,0 +1,72 @@
+export 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 || (ChangeType = {}));
+export var CriticalityLevel;
+(function (CriticalityLevel) {
+    CriticalityLevel["Breaking"] = "BREAKING";
+    CriticalityLevel["NonBreaking"] = "NON_BREAKING";
+    CriticalityLevel["Dangerous"] = "DANGEROUS";
+})(CriticalityLevel || (CriticalityLevel = {}));

package/esm/diff/changes/directive.js

@@ -0,0 +1,111 @@
+import { isNonNullType } from 'graphql';
+import { safeChangeForInputValue } from '../../utils/graphql.js';
+import { ChangeType, CriticalityLevel } from './change.js';
+export function directiveRemoved(directive) {
+    return {
+        criticality: {
+            level: CriticalityLevel.Breaking,
+        },
+        type: ChangeType.DirectiveRemoved,
+        message: `Directive '${directive.name}' was removed`,
+        path: `@${directive.name}`,
+    };
+}
+export function directiveAdded(directive) {
+    return {
+        criticality: {
+            level: CriticalityLevel.NonBreaking,
+        },
+        type: ChangeType.DirectiveAdded,
+        message: `Directive '${directive.name}' was added`,
+        path: `@${directive.name}`,
+    };
+}
+export 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}`,
+    };
+}
+export function directiveLocationAdded(directive, location) {
+    return {
+        criticality: {
+            level: CriticalityLevel.NonBreaking,
+        },
+        type: ChangeType.DirectiveLocationAdded,
+        message: `Location '${location}' was added to directive '${directive.name}'`,
+        path: `@${directive.name}`,
+    };
+}
+export function directiveLocationRemoved(directive, location) {
+    return {
+        criticality: {
+            level: CriticalityLevel.Breaking,
+        },
+        type: ChangeType.DirectiveLocationRemoved,
+        message: `Location '${location}' was removed from directive '${directive.name}'`,
+        path: `@${directive.name}`,
+    };
+}
+export 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}`,
+    };
+}
+export 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}`,
+    };
+}
+export 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}`,
+    };
+}
+export 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}`,
+    };
+}
+export 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}`,
+    };
+}

package/esm/diff/changes/enum.js

@@ -0,0 +1,66 @@
+import { isDeprecated } from '../../utils/is-deprecated.js';
+import { ChangeType, CriticalityLevel } from './change.js';
+export 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}' ${isDeprecated(value) ? '(deprecated) ' : ''}was removed from enum '${oldEnum.name}'`,
+        path: [oldEnum.name, value.name].join('.'),
+    };
+}
+export 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('.'),
+    };
+}
+export 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('.'),
+    };
+}
+export function enumValueDeprecationReasonChanged(newEnum, oldValue, newValue) {
+    return {
+        criticality: {
+            level: CriticalityLevel.NonBreaking,
+        },
+        type: ChangeType.EnumValueDeprecationReasonChanged,
+        message: `Enum value '${newEnum.name}.${newValue.name}' deprecation reason changed from '${oldValue.deprecationReason}' to '${newValue.deprecationReason}'`,
+        path: [newEnum.name, oldValue.name].join('.'),
+    };
+}
+export function enumValueDeprecationReasonAdded(newEnum, oldValue, newValue) {
+    return {
+        criticality: {
+            level: CriticalityLevel.NonBreaking,
+        },
+        type: ChangeType.EnumValueDeprecationReasonAdded,
+        message: `Enum value '${newEnum.name}.${newValue.name}' was deprecated with reason '${newValue.deprecationReason}'`,
+        path: [newEnum.name, oldValue.name].join('.'),
+    };
+}
+export function enumValueDeprecationReasonRemoved(newEnum, oldValue, newValue) {
+    return {
+        criticality: {
+            level: CriticalityLevel.NonBreaking,
+        },
+        type: ChangeType.EnumValueDeprecationReasonRemoved,
+        message: `Deprecation reason was removed from enum value '${newEnum.name}.${newValue.name}'`,
+        path: [newEnum.name, oldValue.name].join('.'),
+    };
+}