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

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

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

@@ -2,77 +2,176 @@ import { isNonNullType } from 'graphql';
 import { safeChangeForInputValue } from '../../utils/graphql.js';
 import { isDeprecated } from '../../utils/is-deprecated.js';
 import { safeString } from '../../utils/string.js';
-import { ChangeType, CriticalityLevel } from './change.js';
-export function inputFieldRemoved(input, field) {
+import { ChangeType, CriticalityLevel, } from './change.js';
+function buildInputFieldRemovedMessage(args) {
+    return `Input field '${args.removedFieldName}' ${args.isInputFieldDeprecated ? '(deprecated) ' : ''}was removed from input object type '${args.inputName}'`;
+}
+export function inputFieldRemovedFromMeta(args) {
     return {
+        type: ChangeType.InputFieldRemoved,
         criticality: {
             level: CriticalityLevel.Breaking,
             reason: 'Removing an input field will cause existing queries that use this input field to error.',
         },
-        type: ChangeType.InputFieldRemoved,
-        message: `Input field '${field.name}' ${isDeprecated(field) ? '(deprecated) ' : ''}was removed from input object type '${input.name}'`,
-        path: [input.name, field.name].join('.'),
+        message: buildInputFieldRemovedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.inputName, args.meta.removedFieldName].join('.'),
     };
 }
-export function inputFieldAdded(input, field) {
+export function inputFieldRemoved(input, field) {
+    return inputFieldRemovedFromMeta({
+        type: ChangeType.InputFieldRemoved,
+        meta: {
+            inputName: input.name,
+            removedFieldName: field.name,
+            isInputFieldDeprecated: isDeprecated(field),
+        },
+    });
+}
+export function buildInputFieldAddedMessage(args) {
+    return `Input field '${args.addedInputFieldName}' of type '${args.addedInputFieldType}' was added to input object type '${args.inputName}'`;
+}
+export function inputFieldAddedFromMeta(args) {
     return {
-        criticality: isNonNullType(field.type)
+        type: ChangeType.InputFieldAdded,
+        criticality: args.meta.isAddedInputFieldTypeNullable
             ? {
-                level: CriticalityLevel.Breaking,
-                reason: 'Adding a required input field to an existing input object type is a breaking change because it will cause existing uses of this input object type to error.',
+                level: CriticalityLevel.Dangerous,
             }
             : {
-                level: CriticalityLevel.Dangerous,
+                level: CriticalityLevel.Breaking,
+                reason: 'Adding a required input field to an existing input object type is a breaking change because it will cause existing uses of this input object type to error.',
             },
-        type: ChangeType.InputFieldAdded,
-        message: `Input field '${field.name}' was added to input object type '${input.name}'`,
-        path: [input.name, field.name].join('.'),
+        message: buildInputFieldAddedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.inputName, args.meta.addedInputFieldName].join('.'),
     };
 }
-export function inputFieldDescriptionAdded(type, field) {
+export function inputFieldAdded(input, field) {
+    return inputFieldAddedFromMeta({
+        type: ChangeType.InputFieldAdded,
+        meta: {
+            inputName: input.name,
+            addedInputFieldName: field.name,
+            isAddedInputFieldTypeNullable: !isNonNullType(field.type),
+            addedInputFieldType: field.type.toString(),
+        },
+    });
+}
+function buildInputFieldDescriptionAddedMessage(args) {
+    return `Input field '${args.inputName}.${args.inputFieldName}' has description '${args.addedInputFieldDescription}'`;
+}
+export function inputFieldDescriptionAddedFromMeta(args) {
     return {
+        type: ChangeType.InputFieldDescriptionAdded,
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
-        type: ChangeType.InputFieldDescriptionAdded,
-        message: `Input field '${type.name}.${field.name}' has description '${field.description}'`,
-        path: [type.name, field.name].join('.'),
+        message: buildInputFieldDescriptionAddedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.inputName, args.meta.inputFieldName].join('.'),
     };
 }
