@graphql-inspector/cli 3.4.13-alpha-20230417141810-fd2d33e7 → 3.4.13

package/cjs/core/src/diff/changes/directive.js

@@ -1,124 +1,293 @@
 "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;
+exports.directiveArgumentTypeChanged = exports.directiveArgumentTypeChangedFromMeta = exports.directiveArgumentDefaultValueChanged = exports.directiveArgumentDefaultValueChangedFromMeta = exports.directiveArgumentDescriptionChanged = exports.directiveArgumentDescriptionChangedFromMeta = exports.directiveArgumentRemoved = exports.directiveArgumentRemovedFromMeta = exports.directiveArgumentAdded = exports.directiveArgumentAddedFromMeta = exports.directiveLocationRemoved = exports.directiveLocationRemovedFromMeta = exports.directiveLocationAdded = exports.directiveLocationAddedFromMeta = exports.directiveDescriptionChanged = exports.directiveDescriptionChangedFromMeta = exports.directiveAdded = exports.directiveAddedFromMeta = exports.directiveRemoved = exports.directiveRemovedFromMeta = void 0;
 const graphql_1 = require("graphql");
 const graphql_js_1 = require("../../utils/graphql.js");
+const string_js_1 = require("../../utils/string.js");
 const change_js_1 = require("./change.js");
