always include nullable outer most input type (#176)

see: #174

.changeset/quick-pans-tan.md

@@ -0,0 +1,9 @@
+---
+'graphql-executor': patch
+---
+
+Always include nullable outermost input type within schema
+
+Because variables could include a default value.
+
+See https://github.com/yaacovCR/graphql-executor/issues/174 for more details.

src/executorSchema/__tests__/toExecutorSchema-test.ts

@@ -2,14 +2,15 @@ import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
 import type {
-  GraphQLNonNull,
   ListTypeNode,
   NamedTypeNode,
   NonNullTypeNode,
+  TypeNode,
 } from 'graphql';
 import {
   GraphQLList,
   GraphQLInputObjectType,
+  GraphQLNonNull,
   GraphQLObjectType,
   GraphQLSchema,
   GraphQLString,
@@ -27,6 +28,16 @@ describe('ExecutorSchema:', () => {
       },
     },
   });
+  const nonNullableInput = new GraphQLNonNull(
+    new GraphQLInputObjectType({
+      name: 'AnotherInput',
+      fields: {
+        inputField: {
+          type: GraphQLString,
+        },
+      },
+    }),
+  );
   const query = new GraphQLObjectType({
     name: 'Query',
     fields: {
@@ -38,6 +49,14 @@ describe('ExecutorSchema:', () => {
           },
         },
       },
+      fieldWithNonNullInputArg: {
+        type: GraphQLString,
+        args: {
+          arg: {
+            type: nonNullableInput,
+          },
+        },
+      },
       fieldWithListInputArg: {
         type: GraphQLString,
         args: {
@@ -102,6 +121,21 @@ describe('ExecutorSchema:', () => {
     expect((type as GraphQLNonNull<any>).ofType).to.equal(input);
   });
 
+  it('allows retrieving non-nullable input types defined in schema when unwrapped', () => {
+    const executorSchema = toExecutorSchema(schema);
+    const nullableTypeNode: TypeNode = {
+      kind: Kind.NAMED_TYPE,
+      name: {
+        kind: Kind.NAME,
+        value: 'AnotherInput',
+      },
+    };
+    const type = executorSchema.getType(nullableTypeNode);
+    expect(type).to.equal(nonNullableInput.ofType);
+    expect(executorSchema.isNonNullType(type)).to.equal(false);
+    expect(executorSchema.isInputType(type)).to.equal(true);
+  });
+
   it('allows retrieving list input types defined in schema', () => {
     const executorSchema = toExecutorSchema(schema);
     const listTypeNode: ListTypeNode = {

src/executorSchema/getPossibleInputTypes.ts

@@ -87,10 +87,17 @@ export function getPossibleInputTypes(
   isNonNullType: (type: unknown) => type is GraphQLNonNull<any>,
   type: GraphQLInputType,
 ): Array<GraphQLInputType> {
+  // See: https://github.com/yaacovCR/graphql-executor/issues/174
+  // Unwrap any non-null modifier to the outermost type because a variable
+  // on the outermost type can be nullable if a default value is supplied.
+  // Non-null versions will then be allowed by the algorithm below as at all
+  // levels.
+  const nullableOuterType = isNonNullType(type) ? type.ofType : type;
+
   const { nonNullListWrappers, nonNull, namedType } = getInputTypeInfo(
     isListType,
     isNonNullType,
-    type,
+    nullableOuterType,
   );
   const sequences = getPossibleSequences(nonNullListWrappers);