-export function inputFieldDescriptionRemoved(type, field) {
+export function inputFieldDescriptionAdded(type, field) {
+    var _a;
+    return inputFieldDescriptionAddedFromMeta({
+        type: ChangeType.InputFieldDescriptionAdded,
+        meta: {
+            inputName: type.name,
+            inputFieldName: field.name,
+            addedInputFieldDescription: (_a = field.description) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+}
+function buildInputFieldDescriptionRemovedMessage(args) {
+    return `Description '${args.removedDescription}' was removed from input field '${args.inputName}.${args.inputFieldName}'`;
+}
+export function inputFieldDescriptionRemovedFromMeta(args) {
     return {
+        type: ChangeType.InputFieldDescriptionRemoved,
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
-        type: ChangeType.InputFieldDescriptionRemoved,
-        message: `Description was removed from input field '${type.name}.${field.name}'`,
-        path: [type.name, field.name].join('.'),
+        message: buildInputFieldDescriptionRemovedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.inputName, args.meta.inputFieldName].join('.'),
     };
 }
-export function inputFieldDescriptionChanged(input, oldField, newField) {
+export function inputFieldDescriptionRemoved(type, field) {
+    var _a;
+    return inputFieldDescriptionRemovedFromMeta({
+        type: ChangeType.InputFieldDescriptionRemoved,
+        meta: {
+            inputName: type.name,
+            inputFieldName: field.name,
+            removedDescription: (_a = field.description) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+}
+function buildInputFieldDescriptionChangedMessage(args) {
+    return `Input field '${args.inputName}.${args.inputFieldName}' description changed from '${args.oldInputFieldDescription}' to '${args.newInputFieldDescription}'`;
+}
+export function inputFieldDescriptionChangedFromMeta(args) {
     return {
+        type: ChangeType.InputFieldDescriptionChanged,
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
-        type: ChangeType.InputFieldDescriptionChanged,
-        message: `Input field '${input.name}.${oldField.name}' description changed from '${oldField.description}' to '${newField.description}'`,
-        path: [input.name, oldField.name].join('.'),
+        message: buildInputFieldDescriptionChangedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.inputName, args.meta.inputFieldName].join('.'),
     };
 }
-export function inputFieldDefaultValueChanged(input, oldField, newField) {
+export function inputFieldDescriptionChanged(input, oldField, newField) {
+    var _a, _b;
+    return inputFieldDescriptionChangedFromMeta({
+        type: ChangeType.InputFieldDescriptionChanged,
+        meta: {
+            inputName: input.name,
+            inputFieldName: oldField.name,
+            oldInputFieldDescription: (_a = oldField.description) !== null && _a !== void 0 ? _a : '',
+            newInputFieldDescription: (_b = newField.description) !== null && _b !== void 0 ? _b : '',
+        },
+    });
+}
+function buildInputFieldDefaultValueChangedMessage(args) {
+    return `Input field '${args.inputName}.${args.inputFieldName}' default value changed from '${args.oldDefaultValue}' to '${args.newDefaultValue}'`;
+}
+export function inputFieldDefaultValueChangedFromMeta(args) {
     return {
+        type: ChangeType.InputFieldDefaultValueChanged,
         criticality: {
             level: CriticalityLevel.Dangerous,
             reason: 'Changing the default value for an argument may change the runtime behavior of a field if it was never provided.',
         },
-        type: ChangeType.InputFieldDefaultValueChanged,
-        message: `Input field '${input.name}.${oldField.name}' default value changed from '${safeString(oldField.defaultValue)}' to '${safeString(newField.defaultValue)}'`,
-        path: [input.name, oldField.name].join('.'),
+        message: buildInputFieldDefaultValueChangedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.inputName, args.meta.inputFieldName].join('.'),
     };
 }
-export function inputFieldTypeChanged(input, oldField, newField) {
+export function inputFieldDefaultValueChanged(input, oldField, newField) {
+    const meta = {
+        inputName: input.name,
+        inputFieldName: oldField.name,
+    };
+    if (oldField.defaultValue !== undefined) {
+        meta.oldDefaultValue = safeString(oldField.defaultValue);
+    }
+    if (newField.defaultValue !== undefined) {
+        meta.newDefaultValue = safeString(newField.defaultValue);
+    }
+    return inputFieldDefaultValueChangedFromMeta({
+        type: ChangeType.InputFieldDefaultValueChanged,
+        meta,
+    });
+}
+function buildInputFieldTypeChangedMessage(args) {
+    return `Input field '${args.inputName}.${args.inputFieldName}' changed type from '${args.oldInputFieldType}' to '${args.newInputFieldType}'`;
+}
+export function inputFieldTypeChangedFromMeta(args) {
     return {
-        criticality: safeChangeForInputValue(oldField.type, newField.type)
+        type: ChangeType.InputFieldTypeChanged,
+        criticality: args.meta.isInputFieldTypeChangeSafe
             ? {
                 level: CriticalityLevel.NonBreaking,
                 reason: 'Changing an input field from non-null to null is considered non-breaking.',
@@ -81,8 +180,20 @@ export function inputFieldTypeChanged(input, oldField, newField) {
                 level: CriticalityLevel.Breaking,
                 reason: 'Changing the type of an input field can cause existing queries that use this field to error.',
             },
-        type: ChangeType.InputFieldTypeChanged,
-        message: `Input field '${input.name}.${oldField.name}' changed type from '${oldField.type.toString()}' to '${newField.type.toString()}'`,
-        path: [input.name, oldField.name].join('.'),
+        message: buildInputFieldTypeChangedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.inputName, args.meta.inputFieldName].join('.'),
     };
 }
+export function inputFieldTypeChanged(input, oldField, newField) {
+    return inputFieldTypeChangedFromMeta({
+        type: ChangeType.InputFieldTypeChanged,
+        meta: {
+            inputName: input.name,
+            inputFieldName: oldField.name,
+            oldInputFieldType: oldField.type.toString(),
+            newInputFieldType: newField.type.toString(),
+            isInputFieldTypeChangeSafe: safeChangeForInputValue(oldField.type, newField.type),
+        },
+    });
+}