Adds safeUnreachable rule

Author: kamilkisiela

CHANGELOG.md

@@ -5,6 +5,7 @@
 - **core**: BREAKING CHANGE - `diff` is now async
 - **github**: BREAKING CHANGE - `experimental_merge` is now enabled by default
 - **core**: Adds `considerUsage` rule
+- **core**: Adds `safeUnreachable` rule
 - **core**: Fixes missing names of default root types
 - **cli**, **ci**: Adds `@aws_lambda` directive
 - **cli**, **ci**: Fixes missing headers in diff command

packages/core/__tests__/diff/rules/safe-unreachable.ts

@@ -0,0 +1,79 @@
+import {buildSchema} from 'graphql';
+
+import {diff, CriticalityLevel} from '../../../src/index';
+import {findFirstChangeByPath} from '../../../utils/testing';
+import {safeUnreachable} from '../../../src/diff/rules/safe-unreachable';
+
+describe('safeUnreachable rule', () => {
+  test('removed field', async () => {
+    const a = buildSchema(/* GraphQL */ `
+      type Foo {
+        a: String!
+      }
+
+      type Bar {
+        a: String
+        b: String
+      }
+    `);
+    const b = buildSchema(/* GraphQL */ `
+      type Foo {
+        a: String!
+      }
+
+      type Bar {
+        a: String
+      }
+    `);
+
+    const changes = await diff(a, b, [safeUnreachable]);
+    const removed = findFirstChangeByPath(changes, 'Bar.b');
+
+    expect(removed.criticality.level).toBe(CriticalityLevel.NonBreaking);
+    expect(removed.message).toContain(`Unreachable from root`);
+  });
+
+  test('removed type', async () => {
+    const a = buildSchema(/* GraphQL */ `
+      type Query {
+        bar: String!
+      }
+
+      type Foo {
+        a: String!
+      }
+    `);
+    const b = buildSchema(/* GraphQL */ `
+      type Query {
+        bar: String!
+      }
+    `);
+
+    const changes = await diff(a, b, [safeUnreachable]);
+    const removed = findFirstChangeByPath(changes, 'Foo');
+
+    expect(removed.criticality.level).toBe(CriticalityLevel.NonBreaking);
+    expect(removed.message).toContain(`Unreachable from root`);
+  });
+
+  test('removed scalar', async () => {
+    const a = buildSchema(/* GraphQL */ `
+      type Query {
+        bar: String!
+      }
+
+      scalar JSON
+    `);
+    const b = buildSchema(/* GraphQL */ `
+      type Query {
+        bar: String!
+      }
+    `);
+
+    const changes = await diff(a, b, [safeUnreachable]);
+    const removed = findFirstChangeByPath(changes, 'JSON');
+
+    expect(removed.criticality.level).toBe(CriticalityLevel.NonBreaking);
+    expect(removed.message).toContain(`Unreachable from root`);
+  });
+});

packages/core/src/diff/rules/safe-unreachable.ts

@@ -0,0 +1,27 @@
+import {CriticalityLevel} from './../changes/change';
+import {Rule} from './types';
+import {parsePath} from '../../utils/path';
+import {getReachableTypes} from '../../utils/graphql';
+
+export const safeUnreachable: Rule = ({changes, oldSchema}) => {
+  const reachable = getReachableTypes(oldSchema);
+
+  return changes.map((change) => {
+    if (change.criticality.level === CriticalityLevel.Breaking && change.path) {
+      const [typeName] = parsePath(change.path);
+
+      if (!reachable.has(typeName)) {
+        return {
+          ...change,
+          criticality: {
+            ...change.criticality,
+            level: CriticalityLevel.NonBreaking,
+          },
+          message: "Unreachable from root"
+        };
+      }
+    }
+
+    return change;
+  });
+};

packages/core/src/utils/graphql.ts

