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

package/cjs/core/src/diff/rules/consider-usage.js

@@ -31,7 +31,7 @@ const considerUsage = ({ changes, config }) => tslib_1.__awaiter(void 0, void 0,
         if (change.criticality.level === change_js_1.CriticalityLevel.Breaking &&
             change.path &&
             suppressedPaths.some(p => change.path.startsWith(p))) {
-            return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: change_js_1.CriticalityLevel.Dangerous }), message: `${change.message} (non-breaking based on usage)` });
+            return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: change_js_1.CriticalityLevel.Dangerous, isSafeBasedOnUsage: true }), message: `${change.message} (non-breaking based on usage)` });
         }
         return change;
     });

package/cjs/core/src/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateTokenCount = exports.countDepth = exports.countDirectives = exports.calculateOperationComplexity = exports.countAliases = exports.validate = exports.getTypePrefix = exports.similar = exports.CriticalityLevel = exports.ChangeType = exports.DiffRule = exports.diff = void 0;
+exports.inputFieldDefaultValueChangedFromMeta = exports.inputFieldDescriptionChangedFromMeta = exports.inputFieldDescriptionRemovedFromMeta = exports.inputFieldDescriptionAddedFromMeta = exports.inputFieldAddedFromMeta = exports.inputFieldRemovedFromMeta = exports.fieldArgumentRemovedFromMeta = exports.fieldArgumentAddedFromMeta = exports.fieldTypeChangedFromMeta = exports.fieldDeprecationReasonRemovedFromMeta = exports.fieldDeprecationReasonAddedFromMeta = exports.fieldDeprecationReasonChangedFromMeta = exports.fieldDeprecationRemovedFromMeta = exports.fieldDeprecationAddedFromMeta = exports.fieldDescriptionRemovedFromMeta = exports.fieldDescriptionAddedFromMeta = exports.fieldDescriptionChangedFromMeta = exports.fieldAddedFromMeta = exports.fieldRemovedFromMeta = exports.enumValueDeprecationReasonRemovedFromMeta = exports.enumValueDeprecationReasonAddedFromMeta = exports.enumValueDeprecationReasonChangedFromMeta = exports.enumValueDescriptionChangedFromMeta = exports.enumValueAddedFromMeta = exports.enumValueRemovedFromMeta = exports.directiveArgumentTypeChangedFromMeta = exports.directiveArgumentDefaultValueChangedFromMeta = exports.directiveArgumentDescriptionChangedFromMeta = exports.directiveArgumentRemovedFromMeta = exports.directiveArgumentAddedFromMeta = exports.directiveLocationRemovedFromMeta = exports.directiveLocationAddedFromMeta = exports.directiveDescriptionChangedFromMeta = exports.directiveAddedFromMeta = exports.directiveRemovedFromMeta = exports.fieldArgumentTypeChangedFromMeta = exports.fieldArgumentDefaultChangedFromMeta = exports.fieldArgumentDescriptionChangedFromMeta = exports.calculateTokenCount = exports.countDepth = exports.countDirectives = exports.calculateOperationComplexity = exports.countAliases = exports.validate = exports.getTypePrefix = exports.similar = exports.CriticalityLevel = exports.ChangeType = exports.DiffRule = exports.diff = void 0;
+exports.buildUnionMemberAddedMessageFromMeta = exports.unionMemberRemovedFromMeta = exports.typeDescriptionAddedFromMeta = exports.typeDescriptionRemovedFromMeta = exports.typeDescriptionChangedFromMeta = exports.typeKindChangedFromMeta = exports.typeAddedFromMeta = exports.typeRemovedFromMeta = exports.schemaSubscriptionTypeChangedFromMeta = exports.schemaMutationTypeChangedFromMeta = exports.schemaQueryTypeChangedFromMeta = exports.objectTypeInterfaceRemovedFromMeta = exports.objectTypeInterfaceAddedFromMeta = exports.inputFieldTypeChangedFromMeta = void 0;
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./coverage/index.js"), exports);
 var index_js_1 = require("./diff/index.js");
