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

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

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

@@ -1,23 +1,49 @@
-import { ChangeType, CriticalityLevel } from './change.js';
-export function objectTypeInterfaceAdded(iface, type) {
+import { ChangeType, CriticalityLevel, } from './change.js';
+function buildObjectTypeInterfaceAddedMessage(args) {
+    return `'${args.objectTypeName}' object implements '${args.addedInterfaceName}' interface`;
+}
+export function objectTypeInterfaceAddedFromMeta(args) {
     return {
+        type: ChangeType.ObjectTypeInterfaceAdded,
         criticality: {
             level: 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: ChangeType.ObjectTypeInterfaceAdded,
-        message: `'${type.name}' object implements '${iface.name}' interface`,
-        path: type.name,
+        message: buildObjectTypeInterfaceAddedMessage(args.meta),
+        meta: args.meta,
+        path: args.meta.objectTypeName,
     };
 }
-export function objectTypeInterfaceRemoved(iface, type) {
+export function objectTypeInterfaceAdded(iface, type) {
+    return objectTypeInterfaceAddedFromMeta({
+        type: ChangeType.ObjectTypeInterfaceAdded,
+        meta: {
+            objectTypeName: type.name,
+            addedInterfaceName: iface.name,
+        },
+    });
+}
+function buildObjectTypeInterfaceRemovedMessage(args) {
+    return `'${args.objectTypeName}' object type no longer implements '${args.removedInterfaceName}' interface`;
+}
+export function objectTypeInterfaceRemovedFromMeta(args) {
     return {
+        type: ChangeType.ObjectTypeInterfaceRemoved,
         criticality: {
             level: CriticalityLevel.Breaking,
             reason: 'Removing an interface from an object type can cause existing queries that use this in a fragment spread to error.',
         },
-        type: 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,
     };
 }
+export function objectTypeInterfaceRemoved(iface, type) {
+    return objectTypeInterfaceRemovedFromMeta({
+        type: ChangeType.ObjectTypeInterfaceRemoved,
+        meta: {
+            objectTypeName: type.name,
+            removedInterfaceName: iface.name,
+        },
+    });
+}

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

@@ -1,34 +1,73 @@
-import { ChangeType, CriticalityLevel } from './change.js';
+import { ChangeType, CriticalityLevel, } from './change.js';
+function buildSchemaQueryTypeChangedMessage(args) {
+    return `Schema query root has changed from '${args.oldQueryTypeName}' to '${args.newQueryTypeName}'`;
+}
+export function schemaQueryTypeChangedFromMeta(args) {
+    return {
+        type: ChangeType.SchemaQueryTypeChanged,
+        criticality: {
+            level: CriticalityLevel.Breaking,
+        },
+        message: buildSchemaQueryTypeChangedMessage(args.meta),
+        meta: args.meta,
+    };
+}
 export function schemaQueryTypeChanged(oldSchema, newSchema) {
     const oldName = (oldSchema.getQueryType() || {}).name || 'unknown';
     const newName = (newSchema.getQueryType() || {}).name || 'unknown';
+    return schemaQueryTypeChangedFromMeta({
+        type: ChangeType.SchemaQueryTypeChanged,
+        meta: {
+            oldQueryTypeName: oldName,
+            newQueryTypeName: newName,
+        },
+    });
+}
+function buildSchemaMutationTypeChangedMessage(args) {
+    return `Schema mutation root has changed from '${args.oldMutationTypeName}' to '${args.newMutationTypeName}'`;
+}
+export function schemaMutationTypeChangedFromMeta(args) {
     return {
+        type: ChangeType.SchemaMutationTypeChanged,
         criticality: {
             level: CriticalityLevel.Breaking,
         },
-        type: ChangeType.SchemaQueryTypeChanged,
-        message: `Schema query root has changed from '${oldName}' to '${newName}'`,
+        message: buildSchemaMutationTypeChangedMessage(args.meta),
+        meta: args.meta,
     };
 }
 export function schemaMutationTypeChanged(oldSchema, newSchema) {
     const oldName = (oldSchema.getMutationType() || {}).name || 'unknown';
     const newName = (newSchema.getMutationType() || {}).name || 'unknown';
+    return schemaMutationTypeChangedFromMeta({
+        type: ChangeType.SchemaMutationTypeChanged,
+        meta: {
+            newMutationTypeName: newName,
+            oldMutationTypeName: oldName,
+        },
+    });
+}
+function buildSchemaSubscriptionTypeChangedMessage(args) {
+    return `Schema subscription root has changed from '${args.oldSubscriptionTypeName}' to '${args.newSubscriptionTypeName}'`;
+}
+export function schemaSubscriptionTypeChangedFromMeta(args) {
     return {
+        type: ChangeType.SchemaSubscriptionTypeChanged,
         criticality: {
             level: CriticalityLevel.Breaking,
         },
-        type: ChangeType.SchemaMutationTypeChanged,
-        message: `Schema mutation root has changed from '${oldName}' to '${newName}'`,
+        message: buildSchemaSubscriptionTypeChangedMessage(args.meta),
+        meta: args.meta,
     };
 }
 export function schemaSubscriptionTypeChanged(oldSchema, newSchema) {
     const oldName = (oldSchema.getSubscriptionType() || {}).name || 'unknown';
     const newName = (newSchema.getSubscriptionType() || {}).name || 'unknown';
-    return {
-        criticality: {
-            level: CriticalityLevel.Breaking,
-        },
+    return schemaSubscriptionTypeChangedFromMeta({
         type: ChangeType.SchemaSubscriptionTypeChanged,
-        message: `Schema subscription root has changed from '${oldName}' to '${newName}'`,
-    };
+        meta: {
+            newSubscriptionTypeName: newName,
+            oldSubscriptionTypeName: oldName,
+        },
+    });
 }

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

@@ -1,63 +1,144 @@
 import { getKind } from '../../utils/graphql.js';
-import { ChangeType, CriticalityLevel } from './change.js';
-export function typeRemoved(type) {
+import { ChangeType, CriticalityLevel, } from './change.js';
+function buildTypeRemovedMessage(type) {
+    return `Type '${type.removedTypeName}' was removed`;
+}
+export function typeRemovedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.Breaking,
         },
         type: ChangeType.TypeRemoved,
-        message: `Type '${type.name}' was removed`,
-        path: type.name,
+        message: buildTypeRemovedMessage(args.meta),
+        meta: args.meta,
+        path: args.meta.removedTypeName,
     };
 }
-export function typeAdded(type) {
+export function typeRemoved(type) {
+    return typeRemovedFromMeta({
+        type: ChangeType.TypeRemoved,
+        meta: {
+            removedTypeName: type.name,
+        },
+    });
+}
+function buildTypeAddedMessage(type) {
+    return `Type '${type.addedTypeName}' was added`;
+}
+export function typeAddedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
         type: ChangeType.TypeAdded,
-        message: `Type '${type.name}' was added`,
-        path: type.name,
+        message: buildTypeAddedMessage(args.meta),
+        meta: args.meta,
+        path: args.meta.addedTypeName,
     };
 }
