@graphql-inspector/cli 3.4.12 → 3.4.13-alpha-20230413084834-8074e32d

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 : '',
+        },
+    });
+}

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

@@ -1,150 +1,328 @@
 import { isInterfaceType, isNonNullType, } from 'graphql';
 import { safeChangeForField } from '../../utils/graphql.js';
-import { isDeprecated } from '../../utils/is-deprecated.js';
-import { ChangeType, CriticalityLevel } from './change.js';
-export function fieldRemoved(type, field) {
-    const entity = isInterfaceType(type) ? 'interface' : 'object type';
+import { ChangeType, CriticalityLevel, } from './change.js';
+function buildFieldRemovedMessage(args) {
+    return `Field '${args.removedFieldName}' ${args.isRemovedFieldDeprecated ? '(deprecated) ' : ''}was removed from ${args.typeType} '${args.typeName}'`;
+}
+export function fieldRemovedFromMeta(args) {
     return {
+        type: ChangeType.FieldRemoved,
         criticality: {
             level: CriticalityLevel.Breaking,
-            reason: field.deprecationReason
+            reason: args.meta.isRemovedFieldDeprecated
                 ? `Removing a deprecated field is a breaking change. Before removing it, you may want to look at the field's usage to see the impact of removing the field.`
                 : `Removing a field is a breaking change. It is preferable to deprecate the field before removing it.`,
         },
+        message: buildFieldRemovedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.removedFieldName].join('.'),
+    };
+}
+export function fieldRemoved(type, field) {
+    const entity = isInterfaceType(type) ? 'interface' : 'object type';
+    return fieldRemovedFromMeta({
         type: ChangeType.FieldRemoved,
-        message: `Field '${field.name}' ${isDeprecated(field) ? '(deprecated) ' : ''}was removed from ${entity} '${type.name}'`,
-        path: [type.name, field.name].join('.'),
+        meta: {
+            typeName: type.name,
+            removedFieldName: field.name,
+            isRemovedFieldDeprecated: field.deprecationReason != null,
+            typeType: entity,
+        },
+    });
+}
+function buildFieldAddedMessage(args) {
+    return `Field '${args.addedFieldName}' was added to ${args.typeType} '${args.typeName}'`;
+}
+export function fieldAddedFromMeta(args) {
+    return {
+        type: ChangeType.FieldAdded,
+        criticality: {
+            level: CriticalityLevel.NonBreaking,
+        },
+        message: buildFieldAddedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.addedFieldName].join('.'),
     };
 }
 export function fieldAdded(type, field) {
     const entity = isInterfaceType(type) ? 'interface' : 'object type';
+    return fieldAddedFromMeta({
+        type: ChangeType.FieldAdded,
+        meta: {
+            typeName: type.name,
+            addedFieldName: field.name,
+            typeType: entity,
+        },
+    });
+}
+function buildFieldDescriptionChangedMessage(args) {
+    return `Field '${args.typeName}.${args.fieldName}' description changed from '${args.oldDescription}' to '${args.newDescription}'`;
+}
+export function fieldDescriptionChangedFromMeta(args) {
     return {
+        type: ChangeType.FieldDescriptionChanged,
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
-        type: ChangeType.FieldAdded,
-        message: `Field '${field.name}' was added to ${entity} '${type.name}'`,
-        path: [type.name, field.name].join('.'),
+        message: buildFieldDescriptionChangedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName].join('.'),
     };
 }
 export function fieldDescriptionChanged(type, oldField, newField) {
+    var _a, _b;
+    return fieldDescriptionChangedFromMeta({
+        type: ChangeType.FieldDescriptionChanged,
+        meta: {
+            fieldName: oldField.name,
+            typeName: type.name,
+            oldDescription: (_a = oldField.description) !== null && _a !== void 0 ? _a : '',
+            newDescription: (_b = newField.description) !== null && _b !== void 0 ? _b : '',
+        },
+    });
+}
+function buildFieldDescriptionAddedMessage(args) {
+    return `Field '${args.typeName}.${args.fieldName}' has description '${args.addedDescription}'`;
+}
+export function fieldDescriptionAddedFromMeta(args) {
     return {
+        type: ChangeType.FieldDescriptionAdded,
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
-        type: ChangeType.FieldDescriptionChanged,
-        message: `Field '${type.name}.${oldField.name}' description changed from '${oldField.description}' to '${newField.description}'`,
-        path: [type.name, oldField.name].join('.'),
+        message: buildFieldDescriptionAddedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName].join('.'),
     };
 }
 export function fieldDescriptionAdded(type, field) {
+    var _a;
+    return fieldDescriptionAddedFromMeta({
+        type: ChangeType.FieldDescriptionAdded,
+        meta: {
+            typeName: type.name,
+            fieldName: field.name,
+            addedDescription: (_a = field.description) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+}
+function buildFieldDescriptionRemovedMessage(args) {
+    return `Description was removed from field '${args.typeName}.${args.fieldName}'`;
+}
+export function fieldDescriptionRemovedFromMeta(args) {
     return {
+        type: ChangeType.FieldDescriptionRemoved,
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
-        type: ChangeType.FieldDescriptionAdded,
-        message: `Field '${type.name}.${field.name}' has description '${field.description}'`,
-        path: [type.name, field.name].join('.'),
+        message: buildFieldDescriptionRemovedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName].join('.'),
     };
 }
 export function fieldDescriptionRemoved(type, field) {
+    return fieldDescriptionRemovedFromMeta({
+        type: ChangeType.FieldDescriptionRemoved,
+        meta: {
+            typeName: type.name,
+            fieldName: field.name,
+        },
+    });
+}
+function buildFieldDeprecatedAddedMessage(args) {
+    return `Field '${args.typeName}.${args.fieldName}' is deprecated`;
+}
+export function fieldDeprecationAddedFromMeta(args) {
     return {
+        type: ChangeType.FieldDeprecationAdded,
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
-        type: ChangeType.FieldDescriptionRemoved,
-        message: `Description was removed from field '${type.name}.${field.name}'`,
-        path: [type.name, field.name].join('.'),
+        message: buildFieldDeprecatedAddedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName].join('.'),
     };
 }
 export function fieldDeprecationAdded(type, field) {
+    return fieldDeprecationAddedFromMeta({
+        type: ChangeType.FieldDeprecationAdded,
+        meta: {
+            typeName: type.name,
+            fieldName: field.name,
+        },
+    });
+}
+export function fieldDeprecationRemovedFromMeta(args) {
     return {
+        type: ChangeType.FieldDeprecationRemoved,
         criticality: {
-            level: CriticalityLevel.NonBreaking,
+            level: CriticalityLevel.Dangerous,
         },
-        type: ChangeType.FieldDeprecationAdded,
-        message: `Field '${type.name}.${field.name}' is deprecated`,
-        path: [type.name, field.name].join('.'),
+        message: `Field '${args.meta.typeName}.${args.meta.fieldName}' is no longer deprecated`,
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName].join('.'),
     };
 }
 export function fieldDeprecationRemoved(type, field) {
+    return fieldDeprecationRemovedFromMeta({
+        type: ChangeType.FieldDeprecationRemoved,
+        meta: {
+            fieldName: field.name,
+            typeName: type.name,
+        },
+    });
+}
+function buildFieldDeprecationReasonChangedMessage(args) {
+    return `Deprecation reason on field '${args.typeName}.${args.fieldName}' has changed from '${args.oldDeprecationReason}' to '${args.newDeprecationReason}'`;
+}
+export function fieldDeprecationReasonChangedFromMeta(args) {
     return {
+        type: ChangeType.FieldDeprecationReasonChanged,
         criticality: {
-            level: CriticalityLevel.Dangerous,
+            level: CriticalityLevel.NonBreaking,
         },
-        type: ChangeType.FieldDeprecationRemoved,
-        message: `Field '${type.name}.${field.name}' is no longer deprecated`,
-        path: [type.name, field.name].join('.'),
+        message: buildFieldDeprecationReasonChangedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName].join('.'),
     };
 }
 export function fieldDeprecationReasonChanged(type, oldField, newField) {
+    var _a, _b;
+    return fieldDeprecationReasonChangedFromMeta({
+        type: ChangeType.FieldDeprecationReasonChanged,
+        meta: {
+            fieldName: newField.name,
+            typeName: type.name,
+            newDeprecationReason: (_a = newField.deprecationReason) !== null && _a !== void 0 ? _a : '',
+            oldDeprecationReason: (_b = oldField.deprecationReason) !== null && _b !== void 0 ? _b : '',
+        },
+    });
+}
+function buildFieldDeprecationReasonAddedMessage(args) {
+    return `Field '${args.typeName}.${args.fieldName}' has deprecation reason '${args.addedDeprecationReason}'`;
+}
+export function fieldDeprecationReasonAddedFromMeta(args) {
     return {
+        type: ChangeType.FieldDeprecationReasonAdded,
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
-        type: ChangeType.FieldDeprecationReasonChanged,
-        message: `Deprecation reason on field '${type.name}.${newField.name}' has changed from '${oldField.deprecationReason}' to '${newField.deprecationReason}'`,
-        path: [type.name, oldField.name].join('.'),
+        message: buildFieldDeprecationReasonAddedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName].join('.'),
     };
 }
 export function fieldDeprecationReasonAdded(type, field) {
+    var _a;
+    return fieldDeprecationReasonAddedFromMeta({
+        type: ChangeType.FieldDeprecationReasonAdded,
+        meta: {
+            typeName: type.name,
+            fieldName: field.name,
+            addedDeprecationReason: (_a = field.deprecationReason) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+}
+export function fieldDeprecationReasonRemovedFromMeta(args) {
     return {
+        type: ChangeType.FieldDeprecationReasonRemoved,
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
-        type: ChangeType.FieldDeprecationReasonAdded,
-        message: `Field '${type.name}.${field.name}' has deprecation reason '${field.deprecationReason}'`,
-        path: [type.name, field.name].join('.'),
+        message: `Deprecation reason was removed from field '${args.meta.typeName}.${args.meta.fieldName}'`,
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName].join('.'),
     };
 }
 export function fieldDeprecationReasonRemoved(type, field) {
+    return fieldDeprecationReasonRemovedFromMeta({
+        type: ChangeType.FieldDeprecationReasonRemoved,
+        meta: {
+            typeName: type.name,
+            fieldName: field.name,
+        },
+    });
+}
+function buildFieldTypeChangedMessage(args) {
+    return `Field '${args.meta.typeName}.${args.meta.fieldName}' changed type from '${args.meta.oldFieldType}' to '${args.meta.newFieldType}'`;
+}
+export function fieldTypeChangedFromMeta(args) {
     return {
+        type: ChangeType.FieldTypeChanged,
         criticality: {
-            level: CriticalityLevel.NonBreaking,
+            level: args.meta.isSafeFieldTypeChange
+                ? CriticalityLevel.NonBreaking
+                : CriticalityLevel.Breaking,
         },
-        type: ChangeType.FieldDeprecationReasonRemoved,
-        message: `Deprecation reason was removed from field '${type.name}.${field.name}'`,
-        path: [type.name, field.name].join('.'),
+        message: buildFieldTypeChangedMessage(args),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName].join('.'),
     };
 }
 export function fieldTypeChanged(type, oldField, newField) {
+    return fieldTypeChangedFromMeta({
+        type: ChangeType.FieldTypeChanged,
+        meta: {
+            typeName: type.name,
+            fieldName: oldField.name,
+            oldFieldType: oldField.type.toString(),
+            newFieldType: newField.type.toString(),
+            isSafeFieldTypeChange: safeChangeForField(oldField.type, newField.type),
+        },
+    });
+}
+function buildFieldArgumentAddedMessage(args) {
+    return `Argument '${args.addedArgumentName}: ${args.addedArgumentType}'${args.hasDefaultValue ? ' (with default value) ' : ' '}added to field '${args.typeName}.${args.fieldName}'`;
+}
+export function fieldArgumentAddedFromMeta(args) {
     return {
+        type: ChangeType.FieldArgumentAdded,
         criticality: {
-            level: safeChangeForField(oldField.type, newField.type)
-                ? CriticalityLevel.NonBreaking
-                : CriticalityLevel.Breaking,
+            level: args.meta.isAddedFieldArgumentBreaking
+                ? CriticalityLevel.Breaking
+                : CriticalityLevel.Dangerous,
         },
-        type: ChangeType.FieldTypeChanged,
-        message: `Field '${type}.${oldField.name}' changed type from '${oldField.type}' to '${newField.type}'`,
-        path: [type.name, oldField.name].join('.'),
+        message: buildFieldArgumentAddedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName, args.meta.addedArgumentName].join('.'),
     };
 }
 export function fieldArgumentAdded(type, field, arg) {
     const isBreaking = isNonNullType(arg.type) && typeof arg.defaultValue === 'undefined';
-    const defaultValueMsg = typeof arg.defaultValue === 'undefined' ? ' ' : ' (with default value) ';
-    return {
-        criticality: isBreaking
-            ? {
-                level: CriticalityLevel.Breaking,
-                reason: `Adding a required argument to an existing field is a breaking change because it will cause existing uses of this field to error.`,
-            }
-            : {
-                level: CriticalityLevel.Dangerous,
-                reason: `Adding a new argument to an existing field may involve a change in resolve function logic that potentially may cause some side effects.`,
-            },
+    return fieldArgumentAddedFromMeta({
         type: ChangeType.FieldArgumentAdded,
-        message: `Argument '${arg.name}: ${arg.type}'${defaultValueMsg}added to field '${type.name}.${field.name}'`,
-        path: [type.name, field.name, arg.name].join('.'),
-    };
+        meta: {
+            typeName: type.name,
+            fieldName: field.name,
+            addedArgumentName: arg.name,
+            addedArgumentType: arg.type.toString(),
+            hasDefaultValue: arg.defaultValue != null,
+            isAddedFieldArgumentBreaking: isBreaking,
+        },
+    });
 }
