chore(core): add missing directive usage exports

.changeset/chilled-squids-knock.md

@@ -0,0 +1,6 @@
+---
+'@graphql-inspector/core': minor
+---
+
+add missing change detection of directive field usage and exports 'directiveUsageFieldAddedFromMeta' &
+'directiveUsageFieldRemovedFromMeta'

packages/core/__tests__/diff/directive-usage.test.ts

@@ -1,5 +1,10 @@
 import { buildSchema } from 'graphql';
-import { CriticalityLevel, diff } from '../../src/index.js';
+import {
+  CriticalityLevel,
+  diff,
+  directiveUsageFieldAddedFromMeta,
+  directiveUsageFieldRemovedFromMeta,
+} from '../../src/index.js';
 import { findFirstChangeByPath } from '../../utils/testing.js';
 
 describe('directive-usage', () => {
@@ -724,4 +729,104 @@ describe('directive-usage', () => {
       expect(change.message).toEqual("Directive 'external' was removed from schema 'Foo'");
     });
   });
+
+  describe('directiveUsageFieldAddedFromMeta and directiveUsageFieldRemovedFromMeta', () => {
+    test('directiveUsageFieldAddedFromMeta creates correct change object', () => {
+      const change = directiveUsageFieldAddedFromMeta({
+        type: 'DIRECTIVE_USAGE_FIELD_ADDED',
+        meta: {
+          typeName: 'User',
+          fieldName: 'email',
+          addedDirectiveName: 'external',
+        },
+      });
+
+      expect(change.type).toEqual('DIRECTIVE_USAGE_FIELD_ADDED');
+      expect(change.criticality.level).toEqual(CriticalityLevel.Dangerous);
+      expect(change.criticality.reason).toEqual("Directive 'external' was added to field 'email'");
+      expect(change.message).toEqual("Directive 'external' was added to field 'User.email'");
+      expect(change.path).toEqual('User.email.external');
+      expect(change.meta).toEqual({
+        typeName: 'User',
+        fieldName: 'email',
+        addedDirectiveName: 'external',
+      });
+    });
+
+    test('directiveUsageFieldAddedFromMeta with @deprecated directive', () => {
+      const change = directiveUsageFieldAddedFromMeta({
+        type: 'DIRECTIVE_USAGE_FIELD_ADDED',
+        meta: {
+          typeName: 'User',
+          fieldName: 'name',
+          addedDirectiveName: 'deprecated',
+        },
+      });
+
+      expect(change.criticality.level).toEqual(CriticalityLevel.NonBreaking);
+    });
+
+    test('directiveUsageFieldAddedFromMeta with @oneOf directive', () => {
+      const change = directiveUsageFieldAddedFromMeta({
+        type: 'DIRECTIVE_USAGE_FIELD_ADDED',
+        meta: {
+          typeName: 'SearchResult',
+          fieldName: 'result',
+          addedDirectiveName: 'oneOf',
+        },
+      });
+
+      expect(change.criticality.level).toEqual(CriticalityLevel.Breaking);
+    });
+
+    test('directiveUsageFieldRemovedFromMeta creates correct change object', () => {
+      const change = directiveUsageFieldRemovedFromMeta({
+        type: 'DIRECTIVE_USAGE_FIELD_REMOVED',
+        meta: {
+          typeName: 'User',
+          fieldName: 'email',
+          removedDirectiveName: 'external',
+        },
+      });
+
+      expect(change.type).toEqual('DIRECTIVE_USAGE_FIELD_REMOVED');
+      expect(change.criticality.level).toEqual(CriticalityLevel.Dangerous);
+      expect(change.criticality.reason).toEqual(
+        "Directive 'external' was removed from field 'email'",
+      );
+      expect(change.message).toEqual("Directive 'external' was removed from field 'User.email'");
+      expect(change.path).toEqual('User.email.external');
+      expect(change.meta).toEqual({
+        typeName: 'User',
+        fieldName: 'email',
+        removedDirectiveName: 'external',
+      });
+    });
+
+    test('directiveUsageFieldRemovedFromMeta with @deprecated directive', () => {
+      const change = directiveUsageFieldRemovedFromMeta({
+        type: 'DIRECTIVE_USAGE_FIELD_REMOVED',
+        meta: {
+          typeName: 'User',
+          fieldName: 'name',
+          removedDirectiveName: 'deprecated',
+        },
+      });
+
+      expect(change.criticality.level).toEqual(CriticalityLevel.NonBreaking);
+    });
+
+    test('directiveUsageFieldRemovedFromMeta with @oneOf directive', () => {
+      const change = directiveUsageFieldRemovedFromMeta({
+        type: 'DIRECTIVE_USAGE_FIELD_REMOVED',
+        meta: {
+          typeName: 'SearchResult',
+          fieldName: 'result',
+          removedDirectiveName: 'oneOf',
+        },
+      });
+
+      expect(change.criticality.level).toEqual(CriticalityLevel.NonBreaking);
+    });
+  });
 });

packages/core/src/diff/changes/directive-usage.ts

