createRequest with transforms API

src/Interfaces.ts

@@ -189,3 +189,10 @@ export type GraphQLParseOptions = {
   allowLegacySDLImplementsInterfaces?: boolean;
   experimentalFragmentVariables?: boolean;
 };
+
+export type OperationRootDefinition = {
+  fieldName: string,
+  alias?: string,
+  args?: { [key: string]: any },
+  info?: GraphQLResolveInfo
+};

src/stitching/delegateToSchema.ts

@@ -1,134 +1,158 @@
 import {
-  ArgumentNode,
-  DocumentNode,
   FieldNode,
-  FragmentDefinitionNode,
+  ArgumentNode,
   Kind,
   OperationDefinitionNode,
   SelectionSetNode,
   SelectionNode,
   subscribe,
   execute,
   validate,
-  VariableDefinitionNode,
+  GraphQLSchema,
+  GraphQLResolveInfo
 } from 'graphql';
-import { Operation, Request, IDelegateToSchemaOptions } from '../Interfaces';
-import {
-  applyRequestTransforms,
-  applyResultTransforms,
-} from '../transforms/transforms';
+import { FetcherOperation } from './makeRemoteExecutableSchema';
+import { Request, Transform, IDelegateToSchemaOptions, OperationRootDefinition } from '../Interfaces';
+import { applyRequestTransforms, applyResultTransforms } from '../transforms/transforms';
 import AddArgumentsAsVariables from '../transforms/AddArgumentsAsVariables';
 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 createOperation(
+  targetSchema: GraphQLSchema,
+  targetOperation: 'query' | 'mutation' | 'subscription',
+  roots: Array<OperationRootDefinition>,
+  graphqlContext: { [key: string]: any },
+  documentInfo: GraphQLResolveInfo,
+  transforms?: Array<Transform>,
+): FetcherOperation {
+  const selections: Array<SelectionNode> = roots.map(({ fieldName, info, alias }) => {
+    const newSelections: Array<SelectionNode> = info
+      ? [].concat(...info.fieldNodes.map((field: FieldNode) => field.selectionSet ? field.selectionSet.selections : []))
+      : [];
+
+    const args: Array<ArgumentNode> = info
+      ? [].concat( ...info.fieldNodes.map((field: FieldNode) => field.arguments || []))
+      : [];
+
+    const rootSelectionSet = newSelections.length > 0
+      ? {
+        kind: Kind.SELECTION_SET,
+        selections: newSelections
+      }
+      : null;
+
+    const rootField: FieldNode = {
+      kind: Kind.FIELD,
+      name: {
+        kind: Kind.NAME,
+        value: fieldName,
+      },
+      alias: alias
+       ? {
+         kind: Kind.NAME,
+         value: alias
+       }
+       : null,
+       selectionSet: rootSelectionSet,
+       arguments: args
+    };
+
+    return rootField;
+  }, []);
+
+  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 || []),
+    AddArgumentsAsVariables(targetSchema, roots),
+    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 = createOperation(
+    options.schema,
+    options.operation,
+    [
+      {
+        fieldName: options.fieldName,
+        args: options.args || {},
+        info: 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],
-  };
-}