Add __Type.oneOf

This exposes a new boolean `oneOf` field on `__Type` that indicates if
a type is `oneOf`. We implement by checking if the AST node for the
object contains a `@oneOf` directive.

Author: erikkessler1

src/type/__tests__/introspection-test.ts

@@ -372,6 +372,17 @@ describe('Introspection', () => {
                   isDeprecated: false,
                   deprecationReason: null,
                 },
+                {
+                  name: 'oneOf',
+                  args: [],
+                  type: {
+                    kind: 'SCALAR',
+                    name: 'Boolean',
+                    ofType: null,
+                  },
+                  isDeprecated: false,
+                  deprecationReason: null,
+                },
               ],
               inputFields: null,
               interfaces: [],
@@ -1525,6 +1536,84 @@ describe('Introspection', () => {
     });
   });
 
+  it('identifies oneOf for objects', () => {
+    const schema = buildSchema(`
+      type SomeObject @oneOf {
+        a: String
+      }
+
+      type AnotherObject {
+        a: String
+        b: String
+      }
+
+      type Query {
+        someField: String
+      }
+    `);
+
+    const source = `
+      {
+        a: __type(name: "SomeObject") {
+          oneOf
+        }
+        b: __type(name: "AnotherObject") {
+          oneOf
+        }
+      }
+    `;
+
+    expect(graphqlSync({ schema, source })).to.deep.equal({
+      data: {
+        a: {
+          oneOf: true,
+        },
+        b: {
+          oneOf: false,
+        },
+      },
+    });
+  });
+
+  it('identifies oneOf for input objects', () => {
+    const schema = buildSchema(`
+      input SomeInputObject @oneOf {
+        a: String
+      }
+
+      input AnotherInputObject {
+        a: String
+        b: String
+      }
+
+      type Query {
+        someField(someArg: SomeInputObject): String
+      }
+    `);
+
+    const source = `
+      {
+        a: __type(name: "SomeInputObject") {
+          oneOf
+        }
+        b: __type(name: "AnotherInputObject") {
+          oneOf
+        }
+      }
+    `;
+
+    expect(graphqlSync({ schema, source })).to.deep.equal({
+      data: {
+        a: {
+          oneOf: true,
+        },
+        b: {
+          oneOf: false,
+        },
+      },
+    });
+  });
+
   it('fails as expected on the __type root field without an arg', () => {
     const schema = buildSchema(`
       type Query {

src/type/definition.ts

@@ -763,6 +763,7 @@ export class GraphQLObjectType<TSource = any, TContext = any> {
   extensions: Readonly<GraphQLObjectTypeExtensions<TSource, TContext>>;
   astNode: Maybe<ObjectTypeDefinitionNode>;
   extensionASTNodes: ReadonlyArray<ObjectTypeExtensionNode>;
+  isOneOf: boolean;
 
   private _fields: ThunkObjMap<GraphQLField<TSource, TContext>>;
   private _interfaces: ThunkReadonlyArray<GraphQLInterfaceType>;
@@ -774,6 +775,7 @@ export class GraphQLObjectType<TSource = any, TContext = any> {
     this.extensions = toObjMap(config.extensions);
     this.astNode = config.astNode;
     this.extensionASTNodes = config.extensionASTNodes ?? [];
+    this.isOneOf = config.isOneOf ?? false;
 
     this._fields = () => defineFieldMap(config);
     this._interfaces = () => defineInterfaces(config);
@@ -942,6 +944,7 @@ export interface GraphQLObjectTypeConfig<TSource, TContext> {
   extensions?: Maybe<Readonly<GraphQLObjectTypeExtensions<TSource, TContext>>>;
   astNode?: Maybe<ObjectTypeDefinitionNode>;
   extensionASTNodes?: Maybe<ReadonlyArray<ObjectTypeExtensionNode>>;
+  isOneOf?: boolean;
 }
 
 interface GraphQLObjectTypeNormalizedConfig<TSource, TContext>
@@ -1611,6 +1614,7 @@ export class GraphQLInputObjectType {
   extensions: Readonly<GraphQLInputObjectTypeExtensions>;
   astNode: Maybe<InputObjectTypeDefinitionNode>;
   extensionASTNodes: ReadonlyArray<InputObjectTypeExtensionNode>;
+  isOneOf: boolean;
 
   private _fields: ThunkObjMap<GraphQLInputField>;
 
@@ -1620,6 +1624,7 @@ export class GraphQLInputObjectType {
     this.extensions = toObjMap(config.extensions);
     this.astNode = config.astNode;
     this.extensionASTNodes = config.extensionASTNodes ?? [];
+    this.isOneOf = config.isOneOf ?? false;
 
     this._fields = defineInputFieldMap.bind(undefined, config);
   }
@@ -1652,6 +1657,7 @@ export class GraphQLInputObjectType {
       extensions: this.extensions,
       astNode: this.astNode,
       extensionASTNodes: this.extensionASTNodes,
+      isOneOf: this.isOneOf,
     };
   }
 
@@ -1697,6 +1703,7 @@ export interface GraphQLInputObjectTypeConfig {
   extensions?: Maybe<Readonly<GraphQLInputObjectTypeExtensions>>;
   astNode?: Maybe<InputObjectTypeDefinitionNode>;
   extensionASTNodes?: Maybe<ReadonlyArray<InputObjectTypeExtensionNode>>;
+  isOneOf?: boolean;
 }
 
 interface GraphQLInputObjectTypeNormalizedConfig

src/type/introspection.ts

@@ -323,6 +323,16 @@ export const __Type: GraphQLObjectType = new GraphQLObjectType({
         type: __Type,
         resolve: (type) => ('ofType' in type ? type.ofType : undefined),
       },
+      oneOf: {
+        type: GraphQLBoolean,
+        resolve: (type) => {
+          if (isInputObjectType(type) || isObjectType(type)) {
+            return type.isOneOf;
+          }
+
+          return null;
+        },
+      },
     } as GraphQLFieldConfigMap<GraphQLType, unknown>),
 });
 

src/utilities/__tests__/printSchema-test.ts

@@ -703,6 +703,7 @@ describe('Type System Printer', () => {
         enumValues(includeDeprecated: Boolean = false): [__EnumValue!]
         inputFields(includeDeprecated: Boolean = false): [__InputValue!]
         ofType: __Type
+        oneOf: Boolean
       }
 
       """An enum describing what kind of type a given \`__Type\` is."""

src/utilities/extendSchema.ts

@@ -66,6 +66,7 @@ import {
 import {
   GraphQLDeprecatedDirective,
   GraphQLDirective,
+  GraphQLOneOfDirective,
   GraphQLSpecifiedByDirective,
 } from '../type/directives';
 import { introspectionTypes, isIntrospectionType } from '../type/introspection';
@@ -592,6 +593,7 @@ export function extendSchemaImpl(
           fields: () => buildFieldMap(allNodes),
           astNode,
           extensionASTNodes,
+          isOneOf: isOneOf(astNode),
         });
       }
       case Kind.INTERFACE_TYPE_DEFINITION: {
@@ -646,6 +648,7 @@ export function extendSchemaImpl(
           fields: () => buildInputFieldMap(allNodes),
           astNode,
           extensionASTNodes,
+          isOneOf: isOneOf(astNode),
         });
       }
     }
@@ -682,3 +685,12 @@ function getSpecifiedByURL(
   // @ts-expect-error validated by `getDirectiveValues`
   return specifiedBy?.url;
 }
+
+/**
+ * Given an input object node, returns if the node should be OneOf.
+ */
+function isOneOf(
+  node: InputObjectTypeDefinitionNode | ObjectTypeDefinitionNode,
+): boolean {
+  return Boolean(getDirectiveValues(GraphQLOneOfDirective, node));
+}