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

package/esm/core/src/diff/changes/argument.js

@@ -1,42 +1,100 @@
 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) {
+import { ChangeType, CriticalityLevel, } from './change.js';
+function buildFieldArgumentDescriptionChangedMessage(args) {
+    return `Description for argument '${args.argumentName}' on field '${args.typeName}.${args.fieldName}' changed from '${args.oldDescription}' to '${args.newDescription}'`;
+}
+export function fieldArgumentDescriptionChangedFromMeta(args) {
     return {
+        type: ChangeType.FieldArgumentDescriptionChanged,
         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('.'),
+        message: buildFieldArgumentDescriptionChangedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName, args.meta.argumentName].join('.'),
     };
 }
-export function fieldArgumentDefaultChanged(type, field, oldArg, newArg) {
+export function fieldArgumentDescriptionChanged(type, field, oldArg, newArg) {
+    var _a, _b;
+    return fieldArgumentDescriptionChangedFromMeta({
+        type: ChangeType.FieldArgumentDescriptionChanged,
+        meta: {
+            typeName: type.name,
+            fieldName: field.name,
+            argumentName: oldArg.name,
+            oldDescription: (_a = oldArg.description) !== null && _a !== void 0 ? _a : null,
+            newDescription: (_b = newArg.description) !== null && _b !== void 0 ? _b : null,
+        },
+    });
+}
+function buildFieldArgumentDefaultChangedMessage(args) {
+    return args.oldDefaultValue === undefined
+        ? `Default value '${args.newDefaultValue}' was added to argument '${args.argumentName}' on field '${args.typeName}.${args.fieldName}'`
+        : `Default value for argument '${args.argumentName}' on field '${args.typeName}.${args.fieldName}' changed from '${args.oldDefaultValue}' to '${args.newDefaultValue}'`;
+}
+const fieldArgumentDefaultChangedCriticalityDangerousReason = 'Changing the default value for an argument may change the runtime behaviour of a field if it was never provided.';
+export function fieldArgumentDefaultChangedFromMeta(args) {
     return {
+        type: ChangeType.FieldArgumentDefaultChanged,
         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.',
+            reason: fieldArgumentDefaultChangedCriticalityDangerousReason,
         },
-        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('.'),
+        message: buildFieldArgumentDefaultChangedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName, args.meta.argumentName].join('.'),
     };
 }
-export function fieldArgumentTypeChanged(type, field, oldArg, newArg) {
+export function fieldArgumentDefaultChanged(type, field, oldArg, newArg) {
+    const meta = {
+        typeName: type.name,
+        fieldName: field.name,
+        argumentName: newArg.name,
+    };
+    if (oldArg.defaultValue !== undefined) {
+        meta.oldDefaultValue = safeString(oldArg.defaultValue);
+    }
+    if (newArg.defaultValue !== undefined) {
+        meta.newDefaultValue = safeString(newArg.defaultValue);
+    }
+    return fieldArgumentDefaultChangedFromMeta({
+        type: ChangeType.FieldArgumentDefaultChanged,
+        meta,
+    });
+}
+function buildFieldArgumentTypeChangedMessage(args) {
+    return `Type for argument '${args.argumentName}' on field '${args.typeName}.${args.fieldName}' changed from '${args.oldArgumentType}' to '${args.newArgumentType}'`;
+}
+const fieldArgumentTypeChangedCriticalityNonBreakingReason = `Changing an input field from non-null to null is considered non-breaking.`;
+const fieldArgumentTypeChangedCriticalityBreakingReason = `Changing the type of a field's argument can cause existing queries that use this argument to error.`;
+export function fieldArgumentTypeChangedFromMeta(args) {
     return {
-        criticality: safeChangeForInputValue(oldArg.type, newArg.type)
+        type: ChangeType.FieldArgumentTypeChanged,
+        criticality: args.meta.isSafeArgumentTypeChange
             ? {
                 level: CriticalityLevel.NonBreaking,
-                reason: `Changing an input field from non-null to null is considered non-breaking.`,
+                reason: fieldArgumentTypeChangedCriticalityNonBreakingReason,
             }
             : {
                 level: CriticalityLevel.Breaking,
-                reason: `Changing the type of a field's argument can cause existing queries that use this argument to error.`,
+                reason: fieldArgumentTypeChangedCriticalityBreakingReason,
             },
-        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('.'),
+        message: buildFieldArgumentTypeChangedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName, args.meta.argumentName].join('.'),
     };
 }
