fix(schema): fix schema crashing when type implements interface field.

Author: Mayank1791989

src/schema/SchemaBuilder/GQLSchema.js

@@ -11,20 +11,13 @@ import {
   GraphQLObjectType,
 } from 'graphql/type/definition';
 
-import {
-  type TypeDefinitionNode,
-  type ASTNode,
-} from 'graphql/language/ast';
+import { type TypeDefinitionNode, type ASTNode } from 'graphql/language/ast';
 
 import { specifiedDirectives } from 'graphql/type/directives';
 import find from 'graphql/jsutils/find';
 import invariant from 'graphql/jsutils/invariant';
 import { isEqualType, isTypeSubTypeOf } from 'graphql/utilities/typeComparators';
-import {
-  type GQLError,
-  SEVERITY,
-  newGQLError,
-} from '../../shared/GQLError';
+import { type GQLError, SEVERITY, newGQLError } from '../../shared/GQLError';
 import { PLACEHOLDER_TYPES } from './PlaceholderTypes';
 import getNamedTypeNode from './getNamedTypeNode';
 
@@ -73,7 +66,9 @@ export default class _GQLSchema {
 
     // create typeMap and implementations map
     types.forEach((type) => {
-      if (type) { this._typeMap[type.name] = type; }
+      if (type) {
+        this._typeMap[type.name] = type;
+      }
       // // NOTE: dont remove type.getFields()
       // // calling to resolve thunks which will add more errors
       // // also wrapping in try catch to suppress errors thrown inside getFields function
@@ -82,16 +77,12 @@ export default class _GQLSchema {
         try {
           // $FlowDisableNextLine
           type.getFields(); // resolve thunk
-        } catch (e) { } // eslint-disable-line no-empty
+        } catch (e) {} // eslint-disable-line no-empty
       }
 
       if (type instanceof GQLObjectType) {
         const _type = type;
         type.getInterfaces().forEach((iface) => {
-          this._errors.push(
-            // eslint-disable-next-line no-use-before-define
-            ...assertObjectImplementsInterface((this: any), _type, iface),
-          );
           const impls = this._implementations[iface.name];
           if (impls) {
             impls.push(_type);
@@ -101,6 +92,19 @@ export default class _GQLSchema {
         });
       }
     });
+
+    // validate GQLObjectType correctly implements interfaces
+    Object.keys(this._typeMap).forEach((typeName) => {
+      const type = this._typeMap[typeName];
+      if (type instanceof GQLObjectType) {
+        type.getInterfaces().forEach((iface) => {
+          this._errors.push(
+            // eslint-disable-next-line no-use-before-define
+            ...assertObjectImplementsInterface((this: any), type, iface),
+          );
+        });
+      }
+    });
   }
 
   getQueryType(): ?GQLObjectType {
@@ -143,10 +147,7 @@ export default class _GQLSchema {
     return (this._implementations[abstractType.name]: any);
   }
 
-  isPossibleType(
-    abstractType: GraphQLAbstractType,
-    possibleType: GraphQLObjectType,
-  ): boolean {
+  isPossibleType(abstractType: GraphQLAbstractType, possibleType: GraphQLObjectType): boolean {
     let possibleTypeMap = this._possibleTypeMap;
     if (!possibleTypeMap) {
       possibleTypeMap = Object.create(null);
@@ -158,14 +159,13 @@ export default class _GQLSchema {
       invariant(
         Array.isArray(possibleTypes),
         `Could not find possible implementing types for ${abstractType.name} ` +
-        'in schema. Check that schema.types is defined and is an array of ' +
-        'all possible types in the schema.',
+          'in schema. Check that schema.types is defined and is an array of ' +
+          'all possible types in the schema.',
+      );
+      possibleTypeMap[abstractType.name] = possibleTypes.reduce(
+        (map, type) => ((map[type.name] = true), map), // eslint-disable-line
+        Object.create(null),
       );
-      possibleTypeMap[abstractType.name] =
-        possibleTypes.reduce(
-          (map, type) => ((map[type.name] = true), map), // eslint-disable-line
-          Object.create(null),
-        );
     }
 
     return Boolean(possibleTypeMap[abstractType.name][possibleType.name]);
@@ -209,13 +209,15 @@ function assertObjectImplementsInterface(
     // Assert interface field type is satisfied by object field type, by being
     // a valid subtype. (covariant)
     if (!isTypeSubTypeOf((schema: any), (objectField.type: any), (ifaceField.type: any))) {
-      errors.push(newGQLError(
-        `${iface.name}.${fieldName} expects type "${String(ifaceField.type)}" ` +
-        'but ' +
-        `${object.name}.${fieldName} provides type "${String(objectField.type)}".`,
-        [getNamedTypeNode(objectField.node.type)],
-        SEVERITY.error,
-      ));
+      errors.push(
+        newGQLError(
+          `${iface.name}.${fieldName} expects type "${String(ifaceField.type)}" ` +
+            'but ' +
+            `${object.name}.${fieldName} provides type "${String(objectField.type)}".`,
+          [getNamedTypeNode(objectField.node.type)],
+          SEVERITY.error,
+        ),
+      );
     }
 
     // Assert each interface field arg is implemented.
@@ -225,26 +227,30 @@ function assertObjectImplementsInterface(
 
       // Assert interface field arg exists on object field.
       if (!objectArg) {
-        errors.push(newGQLError(
-          `${iface.name}.${fieldName} expects argument "${argName}" but ` +
-          `${object.name}.${fieldName} does not provide it.`,
-          [objectField.node],
-          SEVERITY.error,
-        ));
+        errors.push(
+          newGQLError(
+            `${iface.name}.${fieldName} expects argument "${argName}" but ` +
+              `${object.name}.${fieldName} does not provide it.`,
+            [objectField.node],
+            SEVERITY.error,
+          ),
+        );
         return;
       }
 
       // Assert interface field arg type matches object field arg type.
       // (invariant)
       if (!isEqualType((ifaceArg.type: any), (objectArg.type: any))) {
-        errors.push(newGQLError(
-          `${iface.name}.${fieldName}(${argName}:) expects type ` +
-          `"${String(ifaceArg.type)}" but ` +
-          `${object.name}.${fieldName}(${argName}:) provides type ` +
-          `"${String(objectArg.type)}".`,
-          [getNamedTypeNode(objectArg.node.type)],
-          SEVERITY.error,
-        ));
+        errors.push(
+          newGQLError(
+            `${iface.name}.${fieldName}(${argName}:) expects type ` +
+              `"${String(ifaceArg.type)}" but ` +
+              `${object.name}.${fieldName}(${argName}:) provides type ` +
+              `"${String(objectArg.type)}".`,
+            [getNamedTypeNode(objectArg.node.type)],
+            SEVERITY.error,
+          ),
+        );
       }
     });
 
@@ -253,23 +259,27 @@ function assertObjectImplementsInterface(
       const argName = objectArg.name;
       const ifaceArg = find(ifaceField.args, (arg) => arg.name === argName);
       if (!ifaceArg && objectArg.type instanceof GraphQLNonNull) {
-        errors.push(newGQLError(
-          `${object.name}.${fieldName}(${argName}:) is of required type ` +
-          `"${String(objectArg.type)}" but is not also provided by the ` +
-          `interface ${iface.name}.${fieldName}.`,
-          [objectArg.node],
-          SEVERITY.error,
-        ));
+        errors.push(
+          newGQLError(
+            `${object.name}.${fieldName}(${argName}:) is of required type ` +
+              `"${String(objectArg.type)}" but is not also provided by the ` +
+              `interface ${iface.name}.${fieldName}.`,
+            [objectArg.node],
+            SEVERITY.error,
+          ),
+        );
       }
     });
   });
 
   if (missingFields.length > 0) {
-    errors.push(newGQLError(
-      `Missing interface fields [${missingFields.map((field) => field.name).join(', ')}]`,
-      [object.node],
-      SEVERITY.error,
-    ));
+    errors.push(
+      newGQLError(
+        `Missing interface fields [${missingFields.map((field) => field.name).join(', ')}]`,
+        [object.node],
+        SEVERITY.error,
+      ),
+    );
   }
 
   return errors;