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(); }