-export function fieldArgumentRemoved(type, field, arg) {
+function buildFieldArgumentRemovedMessage(args) {
+    return `Argument '${args.meta.removedFieldArgumentName}: ${args.meta.removedFieldType}' was removed from field '${args.meta.typeName}.${args.meta.fieldName}'`;
+}
+export function fieldArgumentRemovedFromMeta(args) {
     return {
+        type: ChangeType.FieldArgumentRemoved,
         criticality: {
             level: CriticalityLevel.Breaking,
-            reason: `Removing a field argument is a breaking change because it will cause existing queries that use this argument to error.`,
         },
-        type: ChangeType.FieldArgumentRemoved,
-        message: `Argument '${arg.name}: ${arg.type}' was removed from field '${type.name}.${field.name}'`,
-        path: [type.name, field.name, arg.name].join('.'),
+        message: buildFieldArgumentRemovedMessage(args),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName, args.meta.removedFieldArgumentName].join('.'),
     };
 }
+export function fieldArgumentRemoved(type, field, arg) {
+    return fieldArgumentRemovedFromMeta({
+        type: ChangeType.FieldArgumentRemoved,
+        meta: {
+            typeName: type.name,
+            fieldName: field.name,
+            removedFieldArgumentName: arg.name,
+            removedFieldType: arg.type.toString(),
+        },
+    });
+}