+export function fieldArgumentTypeChanged(type, field, oldArg, newArg) {
+    return fieldArgumentTypeChangedFromMeta({
+        type: ChangeType.FieldArgumentTypeChanged,
+        meta: {
+            typeName: type.name,
+            fieldName: field.name,
+            argumentName: newArg.name,
+            oldArgumentType: oldArg.type.toString(),
+            newArgumentType: newArg.type.toString(),
+            isSafeArgumentTypeChange: safeChangeForInputValue(oldArg.type, newArg.type),
+        },
+    });
+}

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

@@ -1,111 +1,270 @@
 import { isNonNullType } from 'graphql';
 import { safeChangeForInputValue } from '../../utils/graphql.js';
-import { ChangeType, CriticalityLevel } from './change.js';
-export function directiveRemoved(directive) {
+import { safeString } from '../../utils/string.js';
+import { ChangeType, CriticalityLevel, } from './change.js';
+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.`;
+export function directiveRemovedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.Breaking,
+            reason: directiveRemovedCriticalityBreakingReason,
         },
         type: ChangeType.DirectiveRemoved,
-        message: `Directive '${directive.name}' was removed`,
-        path: `@${directive.name}`,
+        message: buildDirectiveRemovedMessage(args.meta),
+        path: `@${args.meta.removedDirectiveName}`,
+        meta: args.meta,
     };
 }
-export function directiveAdded(directive) {
+export function directiveRemoved(directive) {
+    return directiveRemovedFromMeta({
+        type: ChangeType.DirectiveRemoved,
+        meta: {
+            removedDirectiveName: directive.name,
+        },
+    });
+}
+function buildDirectiveAddedMessage(args) {
+    return `Directive '${args.addedDirectiveName}' was added`;
+}
+export function directiveAddedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
         type: ChangeType.DirectiveAdded,
-        message: `Directive '${directive.name}' was added`,
-        path: `@${directive.name}`,
+        message: buildDirectiveAddedMessage(args.meta),
+        path: `@${args.meta.addedDirectiveName}`,
+        meta: args.meta,
     };
 }
-export function directiveDescriptionChanged(oldDirective, newDirective) {
+export function directiveAdded(directive) {
+    return directiveAddedFromMeta({
+        type: ChangeType.DirectiveAdded,
+        meta: {
+            addedDirectiveName: directive.name,
+        },
+    });
+}
+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'}'`;
+}
+export function directiveDescriptionChangedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
         type: 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,
     };
 }
-export function directiveLocationAdded(directive, location) {
+export function directiveDescriptionChanged(oldDirective, newDirective) {
+    var _a, _b;
+    return directiveDescriptionChangedFromMeta({
+        type: 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,
+        },
+    });
+}
+function buildDirectiveLocationAddedMessage(args) {
+    return `Location '${args.addedDirectiveLocation}' was added to directive '${args.directiveName}'`;
+}
+export function directiveLocationAddedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
         type: 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,
     };
 }
-export function directiveLocationRemoved(directive, location) {
+export function directiveLocationAdded(directive, location) {
+    return directiveLocationAddedFromMeta({
+        type: ChangeType.DirectiveLocationAdded,
+        meta: {
+            directiveName: directive.name,
+            addedDirectiveLocation: location.toString(),
+        },
+    });
+}
+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.`;
+export function directiveLocationRemovedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.Breaking,
+            reason: directiveLocationRemovedBreakingReason,
         },
         type: 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,
     };
 }
-export function directiveArgumentAdded(directive, arg) {
-    return {
-        criticality: {
-            level: isNonNullType(arg.type) ? CriticalityLevel.Breaking : CriticalityLevel.NonBreaking,
+export function directiveLocationRemoved(directive, location) {
+    return directiveLocationRemovedFromMeta({
+        type: ChangeType.DirectiveLocationRemoved,
+        meta: {
+            directiveName: directive.name,
+            removedDirectiveLocation: location.toString(),
         },
+    });
+}
+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.`;
+export function directiveArgumentAddedFromMeta(args) {
+    return {
+        criticality: args.meta.addedDirectiveArgumentTypeIsNonNull
+            ? {
+                level: CriticalityLevel.Breaking,
+                reason: directiveArgumentAddedBreakingReason,
+            }
+            : {
+                level: CriticalityLevel.NonBreaking,
+                reason: directiveArgumentNonBreakingReason,
+            },
         type: 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,
     };
 }
-export function directiveArgumentRemoved(directive, arg) {
+export function directiveArgumentAdded(directive, arg) {
+    return directiveArgumentAddedFromMeta({
+        type: ChangeType.DirectiveArgumentAdded,
+        meta: {
+            directiveName: directive.name,
+            addedDirectiveArgumentName: arg.name,
+            addedDirectiveArgumentTypeIsNonNull: isNonNullType(arg.type),
+        },
+    });
+}
+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.`;
+export function directiveArgumentRemovedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.Breaking,
+            reason: directiveArgumentRemovedBreakingReason,
         },
         type: 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,
     };
 }
-export function directiveArgumentDescriptionChanged(directive, oldArg, newArg) {
+export function directiveArgumentRemoved(directive, arg) {
+    return directiveArgumentRemovedFromMeta({
+        type: ChangeType.DirectiveArgumentRemoved,
+        meta: {
+            directiveName: directive.name,
+            removedDirectiveArgumentName: arg.name,
+        },
+    });
+}
+function buildDirectiveArgumentDescriptionChangedMessage(args) {
+    return `Description for argument '${args.directiveArgumentName}' on directive '${args.directiveName}' changed from '${args.oldDirectiveArgumentDescription}' to '${args.newDirectiveArgumentDescription}'`;
+}
+export function directiveArgumentDescriptionChangedFromMeta(args) {
     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}`,
+        message: buildDirectiveArgumentDescriptionChangedMessage(args.meta),
+        path: `@${args.meta.directiveName}.${args.meta.directiveArgumentName}`,
+        meta: args.meta,
     };
 }