@@ -15,6 +15,17 @@ import {
   visitWithTypeInfo,
   getNamedType,
   FieldNode,
+  isInterfaceType,
+  isScalarType,
+  isObjectType,
+  isUnionType,
+  isInputObjectType,
+  GraphQLScalarType,
+  GraphQLInterfaceType,
+  GraphQLObjectType,
+  GraphQLUnionType,
+  GraphQLEnumType,
+  GraphQLInputObjectType,
 } from 'graphql';
 
 export function safeChangeForField(
@@ -119,19 +130,19 @@ export function findDeprecatedUsages(
       Argument(node) {
         const argument = typeInfo.getArgument();
         if (argument) {
-        const reason = argument.deprecationReason;
-        if (reason) {
-          const fieldDef = typeInfo.getFieldDef();
-          if (fieldDef) {
-            errors.push(
-              new GraphQLError(
-                `The argument '${argument?.name}' of '${fieldDef.name}' is deprecated. ${reason}`,
-                [node],
-              ),
-            );
+          const reason = argument.deprecationReason;
+          if (reason) {
+            const fieldDef = typeInfo.getFieldDef();
+            if (fieldDef) {
+              errors.push(
+                new GraphQLError(
+                  `The argument '${argument?.name}' of '${fieldDef.name}' is deprecated. ${reason}`,
+                  [node],
+                ),
+              );
+            }
           }
         }
-        }
       },
       Field(node) {
         const fieldDef = typeInfo.getFieldDef();
@@ -203,3 +214,98 @@ export function removeDirectives(
 
   return node;
 }
+
+export function getReachableTypes(schema: GraphQLSchema): Set<string> {
+  const reachableTypes = new Set<string>();
+
+  const collect = (type: GraphQLNamedType): false | void => {
+    const typeName = type.name;
+
+    if (reachableTypes.has(typeName)) {
+      return;
+    }
+
+    reachableTypes.add(typeName);
+
+    if (isScalarType(type)) {
+      return;
+    } else if (isInterfaceType(type) || isObjectType(type)) {
+      if (isInterfaceType(type)) {
+        const {objects, interfaces} = schema.getImplementations(type);
+
+        for (const child of objects) {
+          collect(child);
+        }
+
+        for (const child of interfaces) {
+          collect(child);
+        }
+      }
+
+      const fields = type.getFields();
+
+      for (const fieldName in fields) {
+        const field = fields[fieldName];
+
+        collect(resolveOutputType(field.type));
+
+        const args = field.args;
+
+        for (const argName in args) {
+          const arg = args[argName];
+
+          collect(resolveInputType(arg.type));
+        }
+      }
+    } else if (isUnionType(type)) {
+      const types = type.getTypes();
+      for (const child of types) {
+        collect(child);
+      }
+    } else if (isInputObjectType(type)) {
+      const fields = type.getFields();
+      for (const fieldName in fields) {
+        const field = fields[fieldName];
+
+        collect(resolveInputType(field.type));
+      }
+    }
+  };
+
+  for (const type of [
+    schema.getQueryType(),
+    schema.getMutationType(),
+    schema.getSubscriptionType(),
+  ]) {
+    if (type) {
+      collect(type);
+    }
+  }
+
+  return reachableTypes;
+}
+
+function resolveOutputType(
+  output: GraphQLOutputType,
+):
+  | GraphQLScalarType
+  | GraphQLObjectType
+  | GraphQLInterfaceType
+  | GraphQLUnionType
+  | GraphQLEnumType {
+  if (isListType(output) || isNonNullType(output)) {
+    return resolveOutputType(output.ofType);
+  }
+
+  return output;
+}
+
+function resolveInputType(
+  input: GraphQLInputType,
+): GraphQLScalarType | GraphQLEnumType | GraphQLInputObjectType {
+  if (isListType(input) || isNonNullType(input)) {
+    return resolveInputType(input.ofType);
+  }
+
+  return input;
+}

website/docs/essentials/diff.md

@@ -96,6 +96,27 @@ Changes of descriptions are filtered out and are not displayed in the CLI result
 
     graphql-inspector diff https://api.com/graphql schema.graphql --rule ignoreDescriptionChanges
 
+**safeUnreachable**
+
+Breaking changes done on unreachable parts of schema (non-accessible when starting from the root types) won't be marked as breaking.
+
+    graphql-inspector diff https://api.com/graphql schema.graphql --rule safeUnreachable
+
+Example of unreachable type:
+
+```graphql
+type Query {
+  me: String
+}
+
+"""
+User can't be requested, it's unreachable
+"""
+type User {
+  id: ID!
+}
+```
+
 **considerUsage**
 
 Decides if a breaking change are in fact breaking, based on real usage of schema.