public override void OnConfigure( IDescriptorContext context, IObjectFieldDescriptor descriptor, MemberInfo member) { descriptor.Use(_ => _); }
public static IObjectFieldDescriptor UseCustomSelection <TType>(this IObjectFieldDescriptor descriptor) { descriptor .Use <CustomSelectionMiddleware <TType> >(); 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); }
private void ApplyConfigurationToField <TEntity, TType>( IObjectFieldDescriptor field, bool withPaging) where TEntity : class where TType : FilterInputType <TEntity> { field.Use( next => async context => { await next(context); if (context.Result is IQueryable <TEntity> queryable) { try { context.ContextData["sql"] = queryable.ToQueryString(); } catch (Exception) { context.ContextData["sql"] = "EF Core 3.1 does not support ToQueryString"; } } }); if (withPaging) { field.UsePaging <ObjectType <TEntity> >(); } field.UseFiltering <TType>(); }
public static IObjectFieldDescriptor UseBewitProtection <TPayload>( this IObjectFieldDescriptor descriptor) { return(descriptor .Use <BewitMiddleware <TPayload> >() .Type <NonNullType <StringType> >()); }
public static IObjectFieldDescriptor Use <TMiddleware>( this IObjectFieldDescriptor descriptor) where TMiddleware : class { return(descriptor.Use( FieldClassMiddlewareFactory.Create <TMiddleware>())); }
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); }
/// <summary> /// Attach authorizator to the field. /// </summary> /// <returns>Field descriptor with middleware attached.</returns> public static IObjectFieldDescriptor UseAuthorization(this IObjectFieldDescriptor descriptor) { return(descriptor.Use((services, next) => new Authorizator(next, services .CreateScope() .ServiceProvider .GetRequiredService <Tokenizer>()))); }
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 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); }
/// <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); }
/// <summary> /// Adds FluentValidation field middleware. /// It is going to validate all non-null field arguments and report errors if there is one or more failures. /// </summary> /// <param name="errorBuilderType">Custom error builder class type used to construct single validation error.</param> public static IObjectFieldDescriptor UseFluentValidation( this IObjectFieldDescriptor descriptor, Type errorBuilderType) { if (!(typeof(IValidationErrorBuilder).IsAssignableFrom(errorBuilderType) && errorBuilderType.IsClass)) { throw new ArgumentException($"{errorBuilderType.Name} is not a class implementing {nameof(IValidationErrorBuilder)}!"); } return(descriptor.Use((provider, next) => new FluentValidationMiddleware(next, errorBuilderType))); }
public static IObjectFieldDescriptor Use <TMiddleware>( this IObjectFieldDescriptor descriptor, Func <IServiceProvider, FieldDelegate, TMiddleware> factory) where TMiddleware : class { if (factory is null) { throw new ArgumentNullException(nameof(factory)); } return(descriptor.Use(FieldClassMiddlewareFactory.Create(factory))); }
/// <summary> /// Adds TransactionScope field middleware. /// </summary> /// <param name="factoryType">Custom TransactionScope factory class type implementing <see cref="ITransactionScopeFactory"/>.</param> public static IObjectFieldDescriptor UseTransactionScope( this IObjectFieldDescriptor descriptor, Type factoryType) { if (!(typeof(ITransactionScopeFactory).IsAssignableFrom(factoryType) && factoryType.IsClass)) { throw new ArgumentException($"{factoryType.Name} is not a class implementing {nameof(ITransactionScopeFactory)}!"); } return(descriptor.Use((provider, next) => new TransactionScopeMiddleware(next, factoryType))); }
public override void OnConfigure( IDescriptorContext context, IObjectFieldDescriptor descriptor, MemberInfo member) { descriptor.Use(next => context => { context.LocalContextData = context.LocalContextData.SetItem( QueryableProjectionProvider.ContextApplyProjectionKey, CreateApplicatorAsync <Foo>()); return(next(context)); }); }
public static IObjectFieldDescriptor UseSorting( this IObjectFieldDescriptor descriptor, Type sortType, ITypeSystemMember sortTypeInstance = null) { FieldMiddleware placeholder = next => context => Task.CompletedTask; descriptor .Use(placeholder) .Extend() .OnBeforeCreate(definition => { Type argumentType = GetArgumentType(definition, sortType); ITypeReference argumentTypeReference = sortTypeInstance is null ? (ITypeReference) new ClrTypeReference( argumentType, TypeContext.Input) : new SchemaTypeReference(sortTypeInstance); var argumentDefinition = new ArgumentDefinition { Name = OrderByArgumentName, Type = new ClrTypeReference( argumentType, TypeContext.Input) }; definition.Arguments.Add(argumentDefinition); ILazyTypeConfiguration lazyConfiguration = LazyTypeConfigurationBuilder .New <ObjectFieldDefinition>() .Definition(definition) .Configure((context, defintion) => CompileMiddleware( context, definition, argumentTypeReference, placeholder)) .On(ApplyConfigurationOn.Completion) .DependsOn(argumentTypeReference, true) .Build(); definition.Configurations.Add(lazyConfiguration); }); return(descriptor); }
public override void OnConfigure( IDescriptorContext context, IObjectFieldDescriptor descriptor, MemberInfo member) { descriptor.Use(next => async context => { try { await next(context); } catch (Exception ex) { context.ContextData["ex"] = ex.Message; } }); }
private static IObjectFieldDescriptor UseSelection( IObjectFieldDescriptor descriptor, Type?objectType) { FieldMiddleware placeholder = next => context => Task.CompletedTask; descriptor .Use(placeholder) .Extend() .OnBeforeCreate(definition => { Type?selectionType = objectType; if (selectionType == null) { if (!TypeInspector.Default.TryCreate( definition.ResultType, out TypeInfo typeInfo)) { // TODO : resources throw new ArgumentException( "Cannot handle the specified type.", nameof(descriptor)); } selectionType = typeInfo.ClrType; } ILazyTypeConfiguration lazyConfiguration = LazyTypeConfigurationBuilder .New <ObjectFieldDefinition>() .Definition(definition) .Configure((context, defintion) => CompileMiddleware( selectionType, definition, placeholder, context)) .On(ApplyConfigurationOn.Completion) .Build(); definition.Configurations.Add(lazyConfiguration); }); return(descriptor); }
public static IObjectFieldDescriptor ID( this IObjectFieldDescriptor descriptor, NameString typeName = default) { if (descriptor is null) { throw new ArgumentNullException(nameof(descriptor)); } FieldMiddleware placeholder = n => c => default; descriptor.Use(placeholder); descriptor.Extend().OnBeforeCreate(RewriteObjectFieldType); descriptor.Extend().OnBeforeCompletion( (c, d) => AddSerializerToObjectField(c, d, placeholder, typeName)); return(descriptor); }
public override void OnConfigure( IDescriptorContext context, IObjectFieldDescriptor descriptor, MemberInfo member) { descriptor.Use(next => context => { if (!context.ContextData.ContainsKey("currentUserId")) { context.ReportError( ErrorBuilder.New() .SetMessage("Must be authorized to perform this action") .SetCode("NOT_AUTHORIZED") .Build()); context.Result = new ForbidResult(); } return(next(context)); }); }
public static IObjectFieldDescriptor UseAutoSubscription(this IObjectFieldDescriptor descriptor, string subscriptionName) { descriptor .Extend() .OnBeforeNaming((configure, defn) => { if (!configure.ContextData.ContainsKey(AutoSubscriptionTypeInterceptor.AutoSubscriptionContext)) { configure.ContextData[AutoSubscriptionTypeInterceptor.AutoSubscriptionContext] = new List <ObjectFieldDefinition>(); } ((List <ObjectFieldDefinition>)configure.ContextData[AutoSubscriptionTypeInterceptor.AutoSubscriptionContext]).Add(defn); }); descriptor.Use(next => async context => { await next(context); await context.SendSimpleSubscription(subscriptionName, context.Result); }); 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((c, d) => { MemberInfo?member = d.ResolverMember ?? d.Member; IExtendedType schemaType = GetSchemaType(c.TypeInspector, member, type); var configuration = new TypeConfiguration <ObjectFieldDefinition> { Definition = d, On = ApplyConfigurationOn.Completion, Configure = (c, d) => ApplyConfiguration( c, d, entityType, resolvePagingProvider, options, placeholder) }; configuration.Dependencies.Add( new TypeDependency( TypeReference.Create(schemaType, TypeContext.Output), TypeDependencyKind.Named)); d.Configurations.Add(configuration); }); return(descriptor); }
private static IObjectFieldDescriptor UseFiltering( IObjectFieldDescriptor descriptor, Type?filterType, ITypeSystemMember?filterTypeInstance, string?scope) { FieldMiddleware placeholder = next => context => default; string argumentPlaceholder = "_" + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture); descriptor .Use(placeholder) .Extend() .OnBeforeCreate( (c, definition) => { IFilterConvention convention = c.GetFilterConvention(scope); ITypeReference argumentTypeReference; if (filterTypeInstance is not null) { argumentTypeReference = TypeReference.Create(filterTypeInstance, scope); } else if (filterType is null) { if (definition.ResultType is null || definition.ResultType == typeof(object) || !c.TypeInspector.TryCreateTypeInfo( definition.ResultType, out ITypeInfo? typeInfo)) { throw new ArgumentException( FilterObjectFieldDescriptorExtensions_UseFiltering_CannotHandleType, nameof(descriptor)); } argumentTypeReference = convention.GetFieldType(typeInfo.NamedType); } else { argumentTypeReference = c.TypeInspector.GetTypeRef( filterType, TypeContext.Input, scope); } var argumentDefinition = new ArgumentDefinition { Name = argumentPlaceholder, Type = argumentTypeReference }; definition.Arguments.Add(argumentDefinition); definition.Configurations.Add( LazyTypeConfigurationBuilder .New <ObjectFieldDefinition>() .Definition(definition) .Configure( (context, definition) => CompileMiddleware( context, definition, argumentTypeReference, placeholder, scope)) .On(ApplyConfigurationOn.Completion) .DependsOn(argumentTypeReference, true) .Build()); argumentDefinition.Configurations.Add( LazyTypeConfigurationBuilder .New <ArgumentDefinition>() .Definition(argumentDefinition) .Configure( (context, argumentDefinition) => argumentDefinition.Name = context.GetFilterConvention(scope).GetArgumentName()) .On(ApplyConfigurationOn.Naming) .Build()); }); return(descriptor); }
public static IObjectFieldDescriptor AuthorizeBewit <T>( this IObjectFieldDescriptor descriptor) { return(descriptor .Use <BewitAuthorizationMiddleware <T> >()); }
private static IObjectFieldDescriptor UseFiltering( IObjectFieldDescriptor descriptor, Type?filterType, ITypeSystemMember?filterTypeInstance = null) { FieldMiddleware placeholder = _ => _ => Task.CompletedTask; descriptor .Use(placeholder) .Extend() .OnBeforeCreate(definition => { Type?argumentType = filterType; if (argumentType == null) { if (!TypeInspector.Default.TryCreate( definition.ResultType, out TypeInfo typeInfo)) { throw new ArgumentException( FilterResources.FilterObjectFieldDescriptor_InvalidType, nameof(descriptor)); } argumentType = typeof(FilterInputType <>).MakeGenericType(typeInfo.ClrType); } ITypeReference argumentTypeReference = filterTypeInstance is null ? (ITypeReference) new ClrTypeReference(argumentType, TypeContext.Input) : new SchemaTypeReference(filterTypeInstance); if (argumentType == typeof(object)) { throw new SchemaException( SchemaErrorBuilder.New() .SetMessage( FilterResources.FilterObjectFieldDescriptor_InvalidType_Msg) .SetCode(ErrorCodes.Filtering.FilterObjectType) .Build()); } var argumentDefinition = new ArgumentDefinition { Type = new ClrTypeReference(argumentType, TypeContext.Input) }; argumentDefinition.ConfigureArgumentName(); definition.Arguments.Add(argumentDefinition); ILazyTypeConfiguration lazyConfiguration = LazyTypeConfigurationBuilder .New <ObjectFieldDefinition>() .Definition(definition) .Configure((context, definition) => CompileMiddleware( context, definition, argumentTypeReference, placeholder)) .On(ApplyConfigurationOn.Completion) .DependsOn(argumentTypeReference, true) .Build(); definition.Configurations.Add(lazyConfiguration); }); return(descriptor); }
private static IObjectFieldDescriptor UseFiltering( IObjectFieldDescriptor descriptor, Type filterType, ITypeSystemMember filterTypeInstance = null) { FieldMiddleware placeholder = next => context => Task.CompletedTask; descriptor .Use(placeholder) .Extend() .OnBeforeCreate(definition => { Type argumentType = filterType; if (filterType == null) { if (!TypeInspector.Default.TryCreate( definition.ResultType, out TypeInfo typeInfo)) { // TODO : resources throw new ArgumentException( "Cannot handle the specified type.", nameof(descriptor)); } argumentType = typeof(FilterInputType <>).MakeGenericType( typeInfo.ClrType); } var argumentTypeReference = filterTypeInstance is null ? (ITypeReference) new ClrTypeReference( argumentType, TypeContext.Input) : new SchemaTypeReference(filterTypeInstance); if (argumentType == typeof(object)) { // TODO : resources throw new SchemaException( SchemaErrorBuilder.New() .SetMessage( "The filter type cannot be " + "infered from `System.Object`.") .SetCode(ErrorCodes.Filtering.FilterObjectType) .Build()); } var argumentDefinition = new ArgumentDefinition(); argumentDefinition.Name = _whereArgumentName; argumentDefinition.Type = new ClrTypeReference( argumentType, TypeContext.Input); definition.Arguments.Add(argumentDefinition); ILazyTypeConfiguration lazyConfiguration = LazyTypeConfigurationBuilder .New <ObjectFieldDefinition>() .Definition(definition) .Configure((context, defintion) => CompileMiddleware( context, definition, argumentTypeReference, placeholder)) .On(ApplyConfigurationOn.Completion) .DependsOn(argumentTypeReference, true) .Build(); definition.Configurations.Add(lazyConfiguration); }); return(descriptor); }
private static IObjectFieldDescriptor UseFiltering( IObjectFieldDescriptor descriptor, Type?filterType, ITypeSystemMember?filterTypeInstance = null) { FieldMiddleware placeholder = next => context => default; string argumentPlaceholder = "_" + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture); descriptor .Use(placeholder) .Extend() .OnBeforeCreate((c, definition) => { Type?argumentType = filterType; if (argumentType is null) { if (definition.ResultType is null || definition.ResultType == typeof(object) || !c.TypeInspector.TryCreateTypeInfo( definition.ResultType, out ITypeInfo? typeInfo)) { throw new ArgumentException( FilterResources.FilterObjectFieldDescriptor_InvalidType, nameof(descriptor)); } argumentType = typeof(FilterInputType <>) .MakeGenericType(typeInfo.NamedType); } ITypeReference argumentTypeReference = filterTypeInstance is null ? (ITypeReference)c.TypeInspector.GetTypeRef( argumentType, TypeContext.Input) : TypeReference.Create(filterTypeInstance); if (argumentType == typeof(object)) { throw new SchemaException( SchemaErrorBuilder.New() .SetMessage( FilterResources.FilterObjectFieldDescriptor_InvalidType_Msg) .SetCode(ErrorCodes.Filtering.FilterObjectType) .Build()); } var argumentDefinition = new ArgumentDefinition { Name = argumentPlaceholder, Type = c.TypeInspector.GetTypeRef(argumentType, TypeContext.Input) }; argumentDefinition.ConfigureArgumentName(); definition.Arguments.Add(argumentDefinition); ILazyTypeConfiguration lazyConfiguration = LazyTypeConfigurationBuilder .New <ObjectFieldDefinition>() .Definition(definition) .Configure((context, definition) => CompileMiddleware( context, definition, argumentTypeReference, placeholder)) .On(ApplyConfigurationOn.Completion) .DependsOn(argumentTypeReference, true) .Build(); definition.Configurations.Add(lazyConfiguration); }); return(descriptor); }
public static IObjectFieldDescriptor UseBewitUrlProtection( this IObjectFieldDescriptor descriptor) { return(descriptor.Use <BewitUrlMiddleware>() .Type <NonNullType <StringType> >()); }
public static IObjectFieldDescriptor UseSorting( this IObjectFieldDescriptor descriptor, Type?sortType, ITypeSystemMember?sortTypeInstance = null) { FieldMiddleware placeholder = next => context => default; string argumentPlaceholder = "_" + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture); descriptor .Use(placeholder) .Extend() .OnBeforeCreate((c, definition) => { Type argumentType = GetArgumentType(definition, sortType, c.TypeInspector); ITypeReference argumentTypeReference = sortTypeInstance is null ? (ITypeReference)c.TypeInspector.GetTypeRef( argumentType, TypeContext.Input) : TypeReference.Create(sortTypeInstance); var argumentDefinition = new ArgumentDefinition { Name = argumentPlaceholder, Type = c.TypeInspector.GetTypeRef(argumentType, TypeContext.Input) }; ILazyTypeConfiguration lazyArgumentConfiguration = LazyTypeConfigurationBuilder .New <ArgumentDefinition>() .Definition(argumentDefinition) .Configure((context, definition) => { ISortingNamingConvention convention = context.DescriptorContext.GetSortingNamingConvention(); definition.Name = convention.ArgumentName; }) .On(ApplyConfigurationOn.Completion) .Build(); argumentDefinition.Configurations.Add(lazyArgumentConfiguration); definition.Arguments.Add(argumentDefinition); ILazyTypeConfiguration lazyConfiguration = LazyTypeConfigurationBuilder .New <ObjectFieldDefinition>() .Definition(definition) .Configure((context, definition) => CompileMiddleware( context, definition, argumentTypeReference, placeholder)) .On(ApplyConfigurationOn.Completion) .DependsOn(argumentTypeReference, true) .Build(); definition.Configurations.Add(lazyConfiguration); }); return(descriptor); }
private static IObjectFieldDescriptor UseSorting( IObjectFieldDescriptor descriptor, Type?sortType, ITypeSystemMember?sortTypeInstance, string?scope) { FieldMiddleware placeholder = next => context => default; string argumentPlaceholder = "_" + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture); descriptor .Use(placeholder) .Extend() .OnBeforeCreate( (c, definition) => { Type?argumentType = sortType; if (argumentType is null) { if (definition.ResultType is null || definition.ResultType == typeof(object) || !c.TypeInspector.TryCreateTypeInfo( definition.ResultType, out ITypeInfo? typeInfo)) { throw new ArgumentException( SortObjectFieldDescriptorExtensions_UseSorting_CannotHandleType, nameof(descriptor)); } argumentType = typeof(SortInputType <>) .MakeGenericType(typeInfo.NamedType); } ITypeReference argumentTypeReference = sortTypeInstance is null ? (ITypeReference)c.TypeInspector.GetTypeRef( argumentType, TypeContext.Input, scope) : TypeReference.Create(sortTypeInstance, scope); if (argumentType == typeof(object)) { throw SortObjectFieldDescriptorExtensions_CannotInfer(); } argumentType = typeof(ListType <>).MakeGenericType(argumentType); var argumentDefinition = new ArgumentDefinition { Name = argumentPlaceholder, Type = c.TypeInspector.GetTypeRef( argumentType, TypeContext.Input, scope) }; definition.Arguments.Add(argumentDefinition); definition.Configurations.Add( LazyTypeConfigurationBuilder .New <ObjectFieldDefinition>() .Definition(definition) .Configure( (context, def) => CompileMiddleware( context, def, argumentTypeReference, placeholder, scope)) .On(ApplyConfigurationOn.Completion) .DependsOn(argumentTypeReference, true) .Build()); definition.Configurations.Add( LazyTypeConfigurationBuilder .New <ObjectFieldDefinition>() .Definition(definition) .Configure( (context, _) => argumentDefinition.Name = context.GetSortConvention(scope).GetArgumentName()) .On(ApplyConfigurationOn.Naming) .Build()); }); return(descriptor); }