Added new node id serializer.

src/HotChocolate/Core/src/Abstractions/WellKnownContextData.cs

@@ -179,6 +179,11 @@ public static class WellKnownContextData
     /// </summary>
     public const string GlobalIdSupportEnabled = "HotChocolate.Relay.GlobalId";
 
+    /// <summary>
+    /// The key to get the serializer types.
+    /// </summary>
+    public const string SerializerTypes = "HotChocolate.Relay.SerializerTypes";
+
     /// <summary>
     /// The key to get the node id from the context data.
     /// </summary>
@@ -299,4 +304,9 @@ public static class WellKnownContextData
     /// Type key to access the object type configuration hooks in the schema builder context data.
     /// </summary>
     public const string ObjectTypeConfigurations = "HotChocolate.Types.ObjectTypeConfigurations";
+
+    /// <summary>
+    /// Type key to access the node id result formatter on the descriptor context.
+    /// </summary>
+    public const string NodeIdResultFormatter = "HotChocolate.Relay.NodeIdResultFormatter";
 }

src/HotChocolate/Core/src/Execution/DependencyInjection/InternalServiceCollectionExtensions.cs

@@ -108,7 +108,7 @@ internal static IServiceCollection TryAddDeferredWorkStatePool(
 
         return services;
     }
-    
+
     internal static IServiceCollection TryAddTypeConverter(
         this IServiceCollection services)
     {
@@ -183,13 +183,6 @@ internal static IServiceCollection TryAddDefaultDataLoaderRegistry(
         return services;
     }
 
-    internal static IServiceCollection TryAddIdSerializer(
-        this IServiceCollection services)
-    {
-        services.TryAddSingleton<IIdSerializer, IdSerializer>();
-        return services;
-    }
-
     internal static IServiceCollection TryAddDataLoaderParameterExpressionBuilder(
         this IServiceCollection services)
         => services.TryAddParameterExpressionBuilder<DataLoaderParameterExpressionBuilder>();

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

@@ -1,4 +1,7 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
+using HotChocolate;
 using HotChocolate.Execution.Configuration;
 using HotChocolate.Types.Relay;
 using Microsoft.Extensions.DependencyInjection.Extensions;
@@ -8,94 +11,89 @@
 
 public static partial class RequestExecutorBuilderExtensions
 {
-    public static IServiceCollection AddIdSerializer(
-        this IServiceCollection services,
-        bool includeSchemaName = false)
-    {
-        if (services == null)
-        {
-            throw new ArgumentNullException(nameof(services));
-        }
-
-        services.RemoveAll<IIdSerializer>();
-        services.AddSingleton<IIdSerializer>(new IdSerializer(includeSchemaName));
-        return services;
-    }
-
-    public static IServiceCollection AddIdSerializer<T>(
-        this IServiceCollection services)
-        where T : class, IIdSerializer
-    {
-        if (services == null)
-        {
-            throw new ArgumentNullException(nameof(services));
-        }
-
-        services.RemoveAll<IIdSerializer>();
-        services.AddSingleton<IIdSerializer, T>();
-        return services;
-    }
-
-    public static IServiceCollection AddIdSerializer(
-        this IServiceCollection services,
-        Func<IServiceProvider, IIdSerializer> factory)
-    {
-        if (services == null)
-        {
-            throw new ArgumentNullException(nameof(services));
-        }
-
-        if (factory == null)
-        {
-            throw new ArgumentNullException(nameof(factory));
-        }
-
-        services.RemoveAll<IIdSerializer>();
-        services.AddSingleton(factory);
-        return services;
-    }
-
-    public static IRequestExecutorBuilder AddIdSerializer(
+    /// <summary>
+    /// Adds a default node id serializer to the schema.
+    /// </summary>
+    /// <param name="builder">
+    /// The request executor builder.
+    /// </param>
+    /// <param name="maxIdLength">
+    /// The maximum allowed length of a node id.
+    /// </param>
+    /// <returns>
+    /// Returns the request executor builder.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">
+    /// <paramref name="builder"/> is <see langword="null"/>.
+    /// </exception>
+    public static IRequestExecutorBuilder AddDefaultNodeIdSerializer(
         this IRequestExecutorBuilder builder,
-        bool includeSchemaName = false)
+        int maxIdLength = 1024)
     {
         if (builder == null)
         {
             throw new ArgumentNullException(nameof(builder));
         }
 
-        builder.Services.AddIdSerializer(includeSchemaName);
-        return builder;
-    }
+        builder.ConfigureSchemaServices(
+            services =>
+            {
+                services.TryAddSingleton<INodeIdSerializer>(sp =>
+                {
+                    var schema = sp.GetRequiredService<ISchema>();
+                    var boundSerializers = new List<BoundNodeIdValueSerializer>();
+                    var allSerializers = sp.GetServices<INodeIdValueSerializer>().ToArray();
 
-    public static IRequestExecutorBuilder AddIdSerializer<T>(
-        this IRequestExecutorBuilder builder)
-        where T : class, IIdSerializer
-    {
-        if (builder == null)
-        {
-            throw new ArgumentNullException(nameof(builder));
-        }
+                    if (schema.ContextData.TryGetValue(WellKnownContextData.SerializerTypes, out var value))
+                    {
+                        var serializerTypes = (Dictionary<string, Type>)value!;
 
-        builder.Services.AddIdSerializer<T>();
+                        foreach (var item in serializerTypes)
+                        {
+                            foreach (var serializer in allSerializers)
+                            {
+                                if (serializer.IsSupported(item.Value))
+                                {
+                                    boundSerializers.Add(new BoundNodeIdValueSerializer(item.Key, serializer));
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
+                    return new DefaultNodeIdSerializer(boundSerializers, allSerializers, maxIdLength);
+                });
+            });
         return builder;
     }
 
-    public static IRequestExecutorBuilder AddIdSerializer(
-        this IRequestExecutorBuilder builder,
-        Func<IServiceProvider, IIdSerializer> factory)
+    /// <summary>
+    /// Adds a custom node id value serializer to the schema.
+    /// A value serializer is used to format a runtime value into a node id.
+    /// </summary>
+    /// <param name="builder">
+    /// The request executor builder.
+    /// </param>
+    /// <typeparam name="T">
+    /// The type of the node id value serializer.
+    /// </typeparam>
+    /// <returns>
+    /// Returns the request executor builder.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">
+    /// <paramref name="builder"/> is <see langword="null"/>.
+    /// </exception>
+    public static IRequestExecutorBuilder AddNodeIdValueSerializer<T>(
+        this IRequestExecutorBuilder builder)
+        where T : class, INodeIdValueSerializer
     {
         if (builder == null)
         {
             throw new ArgumentNullException(nameof(builder));
         }
 
-        if (factory == null)
-        {
-            throw new ArgumentNullException(nameof(factory));
-        }
-
-        builder.Services.AddIdSerializer(factory);
+        builder.ConfigureSchemaServices(
+            services => services.AddSingleton<INodeIdValueSerializer, T>());
         return builder;
     }
 }

src/HotChocolate/Core/src/Execution/DependencyInjection/RequestExecutorServiceCollectionExtensions.cs

@@ -56,7 +56,6 @@ public static IServiceCollection AddGraphQLCore(this IServiceCollection services
             .TryAddDefaultDocumentHashProvider()
             .TryAddDefaultBatchDispatcher()
             .TryAddDefaultDataLoaderRegistry()
-            .TryAddIdSerializer()
             .TryAddDataLoaderParameterExpressionBuilder()
             .AddSingleton<ResolverProvider>();
 

src/HotChocolate/Core/src/Execution/Processing/MiddlewareContext.Global.cs

@@ -4,6 +4,7 @@
 using System.Threading.Tasks;
 using HotChocolate.Execution.Properties;
 using HotChocolate.Execution.Serialization;
+using HotChocolate.Language;
 using HotChocolate.Resolvers;
 using HotChocolate.Types;
 using Microsoft.Extensions.DependencyInjection;
@@ -44,7 +45,7 @@
     public CancellationToken RequestAborted { get; private set; }
 
     public bool HasCleanupTasks => _cleanupTasks.Count > 0;
-    
+
     public void ReportError(string errorMessage)
     {
         if (string.IsNullOrEmpty(errorMessage))
@@ -115,6 +116,8 @@
             ReportSingle(error);
         }
 
+        return;
+
         void ReportSingle(IError singleError)
         {
             var handled = _operationContext.ErrorHandler.Handle(singleError);
@@ -123,18 +126,35 @@
             {
                 foreach (var ie in ar.Errors)
                 {
-                    _operationContext.Result.AddError(ie, _selection);
-                    _operationContext.DiagnosticEvents.ResolverError(this, ie);
+                    var errorWithPath = EnsurePathAndLocation(ie, _selection.SyntaxNode, Path);
+                    _operationContext.Result.AddError(errorWithPath, _selection);
+                    _operationContext.DiagnosticEvents.ResolverError(this, errorWithPath);
                 }
             }
             else
             {
-                _operationContext.Result.AddError(handled, _selection);
-                _operationContext.DiagnosticEvents.ResolverError(this, handled);
+                var errorWithPath = EnsurePathAndLocation(handled, _selection.SyntaxNode, Path);
+                _operationContext.Result.AddError(errorWithPath, _selection);
+                _operationContext.DiagnosticEvents.ResolverError(this, errorWithPath);
             }
 
             HasErrors = true;
         }
+
+        static IError EnsurePathAndLocation(IError error, ISyntaxNode node, Path path)
+        {
+            if (error.Path is null)
+            {
+                error = error.WithPath(path);
+            }
+
+            if (error.Locations is not { Count: > 0 } && node.Location is not null)
+            {
+                error = error.WithLocations([new Location(node.Location.Line, node.Location.Column)]);
+            }
+
+            return error;
+        }
     }
 
     public async ValueTask<T> ResolveAsync<T>()
@@ -152,7 +172,7 @@
             : (T)_resolverResult;
     }
 
-    public T Resolver<T>() 
+    public T Resolver<T>()
         => _operationContext.Resolvers.GetResolver<T>(_operationContext.Services);
 
     public T Service<T>() where T : notnull => Services.GetRequiredService<T>();