public static IObjectFieldDescriptor UsePagination <TSchemaType>(this IObjectFieldDescriptor descriptor) where TSchemaType : class, IOutputType { FieldMiddleware placeholder = next => default(FieldDelegate); Type middlewareDefinition = typeof(QueryableConnectionMiddleware <>); descriptor .AddPaginationArguments() .Type <PaginationType <TSchemaType> >() .Use(placeholder) .Extend() .OnBeforeCompletion((context, defintion) => { var reference = typeof(TSchemaType)?.BaseType?.GenericTypeArguments?[0]; if (reference != null) { Type middlewareType = middlewareDefinition.MakeGenericType(reference); FieldMiddleware middleware = FieldClassMiddlewareFactory.Create( middlewareType); int index = defintion.MiddlewareComponents.IndexOf(placeholder); defintion.MiddlewareComponents[index] = middleware; } }) .DependsOn <TSchemaType>(); return(descriptor); }
private static void CompileMiddleware( ITypeCompletionContext context, ObjectFieldDefinition definition, ITypeReference argumentTypeReference, FieldMiddleware placeholder, string?scope) { IType resolvedType = context.GetType <IType>(argumentTypeReference); if (!(resolvedType.ElementType().NamedType() is ISortInputType type)) { throw Sorting_TypeOfInvalidFormat(resolvedType); } ISortConvention convention = context.DescriptorContext.GetSortConvention(scope); var fieldDescriptor = ObjectFieldDescriptor.From(context.DescriptorContext, definition); convention.ConfigureField(fieldDescriptor); MethodInfo factory = _factoryTemplate.MakeGenericMethod(type.EntityType.Source); var middleware = (FieldMiddleware)factory.Invoke(null, new object[] { convention }) !; var index = definition.MiddlewareComponents.IndexOf(placeholder); definition.MiddlewareComponents[index] = middleware; }
public static IObjectFieldDescriptor UsePaging <TSchemaType>( this IObjectFieldDescriptor descriptor) where TSchemaType : IOutputType, new() { FieldMiddleware placeholder = next => context => Task.CompletedTask; Type middlewareDefinition = typeof(QueryableConnectionMiddleware <>); descriptor .AddPagingArguments() .Type(ConnectionType <TSchemaType> .CreateWithTotalCount()) .Use(placeholder) .Extend() .OnBeforeCompletion((context, defintion) => { var reference = new ClrTypeReference( typeof(TSchemaType), TypeContext.Output); IOutputType type = context.GetType <IOutputType>(reference); if (type.NamedType() is IHasClrType hasClrType) { Type middlewareType = middlewareDefinition .MakeGenericType(hasClrType.ClrType); FieldMiddleware middleware = FieldClassMiddlewareFactory.Create(middlewareType); int index = defintion.MiddlewareComponents.IndexOf(placeholder); defintion.MiddlewareComponents[index] = middleware; } }) .DependsOn <TSchemaType>(); return(descriptor); }
public static IObjectFieldDescriptor UsePaging <TSchemaType>( this IObjectFieldDescriptor descriptor) where TSchemaType : class, IOutputType { FieldMiddleware placeholder = next => context => default(ValueTask); Type middlewareDefinition = typeof(QueryableConnectionMiddleware <>); descriptor .AddPagingArguments() .Type <ConnectionWithCountType <TSchemaType> >() .Use(placeholder) .Extend() .OnBeforeCompletion((context, defintion) => { ITypeReference reference = context.DescriptorContext.TypeInspector.GetTypeRef(typeof(TSchemaType)); IOutputType type = context.GetType <IOutputType>(reference); if (type.NamedType() is IHasRuntimeType hasClrType) { Type middlewareType = middlewareDefinition.MakeGenericType( hasClrType.RuntimeType); FieldMiddleware middleware = FieldClassMiddlewareFactory.Create( middlewareType); int index = defintion.MiddlewareComponents.IndexOf(placeholder); defintion.MiddlewareComponents[index] = middleware; } }) .DependsOn <TSchemaType>(); return(descriptor); }
private static TDescriptor UseFilter <TDescriptor>( TDescriptor descriptor, Type filterType) where TDescriptor : IObjectFieldDescriptor { FieldMiddleware placeholder = next => context => Task.CompletedTask; Type middlewareDefinition = typeof(QueryableFilterMiddleware <>); descriptor .AddFilterArguments(filterType) .Use(placeholder) .Extend() .OnBeforeCompletion((context, defintion) => { var reference = new ClrTypeReference( filterType, TypeContext.Input); IFilterInputType type = context.GetType <IFilterInputType>(reference); Type middlewareType = middlewareDefinition .MakeGenericType(type.EntityType); FieldMiddleware middleware = FieldClassMiddlewareFactory.Create(middlewareType); int index = defintion.MiddlewareComponents.IndexOf(placeholder); defintion.MiddlewareComponents[index] = middleware; }) .DependsOn(filterType, mustBeCompleted: true); return(descriptor); }
public static IObjectFieldDescriptor UsePaging( IObjectFieldDescriptor descriptor, Type?type, Type?entityType = null, GetPagingProvider?resolvePagingProvider = null, PagingOptions options = default) { if (descriptor is null) { throw new ArgumentNullException(nameof(descriptor)); } FieldMiddleware placeholder = next => context => default; descriptor .Use(placeholder) .Extend() .OnBeforeCreate(definition => { definition.Configurations.Add( new TypeConfiguration <ObjectFieldDefinition> { Definition = definition, On = ApplyConfigurationOn.Completion, Configure = (c, d) => ApplyConfiguration( c, d, entityType, resolvePagingProvider, options, placeholder) }); }); return(descriptor); }
public QueryExecutor( ISchema schema, IServiceProvider applicationServices, QueryDelegate queryDelegate, FieldMiddleware fieldMiddleware) { Schema = schema ?? throw new ArgumentNullException(nameof(schema)); _applicationServices = applicationServices ?? throw new ArgumentNullException(nameof(applicationServices)); _queryDelegate = queryDelegate ?? throw new ArgumentNullException(nameof(queryDelegate)); if (Schema.Services != null) { IEnumerable <IDiagnosticObserver> observers = Schema.Services .GetService <IEnumerable <IDiagnosticObserver> >(); if (observers != null) { QueryExecutionDiagnostics diagnosticEvents = _applicationServices .GetService <QueryExecutionDiagnostics>(); diagnosticEvents.Subscribe(observers); } } _fieldMiddlewareCompiler = new FieldMiddlewareCompiler( schema, fieldMiddleware); }
public static IQueryExecutionBuilder MapField( this IQueryExecutionBuilder builder, FieldReference fieldReference, FieldMiddleware middleware) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } if (fieldReference == null) { throw new ArgumentNullException(nameof(fieldReference)); } if (middleware == null) { throw new ArgumentNullException(nameof(middleware)); } return(builder.UseField( FieldClassMiddlewareFactory.Create <MapMiddleware>( (s, n) => new MapMiddleware( n, fieldReference, middleware(n))))); }
private static void CompileMiddleware( ObjectFieldDefinition definition, FieldMiddleware placeholder, Type keyType, Type valueType, Type dataLoaderType) { Type middlewareType; if (valueType.IsArray) { middlewareType = typeof(GroupedDataLoaderMiddleware <, ,>) .MakeGenericType(dataLoaderType, keyType, valueType.GetElementType() !); } else { middlewareType = typeof(DataLoaderMiddleware <, ,>) .MakeGenericType(dataLoaderType, keyType, valueType); } FieldMiddleware middleware = FieldClassMiddlewareFactory.Create(middlewareType); var index = definition.MiddlewareComponents.IndexOf(placeholder); definition.MiddlewareComponents[index] = middleware; }
public static IQueryExecutionBuilder MapField <TMiddleware>( this IQueryExecutionBuilder builder, FieldReference fieldReference, Func <IServiceProvider, FieldDelegate, TMiddleware> factory) where TMiddleware : class { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } if (fieldReference == null) { throw new ArgumentNullException(nameof(fieldReference)); } if (factory == null) { throw new ArgumentNullException(nameof(factory)); } return(builder.UseField( FieldClassMiddlewareFactory.Create <MapMiddleware>( (s, n) => { FieldMiddleware classMiddleware = FieldClassMiddlewareFactory.Create(factory); return new MapMiddleware( n, fieldReference, classMiddleware(n)); }))); }
private static void AddSerializerToObjectField( ITypeCompletionContext completionContext, ObjectFieldDefinition definition, FieldMiddleware placeholder, NameString typeName) { ITypeInspector typeInspector = completionContext.TypeInspector; IExtendedType? resultType; if (definition.ResultType is not null) { resultType = typeInspector.GetType(definition.ResultType); } else if (definition.Type is ExtendedTypeReference typeReference) { resultType = typeReference.Type; } else { throw new SchemaException(SchemaErrorBuilder.New() .SetMessage("Unable to resolve type from field `{0}`.", definition.Name) .SetTypeSystemObject(completionContext.Type) .Build()); } NameString schemaName = default; completionContext.DescriptorContext.SchemaCompleted += (sender, args) => schemaName = args.Schema.Name; IIdSerializer serializer = completionContext.Services.GetService <IIdSerializer>() ?? new IdSerializer(); var index = definition.MiddlewareComponents.IndexOf(placeholder); definition.MiddlewareComponents[index] = next => async context => { await next(context).ConfigureAwait(false); if (context.Result is not null) { if (resultType.IsArrayOrList) { var list = new List <object?>(); foreach (object?element in (IEnumerable)context.Result) { list.Add(element is null ? element : serializer.Serialize(schemaName, typeName, element)); } context.Result = list; } else { context.Result = serializer.Serialize(schemaName, typeName, context.Result); } } }; }
public static IObjectFieldDescriptor UseDataloader( this IObjectFieldDescriptor descriptor, Type dataLoaderType) { FieldMiddleware placeholder = next => context => default; if (!TryGetDataLoaderTypes(dataLoaderType, out Type? keyType, out Type? valueType)) { throw DataLoader_InvalidType(dataLoaderType); } descriptor .Use(placeholder) .Extend() .OnBeforeCreate( (c, definition) => { IExtendedType schemaType; if (!valueType.IsArray) { IExtendedType resolverType = c.TypeInspector.GetType(definition.ResultType); if (resolverType.IsArrayOrList) { schemaType = c.TypeInspector.GetType( typeof(IEnumerable <>).MakeGenericType(valueType)); } else { schemaType = c.TypeInspector.GetType(valueType); } } else { schemaType = c.TypeInspector.GetType(valueType); } definition.Type = TypeReference.Create(schemaType, TypeContext.Output); definition.Configurations.Add( LazyTypeConfigurationBuilder .New <ObjectFieldDefinition>() .Definition(definition) .Configure( (context, def) => { CompileMiddleware( def, placeholder, keyType, valueType, dataLoaderType); }) .On(ApplyConfigurationOn.Completion) .Build()); }); return(descriptor); }
public StarWarsSchema(IServiceProvider provider) : base(provider) { Query = (StarWarsQuery)provider.GetService(typeof(StarWarsQuery)) ?? throw new InvalidOperationException(); Mutation = (StarWarsMutation)provider.GetService(typeof(StarWarsMutation)) ?? throw new InvalidOperationException(); FieldMiddleware.Use(new InstrumentFieldsMiddleware()); }
private static IObjectFieldDescriptor ApplyMiddleware( this IObjectFieldDescriptor descriptor, string optionName, Type middlewareDefinition) { if (descriptor is null) { throw new ArgumentNullException(nameof(descriptor)); } FieldMiddleware placeholder = next => context => default; descriptor .Use(placeholder) .Extend() .OnBeforeCreate( (context, definition) => { definition.ContextData[optionName] = null; if (definition.ResultType is null || !context.TypeInspector.TryCreateTypeInfo( definition.ResultType, out ITypeInfo? typeInfo)) { Type resultType = definition.ResolverType ?? typeof(object); throw new ArgumentException( $"Cannot handle the specified type `{resultType.FullName}`.", nameof(descriptor)); } Type selectionType = typeInfo.NamedType; definition.ResultType = selectionType; definition.Type = RewriteToNonNullableType( context.TypeInspector, definition.Type); ILazyTypeConfiguration lazyConfiguration = LazyTypeConfigurationBuilder .New <ObjectFieldDefinition>() .Definition(definition) .Configure( (_, __) => { CompileMiddleware( selectionType, definition, placeholder, middlewareDefinition); }) .On(ApplyConfigurationOn.Completion) .Build(); definition.Configurations.Add(lazyConfiguration); }); return(descriptor); }
public void RegisterMiddleware(FieldMiddleware middleware) { if (middleware == null) { throw new ArgumentNullException(nameof(middleware)); } _middlewareComponents.Add(middleware); }
public FieldMiddlewareDefinition( FieldMiddleware middleware, bool isRepeatable = true, string?key = null) { Middleware = middleware; IsRepeatable = isRepeatable; Key = key; }
protected void Use(FieldMiddleware middleware) { if (middleware == null) { throw new ArgumentNullException(nameof(middleware)); } FieldDescription.MiddlewareComponents.Add(middleware); }
public static IObjectFieldDescriptor UseAutoMapperProjection( this IObjectFieldDescriptor descriptor, Type objectType) { FieldMiddleware placeholder = next => context => default; descriptor .Use(placeholder) .Extend() .OnBeforeCreate( (context, definition) => { if (definition.ResultType is null || !context.TypeInspector.TryCreateTypeInfo( definition.ResultType, out ITypeInfo? typeInfo)) { Type resultType = definition.ResolverType ?? typeof(object); throw new ArgumentException( $"Cannot handle the specified type `{resultType.FullName}`.", nameof(descriptor)); } if (!typeof(IQueryable).IsAssignableFrom(definition.ResultType)) { throw new ArgumentException( $"Cannot handle the specified type `{definition.ResultType.FullName}`.", nameof(descriptor)); } Type selectionType = typeInfo.NamedType; definition.ResultType = typeof(IQueryable <>).MakeGenericType(objectType); definition.Type = context.TypeInspector.GetTypeRef(definition.ResultType); ILazyTypeConfiguration lazyConfiguration = LazyTypeConfigurationBuilder .New <ObjectFieldDefinition>() .Definition(definition) .Configure( (_, __) => { CompileMiddleware( selectionType, objectType, definition, placeholder, _middlewareDefinition); }) .On(ApplyConfigurationOn.Completion) .Build(); definition.Configurations.Add(lazyConfiguration); }); return(descriptor); }
public static IMiddlewareConfiguration Map( this IMiddlewareConfiguration configuration, FieldReference fieldReference, FieldMiddleware middleware) { return(configuration.Use( ClassMiddlewareFactory.Create <MapMiddleware>( (s, n) => new MapMiddleware( n, fieldReference, middleware(n))))); }
public QueryExecutor( ISchema schema, IServiceProvider applicationServices, QueryDelegate queryDelegate, FieldMiddleware fieldMiddleware) : this(schema, queryDelegate, fieldMiddleware) { _applicationServices = applicationServices ?? throw new ArgumentNullException(nameof(applicationServices)); }
public IObjectFieldDescriptor Use(FieldMiddleware middleware) { if (middleware == null) { throw new ArgumentNullException(nameof(middleware)); } Definition.MiddlewareComponents.Add(middleware); return(this); }
public static IRequestExecutorBuilder MapField( this IRequestExecutorBuilder builder, FieldReference fieldReference, FieldMiddleware middleware) { return(builder.UseField( FieldClassMiddlewareFactory.Create( (s, n) => new MapMiddleware( n, fieldReference, middleware(n))))); }
public ISchemaBuilder Use(FieldMiddleware middleware) { if (middleware == null) { throw new ArgumentNullException(nameof(middleware)); } _globalComponents.Add(middleware); return(this); }
public static ISchemaBuilder Map( this ISchemaBuilder configuration, FieldReference fieldReference, FieldMiddleware middleware) { return(configuration.Use( FieldClassMiddlewareFactory.Create( (s, n) => new MapMiddleware( n, fieldReference, middleware(n))))); }
public IQueryExecutionBuilder UseField(FieldMiddleware middleware) { if (middleware == null) { throw new ArgumentNullException(nameof(middleware)); } _fieldMiddlewareComponents.Add(middleware); return(this); }
public IMiddlewareConfiguration Use(FieldMiddleware middleware) { if (middleware == null) { throw new ArgumentNullException(nameof(middleware)); } _resolverRegistry.RegisterMiddleware(middleware); return(this); }
public IMiddlewareConfiguration Use(FieldMiddleware middleware) { if (middleware == null) { throw new ArgumentNullException(nameof(middleware)); } _builder.Use(middleware); return(this); }
public static IQueryExecutionBuilder Map( this IQueryExecutionBuilder builder, FieldReference fieldReference, FieldMiddleware middleware) { return(builder.UseField( FieldClassMiddlewareFactory.Create <MapMiddleware>( (s, n) => new MapMiddleware( n, fieldReference, middleware(n))))); }
public static IObjectFieldDescriptor UseDbContext <TDbContext>( this IObjectFieldDescriptor descriptor) where TDbContext : DbContext { string scopedServiceName = typeof(TDbContext).FullName ?? typeof(TDbContext).Name; FieldMiddleware placeholder = next => context => throw new NotSupportedException(); descriptor .Use(next => async context => { await using TDbContext dbContext = context.Services .GetRequiredService <IDbContextFactory <TDbContext> >() .CreateDbContext(); try { context.SetLocalValue(scopedServiceName, dbContext); await next(context).ConfigureAwait(false); } finally { context.RemoveLocalValue(scopedServiceName); } }) .Use(placeholder) .Extend() .OnBeforeNaming((c, d) => { if (d.ResultType is null) { d.MiddlewareComponents.Remove(placeholder); return; } if (TryExtractEntityType(d.ResultType, out Type? entityType)) { Type middleware = typeof(ToListMiddleware <>).MakeGenericType(entityType); var index = d.MiddlewareComponents.IndexOf(placeholder); d.MiddlewareComponents[index] = Create(middleware); return; } if (IsExecutable(d.ResultType)) { Type middleware = typeof(ExecutableMiddleware); var index = d.MiddlewareComponents.IndexOf(placeholder); d.MiddlewareComponents[index] = Create(middleware); } d.MiddlewareComponents.Remove(placeholder); }); return(descriptor); }
/// <summary> /// Projects the selection set of the request onto the field. Registers a middleware that /// uses the registered <see cref="ProjectionConvention"/> to apply the projections /// </summary> /// <param name="descriptor">The descriptor</param> /// <param name="scope"> /// Specify which <see cref="ProjectionConvention"/> is used, based on the value passed in /// <see cref="ProjectionsSchemaBuilderExtensions.AddProjections{T}"/> /// </param> /// <param name="type"> /// The <see cref="Type"/> of the resolved field /// </param> /// <returns>The descriptor passed in by <paramref name="descriptor"/></returns> /// <exception cref="ArgumentNullException"> /// In case the descriptor is null /// </exception> public static IObjectFieldDescriptor UseProjection( this IObjectFieldDescriptor descriptor, Type?type, string?scope = null) { if (descriptor is null) { throw new ArgumentNullException(nameof(descriptor)); } FieldMiddleware placeholder = next => context => default; descriptor .Use(placeholder) .Extend() .OnBeforeCreate( (context, definition) => { Type?selectionType = type; if (selectionType is null) { if (definition.ResultType is null || !context.TypeInspector.TryCreateTypeInfo( definition.ResultType, out ITypeInfo? typeInfo)) { throw new ArgumentException( "Cannot handle the specified type.", nameof(descriptor)); } selectionType = typeInfo.NamedType; } ILazyTypeConfiguration lazyConfiguration = LazyTypeConfigurationBuilder .New <ObjectFieldDefinition>() .Definition(definition) .Configure( (context, definition) => CompileMiddleware( selectionType, definition, placeholder, context, scope)) .On(ApplyConfigurationOn.Completion) .Build(); definition.Configurations.Add(lazyConfiguration); }); return(descriptor); }