@@ -25,3 +26,64 @@ var query_depth_js_1 = require("./validate/query-depth.js");
 Object.defineProperty(exports, "countDepth", { enumerable: true, get: function () { return query_depth_js_1.countDepth; } });
 var token_count_js_1 = require("./validate/token-count.js");
 Object.defineProperty(exports, "calculateTokenCount", { enumerable: true, get: function () { return token_count_js_1.calculateTokenCount; } });
+var argument_js_1 = require("./diff/changes/argument.js");
+Object.defineProperty(exports, "fieldArgumentDescriptionChangedFromMeta", { enumerable: true, get: function () { return argument_js_1.fieldArgumentDescriptionChangedFromMeta; } });
+Object.defineProperty(exports, "fieldArgumentDefaultChangedFromMeta", { enumerable: true, get: function () { return argument_js_1.fieldArgumentDefaultChangedFromMeta; } });
+Object.defineProperty(exports, "fieldArgumentTypeChangedFromMeta", { enumerable: true, get: function () { return argument_js_1.fieldArgumentTypeChangedFromMeta; } });
+var directive_js_1 = require("./diff/changes/directive.js");
+Object.defineProperty(exports, "directiveRemovedFromMeta", { enumerable: true, get: function () { return directive_js_1.directiveRemovedFromMeta; } });
+Object.defineProperty(exports, "directiveAddedFromMeta", { enumerable: true, get: function () { return directive_js_1.directiveAddedFromMeta; } });
+Object.defineProperty(exports, "directiveDescriptionChangedFromMeta", { enumerable: true, get: function () { return directive_js_1.directiveDescriptionChangedFromMeta; } });
+Object.defineProperty(exports, "directiveLocationAddedFromMeta", { enumerable: true, get: function () { return directive_js_1.directiveLocationAddedFromMeta; } });
+Object.defineProperty(exports, "directiveLocationRemovedFromMeta", { enumerable: true, get: function () { return directive_js_1.directiveLocationRemovedFromMeta; } });
+Object.defineProperty(exports, "directiveArgumentAddedFromMeta", { enumerable: true, get: function () { return directive_js_1.directiveArgumentAddedFromMeta; } });
+Object.defineProperty(exports, "directiveArgumentRemovedFromMeta", { enumerable: true, get: function () { return directive_js_1.directiveArgumentRemovedFromMeta; } });
+Object.defineProperty(exports, "directiveArgumentDescriptionChangedFromMeta", { enumerable: true, get: function () { return directive_js_1.directiveArgumentDescriptionChangedFromMeta; } });
+Object.defineProperty(exports, "directiveArgumentDefaultValueChangedFromMeta", { enumerable: true, get: function () { return directive_js_1.directiveArgumentDefaultValueChangedFromMeta; } });
+Object.defineProperty(exports, "directiveArgumentTypeChangedFromMeta", { enumerable: true, get: function () { return directive_js_1.directiveArgumentTypeChangedFromMeta; } });
+var enum_js_1 = require("./diff/changes/enum.js");
+Object.defineProperty(exports, "enumValueRemovedFromMeta", { enumerable: true, get: function () { return enum_js_1.enumValueRemovedFromMeta; } });
+Object.defineProperty(exports, "enumValueAddedFromMeta", { enumerable: true, get: function () { return enum_js_1.enumValueAddedFromMeta; } });
+Object.defineProperty(exports, "enumValueDescriptionChangedFromMeta", { enumerable: true, get: function () { return enum_js_1.enumValueDescriptionChangedFromMeta; } });
+Object.defineProperty(exports, "enumValueDeprecationReasonChangedFromMeta", { enumerable: true, get: function () { return enum_js_1.enumValueDeprecationReasonChangedFromMeta; } });
+Object.defineProperty(exports, "enumValueDeprecationReasonAddedFromMeta", { enumerable: true, get: function () { return enum_js_1.enumValueDeprecationReasonAddedFromMeta; } });
+Object.defineProperty(exports, "enumValueDeprecationReasonRemovedFromMeta", { enumerable: true, get: function () { return enum_js_1.enumValueDeprecationReasonRemovedFromMeta; } });
+var field_js_1 = require("./diff/changes/field.js");
+Object.defineProperty(exports, "fieldRemovedFromMeta", { enumerable: true, get: function () { return field_js_1.fieldRemovedFromMeta; } });
+Object.defineProperty(exports, "fieldAddedFromMeta", { enumerable: true, get: function () { return field_js_1.fieldAddedFromMeta; } });
+Object.defineProperty(exports, "fieldDescriptionChangedFromMeta", { enumerable: true, get: function () { return field_js_1.fieldDescriptionChangedFromMeta; } });
+Object.defineProperty(exports, "fieldDescriptionAddedFromMeta", { enumerable: true, get: function () { return field_js_1.fieldDescriptionAddedFromMeta; } });
+Object.defineProperty(exports, "fieldDescriptionRemovedFromMeta", { enumerable: true, get: function () { return field_js_1.fieldDescriptionRemovedFromMeta; } });
+Object.defineProperty(exports, "fieldDeprecationAddedFromMeta", { enumerable: true, get: function () { return field_js_1.fieldDeprecationAddedFromMeta; } });
+Object.defineProperty(exports, "fieldDeprecationRemovedFromMeta", { enumerable: true, get: function () { return field_js_1.fieldDeprecationRemovedFromMeta; } });
+Object.defineProperty(exports, "fieldDeprecationReasonChangedFromMeta", { enumerable: true, get: function () { return field_js_1.fieldDeprecationReasonChangedFromMeta; } });
+Object.defineProperty(exports, "fieldDeprecationReasonAddedFromMeta", { enumerable: true, get: function () { return field_js_1.fieldDeprecationReasonAddedFromMeta; } });
+Object.defineProperty(exports, "fieldDeprecationReasonRemovedFromMeta", { enumerable: true, get: function () { return field_js_1.fieldDeprecationReasonRemovedFromMeta; } });
+Object.defineProperty(exports, "fieldTypeChangedFromMeta", { enumerable: true, get: function () { return field_js_1.fieldTypeChangedFromMeta; } });
+Object.defineProperty(exports, "fieldArgumentAddedFromMeta", { enumerable: true, get: function () { return field_js_1.fieldArgumentAddedFromMeta; } });
+Object.defineProperty(exports, "fieldArgumentRemovedFromMeta", { enumerable: true, get: function () { return field_js_1.fieldArgumentRemovedFromMeta; } });
+var input_js_1 = require("./diff/changes/input.js");
+Object.defineProperty(exports, "inputFieldRemovedFromMeta", { enumerable: true, get: function () { return input_js_1.inputFieldRemovedFromMeta; } });
+Object.defineProperty(exports, "inputFieldAddedFromMeta", { enumerable: true, get: function () { return input_js_1.inputFieldAddedFromMeta; } });
+Object.defineProperty(exports, "inputFieldDescriptionAddedFromMeta", { enumerable: true, get: function () { return input_js_1.inputFieldDescriptionAddedFromMeta; } });
+Object.defineProperty(exports, "inputFieldDescriptionRemovedFromMeta", { enumerable: true, get: function () { return input_js_1.inputFieldDescriptionRemovedFromMeta; } });
+Object.defineProperty(exports, "inputFieldDescriptionChangedFromMeta", { enumerable: true, get: function () { return input_js_1.inputFieldDescriptionChangedFromMeta; } });
+Object.defineProperty(exports, "inputFieldDefaultValueChangedFromMeta", { enumerable: true, get: function () { return input_js_1.inputFieldDefaultValueChangedFromMeta; } });
+Object.defineProperty(exports, "inputFieldTypeChangedFromMeta", { enumerable: true, get: function () { return input_js_1.inputFieldTypeChangedFromMeta; } });
+var object_js_1 = require("./diff/changes/object.js");
+Object.defineProperty(exports, "objectTypeInterfaceAddedFromMeta", { enumerable: true, get: function () { return object_js_1.objectTypeInterfaceAddedFromMeta; } });
+Object.defineProperty(exports, "objectTypeInterfaceRemovedFromMeta", { enumerable: true, get: function () { return object_js_1.objectTypeInterfaceRemovedFromMeta; } });
+var schema_js_1 = require("./diff/changes/schema.js");
+Object.defineProperty(exports, "schemaQueryTypeChangedFromMeta", { enumerable: true, get: function () { return schema_js_1.schemaQueryTypeChangedFromMeta; } });
+Object.defineProperty(exports, "schemaMutationTypeChangedFromMeta", { enumerable: true, get: function () { return schema_js_1.schemaMutationTypeChangedFromMeta; } });
+Object.defineProperty(exports, "schemaSubscriptionTypeChangedFromMeta", { enumerable: true, get: function () { return schema_js_1.schemaSubscriptionTypeChangedFromMeta; } });
+var type_js_1 = require("./diff/changes/type.js");
+Object.defineProperty(exports, "typeRemovedFromMeta", { enumerable: true, get: function () { return type_js_1.typeRemovedFromMeta; } });
+Object.defineProperty(exports, "typeAddedFromMeta", { enumerable: true, get: function () { return type_js_1.typeAddedFromMeta; } });
+Object.defineProperty(exports, "typeKindChangedFromMeta", { enumerable: true, get: function () { return type_js_1.typeKindChangedFromMeta; } });
+Object.defineProperty(exports, "typeDescriptionChangedFromMeta", { enumerable: true, get: function () { return type_js_1.typeDescriptionChangedFromMeta; } });
+Object.defineProperty(exports, "typeDescriptionRemovedFromMeta", { enumerable: true, get: function () { return type_js_1.typeDescriptionRemovedFromMeta; } });
+Object.defineProperty(exports, "typeDescriptionAddedFromMeta", { enumerable: true, get: function () { return type_js_1.typeDescriptionAddedFromMeta; } });
+var union_js_1 = require("./diff/changes/union.js");
+Object.defineProperty(exports, "unionMemberRemovedFromMeta", { enumerable: true, get: function () { return union_js_1.unionMemberRemovedFromMeta; } });
+Object.defineProperty(exports, "buildUnionMemberAddedMessageFromMeta", { enumerable: true, get: function () { return union_js_1.buildUnionMemberAddedMessageFromMeta; } });

