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

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

@@ -1,87 +1,193 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inputFieldTypeChanged = exports.inputFieldDefaultValueChanged = exports.inputFieldDescriptionChanged = exports.inputFieldDescriptionRemoved = exports.inputFieldDescriptionAdded = exports.inputFieldAdded = exports.inputFieldRemoved = void 0;
+exports.inputFieldTypeChanged = exports.inputFieldTypeChangedFromMeta = exports.inputFieldDefaultValueChanged = exports.inputFieldDefaultValueChangedFromMeta = exports.inputFieldDescriptionChanged = exports.inputFieldDescriptionChangedFromMeta = exports.inputFieldDescriptionRemoved = exports.inputFieldDescriptionRemovedFromMeta = exports.inputFieldDescriptionAdded = exports.inputFieldDescriptionAddedFromMeta = exports.inputFieldAdded = exports.inputFieldAddedFromMeta = exports.buildInputFieldAddedMessage = exports.inputFieldRemoved = exports.inputFieldRemovedFromMeta = void 0;
 const graphql_1 = require("graphql");
 const graphql_js_1 = require("../../utils/graphql.js");
 const is_deprecated_js_1 = require("../../utils/is-deprecated.js");
 const string_js_1 = require("../../utils/string.js");
 const change_js_1 = require("./change.js");