-export function typeKindChanged(oldType, newType) {
+export function typeAdded(type) {
+    return typeAddedFromMeta({
+        type: ChangeType.TypeAdded,
+        meta: {
+            addedTypeName: type.name,
+        },
+    });
+}
+function buildTypeKindChangedMessage(args) {
+    return `'${args.meta.typeName}' kind changed from '${args.meta.oldTypeKind}' to '${args.meta.newTypeKind}'`;
+}
+export function typeKindChangedFromMeta(args) {
     return {
         criticality: {
             level: 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: ChangeType.TypeKindChanged,
-        message: `'${oldType.name}' kind changed from '${getKind(oldType)}' to '${getKind(newType)}'`,
-        path: oldType.name,
+        message: buildTypeKindChangedMessage(args),
+        path: args.meta.typeName,
+        meta: args.meta,
     };
 }
-export function typeDescriptionChanged(oldType, newType) {
+export function typeKindChanged(oldType, newType) {
+    return typeKindChangedFromMeta({
+        type: ChangeType.TypeKindChanged,
+        meta: {
+            typeName: oldType.name,
+            newTypeKind: String(getKind(newType)),
+            oldTypeKind: String(getKind(oldType)),
+        },
+    });
+}
+function buildTypeDescriptionChangedMessage(args) {
+    return `Description '${args.oldTypeDescription}' on type '${args.typeName}' has changed to '${args.newTypeDescription}'`;
+}
+export function typeDescriptionChangedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
         type: 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,
     };
 }
-export function typeDescriptionRemoved(type) {
+export function typeDescriptionChanged(oldType, newType) {
+    var _a, _b;
+    return typeDescriptionChangedFromMeta({
+        type: ChangeType.TypeDescriptionChanged,
+        meta: {
+            typeName: oldType.name,
+            newTypeDescription: (_a = newType.description) !== null && _a !== void 0 ? _a : '',
+            oldTypeDescription: (_b = oldType.description) !== null && _b !== void 0 ? _b : '',
+        },
+    });
+}
+function buildTypeDescriptionRemoved(args) {
+    return `Description '${args.removedTypeDescription}' was removed from object type '${args.typeName}'`;
+}
+export function typeDescriptionRemovedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
         type: 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,
     };
 }
