Less generics

Author: tobias-tengler

src/HotChocolate/Core/src/Execution/DependencyInjection/RequestExecutorBuilderExtensions.Services.cs

@@ -36,7 +36,7 @@ public static IRequestExecutorBuilder AddScopedServiceInitializer<TService>(
 
     /// <summary>
     /// Resolves an instance of <typeparamref name="TService"/> from the application
-    /// service provider and makes it available as a singleton through the schema
+    /// service provider and makes it available as a Singleton through the schema
     /// service provider.
     /// </summary>
     /// <typeparam name="TService">

src/HotChocolate/Data/src/Data/DataResources.Designer.cs

@@ -170,13 +170,13 @@
     <value>The provided value for filter `{0}` of type {1} is invalid. Null values are not supported.</value>
   </data>
   <data name="FilterProvider_UnableToCreateFieldHandler" xml:space="preserve">
-    <value>Unable to create field handler `{0}` for filter provider `{1}`.</value>
+    <value>Unable to create field handler for filter provider `{0}`.</value>
   </data>
   <data name="SortProvider_UnableToCreateFieldHandler" xml:space="preserve">
-    <value>Unable to create field handler `{0}` for sort provider `{1}`.</value>
+    <value>Unable to create field handler for sort provider `{0}`.</value>
   </data>
   <data name="SortProvider_UnableToCreateOperationHandler" xml:space="preserve">
-    <value>Unable to create operation handler `{0}` for sort provider `{1}`.</value>
+    <value>Unable to create operation handler for sort provider `{0}`.</value>
   </data>
   <data name="SortEnumValue_ValueIsNull" xml:space="preserve">
     <value>The inner value of enum value cannot be null or empty</value>
@@ -197,7 +197,7 @@
     <value>No configuration was specified.</value>
   </data>
   <data name="ProjectionProvider_UnableToCreateFieldHandler" xml:space="preserve">
-    <value>Unable to create field handler `{0}` for projection convention `{1}`.</value>
+    <value>Unable to create field handler for projection provider `{0}`.</value>
   </data>
   <data name="ProjectionProvider_NoHandlersConfigured" xml:space="preserve">
     <value>The projection convention `{0}` does not specify and field handler.</value>

src/HotChocolate/Data/src/Data/DataResources.resx

@@ -66,14 +66,13 @@ public static IError CreateNonNullError<T>(
 
     public static ISchemaError ProjectionConvention_UnableToCreateFieldHandler(
         IProjectionProvider convention,
-        Type fieldHandler) =>
+        Exception exception) =>
         SchemaErrorBuilder.New()
             .SetMessage(
-                DataResources.FilterProvider_UnableToCreateFieldHandler,
-                fieldHandler.FullName ?? fieldHandler.Name,
+                DataResources.ProjectionProvider_UnableToCreateFieldHandler,
                 convention.GetType().FullName ?? convention.GetType().Name)
             .SetExtension(nameof(convention), convention)
-            .SetExtension(nameof(fieldHandler), fieldHandler)
+            .SetException(exception)
             .Build();
 
     public static IError ProjectionProvider_CouldNotProjectFiltering(IValueNode node) =>

src/HotChocolate/Data/src/Data/ErrorHelper.cs

@@ -0,0 +1,47 @@
+namespace HotChocolate.Data.Filters;
+
+public readonly struct FilterFieldHandlerConfiguration
+{
+    private readonly Func<FilterProviderContext, IFilterFieldHandler>? _factory;
+    private readonly IFilterFieldHandler? _instance;
+
+    public FilterFieldHandlerConfiguration(IFilterFieldHandler instance)
+    {
+        _instance = instance;
+    }
+
+    public FilterFieldHandlerConfiguration(Func<FilterProviderContext, IFilterFieldHandler> factory)
+    {
+        _factory = factory;
+    }
+
+    public IFilterFieldHandler<TContext> Create<TContext>(FilterProviderContext context)
+        where TContext : IFilterVisitorContext
+    {
+        if (_instance is not null)
+        {
+            if (_instance is not IFilterFieldHandler<TContext> handler)
+            {
+                throw new InvalidOperationException(
+                    $"Expected handler to be of type IFilterFieldHandler<{typeof(TContext).Name}>");
+            }
+
+            return handler;
+        }
+
+        if (_factory is null)
+        {
+            throw new InvalidOperationException("Expected to have either a factory or an instance.");
+        }
+
+        var instance = _factory(context);
+
+        if (instance is not IFilterFieldHandler<TContext> casted)
+        {
+            throw new InvalidOperationException(
+                $"Expected handler to be of type IFilterFieldHandler<{typeof(TContext).Name}>");
+        }
+
+        return casted;
+    }
+}

src/HotChocolate/Data/src/Data/Filters/Visitor/FilterFieldHandlerConfiguration.cs

@@ -12,7 +12,7 @@ namespace HotChocolate.Data.Filters;
 /// </summary>
 /// <typeparam name="TContext">The type of the context</typeparam>
 public abstract class FilterProvider<TContext>
-    : Convention<FilterProviderConfiguration<TContext>>
+    : Convention<FilterProviderConfiguration>
         , IFilterProvider
         , IFilterProviderConvention
     where TContext : IFilterVisitorContext
@@ -31,13 +31,13 @@ protected FilterProvider()
     protected FilterProvider(Action<IFilterProviderDescriptor<TContext>> configure)
         => _configure = configure ?? throw new ArgumentNullException(nameof(configure));
 
-    internal new FilterProviderConfiguration<TContext>? Configuration => base.Configuration;
+    internal new FilterProviderConfiguration? Configuration => base.Configuration;
 
     /// <inheritdoc />
     public IReadOnlyCollection<IFilterFieldHandler> FieldHandlers => _fieldHandlers;
 
     /// <inheritdoc />
-    protected override FilterProviderConfiguration<TContext> CreateConfiguration(IConventionContext context)
+    protected override FilterProviderConfiguration CreateConfiguration(IConventionContext context)
     {
         if (_configure is null)
         {
@@ -68,7 +68,7 @@ void IFilterProviderConvention.Complete(IConventionContext context)
     /// <inheritdoc />
     protected internal override void Complete(IConventionContext context)
     {
-        if (Configuration!.HandlerFactories.Count == 0)
+        if (Configuration!.FieldHandlerConfigurations.Count == 0)
         {
             throw FilterProvider_NoHandlersConfigured(this);
         }
@@ -92,19 +92,17 @@ protected internal override void Complete(IConventionContext context)
             context.DescriptorContext.InputFormatter
         );
 
-        foreach (var factory in Configuration.HandlerFactories)
+        foreach (var handlerConfiguration in Configuration.FieldHandlerConfigurations)
         {
             try
             {
-                var handler = factory(providerContext);
+                var handler = handlerConfiguration.Create<TContext>(providerContext);
 
                 _fieldHandlers.Add(handler);
             }
-            catch
+            catch (Exception exception)
             {
-                // TODO: Proper exception
-                throw new InvalidOperationException();
-                // throw FilterProvider_UnableToCreateFieldHandler(this, type);
+                throw FilterProvider_UnableToCreateFieldHandler(this, exception);
             }
         }
     }

src/HotChocolate/Data/src/Data/Filters/Visitor/FilterProvider.cs

@@ -1,6 +1,6 @@
 namespace HotChocolate.Data.Filters;
 
-public class FilterProviderConfiguration<TContext> where TContext : IFilterVisitorContext
+public class FilterProviderConfiguration
 {
-    public IList<Func<FilterProviderContext, IFilterFieldHandler<TContext>>> HandlerFactories { get; } = [];
+    public IList<FilterFieldHandlerConfiguration> FieldHandlerConfigurations { get; } = [];
 }

src/HotChocolate/Data/src/Data/Filters/Visitor/FilterProviderConfiguration.cs

@@ -8,25 +8,23 @@ protected FilterProviderDescriptor()
     {
     }
 
-    protected FilterProviderConfiguration<TContext> Configuration { get; } = new();
+    protected FilterProviderConfiguration Configuration { get; } = new();
 
-    public FilterProviderConfiguration<TContext> CreateConfiguration() => Configuration;
+    public FilterProviderConfiguration CreateConfiguration() => Configuration;
 
     public IFilterProviderDescriptor<TContext> AddFieldHandler<TFieldHandler>(
         Func<FilterProviderContext, TFieldHandler> factory)
         where TFieldHandler : IFilterFieldHandler<TContext>
     {
-        // TODO: Find a better way
-        Configuration.HandlerFactories.Add(ctx => factory(ctx));
+        Configuration.FieldHandlerConfigurations.Add(new FilterFieldHandlerConfiguration(ctx => factory(ctx)));
         return this;
     }
 
     public IFilterProviderDescriptor<TContext> AddFieldHandler<TFieldHandler>(
         TFieldHandler fieldHandler)
         where TFieldHandler : IFilterFieldHandler<TContext>
     {
-        // TODO: Find a better way
-        Configuration.HandlerFactories.Add(_ => fieldHandler);
+        Configuration.FieldHandlerConfigurations.Add(new FilterFieldHandlerConfiguration(fieldHandler));
         return this;
     }
 

src/HotChocolate/Data/src/Data/Filters/Visitor/FilterProviderDescriptor.cs

@@ -4,7 +4,7 @@
 namespace HotChocolate.Data.Filters;
 
 public abstract class FilterProviderExtensions<TContext>
-    : ConventionExtension<FilterProviderConfiguration<TContext>>,
+    : ConventionExtension<FilterProviderConfiguration>,
       IFilterProviderExtension,
       IFilterProviderConvention
     where TContext : IFilterVisitorContext
@@ -34,7 +34,7 @@ void IFilterProviderConvention.Complete(IConventionContext context)
         Complete(context);
     }
 
-    protected override FilterProviderConfiguration<TContext> CreateConfiguration(IConventionContext context)
+    protected override FilterProviderConfiguration CreateConfiguration(IConventionContext context)
     {
         if (_configure is null)
         {
@@ -60,9 +60,9 @@ public override void Merge(IConventionContext context, Convention convention)
             // Provider extensions should be applied by default before the default handlers, as
             // the interceptor picks up the first handler. A provider extension should adds more
             // specific handlers than the default providers
-            for (var i = Configuration.HandlerFactories.Count - 1; i >= 0; i--)
+            for (var i = Configuration.FieldHandlerConfigurations.Count - 1; i >= 0; i--)
             {
-                target.HandlerFactories.Insert(0, Configuration.HandlerFactories[i]);
+                target.FieldHandlerConfigurations.Insert(0, Configuration.FieldHandlerConfigurations[i]);
             }
         }
     }

src/HotChocolate/Data/src/Data/Filters/Visitor/FilterProviderExtensions.cs

@@ -0,0 +1,32 @@
+namespace HotChocolate.Data.Projections;
+
+public readonly struct ProjectionFieldHandlerConfiguration
+{
+    private readonly Func<ProjectionProviderContext, IProjectionFieldHandler>? _factory;
+    private readonly IProjectionFieldHandler? _instance;
+
+    public ProjectionFieldHandlerConfiguration(IProjectionFieldHandler instance)
+    {
+        _instance = instance;
+    }
+
+    public ProjectionFieldHandlerConfiguration(Func<ProjectionProviderContext, IProjectionFieldHandler> factory)
+    {
+        _factory = factory;
+    }
+
+    public IProjectionFieldHandler Create(ProjectionProviderContext context)
+    {
+        if (_instance is not null)
+        {
+            return _instance;
+        }
+
+        if (_factory is null)
+        {
+            throw new InvalidOperationException("Expected to have either a factory or an instance.");
+        }
+
+        return _factory(context);
+    }
+}