createRequest with transforms API

src/stitching/delegateToSchema.ts

@@ -1,6 +1,4 @@
 import {
-  ArgumentNode,
-  DocumentNode,
   FieldNode,
   FragmentDefinitionNode,
   Kind,
@@ -11,8 +9,10 @@ import {
   execute,
   validate,
   VariableDefinitionNode,
+  GraphQLSchema,
 } from 'graphql';
-import { Operation, Request, IDelegateToSchemaOptions } from '../Interfaces';
+import { FetcherOperation } from './makeRemoteExecutableSchema';
+import { Request, Transform, IDelegateToSchemaOptions } from '../Interfaces';
 import {
   applyRequestTransforms,
   applyResultTransforms,
@@ -22,113 +22,148 @@ import FilterToSchema from '../transforms/FilterToSchema';
 import AddTypenameToAbstract from '../transforms/AddTypenameToAbstract';
 import CheckResultAndHandleErrors from '../transforms/CheckResultAndHandleErrors';
 
-export default async function delegateToSchema(
-  options: IDelegateToSchemaOptions,
-): Promise<any> {
-  const { info, args = {} } = options;
-  const rawDocument: DocumentNode = createDocument(
-    options.fieldName,
-    options.operation,
-    info.fieldNodes,
-    Object.keys(info.fragments).map(
-      fragmentName => info.fragments[fragmentName],
-    ),
-    info.operation.variableDefinitions,
+export function createBatchOperation(
+  targetSchema: GraphQLSchema,
+  targetOperation: 'query' | 'mutation' | 'subscription',
+  rootDefs: { [key: string]: [{ [key: string]: any }, { [key: string]: any }] },
+  graphqlContext: { [key: string]: any },
+  documentInfo: {
+    operation: {
+      name?: { [key: string]: any }
+      variableDefinitions?: Array<VariableDefinitionNode>,
+    },
+    variableValues?: { [variableName: string]: any },
+    fragments?: { [fragmentName: string]: FragmentDefinitionNode },
+  },
+  transforms?: Array<Transform>,
+): FetcherOperation {
+  const roots = Object.keys(rootDefs).map(key => {
+    const [args, info] = rootDefs[key];
+    const [a, n] = key.split(':');
+    const name = n || a;
+    const alias = n ? a : null;
+    return {
+      key: alias || name,
+      name,
+      alias,
+      args,
+      info: info || documentInfo
+    };
+  });
+
+  const selections: Array<SelectionNode> = roots.reduce((newSelections, { key, name: rootFieldName, info, alias, args }) => {
+    const rootSelections = info.fieldNodes.map((selection: FieldNode) => {
+       if (selection.kind === Kind.FIELD) {
+         const rootField: FieldNode = {
+           kind: Kind.FIELD,
+           name: {
+             kind: Kind.NAME,
+             value: rootFieldName,
+           },
+           alias: alias
+            ? {
+              kind: Kind.NAME,
+              value: alias
+            }
+            : null,
+           arguments: selection.arguments,
+           selectionSet: selection.selectionSet
+         };
+         return rootField;
+       }
+       return selection;
+    });
+
+    return newSelections.concat(rootSelections);
+  }, []);
+
+  const selectionSet: SelectionSetNode = {
+    kind: Kind.SELECTION_SET,
+    selections,
+  };
+
+  const operationDefinition: OperationDefinitionNode = {
+    kind: Kind.OPERATION_DEFINITION,
+    operation: targetOperation,
+    variableDefinitions: documentInfo.operation.variableDefinitions,
+    selectionSet,
+  };
+
+  const fragments = Object.keys(documentInfo.fragments).map(
+    fragmentName => documentInfo.fragments[fragmentName],
   );
 
+  const document = {
+    kind: Kind.DOCUMENT,
+    definitions: [operationDefinition, ...fragments],
+  };
+
   const rawRequest: Request = {
-    document: rawDocument,
-    variables: info.variableValues as Record<string, any>,
+    document,
+    variables: documentInfo.variableValues as Record<string, any>,
   };
 
-  const transforms = [
-    ...(options.transforms || []),
-    AddArgumentsAsVariables(options.schema, args),
-    FilterToSchema(options.schema),
-    AddTypenameToAbstract(options.schema),
-    CheckResultAndHandleErrors(info, options.fieldName),
+  transforms = [
+    ...(transforms || []),
+    ...roots.map(({ args }) => AddArgumentsAsVariables(targetSchema, args)),
+    FilterToSchema(targetSchema),
+    AddTypenameToAbstract(targetSchema)
   ];
 
-  const processedRequest = applyRequestTransforms(rawRequest, transforms);
+  const { document: query, variables } = applyRequestTransforms(rawRequest, transforms);
 
-  const errors = validate(options.schema, processedRequest.document);
+  return {
+    query,
+    variables,
+    context: graphqlContext,
+    operationName: documentInfo.operation && documentInfo.operation.name && documentInfo.operation.name.value
+  };
+}
+
+export default async function delegateToSchema(
+  options: IDelegateToSchemaOptions,
+): Promise<any> {
+  const processedRequest = createBatchOperation(
+    options.schema,
+    options.operation,
+    {
+      [options.fieldName]: [options.args || {}, options.info]
+    },
+    options.context,
+    options.info,
+    options.transforms
+  );
+
+  const errors = validate(options.schema, processedRequest.query);
   if (errors.length > 0) {
     throw errors;
   }
 
-  if (options.operation === 'query' ||
-      options.operation === 'mutation') {
-    return applyResultTransforms(await execute(
+  if (options.operation === 'query' || options.operation === 'mutation') {
+    const rawResult = await execute(
       options.schema,
-      processedRequest.document,
-      info.rootValue,
+      processedRequest.query,
+      options.info.rootValue,
       options.context,
       processedRequest.variables,
-    ), transforms);
+    );
+
+    const result = applyResultTransforms(rawResult, [
+      ...(options.transforms || []),
+      CheckResultAndHandleErrors(options.info, options.fieldName),
+    ]);
+
+    return result;
   }
 
   if (options.operation === 'subscription') {
     // apply result processing ???
     return subscribe(
       options.schema,
-      processedRequest.document,
-      info.rootValue,
+      processedRequest.query,
+      options.info.rootValue,
       options.context,
       processedRequest.variables,
     );
   }
 }
-
-function createDocument(
-  targetField: string,
-  targetOperation: Operation,
-  originalSelections: Array<SelectionNode>,
-  fragments: Array<FragmentDefinitionNode>,
-  variables: Array<VariableDefinitionNode>,
-): DocumentNode {
-  let selections: Array<SelectionNode> = [];
-  let args: Array<ArgumentNode> = [];
-
-  originalSelections.forEach((field: FieldNode) => {
-    const fieldSelections = field.selectionSet
-      ? field.selectionSet.selections
-      : [];
-    selections = selections.concat(fieldSelections);
-    args = args.concat(field.arguments || []);
-  });
-
-  let selectionSet = null;
-  if (selections.length > 0) {
-    selectionSet = {
-      kind: Kind.SELECTION_SET,
-      selections: selections,
-    };
-  }
-
-  const rootField: FieldNode = {
-    kind: Kind.FIELD,
-    alias: null,
-    arguments: args,
-    selectionSet,
-    name: {
-      kind: Kind.NAME,
-      value: targetField,
-    },
-  };
-  const rootSelectionSet: SelectionSetNode = {
-    kind: Kind.SELECTION_SET,
-    selections: [rootField],
-  };
-
-  const operationDefinition: OperationDefinitionNode = {
-    kind: Kind.OPERATION_DEFINITION,
-    operation: targetOperation,
-    variableDefinitions: variables,
-    selectionSet: rootSelectionSet,
-  };
-
-  return {
-    kind: Kind.DOCUMENT,
-    definitions: [operationDefinition, ...fragments],
-  };
-}

src/transforms/AddArgumentsAsVariables.ts

@@ -68,13 +68,21 @@ function addVariablesToRootField(
 
     let variableCounter = 0;
     const variables = {};
+    const pairSet = {};
+
+    const generateVariableName = (argName: string, fieldName: string) => {
+      const fieldArgKey = `${argName}${fieldName}`;
+      if (pairSet[fieldArgKey]) {
+        return pairSet[fieldArgKey];
+      }
 
-    const generateVariableName = (argName: string) => {
       let varName;
       do {
         varName = `_v${variableCounter}_${argName}`;
         variableCounter++;
       } while (existingVariables.indexOf(varName) !== -1);
+
+      pairSet[fieldArgKey] = varName;
       return varName;
     };
 
@@ -99,7 +107,7 @@ function addVariablesToRootField(
         const field: GraphQLField<any, any> = type.getFields()[name];
         field.args.forEach((argument: GraphQLArgument) => {
           if (argument.name in args) {
-            const variableName = generateVariableName(argument.name);
+            const variableName = generateVariableName(argument.name, selection.name.value);
             variableNames[argument.name] = variableName;
             newArgs[argument.name] = {
               kind: Kind.ARGUMENT,