-export function typeDescriptionAdded(type) {
+export function typeDescriptionRemoved(type) {
+    var _a;
+    return typeDescriptionRemovedFromMeta({
+        type: ChangeType.TypeDescriptionRemoved,
+        meta: {
+            typeName: type.name,
+            removedTypeDescription: (_a = type.description) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+}
+function buildTypeDescriptionAddedMessage(args) {
+    return `Object type '${args.typeName}' has description '${args.addedTypeDescription}'`;
+}
+export function typeDescriptionAddedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
         type: 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,
     };
 }
+export function typeDescriptionAdded(type) {
+    var _a;
+    return typeDescriptionAddedFromMeta({
+        type: ChangeType.TypeDescriptionAdded,
+        meta: {
+            typeName: type.name,
+            addedTypeDescription: (_a = type.description) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+}

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

@@ -1,23 +1,49 @@
-import { ChangeType, CriticalityLevel } from './change.js';
-export function unionMemberRemoved(union, type) {
+import { ChangeType, CriticalityLevel, } from './change.js';
+function buildUnionMemberRemovedMessage(args) {
+    return `Member '${args.removedUnionMemberTypeName}' was removed from Union type '${args.unionName}'`;
+}
+export function unionMemberRemovedFromMeta(args) {
     return {
         criticality: {
             level: 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: 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,
     };
 }
-export function unionMemberAdded(union, type) {
+export function unionMemberRemoved(union, type) {
+    return unionMemberRemovedFromMeta({
+        type: ChangeType.UnionMemberRemoved,
+        meta: {
+            unionName: union.name,
+            removedUnionMemberTypeName: type.name,
+        },
+    });
+}
+function buildUnionMemberAddedMessage(args) {
+    return `Member '${args.addedUnionMemberTypeName}' was added to Union type '${args.unionName}'`;
+}
+export function buildUnionMemberAddedMessageFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.Dangerous,
             reason: 'Adding a possible type to Unions may break existing clients that were not programming defensively against a new possible type.',
         },
         type: 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,
     };
 }
+export function unionMemberAdded(union, type) {
+    return buildUnionMemberAddedMessageFromMeta({
+        type: ChangeType.UnionMemberAdded,
+        meta: {
+            unionName: union.name,
+            addedUnionMemberTypeName: type.name,
+        },
+    });
+}

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

@@ -28,7 +28,7 @@ export const considerUsage = ({ changes, config }) => __awaiter(void 0, void 0,
         if (change.criticality.level === 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: CriticalityLevel.Dangerous }), message: `${change.message} (non-breaking based on usage)` });
+            return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: CriticalityLevel.Dangerous, isSafeBasedOnUsage: true }), message: `${change.message} (non-breaking based on usage)` });
         }
         return change;
     });

package/esm/core/src/index.js

@@ -9,3 +9,12 @@ export { calculateOperationComplexity, } from './validate/complexity.js';
 export { countDirectives } from './validate/directive-count.js';
 export { countDepth } from './validate/query-depth.js';
 export { calculateTokenCount } from './validate/token-count.js';
+export { fieldArgumentDescriptionChangedFromMeta, fieldArgumentDefaultChangedFromMeta, fieldArgumentTypeChangedFromMeta, } from './diff/changes/argument.js';
+export { directiveRemovedFromMeta, directiveAddedFromMeta, directiveDescriptionChangedFromMeta, directiveLocationAddedFromMeta, directiveLocationRemovedFromMeta, directiveArgumentAddedFromMeta, directiveArgumentRemovedFromMeta, directiveArgumentDescriptionChangedFromMeta, directiveArgumentDefaultValueChangedFromMeta, directiveArgumentTypeChangedFromMeta, } from './diff/changes/directive.js';
+export { enumValueRemovedFromMeta, enumValueAddedFromMeta, enumValueDescriptionChangedFromMeta, enumValueDeprecationReasonChangedFromMeta, enumValueDeprecationReasonAddedFromMeta, enumValueDeprecationReasonRemovedFromMeta, } from './diff/changes/enum.js';
+export { fieldRemovedFromMeta, fieldAddedFromMeta, fieldDescriptionChangedFromMeta, fieldDescriptionAddedFromMeta, fieldDescriptionRemovedFromMeta, fieldDeprecationAddedFromMeta, fieldDeprecationRemovedFromMeta, fieldDeprecationReasonChangedFromMeta, fieldDeprecationReasonAddedFromMeta, fieldDeprecationReasonRemovedFromMeta, fieldTypeChangedFromMeta, fieldArgumentAddedFromMeta, fieldArgumentRemovedFromMeta, } from './diff/changes/field.js';
+export { inputFieldRemovedFromMeta, inputFieldAddedFromMeta, inputFieldDescriptionAddedFromMeta, inputFieldDescriptionRemovedFromMeta, inputFieldDescriptionChangedFromMeta, inputFieldDefaultValueChangedFromMeta, inputFieldTypeChangedFromMeta, } from './diff/changes/input.js';
+export { objectTypeInterfaceAddedFromMeta, objectTypeInterfaceRemovedFromMeta, } from './diff/changes/object.js';
+export { schemaQueryTypeChangedFromMeta, schemaMutationTypeChangedFromMeta, schemaSubscriptionTypeChangedFromMeta, } from './diff/changes/schema.js';
+export { typeRemovedFromMeta, typeAddedFromMeta, typeKindChangedFromMeta, typeDescriptionChangedFromMeta, typeDescriptionRemovedFromMeta, typeDescriptionAddedFromMeta, } from './diff/changes/type.js';
+export { unionMemberRemovedFromMeta, buildUnionMemberAddedMessageFromMeta, } from './diff/changes/union.js';

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

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

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

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