FieldType BuildNavigationField <TSource, TReturn>(
string name,
Func <ResolveFieldContext <TSource>, TReturn> resolve,
IEnumerable <string> includeNames,
Type graphType,
IEnumerable <QueryArgument> arguments)
where TReturn : class
{
Guard.AgainstNullWhiteSpace(nameof(name), name);
Guard.AgainstNull(nameof(resolve), resolve);
graphType = GraphTypeFinder.FindGraphType <TReturn>(graphType);
return(new FieldType
{
Name = name,
Type = graphType,
Arguments = ArgumentAppender.GetQueryArguments(arguments),
Metadata = IncludeAppender.GetIncludeMetadata(name, includeNames),
Resolver = new AsyncFieldResolver <TSource, TReturn>(async context =>
{
var result = resolve(context);
if (await filters.ShouldInclude(context.UserContext, result))
{
return result;
}
return null;
})
});
}
FieldType BuildNavigationField <TSource, TReturn>(
string name,
Func <ResolveEfFieldContext <TDbContext, TSource>, IEnumerable <TReturn> >?resolve,
IEnumerable <string>?includeNames,
Type listGraphType,
IEnumerable <QueryArgument>?arguments,
string?description)
where TReturn : class
{
Guard.AgainstNullWhiteSpace(nameof(name), name);
var fieldType = new FieldType
{
Name = name,
Description = description,
Type = listGraphType,
Arguments = ArgumentAppender.GetQueryArguments(arguments),
Metadata = IncludeAppender.GetIncludeMetadata(name, includeNames)
};
if (resolve != null)
{
fieldType.Resolver = new AsyncFieldResolver <TSource, IEnumerable <TReturn> >(
context =>
{
var efFieldContext = BuildContext(context);
var result = resolve(efFieldContext);
result = result.ApplyGraphQlArguments(context);
return(efFieldContext.Filters.ApplyFilter(result, context.UserContext));
});
}
return(fieldType);
}
FieldType BuildNavigationField <TSource, TReturn>(
string name,
Func <ResolveFieldContext <TSource>, IEnumerable <TReturn> > resolve,
IEnumerable <string> includeNames,
Type listGraphType,
IEnumerable <QueryArgument> arguments)
where TReturn : class
{
Guard.AgainstNullWhiteSpace(nameof(name), name);
Guard.AgainstNull(nameof(resolve), resolve);
return(new FieldType
{
Name = name,
Type = listGraphType,
Arguments = ArgumentAppender.GetQueryArguments(arguments),
Metadata = IncludeAppender.GetIncludeMetadata(name, includeNames),
Resolver = new AsyncFieldResolver <TSource, IEnumerable <TReturn> >(
async context =>
{
var result = resolve(context);
result = result.ApplyGraphQlArguments(context);
return await filters.ApplyFilter(result, context.UserContext);
})
});
}
FieldType BuildNavigationField <TSource, TReturn>(
string name,
Func <ResolveEfFieldContext <TDbContext, TSource>, IEnumerable <TReturn> > resolve,
IEnumerable <string> includeNames,
Type listGraphType,
IEnumerable <QueryArgument> arguments)
where TReturn : class
{
Guard.AgainstNullWhiteSpace(nameof(name), name);
Guard.AgainstNull(nameof(resolve), resolve);
//return the new field type
return(new FieldType
{
Name = name,
Type = listGraphType,
//take the arguments manually specified, if any, and append the query arguments
Arguments = ArgumentAppender.GetQueryArguments(arguments),
//add the metadata for the tables to be included in the query
Metadata = IncludeAppender.GetIncludeMetadata(name, includeNames),
//specify a custom resolve function
Resolver = new AsyncFieldResolver <TSource, IEnumerable <TReturn> >(
context =>
{
var efFieldContext = BuildContext(context);
//run the specified resolve function
var result = resolve(efFieldContext);
//apply any query filters specified in the arguments
result = result.ApplyGraphQlArguments(context);
//apply the global filter on each individually enumerated item
return efFieldContext.Filters.ApplyFilter(result, context.UserContext);
})
});
}
FieldType BuildNavigationField <TSource, TReturn>(
string name,
Func <ResolveEfFieldContext <TDbContext, TSource>, TReturn> resolve,
IEnumerable <string> includeNames,
Type graphType)
where TReturn : class
{
Guard.AgainstNullWhiteSpace(nameof(name), name);
Guard.AgainstNull(nameof(resolve), resolve);
//lookup the graph type if not explicitly specified
graphType = graphType ?? GraphTypeFinder.FindGraphType <TReturn>();
//build field
return(new FieldType
{
Name = name,
Type = graphType,
//add the metadata for the tables to be included in the query
Metadata = IncludeAppender.GetIncludeMetadata(name, includeNames),
//custom resolve function simply applies the global filters; typically it's a pass-through
Resolver = new AsyncFieldResolver <TSource, TReturn>(async context =>
{
var efFieldContext = BuildContext(context);
//run resolve function
var result = resolve(efFieldContext);
//apply global filters and return null if necessary
if (await efFieldContext.Filters.ShouldInclude(context.UserContext, result))
{
return result;
}
return null;
})
});
}
public FieldType AddNavigationField <TSource, TReturn>(
ComplexGraphType <TSource> graph,
string name,
Func <ResolveEfFieldContext <TDbContext, TSource>, TReturn?>?resolve = null,
Type?graphType = null,
IEnumerable <string>?includeNames = null,
string?description = null)
where TReturn : class
{
Guard.AgainstNull(nameof(graph), graph);
Guard.AgainstNullWhiteSpace(nameof(name), name);
graphType ??= GraphTypeFinder.FindGraphType <TReturn>();
FieldType field = new()
{
Name = name,
Type = graphType,
Metadata = IncludeAppender.GetIncludeMetadata(name, includeNames),
Description = description
};
if (resolve != null)
{
field.Resolver = new AsyncFieldResolver <TSource, TReturn?>(
async context =>
{
var fieldContext = BuildContext(context);
var result = resolve(fieldContext);
if (await fieldContext.Filters.ShouldInclude(context.UserContext, result))
{
return(result);
}
return(null);
});
}
return(graph.AddField(field));
}
}
FieldType BuildNavigationField <TSource, TReturn>(
string name,
Func <ResolveEfFieldContext <TDbContext, TSource>, TReturn?>?resolve,
IEnumerable <string>?includeNames,
Type?graphType,
string?description)
where TReturn : class
{
Guard.AgainstNullWhiteSpace(nameof(name), name);
graphType ??= GraphTypeFinder.FindGraphType <TReturn>();
var fieldType = new FieldType
{
Name = name,
Type = graphType,
Metadata = IncludeAppender.GetIncludeMetadata(name, includeNames),
Description = description
};
if (resolve != null)
{
fieldType.Resolver = new AsyncFieldResolver <TSource, TReturn?>(
async context =>
{
var efFieldContext = BuildContext(context);
var result = resolve(efFieldContext);
if (await efFieldContext.Filters.ShouldInclude(context.UserContext, result))
{
return(result);
}
return(null);
});
}
return(fieldType);
}
public FieldType AddNavigationListField <TSource, TReturn>(
ComplexGraphType <TSource> graph,
string name,
Func <ResolveEfFieldContext <TDbContext, TSource>, IEnumerable <TReturn> >?resolve = null,
Type?itemGraphType = null,
IEnumerable <QueryArgument>?arguments = null,
IEnumerable <string>?includeNames = null,
string?description = null)
where TReturn : class
{
Guard.AgainstNull(nameof(graph), graph);
Guard.AgainstNullWhiteSpace(nameof(name), name);
var hasId = keyNames.ContainsKey(typeof(TReturn));
FieldType field = new()
{
Name = name,
Description = description,
Type = MakeListGraphType <TReturn>(itemGraphType),
Arguments = ArgumentAppender.GetQueryArguments(arguments, hasId),
Metadata = IncludeAppender.GetIncludeMetadata(name, includeNames)
};
if (resolve != null)
{
field.Resolver = new AsyncFieldResolver <TSource, IEnumerable <TReturn> >(
context =>
{
var fieldContext = BuildContext(context);
var result = resolve(fieldContext);
result = result.ApplyGraphQlArguments(hasId, context);
return(fieldContext.Filters.ApplyFilter(result, context.UserContext));
});
}
return(graph.AddField(field));
}
}
