fix(delegateToSchema): standardize args format

now that all directly proxied args are serialized automatically, including variables, appropriate to standardize args passed to
delegateToSchema.

Previously, the typeName would be inferred from the proxy target, but serialization would be according to the gateway schema if the type names matched. This would introduce a lot of edge cases and was only necessary as a workaround to facilitate serialization of variables.

Now we can standardize as follows: args format is the internal representation of the proxy target schema. By default, local schemas internal representation will be imported, so that local schema custom enums/scalars do not require manual serialization. For remote schemas should, the internal and external representation is the same, so this is the same as the external representation. If the gateway introduces a new internal representation, args must be converted to the old internal representation manually.

addresses #34
reverts fd1bd8f#diff-06b180be3290dd53bea4c1c98c9dfdd2

src/stitching/delegateToSchema.ts

@@ -149,7 +149,7 @@ export function createDelegatingRequest({
 
   if (args) {
     transforms.push(
-      new AddArgumentsAsVariables(targetSchema, args, info.schema)
+      new AddArgumentsAsVariables(targetSchema, args)
     );
   }
 

src/transforms/AddArgumentsAsVariables.ts

@@ -14,30 +14,25 @@ import {
   SelectionNode,
   TypeNode,
   VariableDefinitionNode,
-  GraphQLEnumType,
-  GraphQLScalarType,
 } from 'graphql';
 import { Request } from '../Interfaces';
 import { Transform } from './transforms';
-import { transformInputValue } from '../utils';
+import { serializeInputValue } from '../utils';
 
 export default class AddArgumentsAsVariablesTransform implements Transform {
   private targetSchema: GraphQLSchema;
   private args: { [key: string]: any };
-  private sourceSchema: GraphQLSchema;
 
-  constructor(targetSchema: GraphQLSchema, args: { [key: string]: any }, sourceSchema: GraphQLSchema) {
+  constructor(targetSchema: GraphQLSchema, args: { [key: string]: any }) {
     this.targetSchema = targetSchema;
     this.args = args;
-    this.sourceSchema = sourceSchema;
   }
 
   public transformRequest(originalRequest: Request): Request {
     const { document, newVariables } = addVariablesToRootField(
       this.targetSchema,
       originalRequest.document,
       this.args,
-      this.sourceSchema,
     );
     const variables = {
       ...originalRequest.variables,
@@ -54,7 +49,6 @@ function addVariablesToRootField(
   targetSchema: GraphQLSchema,
   document: DocumentNode,
   args: { [key: string]: any },
-  sourceSchema: GraphQLSchema,
 ): {
   document: DocumentNode;
   newVariables: { [key: string]: any };
@@ -138,22 +132,10 @@ function addVariablesToRootField(
               },
               type: typeToAst(argument.type),
             };
-            if (sourceSchema) {
-              newVariables[variableName] = transformInputValue(
-                argument.type,
-                args[argument.name],
-                (t, v) => {
-                  const type = sourceSchema.getType(t.name) as GraphQLEnumType | GraphQLScalarType;
-                  return type ? type.serialize(v) : v;
-                }
-              );
-            } else {
-              // tslint:disable-next-line:max-line-length
-              console.warn(
-                'AddArgumentsAsVariables should be passed the wrapping schema so that arguments can be properly serialized prior to delegation.'
-              );
-              newVariables[variableName] = args[argument.name];
-            }
+            newVariables[variableName] = serializeInputValue(
+              argument.type,
+              args[argument.name],
+            );
           }
         });