@@ -23,8 +23,10 @@ import {
   DirectiveUsageEnumRemovedChange,
   DirectiveUsageEnumValueAddedChange,
   DirectiveUsageEnumValueRemovedChange,
+  DirectiveUsageFieldAddedChange,
   DirectiveUsageFieldDefinitionAddedChange,
   DirectiveUsageFieldDefinitionRemovedChange,
+  DirectiveUsageFieldRemovedChange,
   DirectiveUsageInputFieldDefinitionAddedChange,
   DirectiveUsageInputFieldDefinitionRemovedChange,
   DirectiveUsageInputObjectAddedChange,
@@ -72,6 +74,13 @@ type KindToPayload = {
     input: GraphQLEnumType;
     change: DirectiveUsageEnumAddedChange | DirectiveUsageEnumRemovedChange;
   };
+  [Kind.FIELD]: {
+    input: {
+      field: GraphQLField<any, any, any>;
+      parentType: GraphQLInterfaceType | GraphQLObjectType<any, any>;
+    };
+    change: DirectiveUsageFieldAddedChange | DirectiveUsageFieldRemovedChange;
+  };
   [Kind.FIELD_DEFINITION]: {
     input: {
       field: GraphQLField<any, any, any>;
@@ -379,6 +388,25 @@ export function directiveUsageEnumRemovedFromMeta(args: DirectiveUsageEnumRemove
   } as const;
 }
 
+function buildDirectiveUsageFieldAddedMessage(
+  args: DirectiveUsageFieldAddedChange['meta'],
+): string {
+  return `Directive '${args.addedDirectiveName}' was added to field '${args.typeName}.${args.fieldName}'`;
+}
+
+export function directiveUsageFieldAddedFromMeta(args: DirectiveUsageFieldAddedChange) {
+  return {
+    criticality: {
+      level: addedSpecialDirective(args.meta.addedDirectiveName, CriticalityLevel.Dangerous),
+      reason: `Directive '${args.meta.addedDirectiveName}' was added to field '${args.meta.fieldName}'`,
+    },
+    type: ChangeType.DirectiveUsageFieldAdded,
+    message: buildDirectiveUsageFieldAddedMessage(args.meta),
+    path: [args.meta.typeName, args.meta.fieldName, args.meta.addedDirectiveName].join('.'),
+    meta: args.meta,
+  } as const;
+}
+
 function buildDirectiveUsageFieldDefinitionAddedMessage(
   args: DirectiveUsageFieldDefinitionAddedChange['meta'],
 ): string {
@@ -400,6 +428,25 @@ export function directiveUsageFieldDefinitionAddedFromMeta(
   } as const;
 }
 
+function buildDirectiveUsageFieldRemovedMessage(
+  args: DirectiveUsageFieldRemovedChange['meta'],
+): string {
+  return `Directive '${args.removedDirectiveName}' was removed from field '${args.typeName}.${args.fieldName}'`;
+}
+
+export function directiveUsageFieldRemovedFromMeta(args: DirectiveUsageFieldRemovedChange) {
+  return {
+    criticality: {
+      level: removedSpecialDirective(args.meta.removedDirectiveName, CriticalityLevel.Dangerous),
+      reason: `Directive '${args.meta.removedDirectiveName}' was removed from field '${args.meta.fieldName}'`,
+    },
+    type: ChangeType.DirectiveUsageFieldRemoved,
+    message: buildDirectiveUsageFieldRemovedMessage(args.meta),
+    path: [args.meta.typeName, args.meta.fieldName, args.meta.removedDirectiveName].join('.'),
+    meta: args.meta,
+  } as const;
+}
+
 function buildDirectiveUsageFieldDefinitionRemovedMessage(
   args: DirectiveUsageFieldDefinitionRemovedChange['meta'],
 ): string {
@@ -640,6 +687,16 @@ export function directiveUsageAdded<K extends keyof KindToPayload>(
       },
     });
   }
+  if (isOfKind(kind, Kind.FIELD, payload)) {
+    return directiveUsageFieldAddedFromMeta({
+      type: ChangeType.DirectiveUsageFieldAdded,
+      meta: {
+        addedDirectiveName: directive.name.value,
+        fieldName: payload.field.name,
+        typeName: payload.parentType.name,
+      },
+    });
+  }
   if (isOfKind(kind, Kind.FIELD_DEFINITION, payload)) {
     return directiveUsageFieldDefinitionAddedFromMeta({
       type: ChangeType.DirectiveUsageFieldDefinitionAdded,
@@ -757,6 +814,16 @@ export function directiveUsageRemoved<K extends keyof KindToPayload>(
       },
     });
   }
+  if (isOfKind(kind, Kind.FIELD, payload)) {
+    return directiveUsageFieldRemovedFromMeta({
+      type: ChangeType.DirectiveUsageFieldRemoved,
+      meta: {
+        removedDirectiveName: directive.name.value,
+        fieldName: payload.field.name,
+        typeName: payload.parentType.name,
+      },
+    });
+  }
   if (isOfKind(kind, Kind.FIELD_DEFINITION, payload)) {
     return directiveUsageFieldDefinitionRemovedFromMeta({
       type: ChangeType.DirectiveUsageFieldDefinitionRemoved,

packages/core/src/index.ts

@@ -38,9 +38,11 @@ export {
   directiveUsageArgumentDefinitionRemovedFromMeta,
   directiveUsageEnumValueAddedFromMeta,
   directiveUsageEnumValueRemovedFromMeta,
+  directiveUsageFieldAddedFromMeta,
   directiveUsageFieldDefinitionAddedFromMeta,
   directiveUsageAdded,
   directiveUsageFieldDefinitionRemovedFromMeta,
+  directiveUsageFieldRemovedFromMeta,
   directiveUsageInputFieldDefinitionAddedFromMeta,
   directiveUsageInputFieldDefinitionRemovedFromMeta,
   directiveUsageInputObjectAddedFromMeta,