Merge pull request #119 from graphql/arity

[RFC] Expose more information to field resolver functions.

Author: leebyron

src/execution/execute.js

@@ -461,47 +461,55 @@ function resolveField(
   fieldASTs: Array<Field>
 ): any {
   var fieldAST = fieldASTs[0];
+  var fieldName = fieldAST.name.value;
 
-  var fieldDef = getFieldDef(exeContext.schema, parentType, fieldAST);
+  var fieldDef = getFieldDef(exeContext.schema, parentType, fieldName);
   if (!fieldDef) {
     return;
   }
 
-  var fieldType = fieldDef.type;
+  var returnType = fieldDef.type;
   var resolveFn = fieldDef.resolve || defaultResolveFn;
 
   // Build a JS object of arguments from the field.arguments AST, using the
   // variables scope to fulfill any variable references.
   // TODO: find a way to memoize, in case this field is within a List type.
-  var args = fieldDef.args ?
-    getArgumentValues(fieldDef.args, fieldAST.arguments, exeContext.variables) :
-    null;
+  var args = getArgumentValues(
+    fieldDef.args,
+    fieldAST.arguments,
+    exeContext.variables
+  );
+
+  // The resolve function's optional third argument is a collection of
+  // information about the current execution state.
+  var info = {
+    fieldName,
+    fieldASTs,
+    returnType,
+    parentType,
+    schema: exeContext.schema,
+    fragments: exeContext.fragments,
+    rootValue: exeContext.rootValue,
+    operation: exeContext.operation,
+    variables: exeContext.variables,
+  };
 
   // If an error occurs while calling the field `resolve` function, ensure that
   // it is wrapped as a GraphQLError with locations. Log this error and return
   // null if allowed, otherwise throw the error so the parent field can handle
   // it.
   try {
-    var result = resolveFn(
-      source,
-      args,
-      exeContext.rootValue,
-      // TODO: provide all fieldASTs, not just the first field
-      fieldAST,
-      fieldType,
-      parentType,
-      exeContext.schema
-    );
+    var result = resolveFn(source, args, info);
   } catch (error) {
     var reportedError = locatedError(error, fieldASTs);
-    if (fieldType instanceof GraphQLNonNull) {
+    if (returnType instanceof GraphQLNonNull) {
       throw reportedError;
     }
     exeContext.errors.push(reportedError);
     return null;
   }
 
-  return completeValueCatchingError(exeContext, fieldType, fieldASTs, result);
+  return completeValueCatchingError(exeContext, returnType, fieldASTs, result);
 }
 
 function completeValueCatchingError(
@@ -660,8 +668,8 @@ function completeValue(
  * and returns it as the result, or if it's a function, returns the result
  * of calling that function.
  */
-function defaultResolveFn(source, args, root, fieldAST) {
-  var property = source[fieldAST.name.value];
+function defaultResolveFn(source, args, { fieldName }) {
+  var property = source[fieldName];
   return typeof property === 'function' ? property.call(source) : property;
 }
 
@@ -685,17 +693,16 @@ function isThenable(value: any): boolean {
 function getFieldDef(
   schema: GraphQLSchema,
   parentType: GraphQLObjectType,
-  fieldAST: Field
+  fieldName: string
 ): ?GraphQLFieldDefinition {
-  var name = fieldAST.name.value;
-  if (name === SchemaMetaFieldDef.name &&
+  if (fieldName === SchemaMetaFieldDef.name &&
       schema.getQueryType() === parentType) {
     return SchemaMetaFieldDef;
-  } else if (name === TypeMetaFieldDef.name &&
+  } else if (fieldName === TypeMetaFieldDef.name &&
              schema.getQueryType() === parentType) {
     return TypeMetaFieldDef;
-  } else if (name === TypeNameMetaFieldDef.name) {
+  } else if (fieldName === TypeNameMetaFieldDef.name) {
     return TypeNameMetaFieldDef;
   }
-  return parentType.getFields()[name];
+  return parentType.getFields()[fieldName];
 }

src/execution/values.js

@@ -52,11 +52,11 @@ export function getVariableValues(
  * definitions and list of argument AST nodes.
  */
 export function getArgumentValues(
-  argDefs: Array<GraphQLArgument>,
+  argDefs: ?Array<GraphQLArgument>,
   argASTs: ?Array<Argument>,
   variables: { [key: string]: any }
 ): { [key: string]: any } {
-  if (!argASTs) {
+  if (!argDefs || !argASTs) {
     return {};
   }
   var argASTMap = keyMap(argASTs, arg => arg.name.value);

src/type/definition.js

@@ -10,7 +10,12 @@
 
 import invariant from '../jsutils/invariant';
 import { ENUM } from '../language/kinds';
-import type { Value } from '../language/ast';
+import type {
+  OperationDefinition,
+  Field,
+  FragmentDefinition,
+  Value,
+} from '../language/ast';
 import type { GraphQLSchema } from './schema';
 
 
@@ -350,18 +355,28 @@ type GraphQLInterfacesThunk = () => Array<GraphQLInterfaceType>;
 
 type GraphQLFieldConfigMapThunk = () => GraphQLFieldConfigMap;
 
+export type GraphQLFieldResolveFn = (
+  source?: any,
+  args?: {[argName: string]: any},
+  info?: GraphQLFieldExeInfo
+) => any
+
+export type GraphQLFieldExeInfo = {
+  fieldName: string,
+  fieldASTs: Array<Field>,
+  returnType: GraphQLOutputType,
+  parentType: GraphQLCompositeType,
+  schema: GraphQLSchema,
+  fragments: { [fragmentName: string]: FragmentDefinition },
+  rootValue: any,
+  operation: OperationDefinition,
+  variables: { [variableName: string]: any },
+}
+
 export type GraphQLFieldConfig = {
   type: GraphQLOutputType;
   args?: GraphQLFieldConfigArgumentMap;
-    resolve?: (
-    source?: any,
-    args?: ?{[argName: string]: any},
-    context?: any,
-    fieldAST?: any,
-    fieldType?: any,
-    parentType?: any,
-    schema?: GraphQLSchema
-  ) => any;
+  resolve?: GraphQLFieldResolveFn;
   deprecationReason?: string;
   description?: ?string;
 }
@@ -384,15 +399,7 @@ export type GraphQLFieldDefinition = {
   description: ?string;
   type: GraphQLOutputType;
   args: Array<GraphQLArgument>;
-  resolve?: (
-    source?: any,
-    args?: ?{[argName: string]: any},
-    context?: any,
-    fieldAST?: any,
-    fieldType?: any,
-    parentType?: any,
-    schema?: GraphQLSchema
-  ) => any;
+  resolve?: GraphQLFieldResolveFn;
   deprecationReason?: ?string;
 }
 

src/type/introspection.js

@@ -288,15 +288,7 @@ export var SchemaMetaFieldDef: GraphQLFieldDefinition = {
   type: new GraphQLNonNull(__Schema),
   description: 'Access the current type schema of this server.',
   args: [],
-  resolve: (
-    source,
-    args,
-    root,
-    fieldAST,
-    fieldType,
-    parentType,
-    schema
-  ) => schema
+  resolve: (source, args, { schema }) => schema
 };
 
 export var TypeMetaFieldDef: GraphQLFieldDefinition = {
@@ -306,28 +298,13 @@ export var TypeMetaFieldDef: GraphQLFieldDefinition = {
   args: [
     { name: 'name', type: new GraphQLNonNull(GraphQLString) }
   ],
-  resolve: (
-    source,
-    { name },
-    root,
-    fieldAST,
-    fieldType,
-    parentType,
-    schema
-  ) => schema.getType(name)
+  resolve: (source, { name }, { schema }) => schema.getType(name)
 };
 
 export var TypeNameMetaFieldDef: GraphQLFieldDefinition = {
   name: '__typename',
   type: new GraphQLNonNull(GraphQLString),
   description: 'The name of the current Object type at runtime.',
   args: [],
-  resolve: (
-    source,
-    args,
-    root,
-    fieldAST,
-    fieldType,
-    parentType
-  ) => parentType.name
+  resolve: (source, args, { parentType }) => parentType.name
 };