public FieldType AddSingleField <TReturn>(
IObjectGraphType graph,
string name,
Func <ResolveEfFieldContext <TDbContext, object>, IQueryable <TReturn> > resolve,
Func <ResolveEfFieldContext <TDbContext, object>, TReturn, Task>?mutate = null,
Type?graphType = null,
IEnumerable <QueryArgument>?arguments = null,
bool nullable = false,
string?description = null)
where TReturn : class
{
var field = BuildSingleField(name, resolve, mutate, arguments, graphType, nullable, description);
return(graph.AddField(field));
}
public static ExecutionNode BuildExecutionNode(ExecutionNode parent, IGraphType graphType, Field field, FieldType fieldDefinition, int?indexInParentNode = null)
{
if (graphType is NonNullGraphType nonNullFieldType)
{
graphType = nonNullFieldType.ResolvedType;
}
return(graphType switch
{
ListGraphType _ => new ArrayExecutionNode(parent, graphType, field, fieldDefinition, indexInParentNode),
IObjectGraphType _ => new ObjectExecutionNode(parent, graphType, field, fieldDefinition, indexInParentNode),
IAbstractGraphType _ => new ObjectExecutionNode(parent, graphType, field, fieldDefinition, indexInParentNode),
ScalarGraphType _ => new ValueExecutionNode(parent, graphType, field, fieldDefinition, indexInParentNode),
_ => throw new InvalidOperationException($"Unexpected type: {graphType}")
});
/// <summary>
/// Builds an execution node with the specified parameters.
/// </summary>
protected ExecutionNode BuildSubscriptionExecutionNode(ExecutionNode parent, IGraphType graphType, Field field, FieldType fieldDefinition, int?indexInParentNode, object source)
{
if (graphType is NonNullGraphType nonNullFieldType)
{
graphType = nonNullFieldType.ResolvedType;
}
return(graphType switch
{
ListGraphType _ => new SubscriptionArrayExecutionNode(parent, graphType, field, fieldDefinition, indexInParentNode, source),
IObjectGraphType _ => new SubscriptionObjectExecutionNode(parent, graphType, field, fieldDefinition, indexInParentNode, source),
IAbstractGraphType _ => new SubscriptionObjectExecutionNode(parent, graphType, field, fieldDefinition, indexInParentNode, source),
ScalarGraphType scalarGraphType => new SubscriptionValueExecutionNode(parent, scalarGraphType, field, fieldDefinition, indexInParentNode, source),
_ => throw new InvalidOperationException($"Unexpected type: {graphType}")
});
public override void VisitObjectFieldDefinition(FieldType field, IObjectGraphType type, ISchema schema)
{
var applied = field.FindAppliedDirective("upper");
if (applied != null)
{
var inner = field.Resolver ?? NameFieldResolver.Instance;
field.Resolver = new FuncFieldResolver <object>(async context =>
{
object result = await inner.ResolveAsync(context).ConfigureAwait(false);
return(result is string str ? str.ToUpperInvariant() : result);
});
}
}
public string PrintType(IGraphType type)
{
Schema?.Initialize();
return(type switch
{
EnumerationGraphType graphType => PrintEnum(graphType),
ScalarGraphType scalarGraphType => PrintScalar(scalarGraphType),
IObjectGraphType objectGraphType => PrintObject(objectGraphType),
IInterfaceGraphType interfaceGraphType => PrintInterface(interfaceGraphType),
UnionGraphType unionGraphType => PrintUnion(unionGraphType),
DirectiveGraphType directiveGraphType => PrintDirective(directiveGraphType), //TODO: DirectiveGraphType does not inherit IGraphType
IInputObjectGraphType input => PrintInputObject(input),
_ => throw new InvalidOperationException($"Unknown GraphType '{type.GetType().Name}' with name '{type.Name}'")
});
public override string PrintObject(IObjectGraphType type)
{
var isExtension = type.IsExtensionType();
var interfaces = type.ResolvedInterfaces.Select(x => x.Name).ToList();
var delimiter = " & ";
var implementedInterfaces = interfaces.Count > 0
? " implements {0}".ToFormat(string.Join(delimiter, interfaces))
: "";
var federatedDirectives = PrintFederatedDirectives(type);
var extended = isExtension ? "extend " : "";
return(FormatDescription(type.Description) + "{1}type {2}{3}{4} {{{0}{5}{0}}}".ToFormat(Environment.NewLine, extended, type.Name, implementedInterfaces, federatedDirectives, PrintFields(type)));
}
public static void AddFieldToQuery <TFrom, TTo>(
this IGraphQLQueryResolver resolver,
IObjectGraphType query,
string name,
string methodName)
where TFrom : ObjectGraphType <TTo>
{
(query as ObjectGraphType)
.FieldAsync <ListGraphType <TFrom> >(
name,
arguments: resolver.GetQueryArguments(methodName),
resolve: async context =>
{
return(await resolver.InvokeAsync <IEnumerable <TTo> >(context, methodName));
});
}
public static void Field(
this IObjectGraphType obj,
string name,
IGraphType type,
string description = null,
QueryArguments arguments = null,
Func <ResolveFieldContext, object> resolve = null)
{
var field = new FieldType();
field.Name = name;
field.Description = description;
field.Arguments = arguments;
field.ResolvedType = type;
field.Resolver = resolve != null ? new FuncFieldResolver <object>(resolve) : null;
obj.AddField(field);
}
public static ExecutionNode BuildExecutionNode(ExecutionNode parent, IGraphType graphType, Field field, FieldType fieldDefinition, string[] path = null)
{
path ??= AppendPath(parent.Path, field.Name);
if (graphType is NonNullGraphType nonNullFieldType)
{
graphType = nonNullFieldType.ResolvedType;
}
return(graphType switch
{
ListGraphType _ => new ArrayExecutionNode(parent, graphType, field, fieldDefinition, path),
IObjectGraphType _ => new ObjectExecutionNode(parent, graphType, field, fieldDefinition, path),
IAbstractGraphType _ => new ObjectExecutionNode(parent, graphType, field, fieldDefinition, path),
ScalarGraphType _ => new ValueExecutionNode(parent, graphType, field, fieldDefinition, path),
_ => throw new InvalidOperationException($"Unexpected type: {graphType}")
});
public FieldType GetFieldDefinition(ISchema schema, IObjectGraphType parentType, Field field)
{
if (field.Name == SchemaIntrospection.SchemaMeta.Name && schema.Query == parentType)
{
return(SchemaIntrospection.SchemaMeta);
}
if (field.Name == SchemaIntrospection.TypeMeta.Name && schema.Query == parentType)
{
return(SchemaIntrospection.TypeMeta);
}
if (field.Name == SchemaIntrospection.TypeNameMeta.Name)
{
return(SchemaIntrospection.TypeNameMeta);
}
return(parentType.Fields.FirstOrDefault(f => f.Name == field.Name));
}
public override void VisitObjectFieldDefinition(FieldType field, IObjectGraphType type, ISchema schema)
{
var applied = field.FindAppliedDirective(AuthorizeDirective.DirectiveName);
if (applied == null)
{
return;
}
var isAuthenticated = _contextAccessor.HttpContext?.User.Identity?.IsAuthenticated;
if (isAuthenticated == true)
{
return;
}
field.Resolver = new AsyncFieldResolver <object>(async context => { throw new NotAuthenticatedException(); });
}
public override void VisitObjectFieldDefinition(FieldType field, IObjectGraphType type, ISchema schema)
{
var applied = field.FindAppliedDirective("upper");
if (applied != null)
{
var inner = field.Resolver ?? NameFieldResolver.Instance;
field.Resolver = new FuncFieldResolver <object>(context =>
{
object result = inner.Resolve(context);
return(result switch
{
string str => str?.ToUpperInvariant(),
Task <string> task => Task.FromResult(task.GetAwaiter().GetResult()?.ToUpperInvariant()),
_ => result
});
});
public static void FieldAsync(
this IObjectGraphType obj,
string name,
IGraphType type,
string description = null,
QueryArguments arguments = null,
Func <IResolveFieldContext, Task <object> > resolve = null)
{
var field = new FieldType
{
Name = name,
Description = description,
Arguments = arguments,
ResolvedType = type,
Resolver = resolve != null ? new AsyncFieldResolver <object>(resolve) : null
};
obj.AddField(field);
}
/// <summary>
/// Iterates the given <see cref="ControllerActionGraphFieldTemplate" /> and adds
/// all found types to the type system for this <see cref="ISchema" />. Generates
/// a field reference on the provided parent with a resolver pointing to the provided graph action.
/// </summary>
/// <param name="parentType">The parent which will own the generated action field.</param>
/// <param name="action">The action.</param>
private void AddActionAsField(IObjectGraphType parentType, IGraphTypeFieldTemplate action)
{
// apend the action as a field on the parent
var maker = GraphQLProviders.GraphTypeMakerProvider.CreateFieldMaker(this.Schema);
var fieldResult = maker.CreateField(action);
if (fieldResult != null)
{
if (parentType.Fields.ContainsKey(fieldResult.Field.Name))
{
throw new GraphTypeDeclarationException(
$"The '{parentType.Kind}' graph type '{parentType.Name}' already contains a field named '{fieldResult.Field.Name}'. " +
$"The action method '{action.InternalFullName}' cannot be added to the graph type with the same name.");
}
parentType.Extend(fieldResult.Field);
this.EnsureDependents(fieldResult);
}
}
/// <summary>
/// Adds a field with the specified properties to a specified output graph type.
/// </summary>
/// <param name="obj">The graph type to add a field to.</param>
/// <param name="name">The name of the field.</param>
/// <param name="type">The graph type of this field.</param>
/// <param name="description">The description of the field.</param>
/// <param name="arguments">A list of arguments for the field.</param>
/// <param name="resolve">A field resolver delegate. If not specified, <see cref="NameFieldResolver"/> will be used.</param>
public static void Field( //TODO: v5 - change void to T where T : IObjectGraphType
this IObjectGraphType obj,
string name,
IGraphType type,
string description = null,
QueryArguments arguments = null,
Func <IResolveFieldContext, object> resolve = null)
{
var field = new FieldType
{
Name = name,
Description = description,
Arguments = arguments,
ResolvedType = type,
Resolver = resolve != null ? new FuncFieldResolver <object>(resolve) : null
};
obj.AddField(field);
}
public void AddQueryConnectionField <TSource, TReturn>(
IObjectGraphType graph,
string name,
Func <ResolveEfFieldContext <TDbContext, TSource>, IQueryable <TReturn> > resolve,
Type?itemGraphType = null,
IEnumerable <QueryArgument>?arguments = null,
int pageSize = 10,
string?description = null)
where TReturn : class
{
Guard.AgainstNull(nameof(graph), graph);
Guard.AgainstNull(nameof(resolve), resolve);
var connection = BuildQueryConnectionField(name, resolve, pageSize, itemGraphType, description);
var field = graph.AddField(connection.FieldType);
field.AddWhereArgument(arguments);
}
public static FieldType FieldAsync <TGraphType, TSourceType>(
this IObjectGraphType obj,
string name,
string description = null,
QueryArguments arguments = null,
Func <ResolveFieldContext <TSourceType>, Task <object> > resolve = null,
string deprecationReason = null)
where TGraphType : IGraphType
{
return(obj.AddField(new FieldType
{
Name = name,
Description = description,
DeprecationReason = deprecationReason,
Type = typeof(TGraphType),
Arguments = arguments,
Resolver = resolve != null
? new AsyncFieldResolver <TSourceType, object>(resolve)
: null,
}));
}
public override void VisitObjectFieldDefinition(FieldType field, IObjectGraphType type, ISchema schema)
{
var permission = field.GetAppliedPermission();
if (permission == null)
{
return;
}
var isAuthorized = _contextAccessor
.HttpContext
?.User
.HasClaim(x => x.Type == "Permission" && x.Value == permission);
if (isAuthorized == true)
{
return;
}
field.Resolver = new AsyncFieldResolver <object>(async context => throw new NotAuthorizedException());
}
/// <inheritdoc/>
public override void VisitObjectFieldDefinition(FieldType field, IObjectGraphType type, ISchema schema)
{
// 2.2
if (field.Name.StartsWith("__"))
{
throw new InvalidOperationException($"The field '{field.Name}' of an Object type '{type.Name}' must not have a name which begins with the __ (two underscores).");
}
if (field.ResolvedType == null)
{
throw new InvalidOperationException($"The field '{field.Name}' of an Object type '{type.Name}' must have non-null '{nameof(IFieldType.ResolvedType)}' property.");
}
// 2.3
if (!field.ResolvedType.IsOutputType())
{
throw new InvalidOperationException($"The field '{field.Name}' of an Object type '{type.Name}' must be an output type.");
}
ValidateArgumentsUniqueness(field, type);
}
/// <summary>
/// Ensures the object graph type is tracked against all its implemented interfaces and queued
/// to be added to the interfaces it declares that are not known to this instance.
/// </summary>
/// <param name="objectGraphType">The object graph type to watch.</param>
private void EnsureObjectTypeIsTracked(IObjectGraphType objectGraphType)
{
_allKnownTypes.Add(objectGraphType);
foreach (var interfaceName in objectGraphType.InterfaceNames)
{
if (_interfacesByName.TryGetValue(interfaceName, out var interfaceType))
{
_graphTypesByInterface[interfaceType].Add(objectGraphType);
this.ApplyAllFields(interfaceType, objectGraphType);
}
else
{
if (!_queuedTypesByInterfaceName.TryGetValue(interfaceName, out var _))
{
_queuedTypesByInterfaceName.TryAdd(interfaceName, new HashSet <IObjectGraphType>());
}
_queuedTypesByInterfaceName[interfaceName].Add(objectGraphType);
}
}
}
public override string PrintObject(IObjectGraphType type)
{
// Do not return an empty query type: "Query { }" as it is not valid as part of the sdl.
if (type != null && string.Equals(type.Name, "Query", StringComparison.Ordinal) && !type.Fields.Any(x => !IsFederatedType(x.ResolvedType.GetNamedType().Name)))
{
return(string.Empty);
}
var isExtension = type.IsExtensionType();
var interfaces = type.ResolvedInterfaces.List.Select(x => x.Name).ToList();
var delimiter = " & ";
var implementedInterfaces = interfaces.Count > 0
? " implements {0}".ToFormat(string.Join(delimiter, interfaces))
: "";
var federatedDirectives = PrintFederatedDirectives(type);
var extended = isExtension ? "extend " : "";
return(FormatDescription(type.Description) + "{1}type {2}{3}{4} {{{0}{5}{0}}}".ToFormat(Environment.NewLine, extended, type.Name, implementedInterfaces, federatedDirectives, PrintFields(type)));
}
/// <summary>
/// Performs an out-of-band append of a new graph field to a parent. Accounts for type updates in this schema ONLY.
/// </summary>
/// <param name="parentType">the parent type to add the new field to.</param>
/// <param name="fieldName">Name of the field.</param>
/// <param name="path">The path segment to represent the new field.</param>
/// <param name="definition">The definition item from which graph attributes should be used, if any. Attributes will be set to an empty string if not supplied.</param>
/// <returns>The type associated with the field added to the parent type.</returns>
private IObjectGraphType CreateVirtualFieldOnParent(
IObjectGraphType parentType,
string fieldName,
GraphFieldPath path,
IGraphItemTemplate definition = null)
{
var childField = new VirtualGraphField(
fieldName,
path,
this.MakeSafeTypeNameFromRoutePath(path))
{
IsDepreciated = false,
DepreciationReason = string.Empty,
Description = definition?.Description ?? string.Empty,
};
parentType.Extend(childField);
this.Schema.KnownTypes.EnsureGraphType(childField.AssociatedGraphType);
this.EnsureDependents(childField);
return(childField.AssociatedGraphType);
}
/// <summary>
/// Returns a <see cref="FieldType"/> for the specified AST <see cref="Field"/> within a specified parent
/// output graph type within a given schema. For meta-fields, returns the proper meta-field field type.
/// </summary>
public static FieldType GetFieldDefinition(ISchema schema, IObjectGraphType parentType, Field field)
{
if (field.Name == schema.SchemaMetaFieldType.Name && schema.Query == parentType)
{
return(schema.SchemaMetaFieldType);
}
if (field.Name == schema.TypeMetaFieldType.Name && schema.Query == parentType)
{
return(schema.TypeMetaFieldType);
}
if (field.Name == schema.TypeNameMetaFieldType.Name)
{
return(schema.TypeNameMetaFieldType);
}
if (parentType == null)
{
throw new ArgumentNullException(nameof(parentType), $"Schema is not configured correctly to fetch field '{field.Name}'. Are you missing a root type?");
}
return(parentType.GetField(field.Name));
}
/// <summary>
/// Generates the list of used end-types
/// </summary>
/// <param name="providers">The list of defined api providers</param>
/// <param name="types">The list of merged types</param>
/// <param name="nodeInterface">The node interface (for relay compliance)</param>
/// <param name="allInterfaces">The list of defined type interfaces</param>
/// <param name="api">The api root element</param>
/// <param name="mutationType">The type containing all mutation methods</param>
/// <returns>The list of defined types</returns>
private static Dictionary <string, IGraphType> GenerateApiTypes(
List <ApiProvider> providers,
List <MergedType> types,
NodeInterface nodeInterface,
Dictionary <string, IGraphType> allInterfaces,
MergedApiRoot api,
out IObjectGraphType mutationType)
{
var graphTypes = types.ToDictionary(
type => type.ComplexTypeName,
type => type.GenerateGraphType(nodeInterface, GetTypeInterfaces(type, providers, allInterfaces)));
mutationType = api.GenerateMutationType();
graphTypes[mutationType.Name] = mutationType;
graphTypes.Values.OfType <IComplexGraphType>().SelectMany(a => a.Fields).ForEach(
f =>
{
var fieldDescription = f.GetMetadata <MergedField>(MergedType.MetaDataTypeKey);
if (fieldDescription == null)
{
return;
}
SetFieldArguments(f, fieldDescription, graphTypes);
f.ResolvedType = GetTypeForField(fieldDescription, graphTypes);
if (f.Resolver == null)
{
f.Resolver = fieldDescription.Resolver ?? fieldDescription.Type;
}
if (!string.IsNullOrWhiteSpace(fieldDescription.Description))
{
f.Description = fieldDescription.Description;
}
});
return(graphTypes);
}
public GraphQLModel(IAppEntity app,
IEnumerable <ISchemaEntity> schemas,
int pageSizeContents,
int pageSizeAssets,
IUrlGenerator urlGenerator)
{
partitionResolver = app.PartitionResolver();
CanGenerateAssetSourceUrl = urlGenerator.CanGenerateAssetSourceUrl;
assetType = new AssetGraphType(this);
assetListType = new ListGraphType(new NonNullGraphType(assetType));
var allSchemas = schemas.Where(x => x.SchemaDef.IsPublished).ToList();
BuildSchemas(allSchemas);
graphQLSchema = BuildSchema(this, pageSizeContents, pageSizeAssets, allSchemas);
graphQLSchema.RegisterValueConverter(JsonConverter.Instance);
graphQLSchema.RegisterValueConverter(InstantConverter.Instance);
InitializeContentTypes();
}
// See 'Type Validation' section in https://spec.graphql.org/June2018/#sec-Objects
// Object types have the potential to be invalid if incorrectly defined.
// This set of rules must be adhered to by every Object type in a GraphQL schema.
/// <inheritdoc/>
public override void VisitObject(IObjectGraphType type, ISchema schema)
{
// 1
if (type.Fields.Count == 0)
{
throw new InvalidOperationException($"An Object type '{type.Name}' must define one or more fields.");
}
// 2.1
foreach (var item in type.Fields.List.ToLookup(f => f.Name))
{
if (item.Count() > 1)
{
throw new InvalidOperationException($"The field '{item.Key}' must have a unique name within Object type '{type.Name}'; no two fields may share the same name.");
}
}
// 3
// TODO: ? An object type may declare that it implements one or more unique interfaces.
// 4
// TODO: An object type must be a super‐set of all interfaces it implements
}
private async Task ExtractFieldAsync(ExecutionContext context, IObjectGraphType rootType, object source,
Field field, FieldType fieldType, ConcurrentDictionary <string, object> data, IEnumerable <string> path)
{
context.CancellationToken.ThrowIfCancellationRequested();
var name = field.Alias ?? field.Name;
if (data.ContainsKey(name))
{
return;
}
if (!ShouldIncludeNode(context, field.Directives))
{
return;
}
if (CanResolveFromData(field, fieldType))
{
var result = await ResolveFieldFromDataAsync(context, rootType, source, fieldType, field, path)
.ConfigureAwait(false);
data.TryAdd(name, result);
}
else
{
var result = await ResolveFieldAsync(context, rootType, source, field, path)
.ConfigureAwait(false);
if (result.Skip)
{
return;
}
data.TryAdd(name, result.Value);
}
}
public async Task <IActionResult> Post([FromBody] GraphQlQuery query)
{
IObjectGraphType currentObjectGraphType = null;
switch (query.OperationName)
{
case "GetBlogData":
currentObjectGraphType = new BlogQuery(blogService);
break;
case "GetAuthors":
currentObjectGraphType = new AuthorsQuery(blogService);
break;
default:
currentObjectGraphType = new BlogQuery(blogService);
break;
}
var schema = new Schema {
Query = currentObjectGraphType
};
var result = await new DocumentExecuter().ExecuteAsync(x =>
{
x.Schema = schema;
x.Query = query.Query;
x.Inputs = query.Variables;
});
if (result.Errors?.Count > 0)
{
return(BadRequest());
}
return(Ok(result));
}
/// <summary>
/// Inspects the root and ensures that any intermediate, virtual fields
/// are accounted for and returns a reference to the immediate parent this action should be added to.
/// </summary>
/// <param name="action">The action.</param>
/// <returns>IGraphField.</returns>
private IObjectGraphType AddOrRetrieveRoutePath(IGraphTypeFieldTemplate action)
{
var pathSegments = action.Route.GenerateParentPathSegments();
// loop through all parent path parts of this action
// creating virtual fields as necessary or using existing ones and adding on to them
IObjectGraphType parentType = this.Schema.OperationTypes[action.Route.RootCollection];
for (var i = 0; i < pathSegments.Count; i++)
{
var segment = pathSegments[i];
var formattedName = _formatter.FormatFieldName(segment.Name);
if (parentType.Fields.ContainsKey(formattedName))
{
var field = parentType[formattedName];
var foundType = Schema.KnownTypes.FindGraphType(field.TypeExpression.TypeName);
if (foundType is IObjectGraphType ogt)
{
parentType = ogt;
continue;
}
throw new GraphTypeDeclarationException(
$"The action '{action.Name}' attempted to nest itself under the grpah type '{foundType?.Name}' but the graph type " +
"does not exist or does not accept fields.");
}
var fieldType = this.CreateVirtualFieldOnParent(
parentType,
formattedName,
segment,
i == 0 ? action.Parent : null);
parentType = fieldType;
}
return(parentType);
}
public FieldType GetFieldDefinition(Document document, ISchema schema, IObjectGraphType parentType, Field field)
{
if (field.Name == SchemaIntrospection.SchemaMeta.Name && schema.Query == parentType)
{
return(SchemaIntrospection.SchemaMeta);
}
if (field.Name == SchemaIntrospection.TypeMeta.Name && schema.Query == parentType)
{
return(SchemaIntrospection.TypeMeta);
}
if (field.Name == SchemaIntrospection.TypeNameMeta.Name)
{
return(SchemaIntrospection.TypeNameMeta);
}
if (parentType == null)
{
var error = new ExecutionError($"Schema is not configured correctly to fetch {field.Name}. Are you missing a root type?");
error.AddLocation(field, document);
throw error;
}
return(parentType.Fields.FirstOrDefault(f => f.Name == field.Name));
}
public FieldType GetFieldDefinition(ISchema schema, IObjectGraphType parentType, Field field)
{
if (field.Name == SchemaIntrospection.SchemaMeta.Name && schema.Query == parentType)
{
return SchemaIntrospection.SchemaMeta;
}
if (field.Name == SchemaIntrospection.TypeMeta.Name && schema.Query == parentType)
{
return SchemaIntrospection.TypeMeta;
}
if (field.Name == SchemaIntrospection.TypeNameMeta.Name)
{
return SchemaIntrospection.TypeNameMeta;
}
return parentType.Fields.FirstOrDefault(f => f.Name == field.Name);
}
public async Task<ResolveFieldResult<object>> ResolveFieldAsync(ExecutionContext context, IObjectGraphType parentType, object source, Fields fields)
{
context.CancellationToken.ThrowIfCancellationRequested();
var resolveResult = new ResolveFieldResult<object>
{
Skip = false
};
var field = fields.First();
var fieldDefinition = GetFieldDefinition(context.Schema, parentType, field);
if (fieldDefinition == null)
{
resolveResult.Skip = true;
return resolveResult;
}
var arguments = GetArgumentValues(context.Schema, fieldDefinition.Arguments, field.Arguments, context.Variables);
try
{
var resolveContext = new ResolveFieldContext();
resolveContext.FieldName = field.Name;
resolveContext.FieldAst = field;
resolveContext.FieldDefinition = fieldDefinition;
resolveContext.ReturnType = fieldDefinition.ResolvedType;
resolveContext.ParentType = parentType;
resolveContext.Arguments = arguments;
resolveContext.Source = source;
resolveContext.Schema = context.Schema;
resolveContext.Document = context.Document;
resolveContext.Fragments = context.Fragments;
resolveContext.RootValue = context.RootValue;
resolveContext.UserContext = context.UserContext;
resolveContext.Operation = context.Operation;
resolveContext.Variables = context.Variables;
resolveContext.CancellationToken = context.CancellationToken;
resolveContext.Metrics = context.Metrics;
var resolver = fieldDefinition.Resolver ?? new NameFieldResolver();
var result = resolver.Resolve(resolveContext);
if (result is Task)
{
var task = result as Task;
await task.ConfigureAwait(false);
result = task.GetProperyValue("Result");
}
resolveResult.Value =
await CompleteValueAsync(context, fieldDefinition.ResolvedType, fields, result).ConfigureAwait(false);
return resolveResult;
}
catch (Exception exc)
{
var error = new ExecutionError("Error trying to resolve {0}.".ToFormat(field.Name), exc);
error.AddLocation(field, context.Document);
context.Errors.Add(error);
resolveResult.Skip = false;
return resolveResult;
}
}
public Task<Dictionary<string, object>> ExecuteFieldsAsync(ExecutionContext context, IObjectGraphType rootType, object source, Dictionary<string, Fields> fields)
{
return fields.ToDictionaryAsync<KeyValuePair<string, Fields>, string, ResolveFieldResult<object>, object>(
pair => pair.Key,
pair => ResolveFieldAsync(context, rootType, source, pair.Value));
}
