do not send variables with value undefined (#1455)

graphql-js converts these to null

See graphql/graphql-js#2533

Author: yaacovCR

src/Interfaces.ts

@@ -174,8 +174,12 @@ export interface ExecutionParams<TArgs = Record<string, any>, TContext = any> {
   context?: TContext;
   info?: GraphQLResolveInfo;
 }
-export type Executor = (params: ExecutionParams) => Promise<ExecutionResult> | ExecutionResult;
-export type Subscriber = (params: ExecutionParams) => Promise<AsyncIterator<ExecutionResult> | ExecutionResult>;
+export type Executor = (
+  params: ExecutionParams,
+) => Promise<ExecutionResult> | ExecutionResult;
+export type Subscriber = (
+  params: ExecutionParams,
+) => Promise<AsyncIterator<ExecutionResult> | ExecutionResult>;
 
 export interface SubschemaConfig {
   schema: GraphQLSchema;
@@ -222,7 +226,10 @@ export interface IMakeRemoteExecutableSchemaOptions {
   schema: GraphQLSchema | string;
   executor?: Executor;
   subscriber?: Subscriber;
-  createResolver?: (executor: Executor, subscriber: Subscriber) => GraphQLFieldResolver<any, any>;
+  createResolver?: (
+    executor: Executor,
+    subscriber: Subscriber,
+  ) => GraphQLFieldResolver<any, any>;
   buildSchemaOptions?: BuildSchemaOptions;
 }
 

src/delegate/createRequest.ts

@@ -113,10 +113,13 @@ export function createRequest({
         sourceSchema,
         def.type as NamedTypeNode,
       ) as GraphQLInputType;
-      newVariables[varName] = serializeInputValue(
+      const serializedValue = serializeInputValue(
         varType,
         variableValues[varName],
       );
+      if (serializedValue !== undefined) {
+        newVariables[varName] = serializedValue;
+      }
     });
   }
 

src/delegate/transforms/FilterToSchema.ts

@@ -142,7 +142,10 @@ function filterToSchema(
   });
 
   const newVariables = usedVariables.reduce((acc, variableName) => {
-    acc[variableName] = variables[variableName];
+    const variableValue = variables[variableName];
+    if (variableValue !== undefined) {
+      acc[variableName] = variableValue;
+    }
     return acc;
   }, {});
 

src/stitch/typeFromAST.ts

@@ -188,7 +188,7 @@ function makeValues(
       [node.name.value]: {
         type: createStub(node.type, 'input'),
         defaultValue:
-          node.defaultValue != null
+          node.defaultValue !== undefined
             ? valueFromASTUntyped(node.defaultValue)
             : undefined,
         description: getDescription(node, backcompatOptions),

src/test/alternateStitchSchemas.test.ts

@@ -426,6 +426,83 @@ describe('transform object fields', () => {
   });
 });
 
