public GraphQlExecutor(IGraphQlServiceProvider serviceProvider, IAbstractSyntaxTreeGenerator astGenerator, IGraphQlExecutionOptions options, ILoggerFactory loggerFactory)
{
this.ServiceProvider = serviceProvider;
this.astGenerator = astGenerator;
this.options = options;
this.logger = loggerFactory.CreateLogger <GraphLinqQL.Execution.GraphQlExecutor>();
}
internal ComplexResolverBuilder(
IContract contractMappings,
IGraphQlServiceProvider serviceProvider,
Func <IReadOnlyList <LambdaExpression>, IGraphQlScalarResult <object> > resolve,
Type modelType)
: this(contractMappings.Resolvables.Select(e => CreateComplexResolution(serviceProvider, e)).ToArray(), resolve, modelType)
{
}
public IComplexResolverBuilder ResolveComplex(IGraphQlServiceProvider serviceProvider)
{
return(new ComplexResolverBuilder(
Contract !,
serviceProvider,
ToResult,
visitor.ModelType !
));
}
public static IGraphQlScalarResult <object> GetResult <TRoot>(this IGraphQlServiceProvider serviceProvider, Type contract, Func <IComplexResolverBuilder, IGraphQlScalarResult <object> > resolver)
{
IGraphQlResultFactory <TRoot> resultFactory = new GraphQlResultFactory <TRoot>(FieldContext.Empty);
var scalar = resultFactory.Resolve(a => a);
var objectResult = scalar.AsContract <object>(new ContractMapping(contract, typeof(TRoot)), GraphQlContractExpression.ResolveContractIndexed(0));
var contractBuilder = objectResult.ResolveComplex(serviceProvider);
var resolved = resolver(contractBuilder);
return(resolved);
}
private static ComplexResolutionEntry CreateComplexResolution(IGraphQlServiceProvider serviceProvider, ContractEntry entry)
{
var modelType = entry.Contract.GetInterfaces().Where(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IGraphQlAccepts <>)).First().GetGenericArguments()[0];
var contract = CreateContract(entry.Contract, serviceProvider);
var accepts = contract as IGraphQlAccepts;
if (accepts == null)
{
throw new ArgumentException("Contract does not accept an input type");
}
return(new ComplexResolutionEntry(
contract,
entry.DomainType,
(fieldContext) =>
{
contract.FieldContext = fieldContext;
accepts.Original = GraphQlResultFactory.Construct(fieldContext, modelType);
}
));
}
public GraphQlType(IGraphQlServiceProvider serviceProvider)
{
typeInformation = GraphQlJoin.JoinSingle <Type, IGraphQlTypeInformation>((type) => serviceProvider.TryGetTypeInformation(type) !);
}
public static Task <ExecutionResult> GraphQlRootAsync(this IGraphQlServiceProvider serviceProvider, Type contract, Func <IComplexResolverBuilder, IGraphQlScalarResult <object> > resolver, Microsoft.Extensions.Logging.ILogger logger, CancellationToken cancellationToken = default)
{
var resolved = GetResult <GraphQlRoot>(serviceProvider, contract, resolver).Catch();
return(Execution.GraphQlResultExtensions.InvokeResult(resolved, new GraphQlRoot(), logger, cancellationToken));
}
private static IGraphQlResolvable CreateContract(Type contractType, IGraphQlServiceProvider serviceProvider)
{
var contract = serviceProvider.GetResolverContract(contractType);
return(contract);
}
public IntrospectionQuery(IGraphQlServiceProvider servicesProvider)
{
this.originalQuery = (TQuery)servicesProvider.GetResolverContract(typeof(TQuery));
this.typeListing = servicesProvider.GetTypeListing();
this.introspectionTypeListing = new Interfaces.Introspection.TypeListing();
}
