Add patch package to apply diff changes to schemas

.changeset/seven-jars-yell.md

@@ -0,0 +1,6 @@
+---
+'@graphql-inspector/core': major
+---
+
+"diff" includes all nested changes when a node is added. Some change types have had additional meta fields added.
+On deprecation add with a reason, a separate "fieldDeprecationReasonAdded" change is no longer included.

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

@@ -28,6 +28,29 @@ describe('directive-usage', () => {
       expect(change.message).toEqual("Directive 'external' was added to field 'Query.a'");
     });
 
+    test('added directive on added field', async () => {
+      const a = buildSchema(/* GraphQL */ `
+        type Query {
+          _: String
+        }
+      `);
+      const b = buildSchema(/* GraphQL */ `
+        directive @external on FIELD_DEFINITION
+
+        type Query {
+          _: String
+          a: String @external
+        }
+      `);
+
+      const changes = await diff(a, b);
+      const change = findFirstChangeByPath(changes, 'Query.a.external');
+
+      expect(change.criticality.level).toEqual(CriticalityLevel.NonBreaking);
+      expect(change.type).toEqual('DIRECTIVE_USAGE_FIELD_DEFINITION_ADDED');
+      expect(change.message).toEqual("Directive 'external' was added to field 'Query.a'");
+    });
+
     test('removed directive', async () => {
       const a = buildSchema(/* GraphQL */ `
         directive @external on FIELD_DEFINITION

packages/core/__tests__/diff/enum.test.ts

@@ -3,6 +3,54 @@ import { CriticalityLevel, diff, DiffRule } from '../../src/index.js';
 import { findFirstChangeByPath } from '../../utils/testing.js';
 
 describe('enum', () => {
+  test('added', async () => {
+    const a = buildSchema(/* GraphQL */ `
+      type Query {
+        fieldA: String
+      }
+    `);
+
+    const b = buildSchema(/* GraphQL */ `
+      type Query {
+        fieldA: String
+      }
+
+      enum enumA {
+        """
+        A is the first letter in the alphabet
+        """
+        A
+        B
+      }
+    `);
+
+    const changes = await diff(a, b);
+    expect(changes.length).toEqual(4);
+
+    {
+      const change = findFirstChangeByPath(changes, 'enumA');
+      expect(change.meta).toMatchObject({
+        addedTypeKind: 'EnumTypeDefinition',
+        addedTypeName: 'enumA',
+      });
+      expect(change.criticality.level).toEqual(CriticalityLevel.NonBreaking);
+      expect(change.criticality.reason).not.toBeDefined();
+      expect(change.message).toEqual(`Type 'enumA' was added`);
+    }
+
+    {
+      const change = findFirstChangeByPath(changes, 'enumA.A');
+      expect(change.criticality.level).toEqual(CriticalityLevel.NonBreaking);
+      expect(change.criticality.reason).not.toBeDefined();
+      expect(change.message).toEqual(`Enum value 'A' was added to enum 'enumA'`);
+      expect(change.meta).toMatchObject({
+        addedEnumValueName: 'A',
+        enumName: 'enumA',
+        addedToNewType: true,
+      });
+    }
+  });
+
   test('value added', async () => {
     const a = buildSchema(/* GraphQL */ `
       type Query {

packages/core/__tests__/diff/input.test.ts

@@ -1,6 +1,6 @@
 import { buildSchema } from 'graphql';
 import { CriticalityLevel, diff, DiffRule } from '../../src/index.js';
-import { findFirstChangeByPath } from '../../utils/testing.js';
+import { findChangesByPath, findFirstChangeByPath } from '../../utils/testing.js';
 
 describe('input', () => {
   describe('fields', () => {
@@ -38,6 +38,61 @@ describe('input', () => {
         "Input field 'd' of type 'String' was added to input object type 'Foo'",
       );
     });
+
+    test('added with a default value', async () => {
+      const a = buildSchema(/* GraphQL */ `
+        input Foo {
+          a: String!
+        }
+      `);
+      const b = buildSchema(/* GraphQL */ `
+        input Foo {
+          a: String!
+          b: String! = "B"
+        }
+      `);
+
+      const change = findFirstChangeByPath(await diff(a, b), 'Foo.b');
+      expect(change.criticality.level).toEqual(CriticalityLevel.Dangerous);
+      expect(change.type).toEqual('INPUT_FIELD_ADDED');
+      expect(change.meta).toMatchObject({
+        addedFieldDefault: '"B"',
+        addedInputFieldName: 'b',
+        addedInputFieldType: 'String!',
+        addedToNewType: false,
+        inputName: 'Foo',
+        isAddedInputFieldTypeNullable: false,
+      });
+      expect(change.message).toEqual(
+        `Input field 'b' of type 'String!' with default value '"B"' was added to input object type 'Foo'`,
+      );
+    });
+
+    test('added to an added input', async () => {
+      const a = buildSchema(/* GraphQL */ `
+        type Query {
+          _: String
+        }
+      `);
+      const b = buildSchema(/* GraphQL */ `
+        type Query {
+          _: String
+        }
+
+        input Foo {
+          a: String!
+        }
+      `);
+
+      const change = findFirstChangeByPath(await diff(a, b), 'Foo.a');
+
+      expect(change.type).toEqual('INPUT_FIELD_ADDED');
+      expect(change.criticality.level).toEqual(CriticalityLevel.NonBreaking);
+      expect(change.message).toEqual(
+        "Input field 'a' of type 'String!' was added to input object type 'Foo'",
+      );
+    });
+
     test('removed', async () => {
       const a = buildSchema(/* GraphQL */ `
         input Foo {

packages/core/__tests__/diff/interface.test.ts

@@ -169,24 +169,24 @@ describe('interface', () => {
       const changes = await diff(a, b);
       const change = {
         a: findFirstChangeByPath(changes, 'Foo.a'),
-        b: findChangesByPath(changes, 'Foo.b')[1],
-        c: findChangesByPath(changes, 'Foo.c')[1],
+        b: findFirstChangeByPath(changes, 'Foo.b'),
+        c: findFirstChangeByPath(changes, 'Foo.c'),
       };
 
       // Changed
-      expect(change.a.criticality.level).toEqual(CriticalityLevel.NonBreaking);
       expect(change.a.type).toEqual('FIELD_DEPRECATION_REASON_CHANGED');
+      expect(change.a.criticality.level).toEqual(CriticalityLevel.NonBreaking);
       expect(change.a.message).toEqual(
         "Deprecation reason on field 'Foo.a' has changed from 'OLD' to 'NEW'",
       );
       // Removed
-      expect(change.b.criticality.level).toEqual(CriticalityLevel.NonBreaking);
-      expect(change.b.type).toEqual('FIELD_DEPRECATION_REASON_REMOVED');
-      expect(change.b.message).toEqual("Deprecation reason was removed from field 'Foo.b'");
+      expect(change.b.type).toEqual('FIELD_DEPRECATION_REMOVED');
+      expect(change.b.criticality.level).toEqual(CriticalityLevel.Dangerous);
+      expect(change.b.message).toEqual("Field 'Foo.b' is no longer deprecated");
       // Added
+      expect(change.c.type).toEqual('FIELD_DEPRECATION_ADDED');
       expect(change.c.criticality.level).toEqual(CriticalityLevel.NonBreaking);
-      expect(change.c.type).toEqual('FIELD_DEPRECATION_REASON_ADDED');
-      expect(change.c.message).toEqual("Field 'Foo.c' has deprecation reason 'CCC'");
+      expect(change.c.message).toEqual("Field 'Foo.c' is deprecated");
     });
 
     test('deprecation added / removed', async () => {
@@ -219,4 +219,32 @@ describe('interface', () => {
       expect(change.b.message).toEqual("Field 'Foo.b' is deprecated");
     });
   });
+
+  test('deprecation added w/reason', async () => {
+    const a = buildSchema(/* GraphQL */ `
+      interface Foo {
+        a: String!
+      }
+    `);
+    const b = buildSchema(/* GraphQL */ `
+      interface Foo {
+        a: String! @deprecated(reason: "A is the first letter.")
+      }
+    `);
+
+    const changes = await diff(a, b);
+
+    expect(findChangesByPath(changes, 'Foo.a')).toHaveLength(1);
+    const change = findFirstChangeByPath(changes, 'Foo.a');
+
+    // added
+    expect(change.criticality.level).toEqual(CriticalityLevel.NonBreaking);
+    expect(change.type).toEqual('FIELD_DEPRECATION_ADDED');
+    expect(change.message).toEqual("Field 'Foo.a' is deprecated");
+    expect(change.meta).toMatchObject({
+      deprecationReason: 'A is the first letter.',
+      fieldName: 'a',
+      typeName: 'Foo',
+    });
+  });
 });

packages/core/__tests__/diff/object.test.ts

@@ -31,11 +31,18 @@ describe('object', () => {
       }
     `);
 
-    const change = findFirstChangeByPath(await diff(a, b), 'B');
-    const mutation = findFirstChangeByPath(await diff(a, b), 'Mutation');
+    const changes = await diff(a, b);
+    expect(changes).toHaveLength(4);
+
+    const change = findFirstChangeByPath(changes, 'B');
+    const mutation = findFirstChangeByPath(changes, 'Mutation');
 
     expect(change.criticality.level).toEqual(CriticalityLevel.NonBreaking);
     expect(mutation.criticality.level).toEqual(CriticalityLevel.NonBreaking);
+    expect(change.meta).toMatchObject({
+      addedTypeKind: 'ObjectTypeDefinition',
+      addedTypeName: 'B',
+    });
   });
 
   describe('interfaces', () => {
@@ -63,7 +70,8 @@ describe('object', () => {
           b: String!
         }
 
-        interface C {
+        interface C implements B {
+          b: String!
           c: String!
         }
 
@@ -74,11 +82,43 @@ describe('object', () => {
         }
       `);
 
-      const change = findFirstChangeByPath(await diff(a, b), 'Foo');
+      const changes = await diff(a, b);
+
+      {
+        const change = findFirstChangeByPath(changes, 'Foo');
+        expect(change.criticality.level).toEqual(CriticalityLevel.Dangerous);
+        expect(change.type).toEqual('OBJECT_TYPE_INTERFACE_ADDED');
+        expect(change.message).toEqual("'Foo' object implements 'C' interface");
+        expect(change.meta).toMatchObject({
+          addedInterfaceName: 'C',
+          objectTypeName: 'Foo',
+        });
+      }
+
+      const cChanges = findChangesByPath(changes, 'C');
+      expect(cChanges).toHaveLength(2);
+      {
+        const change = cChanges[0];
+        expect(change.type).toEqual('TYPE_ADDED');
+        expect(change.meta).toMatchObject({
+          addedTypeKind: 'InterfaceTypeDefinition',
+          addedTypeName: 'C',
+        });
+      }
+
+      {
+        const change = cChanges[1];
+        expect(change.type).toEqual('OBJECT_TYPE_INTERFACE_ADDED');
+        expect(change.meta).toMatchObject({
+          addedInterfaceName: 'B',
+          objectTypeName: 'C',
+        });
+      }
 
-      expect(change.criticality.level).toEqual(CriticalityLevel.Dangerous);
-      expect(change.type).toEqual('OBJECT_TYPE_INTERFACE_ADDED');
-      expect(change.message).toEqual("'Foo' object implements 'C' interface");
+      {
+        const change = findFirstChangeByPath(changes, 'C.b');
+        expect(change.criticality.level).toEqual(CriticalityLevel.NonBreaking);
+      }
     });
 
     test('removed', async () => {
@@ -290,24 +330,24 @@ describe('object', () => {
       const changes = await diff(a, b);
       const change = {
         a: findFirstChangeByPath(changes, 'Foo.a'),
-        b: findChangesByPath(changes, 'Foo.b')[1],
-        c: findChangesByPath(changes, 'Foo.c')[1],
+        b: findFirstChangeByPath(changes, 'Foo.b'),
+        c: findFirstChangeByPath(changes, 'Foo.c'),
       };
 
       // Changed
-      expect(change.a.criticality.level).toEqual(CriticalityLevel.NonBreaking);
       expect(change.a.type).toEqual('FIELD_DEPRECATION_REASON_CHANGED');
+      expect(change.a.criticality.level).toEqual(CriticalityLevel.NonBreaking);
       expect(change.a.message).toEqual(
         "Deprecation reason on field 'Foo.a' has changed from 'OLD' to 'NEW'",
       );
       // Removed
-      expect(change.b.criticality.level).toEqual(CriticalityLevel.NonBreaking);
-      expect(change.b.type).toEqual('FIELD_DEPRECATION_REASON_REMOVED');
-      expect(change.b.message).toEqual("Deprecation reason was removed from field 'Foo.b'");
+      expect(change.b.type).toEqual('FIELD_DEPRECATION_REMOVED');
+      expect(change.b.criticality.level).toEqual(CriticalityLevel.Dangerous);
+      expect(change.b.message).toEqual("Field 'Foo.b' is no longer deprecated");
       // Added
+      expect(change.c.type).toEqual('FIELD_DEPRECATION_ADDED');
       expect(change.c.criticality.level).toEqual(CriticalityLevel.NonBreaking);
-      expect(change.c.type).toEqual('FIELD_DEPRECATION_REASON_ADDED');
-      expect(change.c.message).toEqual("Field 'Foo.c' has deprecation reason 'CCC'");
+      expect(change.c.message).toEqual("Field 'Foo.c' is deprecated");
     });
 
     test('deprecation added / removed', async () => {

packages/core/__tests__/diff/schema.test.ts

@@ -1,6 +1,7 @@
 import { buildClientSchema, buildSchema, introspectionFromSchema } from 'graphql';
 import { Change, CriticalityLevel, diff } from '../../src/index.js';
 import { findBestMatch } from '../../src/utils/string.js';
+import { findChangesByPath, findFirstChangeByPath } from '../../utils/testing.js';
 
 test('same schema', async () => {
   const schemaA = buildSchema(/* GraphQL */ `
@@ -820,9 +821,9 @@ test('adding root type should not be breaking', async () => {
   `);
 
   const changes = await diff(schemaA, schemaB);
-  const subscription = changes[0];
+  expect(changes).toHaveLength(2);
 
-  expect(changes).toHaveLength(1);
+  const subscription = findFirstChangeByPath(changes, 'Subscription');
   expect(subscription).toBeDefined();
   expect(subscription!.criticality.level).toEqual(CriticalityLevel.NonBreaking);
 });