package/cjs/core/src/utils/is-deprecated.js

@@ -4,7 +4,7 @@ exports.isDeprecated = void 0;
 function isDeprecated(fieldOrEnumValue) {
     var _a, _b;
     if ('isDeprecated' in fieldOrEnumValue) {
-        return fieldOrEnumValue['isDeprecated'];
+        return !!fieldOrEnumValue['isDeprecated'];
     }
     if (fieldOrEnumValue.deprecationReason != null) {
         return true;

package/cjs/core/src/utils/string.js

@@ -63,6 +63,9 @@ function wordLetterPairs(str) {
     return flattenDeep(pairs);
 }
 function safeString(obj) {
+    if (typeof obj === 'string') {
+        return JSON.stringify(obj);
+    }
     return (0, object_inspect_1.default)(obj)
         .replace(/\[Object: null prototype\] /g, '')
         .replace(/(^')|('$)/g, '');

package/cjs/github/src/helpers/config.js

@@ -87,12 +87,16 @@ function createConfig(rawConfig, setConfigKind, branches = [], fallbackBranch =
         return config;
     }
     for (const branch of branches) {
-        config = config || findConfigByBranch(branch, normalizedConfig, false);
+        if (config == null) {
+            config = findConfigByBranch(branch, normalizedConfig, false);
+        }
         if (config) {
             break;
         }
     }
-    config = config || getGlobalConfig(rawConfig, fallbackBranch);
+    if (config == null) {
+        config = getGlobalConfig(rawConfig, fallbackBranch);
+    }
     return config;
 }
 exports.createConfig = createConfig;

package/cjs/github/src/helpers/utils.js

@@ -27,7 +27,7 @@ function filterChangesByLevel(level) {
     return (change) => change.criticality.level === level;
 }
 exports.filterChangesByLevel = filterChangesByLevel;
-function createSummary(changes, summaryLimit, isLegacyConfig) {
+function createSummary(changes, summaryLimit, isLegacyConfig = false) {
     const breakingChanges = changes.filter(filterChangesByLevel(core_1.CriticalityLevel.Breaking));
     const dangerousChanges = changes.filter(filterChangesByLevel(core_1.CriticalityLevel.Dangerous));
     const safeChanges = changes.filter(filterChangesByLevel(core_1.CriticalityLevel.NonBreaking));

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