-export function directiveArgumentDefaultValueChanged(directive, oldArg, newArg) {
+export function directiveArgumentDescriptionChanged(directive, oldArg, newArg) {
+    var _a, _b;
+    return directiveArgumentDescriptionChangedFromMeta({
+        type: 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,
+        },
+    });
+}
+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.';
+export function directiveArgumentDefaultValueChangedFromMeta(args) {
     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.',
+            reason: directiveArgumentDefaultValueChangedDangerousReason,
         },
         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}`,
+        message: buildDirectiveArgumentDefaultValueChanged(args.meta),
+        path: `@${args.meta.directiveName}.${args.meta.directiveArgumentName}`,
+        meta: args.meta,
     };
 }
-export function directiveArgumentTypeChanged(directive, oldArg, newArg) {
+export function directiveArgumentDefaultValueChanged(directive, oldArg, newArg) {
+    const meta = {
+        directiveName: directive.name,
+        directiveArgumentName: oldArg.name,
+    };
+    if (oldArg.defaultValue !== undefined) {
+        meta.oldDirectiveArgumentDefaultValue = safeString(oldArg.defaultValue);
+    }
+    if (newArg.defaultValue !== undefined) {
+        meta.newDirectiveArgumentDefaultValue = safeString(newArg.defaultValue);
+    }
+    return directiveArgumentDefaultValueChangedFromMeta({
+        type: ChangeType.DirectiveArgumentDefaultValueChanged,
+        meta,
+    });
+}
+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.';
+export function directiveArgumentTypeChangedFromMeta(args) {
     return {
-        criticality: safeChangeForInputValue(oldArg.type, newArg.type)
+        criticality: args.meta.isSafeDirectiveArgumentTypeChange
             ? {
                 level: CriticalityLevel.NonBreaking,
-                reason: 'Changing an input field from non-null to null is considered non-breaking.',
+                reason: directiveArgumentTypeChangedNonBreakingReason,
             }
             : {
                 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}`,
+        message: buildDirectiveArgumentTypeChangedMessage(args),
+        path: `@${args.meta.directiveName}.${args.meta.directiveArgumentName}`,
+        meta: args.meta,
     };
 }
+export function directiveArgumentTypeChanged(directive, oldArg, newArg) {
+    return directiveArgumentTypeChangedFromMeta({
+        type: ChangeType.DirectiveArgumentTypeChanged,
+        meta: {
+            directiveName: directive.name,
+            directiveArgumentName: oldArg.name,
+            oldDirectiveArgumentType: oldArg.type.toString(),
+            newDirectiveArgumentType: newArg.type.toString(),
+            isSafeDirectiveArgumentTypeChange: safeChangeForInputValue(oldArg.type, newArg.type),
+        },
+    });
+}

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

@@ -1,66 +1,158 @@
 import { isDeprecated } from '../../utils/is-deprecated.js';
-import { ChangeType, CriticalityLevel } from './change.js';
-export function enumValueRemoved(oldEnum, value) {
+import { ChangeType, CriticalityLevel, } from './change.js';
+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.`;
+export function enumValueRemovedFromMeta(args) {
     return {
+        type: ChangeType.EnumValueRemoved,
         criticality: {
             level: CriticalityLevel.Breaking,
-            reason: `Removing an enum value will cause existing queries that use this enum value to error.`,
+            reason: enumValueRemovedCriticalityBreakingReason,
         },
-        type: ChangeType.EnumValueRemoved,
-        message: `Enum value '${value.name}' ${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('.'),
     };
 }