+describe('optional arguments', () => {
+  const schema = makeExecutableSchema({
+    typeDefs: `
+      enum Arg {
+        possibleArg
+      }
+      type Query {
+        test(arg: Arg): Boolean
+      }
+    `,
+    resolvers: {
+      Query: {
+        test: (_root, args, _context) => args.arg === undefined,
+      },
+    },
+  });
+
+  const stitchedSchema = stitchSchemas({
+    schemas: [schema],
+  });
+
+  it('work with schema stitching', async () => {
+    const query = `
+      {
+        test
+      }
+    `;
+
+    const originalResult = await graphql(schema, query);
+    expect(originalResult.data.test).toEqual(true);
+
+    const stitchedResult = await graphql(stitchedSchema, query);
+    expect(stitchedResult.data.test).toEqual(true);
+  });
+
+  it('work with schema stitching when using variables', async () => {
+    const query = `
+      query test($arg: Arg) {
+        test(arg: $arg)
+      }
+    `;
+
+    const originalResult = await graphql(schema, query);
+    expect(originalResult.data.test).toEqual(true);
+
+    const stitchedResult = await graphql(stitchedSchema, query);
+    expect(stitchedResult.data.test).toEqual(true);
+  });
+
+  // See https://github.com/graphql/graphql-js/issues/2533
+  it('may not work as expected when explicitly passing in an undefined value', async () => {
+    const query = `
+      query test($arg: Arg) {
+        test(arg: $arg)
+      }
+    `;
+
+    const originalResult = await graphql(
+      schema,
+      query,
+      {},
+      {},
+      { arg: undefined },
+    );
+    expect(originalResult.data.test).toEqual(false);
+
+    const stitchedResult = await graphql(
+      stitchedSchema,
+      query,
+      {},
+      {},
+      { arg: undefined },
+    );
+    expect(stitchedResult.data.test).toEqual(false);
+  });
+});
+
 describe('default values', () => {
   test('should work to add a default value even when renaming root fields', async () => {
     const transformedPropertySchema = transformSchema(propertySchema, [

src/test/fixtures/schemas.ts

@@ -297,7 +297,7 @@ const propertyRootTypeDefs = `
     testString: String
     bar: String
   }`
-    : `type TestImpl2 implements TestInterface {
+      : `type TestImpl2 implements TestInterface {
     kind: TestInterfaceKind
     testString: String
     bar: String
@@ -364,27 +364,27 @@ const propertyResolvers: IResolvers = {
     interfaceTest(_root, { kind }) {
       return kind === 'ONE'
         ? {
-          kind: 'ONE',
-          testString: 'test',
-          foo: 'foo',
-        }
+            kind: 'ONE',
+            testString: 'test',
+            foo: 'foo',
+          }
         : {
-          kind: 'TWO',
-          testString: 'test',
-          bar: 'bar',
-        };
+            kind: 'TWO',
+            testString: 'test',
+            bar: 'bar',
+          };
     },
 
     unionTest(_root, { output }) {
       return output === 'Interface'
         ? {
-          kind: 'ONE',
-          testString: 'test',
-          foo: 'foo',
-        }
+            kind: 'ONE',
+            testString: 'test',
+            foo: 'foo',
+          }
         : {
-          someField: 'Bar',
-        };
+            someField: 'Bar',
+          };
     },
 
     errorTest() {
@@ -680,23 +680,13 @@ export const subscriptionSchema: GraphQLSchema = makeExecutableSchema({
 });
 
 function makeExecutorFromSchema(schema: GraphQLSchema): Executor {
-  return async ({ document, variables, context }) => graphql(
-    schema,
-    print(document),
-    null,
-    context,
-    variables,
-  );
+  return async ({ document, variables, context }) =>
+    graphql(schema, print(document), null, context, variables);
 }
 
 function makeSubscriberFromSchema(schema: GraphQLSchema): Subscriber {
-  return async ({ document, variables, context }) => subscribe(
-    schema,
-    document,
-    null,
-    context,
-    variables,
-  )
+  return async ({ document, variables, context }) =>
+    subscribe(schema, document, null, context, variables);
 }
 
 export async function makeSchemaRemote(
@@ -713,9 +703,5 @@ export async function makeSchemaRemote(
 }
 
 export const remotePropertySchema = makeSchemaRemote(propertySchema);
-export const remoteProductSchema = makeSchemaRemote(
-  productSchema,
-);
-export const remoteBookingSchema = makeSchemaRemote(
-  bookingSchema,
-);
+export const remoteProductSchema = makeSchemaRemote(productSchema);
+export const remoteBookingSchema = makeSchemaRemote(bookingSchema);

src/utils/updateArgument.ts

@@ -47,5 +47,9 @@ export function updateArgument(
     type: astFromType(argType),
   };
 
-  variableValues[varName] = newArg;
+  if (newArg === undefined) {
+    delete variableValues[varName];
+  } else {
+    variableValues[varName] = newArg;
+  }
 }

src/wrap/transforms/MapFields.ts

@@ -12,10 +12,13 @@ export default class MapFields implements Transform {
       (_typeName, _fieldName, field) => ({
         description: field.deprecationReason,
         type: field.type,
-        args: field.args.reduce<GraphQLFieldConfigArgumentMap>((prev, curr) => ({
-          ...prev,
-          [curr.name]: curr,
-        }), {}),
+        args: field.args.reduce<GraphQLFieldConfigArgumentMap>(
+          (prev, curr) => ({
+            ...prev,
+            [curr.name]: curr,
+          }),
+          {},
+        ),
         resolve: field.resolve,
         subscribe: field.subscribe,
         deprecationReason: field.deprecationReason,