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; }
private void OnBeforeCompleteName( ITypeCompletionContext completionContext, SortInputTypeDefinition definition) { ISortConvention convention = GetConvention( completionContext.DescriptorContext, definition.Scope); var descriptor = SortInputTypeDescriptor.New( completionContext.DescriptorContext, definition.EntityType, definition.Scope); SchemaTypeReference typeReference = TypeReference.Create( completionContext.Type, definition.Scope); convention.ApplyConfigurations(typeReference, descriptor); DataTypeExtensionHelper.MergeSortInputTypeDefinitions( completionContext, descriptor.CreateDefinition(), definition); if (definition is { Name : {} } &&
public static SchemaException SortConvention_OperationIsNotNamed( ISortConvention sortConvention, SortOperation sortOperation) => new SchemaException( SchemaErrorBuilder.New() .SetMessage( DataResources.SortProvider_UnableToCreateFieldHandler, sortOperation.Id, sortConvention.GetType().FullName ?? sortConvention.GetType().Name, sortConvention.Scope ?? "Default") .SetExtension(nameof(sortConvention), sortConvention) .SetExtension(nameof(sortOperation), sortOperation) .Build());
protected SortEnumValueDescriptor( IDescriptorContext context, string?scope, int value) : base(context, new SortEnumValueDefinition { Operation = value }) { ISortConvention convention = context.GetSortConvention(scope); Definition.Name = convention.GetOperationName(value); Definition.Description = convention.GetOperationDescription(value); Definition.RuntimeValue = Definition.Name.Value; }
private void ConfigureSortInputType( ITypeDiscoveryContext discoveryContext, SortInputTypeDefinition definition) { ISortConvention convention = GetConvention( discoveryContext.DescriptorContext, definition.Scope); var descriptor = SortInputTypeDescriptor.From( discoveryContext.DescriptorContext, definition, definition.Scope); SchemaTypeReference typeReference = TypeReference.Create( discoveryContext.Type, definition.Scope); convention.ApplyConfigurations(typeReference, descriptor); foreach (InputFieldDefinition field in definition.Fields) { if (field is SortFieldDefinition sortFieldDefinition) { if (discoveryContext.TryPredictTypeKind( sortFieldDefinition.Type, out TypeKind kind) && kind != TypeKind.Enum) { field.Type = field.Type.With(scope: discoveryContext.Scope); } if (convention.TryGetFieldHandler( discoveryContext, definition, sortFieldDefinition, out ISortFieldHandler? handler)) { sortFieldDefinition.Handler = handler; } else { throw ThrowHelper.SortInterceptor_NoFieldHandlerFoundForField( definition, sortFieldDefinition); } } } }
private static void CompileMiddleware( ITypeCompletionContext context, ObjectFieldDefinition definition, ITypeReference argumentTypeReference, FieldMiddleware placeholder, string?scope) { ISortInputType type = context.GetType <ISortInputType>(argumentTypeReference); ISortConvention convention = context.DescriptorContext.GetSortConvention(scope); 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; }
private void ConfigureSortEnumType( ITypeDiscoveryContext discoveryContext, SortEnumTypeDefinition definition) { ISortConvention convention = GetConvention( discoveryContext.DescriptorContext, discoveryContext.Scope); ISortEnumTypeDescriptor descriptor = SortEnumTypeDescriptor.From( discoveryContext.DescriptorContext, definition); SchemaTypeReference typeReference = TypeReference.Create( discoveryContext.Type, discoveryContext.Scope); convention.ApplyConfigurations(typeReference, descriptor); foreach (var enumValue in definition.Values) { if (enumValue is SortEnumValueDefinition sortEnumValueDefinition) { if (convention.TryGetOperationHandler( discoveryContext, definition, sortEnumValueDefinition, out ISortOperationHandler? handler)) { sortEnumValueDefinition.Handler = handler; } else { throw ThrowHelper.SortInterceptor_NoOperationHandlerFoundForValue( definition, sortEnumValueDefinition); } } } }
private void OnBeforeRegisteringDependencies( ITypeDiscoveryContext discoveryContext, SortEnumTypeDefinition definition) { ISortConvention convention = GetConvention( discoveryContext.DescriptorContext, definition.Scope); var descriptor = SortEnumTypeDescriptor.New( discoveryContext.DescriptorContext, definition.EntityType, definition.Scope); SchemaTypeReference typeReference = TypeReference.Create( discoveryContext.Type, definition.Scope); convention.ApplyConfigurations(typeReference, descriptor); SortEnumTypeDefinition extensionDefinition = descriptor.CreateDefinition(); discoveryContext.RegisterDependencies(extensionDefinition); }
private static FieldMiddleware CreateMiddleware <TEntity>( ISortConvention convention) => convention.CreateExecutor <TEntity>();
private static IObjectFieldDescriptor UseSortingInternal( IObjectFieldDescriptor descriptor, Type?sortType, string?scope) { FieldMiddleware placeholder = next => context => default; string argumentPlaceholder = "_" + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture); descriptor .Use(placeholder) .Extend() .OnBeforeCreate( (c, definition) => { ISortConvention convention = c.GetSortConvention(scope); Type argumentType; if (sortType 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)); } ExtendedTypeReference fieldType = convention .GetFieldType(typeInfo.NamedType); argumentType = fieldType.Type.Type; } else { argumentType = sortType; } ExtendedTypeReference argumentTypeReference = c.TypeInspector.GetTypeRef( typeof(ListType <>).MakeGenericType( typeof(NonNullType <>).MakeGenericType(argumentType)), 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, def) => CompileMiddleware( context, def, argumentTypeReference, placeholder, scope)) .On(ApplyConfigurationOn.Completion) .DependsOn(argumentTypeReference, true) .Build()); argumentDefinition.Configurations.Add( LazyTypeConfigurationBuilder .New <ArgumentDefinition>() .Definition(argumentDefinition) .Configure( (context, argumentDefinition) => argumentDefinition.Name = context.GetSortConvention(scope).GetArgumentName()) .On(ApplyConfigurationOn.Naming) .Build()); }); return(descriptor); }