-function directiveRemoved(directive) {
+function buildDirectiveRemovedMessage(args) {
+    return `Directive '${args.removedDirectiveName}' was removed`;
+}
+const directiveRemovedCriticalityBreakingReason = `A directive could be in use of a client application. Removing it could break the client application.`;
+function directiveRemovedFromMeta(args) {
     return {
         criticality: {
             level: change_js_1.CriticalityLevel.Breaking,
+            reason: directiveRemovedCriticalityBreakingReason,
         },
         type: change_js_1.ChangeType.DirectiveRemoved,
-        message: `Directive '${directive.name}' was removed`,
-        path: `@${directive.name}`,
+        message: buildDirectiveRemovedMessage(args.meta),
+        path: `@${args.meta.removedDirectiveName}`,
+        meta: args.meta,
     };
 }
+exports.directiveRemovedFromMeta = directiveRemovedFromMeta;
+function directiveRemoved(directive) {
+    return directiveRemovedFromMeta({
+        type: change_js_1.ChangeType.DirectiveRemoved,
+        meta: {
+            removedDirectiveName: directive.name,
+        },
+    });
+}
 exports.directiveRemoved = directiveRemoved;
-function directiveAdded(directive) {
+function buildDirectiveAddedMessage(args) {
+    return `Directive '${args.addedDirectiveName}' was added`;
+}
+function directiveAddedFromMeta(args) {
     return {
         criticality: {
             level: change_js_1.CriticalityLevel.NonBreaking,
         },
         type: change_js_1.ChangeType.DirectiveAdded,
-        message: `Directive '${directive.name}' was added`,
-        path: `@${directive.name}`,
+        message: buildDirectiveAddedMessage(args.meta),
+        path: `@${args.meta.addedDirectiveName}`,
+        meta: args.meta,
     };
 }
+exports.directiveAddedFromMeta = directiveAddedFromMeta;
+function directiveAdded(directive) {
+    return directiveAddedFromMeta({
+        type: change_js_1.ChangeType.DirectiveAdded,
+        meta: {
+            addedDirectiveName: directive.name,
+        },
+    });
+}
 exports.directiveAdded = directiveAdded;
-function directiveDescriptionChanged(oldDirective, newDirective) {
+function buildDirectiveDescriptionChangedMessage(args) {
+    var _a, _b;
+    return `Directive '${args.directiveName}' description changed from '${(_a = args.oldDirectiveDescription) !== null && _a !== void 0 ? _a : 'undefined'}' to '${(_b = args.newDirectiveDescription) !== null && _b !== void 0 ? _b : 'undefined'}'`;
+}
+function directiveDescriptionChangedFromMeta(args) {
     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}`,
+        message: buildDirectiveDescriptionChangedMessage(args.meta),
+        path: `@${args.meta.directiveName}`,
+        meta: args.meta,
     };
 }
+exports.directiveDescriptionChangedFromMeta = directiveDescriptionChangedFromMeta;
+function directiveDescriptionChanged(oldDirective, newDirective) {
+    var _a, _b;
+    return directiveDescriptionChangedFromMeta({
+        type: change_js_1.ChangeType.DirectiveDescriptionChanged,
+        meta: {
+            directiveName: oldDirective.name,
+            oldDirectiveDescription: (_a = oldDirective.description) !== null && _a !== void 0 ? _a : null,
+            newDirectiveDescription: (_b = newDirective.description) !== null && _b !== void 0 ? _b : null,
+        },
+    });
+}
 exports.directiveDescriptionChanged = directiveDescriptionChanged;
-function directiveLocationAdded(directive, location) {
+function buildDirectiveLocationAddedMessage(args) {
+    return `Location '${args.addedDirectiveLocation}' was added to directive '${args.directiveName}'`;
+}
+function directiveLocationAddedFromMeta(args) {
     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}`,
+        message: buildDirectiveLocationAddedMessage(args.meta),
+        path: `@${args.meta.directiveName}`,
+        meta: args.meta,
     };
 }
+exports.directiveLocationAddedFromMeta = directiveLocationAddedFromMeta;
+function directiveLocationAdded(directive, location) {
+    return directiveLocationAddedFromMeta({
+        type: change_js_1.ChangeType.DirectiveLocationAdded,
+        meta: {
+            directiveName: directive.name,
+            addedDirectiveLocation: location.toString(),
+        },
+    });
+}
 exports.directiveLocationAdded = directiveLocationAdded;
-function directiveLocationRemoved(directive, location) {
+function buildDirectiveLocationRemovedMessage(args) {
+    return `Location '${args.removedDirectiveLocation}' was removed from directive '${args.directiveName}'`;
+}
+const directiveLocationRemovedBreakingReason = `A directive could be in use of a client application. Removing it could break the client application.`;
+function directiveLocationRemovedFromMeta(args) {
     return {
         criticality: {
             level: change_js_1.CriticalityLevel.Breaking,
+            reason: directiveLocationRemovedBreakingReason,
         },
         type: change_js_1.ChangeType.DirectiveLocationRemoved,
-        message: `Location '${location}' was removed from directive '${directive.name}'`,
-        path: `@${directive.name}`,
+        message: buildDirectiveLocationRemovedMessage(args.meta),
+        path: `@${args.meta.directiveName}`,
+        meta: args.meta,
     };
 }
+exports.directiveLocationRemovedFromMeta = directiveLocationRemovedFromMeta;
+function directiveLocationRemoved(directive, location) {
+    return directiveLocationRemovedFromMeta({
+        type: change_js_1.ChangeType.DirectiveLocationRemoved,
+        meta: {
+            directiveName: directive.name,
+            removedDirectiveLocation: location.toString(),
+        },
+    });
+}
 exports.directiveLocationRemoved = directiveLocationRemoved;
-function directiveArgumentAdded(directive, arg) {
+const directiveArgumentAddedBreakingReason = `A directive could be in use of a client application. Adding a non-nullable argument will break those clients.`;
+const directiveArgumentNonBreakingReason = `A directive could be in use of a client application. Adding a non-nullable argument will break those clients.`;
+function directiveArgumentAddedFromMeta(args) {
     return {
-        criticality: {
-            level: (0, graphql_1.isNonNullType)(arg.type) ? change_js_1.CriticalityLevel.Breaking : change_js_1.CriticalityLevel.NonBreaking,
-        },
+        criticality: args.meta.addedDirectiveArgumentTypeIsNonNull
+            ? {
+                level: change_js_1.CriticalityLevel.Breaking,
+                reason: directiveArgumentAddedBreakingReason,
+            }
+            : {
+                level: change_js_1.CriticalityLevel.NonBreaking,
+                reason: directiveArgumentNonBreakingReason,
+            },
         type: change_js_1.ChangeType.DirectiveArgumentAdded,
-        message: `Argument '${arg.name}' was added to directive '${directive.name}'`,
-        path: `@${directive.name}`,
+        message: `Argument '${args.meta.addedDirectiveArgumentName}' was added to directive '${args.meta.directiveName}'`,
+        path: `@${args.meta.directiveName}`,
+        meta: args.meta,
     };
 }
+exports.directiveArgumentAddedFromMeta = directiveArgumentAddedFromMeta;
+function directiveArgumentAdded(directive, arg) {
+    return directiveArgumentAddedFromMeta({
+        type: change_js_1.ChangeType.DirectiveArgumentAdded,
+        meta: {
+            directiveName: directive.name,
+            addedDirectiveArgumentName: arg.name,
+            addedDirectiveArgumentTypeIsNonNull: (0, graphql_1.isNonNullType)(arg.type),
+        },
+    });
+}
 exports.directiveArgumentAdded = directiveArgumentAdded;
-function directiveArgumentRemoved(directive, arg) {
+function buildDirectiveArgumentRemovedMessage(args) {
+    return `Argument '${args.removedDirectiveArgumentName}' was removed from directive '${args.directiveName}'`;
+}
+const directiveArgumentRemovedBreakingReason = `A directive argument could be in use of a client application. Removing the argument can break client applications.`;
+function directiveArgumentRemovedFromMeta(args) {
     return {
         criticality: {
             level: change_js_1.CriticalityLevel.Breaking,
+            reason: directiveArgumentRemovedBreakingReason,
         },
         type: change_js_1.ChangeType.DirectiveArgumentRemoved,
-        message: `Argument '${arg.name}' was removed from directive '${directive.name}'`,
-        path: `@${directive.name}.${arg.name}`,
+        message: buildDirectiveArgumentRemovedMessage(args.meta),
+        path: `@${args.meta.directiveName}.${args.meta.removedDirectiveArgumentName}`,
+        meta: args.meta,
     };
 }
+exports.directiveArgumentRemovedFromMeta = directiveArgumentRemovedFromMeta;
+function directiveArgumentRemoved(directive, arg) {
+    return directiveArgumentRemovedFromMeta({
+        type: change_js_1.ChangeType.DirectiveArgumentRemoved,
+        meta: {
+            directiveName: directive.name,
+            removedDirectiveArgumentName: arg.name,
+        },
+    });
+}
 exports.directiveArgumentRemoved = directiveArgumentRemoved;
-function directiveArgumentDescriptionChanged(directive, oldArg, newArg) {
+function buildDirectiveArgumentDescriptionChangedMessage(args) {
+    return `Description for argument '${args.directiveArgumentName}' on directive '${args.directiveName}' changed from '${args.oldDirectiveArgumentDescription}' to '${args.newDirectiveArgumentDescription}'`;
+}
+function directiveArgumentDescriptionChangedFromMeta(args) {
     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}`,
+        message: buildDirectiveArgumentDescriptionChangedMessage(args.meta),
+        path: `@${args.meta.directiveName}.${args.meta.directiveArgumentName}`,
+        meta: args.meta,
     };
 }
+exports.directiveArgumentDescriptionChangedFromMeta = directiveArgumentDescriptionChangedFromMeta;
+function directiveArgumentDescriptionChanged(directive, oldArg, newArg) {
+    var _a, _b;
+    return directiveArgumentDescriptionChangedFromMeta({
+        type: change_js_1.ChangeType.DirectiveArgumentDescriptionChanged,
+        meta: {
+            directiveName: directive.name,
+            directiveArgumentName: oldArg.name,
+            oldDirectiveArgumentDescription: (_a = oldArg.description) !== null && _a !== void 0 ? _a : null,
+            newDirectiveArgumentDescription: (_b = newArg.description) !== null && _b !== void 0 ? _b : null,
+        },
+    });
+}
 exports.directiveArgumentDescriptionChanged = directiveArgumentDescriptionChanged;
-function directiveArgumentDefaultValueChanged(directive, oldArg, newArg) {
+function buildDirectiveArgumentDefaultValueChanged(args) {
+    return args.oldDirectiveArgumentDefaultValue === undefined
+        ? `Default value '${args.newDirectiveArgumentDefaultValue}' was added to argument '${args.directiveArgumentName}' on directive '${args.directiveName}'`
+        : `Default value for argument '${args.directiveArgumentName}' on directive '${args.directiveName}' changed from '${args.oldDirectiveArgumentDefaultValue}' to '${args.newDirectiveArgumentDefaultValue}'`;
+}
+const directiveArgumentDefaultValueChangedDangerousReason = 'Changing the default value for an argument may change the runtime behaviour of a field if it was never provided.';
+function directiveArgumentDefaultValueChangedFromMeta(args) {
     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.',
+            reason: directiveArgumentDefaultValueChangedDangerousReason,
         },
         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}`,
+        message: buildDirectiveArgumentDefaultValueChanged(args.meta),
+        path: `@${args.meta.directiveName}.${args.meta.directiveArgumentName}`,
+        meta: args.meta,
+    };
+}
+exports.directiveArgumentDefaultValueChangedFromMeta = directiveArgumentDefaultValueChangedFromMeta;
+function directiveArgumentDefaultValueChanged(directive, oldArg, newArg) {
+    const meta = {
+        directiveName: directive.name,
+        directiveArgumentName: oldArg.name,
     };
+    if (oldArg.defaultValue !== undefined) {
+        meta.oldDirectiveArgumentDefaultValue = (0, string_js_1.safeString)(oldArg.defaultValue);
+    }
+    if (newArg.defaultValue !== undefined) {
+        meta.newDirectiveArgumentDefaultValue = (0, string_js_1.safeString)(newArg.defaultValue);
+    }
+    return directiveArgumentDefaultValueChangedFromMeta({
+        type: change_js_1.ChangeType.DirectiveArgumentDefaultValueChanged,
+        meta,
+    });
 }
 exports.directiveArgumentDefaultValueChanged = directiveArgumentDefaultValueChanged;
-function directiveArgumentTypeChanged(directive, oldArg, newArg) {
+function buildDirectiveArgumentTypeChangedMessage(args) {
+    return `Type for argument '${args.meta.directiveArgumentName}' on directive '${args.meta.directiveName}' changed from '${args.meta.oldDirectiveArgumentType}' to '${args.meta.newDirectiveArgumentType}'`;
+}
+const directiveArgumentTypeChangedNonBreakingReason = 'Changing an input field from non-null to null is considered non-breaking.';
+function directiveArgumentTypeChangedFromMeta(args) {
     return {
-        criticality: (0, graphql_js_1.safeChangeForInputValue)(oldArg.type, newArg.type)
+        criticality: args.meta.isSafeDirectiveArgumentTypeChange
             ? {
                 level: change_js_1.CriticalityLevel.NonBreaking,
-                reason: 'Changing an input field from non-null to null is considered non-breaking.',
+                reason: directiveArgumentTypeChangedNonBreakingReason,
             }
             : {
                 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}`,
+        message: buildDirectiveArgumentTypeChangedMessage(args),
+        path: `@${args.meta.directiveName}.${args.meta.directiveArgumentName}`,
+        meta: args.meta,
     };
 }
+exports.directiveArgumentTypeChangedFromMeta = directiveArgumentTypeChangedFromMeta;
+function directiveArgumentTypeChanged(directive, oldArg, newArg) {
+    return directiveArgumentTypeChangedFromMeta({
+        type: change_js_1.ChangeType.DirectiveArgumentTypeChanged,
+        meta: {
+            directiveName: directive.name,
+            directiveArgumentName: oldArg.name,
+            oldDirectiveArgumentType: oldArg.type.toString(),
+            newDirectiveArgumentType: newArg.type.toString(),
+            isSafeDirectiveArgumentTypeChange: (0, graphql_js_1.safeChangeForInputValue)(oldArg.type, newArg.type),
+        },
+    });
+}
 exports.directiveArgumentTypeChanged = directiveArgumentTypeChanged;

package/cjs/core/src/diff/changes/enum.js

@@ -1,75 +1,173 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.enumValueDeprecationReasonRemoved = exports.enumValueDeprecationReasonAdded = exports.enumValueDeprecationReasonChanged = exports.enumValueDescriptionChanged = exports.enumValueAdded = exports.enumValueRemoved = void 0;
+exports.enumValueDeprecationReasonRemoved = exports.enumValueDeprecationReasonRemovedFromMeta = exports.enumValueDeprecationReasonAdded = exports.enumValueDeprecationReasonAddedFromMeta = exports.enumValueDeprecationReasonChanged = exports.enumValueDeprecationReasonChangedFromMeta = exports.enumValueDescriptionChanged = exports.enumValueDescriptionChangedFromMeta = exports.enumValueAdded = exports.enumValueAddedFromMeta = exports.enumValueRemoved = exports.enumValueRemovedFromMeta = void 0;
 const is_deprecated_js_1 = require("../../utils/is-deprecated.js");
 const change_js_1 = require("./change.js");
-function enumValueRemoved(oldEnum, value) {
+function buildEnumValueRemovedMessage(args) {
+    return `Enum value '${args.removedEnumValueName}' ${args.isEnumValueDeprecated ? '(deprecated) ' : ''}was removed from enum '${args.enumName}'`;
+}
+const enumValueRemovedCriticalityBreakingReason = `Removing an enum value will cause existing queries that use this enum value to error.`;
+function enumValueRemovedFromMeta(args) {
     return {
+        type: change_js_1.ChangeType.EnumValueRemoved,
         criticality: {
             level: change_js_1.CriticalityLevel.Breaking,
-            reason: `Removing an enum value will cause existing queries that use this enum value to error.`,
+            reason: enumValueRemovedCriticalityBreakingReason,
         },
-        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('.'),
+        message: buildEnumValueRemovedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.enumName, args.meta.removedEnumValueName].join('.'),
     };
 }
+exports.enumValueRemovedFromMeta = enumValueRemovedFromMeta;
+function enumValueRemoved(oldEnum, value) {
+    return enumValueRemovedFromMeta({
+        type: change_js_1.ChangeType.EnumValueRemoved,
+        meta: {
+            enumName: oldEnum.name,
+            removedEnumValueName: value.name,
+            isEnumValueDeprecated: (0, is_deprecated_js_1.isDeprecated)(value),
+        },
+    });
+}
 exports.enumValueRemoved = enumValueRemoved;
-function enumValueAdded(newEnum, value) {
+function buildEnumValueAddedMessage(args) {
+    return `Enum value '${args.meta.addedEnumValueName}' was added to enum '${args.meta.enumName}'`;
+}
+const enumValueAddedCriticalityDangerousReason = `Adding an enum value may break existing clients that were not programming defensively against an added case when querying an enum.`;
+function enumValueAddedFromMeta(args) {
     return {
+        type: change_js_1.ChangeType.EnumValueAdded,
         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.`,
+            reason: enumValueAddedCriticalityDangerousReason,
         },
-        type: change_js_1.ChangeType.EnumValueAdded,
-        message: `Enum value '${value.name}' was added to enum '${newEnum.name}'`,
-        path: [newEnum.name, value.name].join('.'),
+        message: buildEnumValueAddedMessage(args),
+        meta: args.meta,
+        path: [args.meta.enumName, args.meta.addedEnumValueName].join('.'),
     };
 }
+exports.enumValueAddedFromMeta = enumValueAddedFromMeta;
+function enumValueAdded(newEnum, value) {
+    return enumValueAddedFromMeta({
+        type: change_js_1.ChangeType.EnumValueAdded,
+        meta: {
+            enumName: newEnum.name,
+            addedEnumValueName: value.name,
+        },
+    });
+}
 exports.enumValueAdded = enumValueAdded;
-function enumValueDescriptionChanged(newEnum, oldValue, newValue) {
+function buildEnumValueDescriptionChangedMessage(args) {
+    var _a, _b, _c;
+    return args.oldEnumValueDescription === null
+        ? `Description '${(_a = args.newEnumValueDescription) !== null && _a !== void 0 ? _a : 'undefined'}' was added to enum value '${args.enumName}.${args.enumValueName}'`
+        : `Description for enum value '${args.enumName}.${args.enumValueName}' changed from '${(_b = args.oldEnumValueDescription) !== null && _b !== void 0 ? _b : 'undefined'}' to '${(_c = args.newEnumValueDescription) !== null && _c !== void 0 ? _c : 'undefined'}'`;
+}
+function enumValueDescriptionChangedFromMeta(args) {
     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('.'),
+        message: buildEnumValueDescriptionChangedMessage(args.meta),
+        path: [args.meta.enumName, args.meta.enumValueName].join('.'),
+        meta: args.meta,
     };
 }
+exports.enumValueDescriptionChangedFromMeta = enumValueDescriptionChangedFromMeta;
+function enumValueDescriptionChanged(newEnum, oldValue, newValue) {
+    var _a, _b;
+    return enumValueDescriptionChangedFromMeta({
+        type: change_js_1.ChangeType.EnumValueDescriptionChanged,
+        meta: {
+            enumName: newEnum.name,
+            enumValueName: oldValue.name,
+            oldEnumValueDescription: (_a = oldValue.description) !== null && _a !== void 0 ? _a : null,
+            newEnumValueDescription: (_b = newValue.description) !== null && _b !== void 0 ? _b : null,
+        },
+    });
+}
 exports.enumValueDescriptionChanged = enumValueDescriptionChanged;
-function enumValueDeprecationReasonChanged(newEnum, oldValue, newValue) {
+function buildEnumValueDeprecationChangedMessage(args) {
+    return `Enum value '${args.enumName}.${args.enumValueName}' deprecation reason changed from '${args.oldEnumValueDeprecationReason}' to '${args.newEnumValueDeprecationReason}'`;
+}
+function enumValueDeprecationReasonChangedFromMeta(args) {
     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('.'),
+        message: buildEnumValueDeprecationChangedMessage(args.meta),
+        path: [args.meta.enumName, args.meta.enumValueName].join('.'),
+        meta: args.meta,
     };
 }
+exports.enumValueDeprecationReasonChangedFromMeta = enumValueDeprecationReasonChangedFromMeta;
+function enumValueDeprecationReasonChanged(newEnum, oldValue, newValue) {
+    var _a, _b;
+    return enumValueDeprecationReasonChangedFromMeta({
+        type: change_js_1.ChangeType.EnumValueDeprecationReasonChanged,
+        meta: {
+            enumName: newEnum.name,
+            enumValueName: oldValue.name,
+            oldEnumValueDeprecationReason: (_a = oldValue.deprecationReason) !== null && _a !== void 0 ? _a : '',
+            newEnumValueDeprecationReason: (_b = newValue.deprecationReason) !== null && _b !== void 0 ? _b : '',
+        },
+    });
+}
 exports.enumValueDeprecationReasonChanged = enumValueDeprecationReasonChanged;
-function enumValueDeprecationReasonAdded(newEnum, oldValue, newValue) {
+function buildEnumValueDeprecationReasonAddedMessage(args) {
+    return `Enum value '${args.enumName}.${args.enumValueName}' was deprecated with reason '${args.addedValueDeprecationReason}'`;
+}
+function enumValueDeprecationReasonAddedFromMeta(args) {
     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('.'),
+        message: buildEnumValueDeprecationReasonAddedMessage(args.meta),
+        path: [args.meta.enumName, args.meta.enumValueName].join('.'),
+        meta: args.meta,
     };
 }
+exports.enumValueDeprecationReasonAddedFromMeta = enumValueDeprecationReasonAddedFromMeta;
+function enumValueDeprecationReasonAdded(newEnum, oldValue, newValue) {
+    var _a;
+    return enumValueDeprecationReasonAddedFromMeta({
+        type: change_js_1.ChangeType.EnumValueDeprecationReasonAdded,
+        meta: {
+            enumName: newEnum.name,
+            enumValueName: oldValue.name,
+            addedValueDeprecationReason: (_a = newValue.deprecationReason) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+}
 exports.enumValueDeprecationReasonAdded = enumValueDeprecationReasonAdded;
-function enumValueDeprecationReasonRemoved(newEnum, oldValue, newValue) {
+function buildEnumValueDeprecationReasonRemovedMessage(args) {
+    return `Deprecation reason was removed from enum value '${args.enumName}.${args.enumValueName}'`;
+}
+function enumValueDeprecationReasonRemovedFromMeta(args) {
     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('.'),
+        message: buildEnumValueDeprecationReasonRemovedMessage(args.meta),
+        path: [args.meta.enumName, args.meta.enumValueName].join('.'),
+        meta: args.meta,
     };
 }
+exports.enumValueDeprecationReasonRemovedFromMeta = enumValueDeprecationReasonRemovedFromMeta;
+function enumValueDeprecationReasonRemoved(newEnum, oldValue, _newValue) {
+    var _a;
+    return enumValueDeprecationReasonRemovedFromMeta({
+        type: change_js_1.ChangeType.EnumValueDeprecationReasonRemoved,
+        meta: {
+            enumName: newEnum.name,
+            enumValueName: oldValue.name,
+            removedEnumValueDeprecationReason: (_a = oldValue.deprecationReason) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+}
 exports.enumValueDeprecationReasonRemoved = enumValueDeprecationReasonRemoved;