-export function enumValueAdded(newEnum, value) {
+export function enumValueRemoved(oldEnum, value) {
+    return enumValueRemovedFromMeta({
+        type: ChangeType.EnumValueRemoved,
+        meta: {
+            enumName: oldEnum.name,
+            removedEnumValueName: value.name,
+            isEnumValueDeprecated: isDeprecated(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.`;
+export function enumValueAddedFromMeta(args) {
     return {
+        type: ChangeType.EnumValueAdded,
         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.`,
+            reason: enumValueAddedCriticalityDangerousReason,
         },
-        type: 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('.'),
     };
 }
-export function enumValueDescriptionChanged(newEnum, oldValue, newValue) {
+export function enumValueAdded(newEnum, value) {
+    return enumValueAddedFromMeta({
+        type: ChangeType.EnumValueAdded,
+        meta: {
+            enumName: newEnum.name,
+            addedEnumValueName: value.name,
+        },
+    });
+}
+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'}'`;
+}
+export function enumValueDescriptionChangedFromMeta(args) {
     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('.'),
+        message: buildEnumValueDescriptionChangedMessage(args.meta),
+        path: [args.meta.enumName, args.meta.enumValueName].join('.'),
+        meta: args.meta,
     };
 }
-export function enumValueDeprecationReasonChanged(newEnum, oldValue, newValue) {
+export function enumValueDescriptionChanged(newEnum, oldValue, newValue) {
+    var _a, _b;
+    return enumValueDescriptionChangedFromMeta({
+        type: 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,
+        },
+    });
+}
+function buildEnumValueDeprecationChangedMessage(args) {
+    return `Enum value '${args.enumName}.${args.enumValueName}' deprecation reason changed from '${args.oldEnumValueDeprecationReason}' to '${args.newEnumValueDeprecationReason}'`;
+}
+export function enumValueDeprecationReasonChangedFromMeta(args) {
     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('.'),
+        message: buildEnumValueDeprecationChangedMessage(args.meta),
+        path: [args.meta.enumName, args.meta.enumValueName].join('.'),
+        meta: args.meta,
     };
 }
-export function enumValueDeprecationReasonAdded(newEnum, oldValue, newValue) {
+export function enumValueDeprecationReasonChanged(newEnum, oldValue, newValue) {
+    var _a, _b;
+    return enumValueDeprecationReasonChangedFromMeta({
+        type: 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 : '',
+        },
+    });
+}
+function buildEnumValueDeprecationReasonAddedMessage(args) {
+    return `Enum value '${args.enumName}.${args.enumValueName}' was deprecated with reason '${args.addedValueDeprecationReason}'`;
+}
+export function enumValueDeprecationReasonAddedFromMeta(args) {
     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('.'),
+        message: buildEnumValueDeprecationReasonAddedMessage(args.meta),
+        path: [args.meta.enumName, args.meta.enumValueName].join('.'),
+        meta: args.meta,
     };
 }
-export function enumValueDeprecationReasonRemoved(newEnum, oldValue, newValue) {
+export function enumValueDeprecationReasonAdded(newEnum, oldValue, newValue) {
+    var _a;
+    return enumValueDeprecationReasonAddedFromMeta({
+        type: ChangeType.EnumValueDeprecationReasonAdded,
+        meta: {
+            enumName: newEnum.name,
+            enumValueName: oldValue.name,
+            addedValueDeprecationReason: (_a = newValue.deprecationReason) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+}
+function buildEnumValueDeprecationReasonRemovedMessage(args) {
+    return `Deprecation reason was removed from enum value '${args.enumName}.${args.enumValueName}'`;
+}
+export function enumValueDeprecationReasonRemovedFromMeta(args) {
     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('.'),
+        message: buildEnumValueDeprecationReasonRemovedMessage(args.meta),
+        path: [args.meta.enumName, args.meta.enumValueName].join('.'),
+        meta: args.meta,
     };
 }
+export function enumValueDeprecationReasonRemoved(newEnum, oldValue, _newValue) {
+    var _a;
+    return enumValueDeprecationReasonRemovedFromMeta({
+        type: ChangeType.EnumValueDeprecationReasonRemoved,
+        meta: {
+            enumName: newEnum.name,
+            enumValueName: oldValue.name,
+            removedEnumValueDeprecationReason: (_a = oldValue.deprecationReason) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+}