Detect uninhabitable input types formed by OneOf and non-OneOf cycles

Rework the circular references validation to detect input object types
that cannot be provided a finite value. This covers:

- Self-recursive OneOf types (e.g. input A @OneOf { a: A })
- Mixed OneOf/non-OneOf cycles with no escape path
- Standard non-null circular references (existing behavior preserved)

Rename algorithms to match spec terminology:
- InputObjectHasUnbreakableCycle (was InputObjectCanBeProvidedAFiniteValue)
- InputFieldTypeHasUnbreakableCycle (was FieldTypeCanBeProvidedAFiniteValue)

Author: jbellenger

src/type/__tests__/validation-test.ts

@@ -924,7 +924,7 @@ describe('Type System: Input Objects must have fields', () => {
     expectJSON(validateSchema(schema)).toDeepEqual([
       {
         message:
-          'Invalid circular reference. The Input Object SomeInputObject references itself in the non-null field SomeInputObject.nonNullSelf.',
+          'Input Object SomeInputObject references itself via the required fields: SomeInputObject.nonNullSelf.',
         locations: [{ line: 7, column: 9 }],
       },
     ]);
@@ -952,13 +952,31 @@ describe('Type System: Input Objects must have fields', () => {
     expectJSON(validateSchema(schema)).toDeepEqual([
       {
         message:
-          'Invalid circular reference. The Input Object SomeInputObject references itself via the non-null fields: SomeInputObject.startLoop, AnotherInputObject.nextInLoop, YetAnotherInputObject.closeLoop.',
+          'Input Object SomeInputObject references itself via the required fields: SomeInputObject.startLoop, AnotherInputObject.nextInLoop, YetAnotherInputObject.closeLoop.',
         locations: [
           { line: 7, column: 9 },
           { line: 11, column: 9 },
           { line: 15, column: 9 },
         ],
       },
+      {
+        message:
+          'Input Object AnotherInputObject references itself via the required fields: AnotherInputObject.nextInLoop, YetAnotherInputObject.closeLoop, SomeInputObject.startLoop.',
+        locations: [
+          { line: 11, column: 9 },
+          { line: 15, column: 9 },
+          { line: 7, column: 9 },
+        ],
+      },
+      {
+        message:
+          'Input Object YetAnotherInputObject references itself via the required fields: YetAnotherInputObject.closeLoop, SomeInputObject.startLoop, AnotherInputObject.nextInLoop.',
+        locations: [
+          { line: 15, column: 9 },
+          { line: 7, column: 9 },
+          { line: 11, column: 9 },
+        ],
+      },
     ]);
   });
 
@@ -986,24 +1004,28 @@ describe('Type System: Input Objects must have fields', () => {
     expectJSON(validateSchema(schema)).toDeepEqual([
       {
         message:
-          'Invalid circular reference. The Input Object SomeInputObject references itself via the non-null fields: SomeInputObject.startLoop, AnotherInputObject.closeLoop.',
+          'Input Object SomeInputObject references itself via the required fields: SomeInputObject.startLoop, AnotherInputObject.closeLoop.',
         locations: [
           { line: 7, column: 9 },
           { line: 11, column: 9 },
         ],
       },
       {
         message:
-          'Invalid circular reference. The Input Object AnotherInputObject references itself via the non-null fields: AnotherInputObject.startSecondLoop, YetAnotherInputObject.closeSecondLoop.',
+          'Input Object AnotherInputObject references itself via the required fields: AnotherInputObject.closeLoop, SomeInputObject.startLoop.',
         locations: [
-          { line: 12, column: 9 },
-          { line: 16, column: 9 },
+          { line: 11, column: 9 },
+          { line: 7, column: 9 },
         ],
       },
       {
         message:
-          'Invalid circular reference. The Input Object YetAnotherInputObject references itself in the non-null field YetAnotherInputObject.nonNullSelf.',
-        locations: [{ line: 17, column: 9 }],
+          'Input Object YetAnotherInputObject references itself via the required fields: YetAnotherInputObject.closeSecondLoop, AnotherInputObject.closeLoop, SomeInputObject.startLoop.',
+        locations: [
+          { line: 16, column: 9 },
+          { line: 11, column: 9 },
+          { line: 7, column: 9 },
+        ],
       },
     ]);
   });
@@ -2409,173 +2431,202 @@ describe('Type System: OneOf Input Object fields must be nullable', () => {
   });
 });
 
