check oneof inhabitability

Author: jbellenger

src/type/__tests__/validation-test.ts

@@ -2409,6 +2409,199 @@ describe('Type System: OneOf Input Object fields must be nullable', () => {
   });
 });
 
+describe('Type System: OneOf Input Objects must be inhabitable', () => {
+  it('accepts a OneOf Input Object with a scalar field', () => {
+    const schema = buildSchema(`
+      type Query {
+        test(arg: A): String
+      }
+
+      input A @oneOf {
+        a: String
+        b: Int
+      }
+    `);
+    expectJSON(validateSchema(schema)).toDeepEqual([]);
+  });
+
+  it('accepts a OneOf Input Object with an enum field', () => {
+    const schema = buildSchema(`
+      type Query {
+        test(arg: A): String
+      }
+
+      enum Color { RED GREEN BLUE }
+
+      input A @oneOf {
+        a: Color
+      }
+    `);
+    expectJSON(validateSchema(schema)).toDeepEqual([]);
+  });
+
+  it('accepts a OneOf Input Object with a list field', () => {
+    const schema = buildSchema(`
+      type Query {
+        test(arg: A): String
+      }
+
+      input A @oneOf {
+        a: [A]
+      }
+    `);
+    expectJSON(validateSchema(schema)).toDeepEqual([]);
+  });
+
+  it('accepts a OneOf Input Object referencing a non-OneOf input object', () => {
+    const schema = buildSchema(`
+      type Query {
+        test(arg: A): String
+      }
+
+      input A @oneOf {
+        a: RegularInput
+      }
+
+      input RegularInput {
+        x: String
+      }
+    `);
+    expectJSON(validateSchema(schema)).toDeepEqual([]);
+  });
+
+  it('accepts a OneOf Input Object with at least one escape field', () => {
+    const schema = buildSchema(`
+      type Query {
+        test(arg: A): String
+      }
+
+      input A @oneOf {
+        b: B
+        escape: String
+      }
+
+      input B @oneOf {
+        a: A
+      }
+    `);
+    expectJSON(validateSchema(schema)).toDeepEqual([]);
+  });
+
+  it('accepts mutually referencing OneOf types where one has a scalar escape', () => {
+    const schema = buildSchema(`
+      type Query {
+        test(arg: A): String
+      }
+
+      input A @oneOf {
+        b: B
+      }
+
+      input B @oneOf {
+        a: A
+        escape: Int
+      }
+    `);
+    expectJSON(validateSchema(schema)).toDeepEqual([]);
+  });
+
+  it('accepts a OneOf referencing a non-OneOf which references back', () => {
+    const schema = buildSchema(`
+      type Query {
+        test(arg: A): String
+      }
+
+      input A @oneOf {
+        b: RegularInput
+      }
+
+      input RegularInput {
+        back: A
+      }
+    `);
+    expectJSON(validateSchema(schema)).toDeepEqual([]);
+  });
+
+  it('accepts a OneOf with multiple fields where one escapes through chained OneOf types', () => {
+    const schema = buildSchema(`
+      type Query {
+        test(arg: A): String
+      }
+
+      input A @oneOf {
+        b: B
+        c: C
+      }
+
+      input B @oneOf {
+        a: A
+      }
+
+      input C @oneOf {
+        a: A
+        escape: String
+      }
+    `);
+    expectJSON(validateSchema(schema)).toDeepEqual([]);
+  });
+
+  it('rejects a closed subgraph of one OneOf type', () => {
+    const schema = buildSchema(`
+      type Query {
+        test(arg: A): String
+      }
+
+      input A @oneOf {
+        self: A
+      }
+    `);
+    expectJSON(validateSchema(schema)).toDeepEqual([
+      {
+        message:
+          'OneOf Input Object A must be inhabitable but all fields recursively reference only other OneOf Input Objects forming an unresolvable cycle.',
+        locations: [{ line: 6, column: 7 }],
+      },
+    ]);
+  });
+
+  it('rejects a closed subgraph of multiple OneOf types', () => {
+    const schema = buildSchema(`
+      type Query {
+        test(arg: A): String
+      }
+
+      input A @oneOf {
+        b: B
+      }
+
+      input B @oneOf {
+        c: C
+      }
+
+      input C @oneOf {
+        a: A
+      }
+    `);
+    expectJSON(validateSchema(schema)).toDeepEqual([
+      {
+        message:
+          'OneOf Input Object A must be inhabitable but all fields recursively reference only other OneOf Input Objects forming an unresolvable cycle.',
+        locations: [{ line: 6, column: 7 }],
+      },
+      {
+        message:
+          'OneOf Input Object B must be inhabitable but all fields recursively reference only other OneOf Input Objects forming an unresolvable cycle.',
+        locations: [{ line: 10, column: 7 }],
+      },
+      {
+        message:
+          'OneOf Input Object C must be inhabitable but all fields recursively reference only other OneOf Input Objects forming an unresolvable cycle.',
+        locations: [{ line: 14, column: 7 }],
+      },
+    ]);
+  });
+});
+
 describe('Objects must adhere to Interface they implement', () => {
   it('accepts an Object which implements an Interface', () => {
     const schema = buildSchema(`

src/type/validate.ts

@@ -365,6 +365,8 @@ function validateTypes(context: SchemaValidationContext): void {
     createInputObjectNonNullCircularRefsValidator(context);
   const validateInputObjectDefaultValueCircularRefs =
     createInputObjectDefaultValueCircularRefsValidator(context);
+  const validateOneOfInputObjectInhabitability =
+    createOneOfInputObjectInhabitabilityValidator(context);
   const typeMap = context.schema.getTypeMap();
   for (const type of Object.values(typeMap)) {
     // Ensure all provided types are in fact GraphQL type.
@@ -409,6 +411,11 @@ function validateTypes(context: SchemaValidationContext): void {
 
       // Ensure Input Objects do not contain invalid default value circular references.
       validateInputObjectDefaultValueCircularRefs(type);
+
+      // Ensure OneOf Input Objects are inhabitable.
+      if (type.isOneOf) {
+        validateOneOfInputObjectInhabitability(type);
+      }
     }
   }
 }
@@ -943,6 +950,64 @@ function createInputObjectDefaultValueCircularRefsValidator(
   }
 }
 
+function createOneOfInputObjectInhabitabilityValidator(
+  context: SchemaValidationContext,
+): (inputObj: GraphQLInputObjectType) => void {
+  // Tracks already validated types to maintain O(N) across top-level calls.
+  const visitedTypes = new Set<GraphQLInputObjectType>();
+
+  return function validateOneOfInputObjectInhabitability(
+    inputObj: GraphQLInputObjectType,
+  ): void {
+    if (visitedTypes.has(inputObj)) {
+      return;
+    }
+
+    if (!isInhabitable(inputObj, new Set())) {
+      context.reportError(
+        `OneOf Input Object ${inputObj} must be inhabitable but all fields recursively reference only other OneOf Input Objects forming an unresolvable cycle.`,
+        inputObj.astNode,
+      );
+    }
+
+    visitedTypes.add(inputObj);
+  };
+
+  function isInhabitable(
+    inputObj: GraphQLInputObjectType,
+    visited: ReadonlySet<GraphQLInputObjectType>,
+  ): boolean {
+    if (visited.has(inputObj)) {
+      return false;
+    }
+
+    const nextVisited = new Set(visited);
+    nextVisited.add(inputObj);
+
+    for (const field of Object.values(inputObj.getFields())) {
+      if (isListType(field.type)) {
+        return true;
+      }
+
+      const namedType = getNamedType(field.type);
+
+      if (!isInputObjectType(namedType)) {
+        return true;
+      }
+
+      if (!namedType.isOneOf) {
+        return true;
+      }
+
+      if (isInhabitable(namedType, nextVisited)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+}
+
 function getAllImplementsInterfaceNodes(
   type: GraphQLObjectType | GraphQLInterfaceType,
   iface: GraphQLInterfaceType,