-function inputFieldRemoved(input, field) {
+function buildInputFieldRemovedMessage(args) {
+    return `Input field '${args.removedFieldName}' ${args.isInputFieldDeprecated ? '(deprecated) ' : ''}was removed from input object type '${args.inputName}'`;
+}
+function inputFieldRemovedFromMeta(args) {
     return {
+        type: change_js_1.ChangeType.InputFieldRemoved,
         criticality: {
             level: change_js_1.CriticalityLevel.Breaking,
             reason: 'Removing an input field will cause existing queries that use this input field to error.',
         },
-        type: change_js_1.ChangeType.InputFieldRemoved,
-        message: `Input field '${field.name}' ${(0, is_deprecated_js_1.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('.'),
     };
 }
+exports.inputFieldRemovedFromMeta = inputFieldRemovedFromMeta;
+function inputFieldRemoved(input, field) {
+    return inputFieldRemovedFromMeta({
+        type: change_js_1.ChangeType.InputFieldRemoved,
+        meta: {
+            inputName: input.name,
+            removedFieldName: field.name,
+            isInputFieldDeprecated: (0, is_deprecated_js_1.isDeprecated)(field),
+        },
+    });
+}
 exports.inputFieldRemoved = inputFieldRemoved;
-function inputFieldAdded(input, field) {
+function buildInputFieldAddedMessage(args) {
+    return `Input field '${args.addedInputFieldName}' of type '${args.addedInputFieldType}' was added to input object type '${args.inputName}'`;
+}
+exports.buildInputFieldAddedMessage = buildInputFieldAddedMessage;
+function inputFieldAddedFromMeta(args) {
     return {
-        criticality: (0, graphql_1.isNonNullType)(field.type)
+        type: change_js_1.ChangeType.InputFieldAdded,
+        criticality: args.meta.isAddedInputFieldTypeNullable
             ? {
-                level: change_js_1.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: change_js_1.CriticalityLevel.Dangerous,
             }
             : {
-                level: change_js_1.CriticalityLevel.Dangerous,
+                level: change_js_1.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: change_js_1.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('.'),
     };
 }
+exports.inputFieldAddedFromMeta = inputFieldAddedFromMeta;
+function inputFieldAdded(input, field) {
+    return inputFieldAddedFromMeta({
+        type: change_js_1.ChangeType.InputFieldAdded,
+        meta: {
+            inputName: input.name,
+            addedInputFieldName: field.name,
+            isAddedInputFieldTypeNullable: !(0, graphql_1.isNonNullType)(field.type),
+            addedInputFieldType: field.type.toString(),
+        },
+    });
+}
 exports.inputFieldAdded = inputFieldAdded;
-function inputFieldDescriptionAdded(type, field) {
+function buildInputFieldDescriptionAddedMessage(args) {
+    return `Input field '${args.inputName}.${args.inputFieldName}' has description '${args.addedInputFieldDescription}'`;
+}
+function inputFieldDescriptionAddedFromMeta(args) {
     return {
+        type: change_js_1.ChangeType.InputFieldDescriptionAdded,
         criticality: {
             level: change_js_1.CriticalityLevel.NonBreaking,
         },
-        type: change_js_1.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('.'),
     };
 }
+exports.inputFieldDescriptionAddedFromMeta = inputFieldDescriptionAddedFromMeta;
+function inputFieldDescriptionAdded(type, field) {
+    var _a;
+    return inputFieldDescriptionAddedFromMeta({
+        type: change_js_1.ChangeType.InputFieldDescriptionAdded,
+        meta: {
+            inputName: type.name,
+            inputFieldName: field.name,
+            addedInputFieldDescription: (_a = field.description) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+}
 exports.inputFieldDescriptionAdded = inputFieldDescriptionAdded;
-function inputFieldDescriptionRemoved(type, field) {
+function buildInputFieldDescriptionRemovedMessage(args) {
+    return `Description '${args.removedDescription}' was removed from input field '${args.inputName}.${args.inputFieldName}'`;
+}
+function inputFieldDescriptionRemovedFromMeta(args) {
     return {
+        type: change_js_1.ChangeType.InputFieldDescriptionRemoved,
         criticality: {
             level: change_js_1.CriticalityLevel.NonBreaking,
         },
-        type: change_js_1.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('.'),
     };
 }
+exports.inputFieldDescriptionRemovedFromMeta = inputFieldDescriptionRemovedFromMeta;
+function inputFieldDescriptionRemoved(type, field) {
+    var _a;
+    return inputFieldDescriptionRemovedFromMeta({
+        type: change_js_1.ChangeType.InputFieldDescriptionRemoved,
+        meta: {
+            inputName: type.name,
+            inputFieldName: field.name,
+            removedDescription: (_a = field.description) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+}
 exports.inputFieldDescriptionRemoved = inputFieldDescriptionRemoved;
-function inputFieldDescriptionChanged(input, oldField, newField) {
+function buildInputFieldDescriptionChangedMessage(args) {
+    return `Input field '${args.inputName}.${args.inputFieldName}' description changed from '${args.oldInputFieldDescription}' to '${args.newInputFieldDescription}'`;
+}
+function inputFieldDescriptionChangedFromMeta(args) {
     return {
+        type: change_js_1.ChangeType.InputFieldDescriptionChanged,
         criticality: {
             level: change_js_1.CriticalityLevel.NonBreaking,
         },
-        type: change_js_1.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('.'),
     };
 }
+exports.inputFieldDescriptionChangedFromMeta = inputFieldDescriptionChangedFromMeta;
+function inputFieldDescriptionChanged(input, oldField, newField) {
+    var _a, _b;
+    return inputFieldDescriptionChangedFromMeta({
+        type: change_js_1.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 : '',
+        },
+    });
+}
 exports.inputFieldDescriptionChanged = inputFieldDescriptionChanged;
-function inputFieldDefaultValueChanged(input, oldField, newField) {
+function buildInputFieldDefaultValueChangedMessage(args) {
+    return `Input field '${args.inputName}.${args.inputFieldName}' default value changed from '${args.oldDefaultValue}' to '${args.newDefaultValue}'`;
+}
+function inputFieldDefaultValueChangedFromMeta(args) {
     return {
+        type: change_js_1.ChangeType.InputFieldDefaultValueChanged,
         criticality: {
             level: change_js_1.CriticalityLevel.Dangerous,
             reason: 'Changing the default value for an argument may change the runtime behavior of a field if it was never provided.',
         },
-        type: change_js_1.ChangeType.InputFieldDefaultValueChanged,
-        message: `Input field '${input.name}.${oldField.name}' default value changed from '${(0, string_js_1.safeString)(oldField.defaultValue)}' to '${(0, string_js_1.safeString)(newField.defaultValue)}'`,
-        path: [input.name, oldField.name].join('.'),
+        message: buildInputFieldDefaultValueChangedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.inputName, args.meta.inputFieldName].join('.'),
+    };
+}
+exports.inputFieldDefaultValueChangedFromMeta = inputFieldDefaultValueChangedFromMeta;
+function inputFieldDefaultValueChanged(input, oldField, newField) {
+    const meta = {
+        inputName: input.name,
+        inputFieldName: oldField.name,
     };
+    if (oldField.defaultValue !== undefined) {
+        meta.oldDefaultValue = (0, string_js_1.safeString)(oldField.defaultValue);
+    }
+    if (newField.defaultValue !== undefined) {
+        meta.newDefaultValue = (0, string_js_1.safeString)(newField.defaultValue);
+    }
+    return inputFieldDefaultValueChangedFromMeta({
+        type: change_js_1.ChangeType.InputFieldDefaultValueChanged,
+        meta,
+    });
 }
 exports.inputFieldDefaultValueChanged = inputFieldDefaultValueChanged;
-function inputFieldTypeChanged(input, oldField, newField) {
+function buildInputFieldTypeChangedMessage(args) {
+    return `Input field '${args.inputName}.${args.inputFieldName}' changed type from '${args.oldInputFieldType}' to '${args.newInputFieldType}'`;
+}
+function inputFieldTypeChangedFromMeta(args) {
     return {
-        criticality: (0, graphql_js_1.safeChangeForInputValue)(oldField.type, newField.type)
+        type: change_js_1.ChangeType.InputFieldTypeChanged,
+        criticality: args.meta.isInputFieldTypeChangeSafe
             ? {
                 level: change_js_1.CriticalityLevel.NonBreaking,
                 reason: 'Changing an input field from non-null to null is considered non-breaking.',
@@ -90,9 +196,22 @@ function inputFieldTypeChanged(input, oldField, newField) {
                 level: change_js_1.CriticalityLevel.Breaking,
                 reason: 'Changing the type of an input field can cause existing queries that use this field to error.',
             },
-        type: change_js_1.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('.'),
     };
 }
+exports.inputFieldTypeChangedFromMeta = inputFieldTypeChangedFromMeta;
+function inputFieldTypeChanged(input, oldField, newField) {
+    return inputFieldTypeChangedFromMeta({
+        type: change_js_1.ChangeType.InputFieldTypeChanged,
+        meta: {
+            inputName: input.name,
+            inputFieldName: oldField.name,
+            oldInputFieldType: oldField.type.toString(),
+            newInputFieldType: newField.type.toString(),
+            isInputFieldTypeChangeSafe: (0, graphql_js_1.safeChangeForInputValue)(oldField.type, newField.type),
+        },
+    });
+}
 exports.inputFieldTypeChanged = inputFieldTypeChanged;

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

@@ -1,28 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.objectTypeInterfaceRemoved = exports.objectTypeInterfaceAdded = void 0;
+exports.objectTypeInterfaceRemoved = exports.objectTypeInterfaceRemovedFromMeta = exports.objectTypeInterfaceAdded = exports.objectTypeInterfaceAddedFromMeta = void 0;
 const change_js_1 = require("./change.js");
-function objectTypeInterfaceAdded(iface, type) {
+function buildObjectTypeInterfaceAddedMessage(args) {
+    return `'${args.objectTypeName}' object implements '${args.addedInterfaceName}' interface`;
+}
+function objectTypeInterfaceAddedFromMeta(args) {
     return {
+        type: change_js_1.ChangeType.ObjectTypeInterfaceAdded,
         criticality: {
             level: change_js_1.CriticalityLevel.Dangerous,
             reason: 'Adding an interface to an object type may break existing clients that were not programming defensively against a new possible type.',
         },
-        type: change_js_1.ChangeType.ObjectTypeInterfaceAdded,
-        message: `'${type.name}' object implements '${iface.name}' interface`,
-        path: type.name,
+        message: buildObjectTypeInterfaceAddedMessage(args.meta),
+        meta: args.meta,
+        path: args.meta.objectTypeName,
     };
 }
+exports.objectTypeInterfaceAddedFromMeta = objectTypeInterfaceAddedFromMeta;
+function objectTypeInterfaceAdded(iface, type) {
+    return objectTypeInterfaceAddedFromMeta({
+        type: change_js_1.ChangeType.ObjectTypeInterfaceAdded,
+        meta: {
+            objectTypeName: type.name,
+            addedInterfaceName: iface.name,
+        },
+    });
+}
 exports.objectTypeInterfaceAdded = objectTypeInterfaceAdded;
-function objectTypeInterfaceRemoved(iface, type) {
+function buildObjectTypeInterfaceRemovedMessage(args) {
+    return `'${args.objectTypeName}' object type no longer implements '${args.removedInterfaceName}' interface`;
+}
+function objectTypeInterfaceRemovedFromMeta(args) {
     return {
+        type: change_js_1.ChangeType.ObjectTypeInterfaceRemoved,
         criticality: {
             level: change_js_1.CriticalityLevel.Breaking,
             reason: 'Removing an interface from an object type can cause existing queries that use this in a fragment spread to error.',
         },
-        type: change_js_1.ChangeType.ObjectTypeInterfaceRemoved,
-        message: `'${type.name}' object type no longer implements '${iface.name}' interface`,
-        path: type.name,
+        message: buildObjectTypeInterfaceRemovedMessage(args.meta),
+        meta: args.meta,
+        path: args.meta.objectTypeName,
     };
 }
+exports.objectTypeInterfaceRemovedFromMeta = objectTypeInterfaceRemovedFromMeta;
+function objectTypeInterfaceRemoved(iface, type) {
+    return objectTypeInterfaceRemovedFromMeta({
+        type: change_js_1.ChangeType.ObjectTypeInterfaceRemoved,
+        meta: {
+            objectTypeName: type.name,
+            removedInterfaceName: iface.name,
+        },
+    });
+}
 exports.objectTypeInterfaceRemoved = objectTypeInterfaceRemoved;

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

@@ -1,40 +1,82 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.schemaSubscriptionTypeChanged = exports.schemaMutationTypeChanged = exports.schemaQueryTypeChanged = void 0;
+exports.schemaSubscriptionTypeChanged = exports.schemaSubscriptionTypeChangedFromMeta = exports.schemaMutationTypeChanged = exports.schemaMutationTypeChangedFromMeta = exports.schemaQueryTypeChanged = exports.schemaQueryTypeChangedFromMeta = void 0;
 const change_js_1 = require("./change.js");
+function buildSchemaQueryTypeChangedMessage(args) {
+    return `Schema query root has changed from '${args.oldQueryTypeName}' to '${args.newQueryTypeName}'`;
+}
+function schemaQueryTypeChangedFromMeta(args) {
+    return {
+        type: change_js_1.ChangeType.SchemaQueryTypeChanged,
+        criticality: {
+            level: change_js_1.CriticalityLevel.Breaking,
+        },
+        message: buildSchemaQueryTypeChangedMessage(args.meta),
+        meta: args.meta,
+    };
+}
+exports.schemaQueryTypeChangedFromMeta = schemaQueryTypeChangedFromMeta;
 function schemaQueryTypeChanged(oldSchema, newSchema) {
     const oldName = (oldSchema.getQueryType() || {}).name || 'unknown';
     const newName = (newSchema.getQueryType() || {}).name || 'unknown';
+    return schemaQueryTypeChangedFromMeta({
+        type: change_js_1.ChangeType.SchemaQueryTypeChanged,
+        meta: {
+            oldQueryTypeName: oldName,
+            newQueryTypeName: newName,
+        },
+    });
+}
+exports.schemaQueryTypeChanged = schemaQueryTypeChanged;
+function buildSchemaMutationTypeChangedMessage(args) {
+    return `Schema mutation root has changed from '${args.oldMutationTypeName}' to '${args.newMutationTypeName}'`;
+}
+function schemaMutationTypeChangedFromMeta(args) {
     return {
+        type: change_js_1.ChangeType.SchemaMutationTypeChanged,
         criticality: {
             level: change_js_1.CriticalityLevel.Breaking,
         },
-        type: change_js_1.ChangeType.SchemaQueryTypeChanged,
-        message: `Schema query root has changed from '${oldName}' to '${newName}'`,
+        message: buildSchemaMutationTypeChangedMessage(args.meta),
+        meta: args.meta,
     };
 }
-exports.schemaQueryTypeChanged = schemaQueryTypeChanged;
+exports.schemaMutationTypeChangedFromMeta = schemaMutationTypeChangedFromMeta;
 function schemaMutationTypeChanged(oldSchema, newSchema) {
     const oldName = (oldSchema.getMutationType() || {}).name || 'unknown';
     const newName = (newSchema.getMutationType() || {}).name || 'unknown';
+    return schemaMutationTypeChangedFromMeta({
+        type: change_js_1.ChangeType.SchemaMutationTypeChanged,
+        meta: {
+            newMutationTypeName: newName,
+            oldMutationTypeName: oldName,
+        },
+    });
+}
+exports.schemaMutationTypeChanged = schemaMutationTypeChanged;
+function buildSchemaSubscriptionTypeChangedMessage(args) {
+    return `Schema subscription root has changed from '${args.oldSubscriptionTypeName}' to '${args.newSubscriptionTypeName}'`;
+}
+function schemaSubscriptionTypeChangedFromMeta(args) {
     return {
+        type: change_js_1.ChangeType.SchemaSubscriptionTypeChanged,
         criticality: {
             level: change_js_1.CriticalityLevel.Breaking,
         },
-        type: change_js_1.ChangeType.SchemaMutationTypeChanged,
-        message: `Schema mutation root has changed from '${oldName}' to '${newName}'`,
+        message: buildSchemaSubscriptionTypeChangedMessage(args.meta),
+        meta: args.meta,
     };
 }
-exports.schemaMutationTypeChanged = schemaMutationTypeChanged;
+exports.schemaSubscriptionTypeChangedFromMeta = schemaSubscriptionTypeChangedFromMeta;
 function schemaSubscriptionTypeChanged(oldSchema, newSchema) {
     const oldName = (oldSchema.getSubscriptionType() || {}).name || 'unknown';
     const newName = (newSchema.getSubscriptionType() || {}).name || 'unknown';
-    return {
-        criticality: {
-            level: change_js_1.CriticalityLevel.Breaking,
-        },
+    return schemaSubscriptionTypeChangedFromMeta({
         type: change_js_1.ChangeType.SchemaSubscriptionTypeChanged,
-        message: `Schema subscription root has changed from '${oldName}' to '${newName}'`,
-    };
+        meta: {
+            newSubscriptionTypeName: newName,
+            oldSubscriptionTypeName: oldName,
+        },
+    });
 }
 exports.schemaSubscriptionTypeChanged = schemaSubscriptionTypeChanged;

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

@@ -1,72 +1,159 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.typeDescriptionAdded = exports.typeDescriptionRemoved = exports.typeDescriptionChanged = exports.typeKindChanged = exports.typeAdded = exports.typeRemoved = void 0;
+exports.typeDescriptionAdded = exports.typeDescriptionAddedFromMeta = exports.typeDescriptionRemoved = exports.typeDescriptionRemovedFromMeta = exports.typeDescriptionChanged = exports.typeDescriptionChangedFromMeta = exports.typeKindChanged = exports.typeKindChangedFromMeta = exports.typeAdded = exports.typeAddedFromMeta = exports.typeRemoved = exports.typeRemovedFromMeta = void 0;
 const graphql_js_1 = require("../../utils/graphql.js");
 const change_js_1 = require("./change.js");
-function typeRemoved(type) {
+function buildTypeRemovedMessage(type) {
+    return `Type '${type.removedTypeName}' was removed`;
+}
+function typeRemovedFromMeta(args) {
     return {
         criticality: {
             level: change_js_1.CriticalityLevel.Breaking,
         },
         type: change_js_1.ChangeType.TypeRemoved,
-        message: `Type '${type.name}' was removed`,
-        path: type.name,
+        message: buildTypeRemovedMessage(args.meta),
+        meta: args.meta,
+        path: args.meta.removedTypeName,
     };
 }
+exports.typeRemovedFromMeta = typeRemovedFromMeta;
+function typeRemoved(type) {
+    return typeRemovedFromMeta({
+        type: change_js_1.ChangeType.TypeRemoved,
+        meta: {
+            removedTypeName: type.name,
+        },
+    });
+}
 exports.typeRemoved = typeRemoved;
-function typeAdded(type) {
+function buildTypeAddedMessage(type) {
+    return `Type '${type.addedTypeName}' was added`;
+}
+function typeAddedFromMeta(args) {
     return {
         criticality: {
             level: change_js_1.CriticalityLevel.NonBreaking,
         },
         type: change_js_1.ChangeType.TypeAdded,
-        message: `Type '${type.name}' was added`,
-        path: type.name,
+        message: buildTypeAddedMessage(args.meta),
+        meta: args.meta,
+        path: args.meta.addedTypeName,
     };
 }
+exports.typeAddedFromMeta = typeAddedFromMeta;
+function typeAdded(type) {
+    return typeAddedFromMeta({
+        type: change_js_1.ChangeType.TypeAdded,
+        meta: {
+            addedTypeName: type.name,
+        },
+    });
+}
 exports.typeAdded = typeAdded;
-function typeKindChanged(oldType, newType) {
+function buildTypeKindChangedMessage(args) {
+    return `'${args.meta.typeName}' kind changed from '${args.meta.oldTypeKind}' to '${args.meta.newTypeKind}'`;
+}
+function typeKindChangedFromMeta(args) {
     return {
         criticality: {
             level: change_js_1.CriticalityLevel.Breaking,
             reason: `Changing the kind of a type is a breaking change because it can cause existing queries to error. For example, turning an object type to a scalar type would break queries that define a selection set for this type.`,
         },
         type: change_js_1.ChangeType.TypeKindChanged,
-        message: `'${oldType.name}' kind changed from '${(0, graphql_js_1.getKind)(oldType)}' to '${(0, graphql_js_1.getKind)(newType)}'`,
-        path: oldType.name,
+        message: buildTypeKindChangedMessage(args),
+        path: args.meta.typeName,
+        meta: args.meta,
     };
 }
+exports.typeKindChangedFromMeta = typeKindChangedFromMeta;
+function typeKindChanged(oldType, newType) {
+    return typeKindChangedFromMeta({
+        type: change_js_1.ChangeType.TypeKindChanged,
+        meta: {
+            typeName: oldType.name,
+            newTypeKind: String((0, graphql_js_1.getKind)(newType)),
+            oldTypeKind: String((0, graphql_js_1.getKind)(oldType)),
+        },
+    });
+}
 exports.typeKindChanged = typeKindChanged;
-function typeDescriptionChanged(oldType, newType) {
+function buildTypeDescriptionChangedMessage(args) {
+    return `Description '${args.oldTypeDescription}' on type '${args.typeName}' has changed to '${args.newTypeDescription}'`;
+}
+function typeDescriptionChangedFromMeta(args) {
     return {
         criticality: {
             level: change_js_1.CriticalityLevel.NonBreaking,
         },
         type: change_js_1.ChangeType.TypeDescriptionChanged,
-        message: `Description '${oldType.description}' on type '${oldType.name}' has changed to '${newType.description}'`,
-        path: oldType.name,
+        message: buildTypeDescriptionChangedMessage(args.meta),
+        path: args.meta.typeName,
+        meta: args.meta,
     };
 }
+exports.typeDescriptionChangedFromMeta = typeDescriptionChangedFromMeta;
+function typeDescriptionChanged(oldType, newType) {
+    var _a, _b;
+    return typeDescriptionChangedFromMeta({
+        type: change_js_1.ChangeType.TypeDescriptionChanged,
+        meta: {
+            typeName: oldType.name,
+            newTypeDescription: (_a = newType.description) !== null && _a !== void 0 ? _a : '',
+            oldTypeDescription: (_b = oldType.description) !== null && _b !== void 0 ? _b : '',
+        },
+    });
+}
 exports.typeDescriptionChanged = typeDescriptionChanged;
-function typeDescriptionRemoved(type) {
+function buildTypeDescriptionRemoved(args) {
+    return `Description '${args.removedTypeDescription}' was removed from object type '${args.typeName}'`;
+}
+function typeDescriptionRemovedFromMeta(args) {
     return {
         criticality: {
             level: change_js_1.CriticalityLevel.NonBreaking,
         },
         type: change_js_1.ChangeType.TypeDescriptionRemoved,
-        message: `Description '${type.description}' was removed from object type '${type.name}'`,
-        path: type.name,
+        message: buildTypeDescriptionRemoved(args.meta),
+        path: args.meta.typeName,
+        meta: args.meta,
     };
 }
+exports.typeDescriptionRemovedFromMeta = typeDescriptionRemovedFromMeta;
+function typeDescriptionRemoved(type) {
+    var _a;
+    return typeDescriptionRemovedFromMeta({
+        type: change_js_1.ChangeType.TypeDescriptionRemoved,
+        meta: {
+            typeName: type.name,
+            removedTypeDescription: (_a = type.description) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+}
 exports.typeDescriptionRemoved = typeDescriptionRemoved;
-function typeDescriptionAdded(type) {
+function buildTypeDescriptionAddedMessage(args) {
+    return `Object type '${args.typeName}' has description '${args.addedTypeDescription}'`;
+}
+function typeDescriptionAddedFromMeta(args) {
     return {
         criticality: {
             level: change_js_1.CriticalityLevel.NonBreaking,
         },
         type: change_js_1.ChangeType.TypeDescriptionAdded,
-        message: `Object type '${type.name}' has description '${type.description}'`,
-        path: type.name,
+        message: buildTypeDescriptionAddedMessage(args.meta),
+        path: args.meta.typeName,
+        meta: args.meta,
     };
 }
+exports.typeDescriptionAddedFromMeta = typeDescriptionAddedFromMeta;
+function typeDescriptionAdded(type) {
+    var _a;
+    return typeDescriptionAddedFromMeta({
+        type: change_js_1.ChangeType.TypeDescriptionAdded,
+        meta: {
+            typeName: type.name,
+            addedTypeDescription: (_a = type.description) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+}
 exports.typeDescriptionAdded = typeDescriptionAdded;

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

@@ -1,28 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unionMemberAdded = exports.unionMemberRemoved = void 0;
+exports.unionMemberAdded = exports.buildUnionMemberAddedMessageFromMeta = exports.unionMemberRemoved = exports.unionMemberRemovedFromMeta = void 0;
 const change_js_1 = require("./change.js");
-function unionMemberRemoved(union, type) {
+function buildUnionMemberRemovedMessage(args) {
+    return `Member '${args.removedUnionMemberTypeName}' was removed from Union type '${args.unionName}'`;
+}
+function unionMemberRemovedFromMeta(args) {
     return {
         criticality: {
             level: change_js_1.CriticalityLevel.Breaking,
             reason: 'Removing a union member from a union can cause existing queries that use this union member in a fragment spread to error.',
         },
         type: change_js_1.ChangeType.UnionMemberRemoved,
-        message: `Member '${type.name}' was removed from Union type '${union.name}'`,
-        path: union.name,
+        message: buildUnionMemberRemovedMessage(args.meta),
+        meta: args.meta,
+        path: args.meta.unionName,
     };
 }
+exports.unionMemberRemovedFromMeta = unionMemberRemovedFromMeta;
+function unionMemberRemoved(union, type) {
+    return unionMemberRemovedFromMeta({
+        type: change_js_1.ChangeType.UnionMemberRemoved,
+        meta: {
+            unionName: union.name,
+            removedUnionMemberTypeName: type.name,
+        },
+    });
+}
 exports.unionMemberRemoved = unionMemberRemoved;
-function unionMemberAdded(union, type) {
+function buildUnionMemberAddedMessage(args) {
+    return `Member '${args.addedUnionMemberTypeName}' was added to Union type '${args.unionName}'`;
+}
+function buildUnionMemberAddedMessageFromMeta(args) {
     return {
         criticality: {
             level: change_js_1.CriticalityLevel.Dangerous,
             reason: 'Adding a possible type to Unions may break existing clients that were not programming defensively against a new possible type.',
         },
         type: change_js_1.ChangeType.UnionMemberAdded,
-        message: `Member '${type.name}' was added to Union type '${union.name}'`,
-        path: union.name,
+        message: buildUnionMemberAddedMessage(args.meta),
+        meta: args.meta,
+        path: args.meta.unionName,
     };
 }
+exports.buildUnionMemberAddedMessageFromMeta = buildUnionMemberAddedMessageFromMeta;
+function unionMemberAdded(union, type) {
+    return buildUnionMemberAddedMessageFromMeta({
+        type: change_js_1.ChangeType.UnionMemberAdded,
+        meta: {
+            unionName: union.name,
+            addedUnionMemberTypeName: type.name,
+        },
+    });
+}
 exports.unionMemberAdded = unionMemberAdded;