-describe('Type System: OneOf Input Objects must be inhabitable', () => {
+describe('Type System: Input Objects must not have unbreakable cycles', () => {
   it('accepts a OneOf Input Object with a scalar field', () => {
     const schema = buildSchema(`
       type Query {
-        test(arg: A): String
+        test(arg: A): Int
       }
 
       input A @oneOf {
-        a: String
-        b: Int
+        a: Int
       }
     `);
     expectJSON(validateSchema(schema)).toDeepEqual([]);
   });
 
-  it('accepts a OneOf Input Object with an enum field', () => {
+  it('accepts a OneOf Input Object with a recursive list field', () => {
     const schema = buildSchema(`
       type Query {
-        test(arg: A): String
+        test(arg: A): Int
       }
 
-      enum Color { RED GREEN BLUE }
-
       input A @oneOf {
-        a: Color
+        a: [A!]
       }
     `);
     expectJSON(validateSchema(schema)).toDeepEqual([]);
   });
 
-  it('accepts a OneOf Input Object with a list field', () => {
+  it('accepts a OneOf Input Object referencing a non-OneOf input object', () => {
     const schema = buildSchema(`
       type Query {
-        test(arg: A): String
+        test(arg: A): Int
       }
 
       input A @oneOf {
-        a: [A]
+        b: B
+      }
+
+      input B {
+        x: Int
       }
     `);
     expectJSON(validateSchema(schema)).toDeepEqual([]);
   });
 
-  it('accepts a OneOf Input Object referencing a non-OneOf input object', () => {
+  it('accepts a OneOf/OneOf cycle with a scalar escape', () => {
     const schema = buildSchema(`
       type Query {
-        test(arg: A): String
+        test(arg: A): Int
       }
 
       input A @oneOf {
-        a: RegularInput
+        b: B
+        escape: Int
       }
 
-      input RegularInput {
-        x: String
+      input B @oneOf {
+        a: A
       }
     `);
     expectJSON(validateSchema(schema)).toDeepEqual([]);
   });
 
-  it('accepts a OneOf Input Object with at least one escape field', () => {
+  it('accepts a OneOf/non-OneOf cycle with a nullable escape', () => {
     const schema = buildSchema(`
       type Query {
-        test(arg: A): String
+        test(arg: A): Int
       }
 
       input A @oneOf {
         b: B
-        escape: String
       }
 
-      input B @oneOf {
+      input B {
         a: A
       }
     `);
     expectJSON(validateSchema(schema)).toDeepEqual([]);
   });
 
-  it('accepts mutually referencing OneOf types where one has a scalar escape', () => {
+  it('rejects a self-referencing OneOf type with no escapes', () => {
     const schema = buildSchema(`
       type Query {
-        test(arg: A): String
+        test(arg: A): Int
       }
 
       input A @oneOf {
-        b: B
-      }
-
-      input B @oneOf {
-        a: A
-        escape: Int
+        self: A
       }
     `);
-    expectJSON(validateSchema(schema)).toDeepEqual([]);
+    expectJSON(validateSchema(schema)).toDeepEqual([
+      {
+        message:
+          'Input Object A references itself via the required fields: A.self.',
+        locations: [{ line: 7, column: 9 }],
+      },
+    ]);
   });
 
-  it('accepts a OneOf referencing a non-OneOf which references back', () => {
+  it('rejects a mixed OneOf/non-OneOf cycle with no escapes', () => {
     const schema = buildSchema(`
       type Query {
-        test(arg: A): String
+        test(arg: A): Int
       }
 
       input A @oneOf {
-        b: RegularInput
+        b: B
       }
 
-      input RegularInput {
-        back: A
+      input B {
+        a: A!
       }
     `);
-    expectJSON(validateSchema(schema)).toDeepEqual([]);
+    expectJSON(validateSchema(schema)).toDeepEqual([
+      {
+        message:
+          'Input Object A references itself via the required fields: A.b, B.a.',
+        locations: [
+          { line: 7, column: 9 },
+          { line: 11, column: 9 },
+        ],
+      },
+      {
+        message:
+          'Input Object B references itself via the required fields: B.a, A.b.',
+        locations: [
+          { line: 11, column: 9 },
+          { line: 7, column: 9 },
+        ],
+      },
+    ]);
   });
 
-  it('accepts a OneOf with multiple fields where one escapes through chained OneOf types', () => {
+  it('accepts a OneOf/non-OneOf with scalar escape', () => {
     const schema = buildSchema(`
       type Query {
-        test(arg: A): String
+        test(arg: A): Int
       }
 
       input A @oneOf {
         b: B
-        c: C
+        escape: Int
       }
 
-      input B @oneOf {
-        a: A
+      input B {
+        a: A!
       }
+    `);
+    expectJSON(validateSchema(schema)).toDeepEqual([]);
+  });
 
-      input C @oneOf {
+  it('accepts a non-OneOf/non-OneOf cycle with a nullable escape', () => {
+    const schema = buildSchema(`
+      type Query {
+        test(arg: A): Int
+      }
+
+      input A {
+        b: B!
+      }
+
+      input B {
         a: A
-        escape: String
       }
     `);
     expectJSON(validateSchema(schema)).toDeepEqual([]);
   });
 
-  it('rejects a closed subgraph of one OneOf type', () => {
+  it('accepts a non-OneOf/non-OneOf cycle with a list escape', () => {
     const schema = buildSchema(`
       type Query {
-        test(arg: A): String
+        test(arg: A): Int
       }
 
-      input A @oneOf {
-        self: A
+      input A {
+        b: [B!]!
+      }
+
+      input B {
+        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 }],
-      },
-    ]);
+    expectJSON(validateSchema(schema)).toDeepEqual([]);
   });
 
-  it('rejects a closed subgraph of multiple OneOf types', () => {
+  it('rejects a larger mixed OneOf/non-OneOf cycle with no escapes', () => {
     const schema = buildSchema(`
       type Query {
-        test(arg: A): String
+        test(arg: A): Int
       }
 
       input A @oneOf {
         b: B
       }
 
-      input B @oneOf {
-        c: C
+      input B {
+        c: C!
       }
 
       input C @oneOf {
@@ -2585,18 +2636,30 @@ describe('Type System: OneOf Input Objects must be inhabitable', () => {
     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 }],
+          'Input Object A references itself via the required fields: A.b, B.c, C.a.',
+        locations: [
+          { line: 7, column: 9 },
+          { line: 11, column: 9 },
+          { line: 15, column: 9 },
+        ],
       },
       {
         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 }],
+          'Input Object B references itself via the required fields: B.c, C.a, A.b.',
+        locations: [
+          { line: 11, column: 9 },
+          { line: 15, column: 9 },
+          { line: 7, column: 9 },
+        ],
       },
       {
         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 }],
+          'Input Object C references itself via the required fields: C.a, A.b, B.c.',
+        locations: [
+          { line: 15, column: 9 },
+          { line: 7, column: 9 },
+          { line: 11, column: 9 },
+        ],
       },
     ]);
   });