Merge branch 'main' into mst/execution-preparations

michaelstaib · web-flow · commit c45c8b06b4d6 · 2025-05-26T10:10:42.000+02:00
diff --git a/src/HotChocolate/Core/src/Types.Analyzers/FileBuilders/RequestMiddlewareFileBuilder.cs b/src/HotChocolate/Core/src/Types.Analyzers/FileBuilders/RequestMiddlewareFileBuilder.cs
@@ -121,14 +121,14 @@ private void WriteCtorServiceResolution(List<RequestMiddlewareParameterInfo> par
 
                 case RequestMiddlewareParameterKind.SchemaService when !parameter.IsNullable:
                     _writer.WriteIndentedLine(
-                        "var cp{0} = core.SchemaServices.GetRequiredService<global::{1}>();",
+                        "var cp{0} = core.SchemaServices.GetRequiredService<{1}>();",
                         i,
                         parameter.TypeName);
                     break;
 
                 case RequestMiddlewareParameterKind.SchemaService when parameter.IsNullable:
                     _writer.WriteIndentedLine(
-                        "var cp{0} = core.SchemaServices.GetService<global::{1}>();",
+                        "var cp{0} = core.SchemaServices.GetService<{1}>();",
                         i,
                         parameter.TypeName);
                     break;
diff --git a/src/HotChocolate/Core/src/Types.Analyzers/Inspectors/RequestMiddlewareInspector.cs b/src/HotChocolate/Core/src/Types.Analyzers/Inspectors/RequestMiddlewareInspector.cs
@@ -87,7 +87,11 @@ ctor is not
                     kind = RequestMiddlewareParameterKind.Service;
                 }
 
-                ctorParameters.Add(new RequestMiddlewareParameterInfo(kind, parameterTypeName));
+                ctorParameters.Add(
+                    new RequestMiddlewareParameterInfo(
+                        kind,
+                        parameterTypeName,
+                        isNullable: !parameter.IsNonNullable()));
             }
 
             foreach (var parameter in invokeMethod.Parameters)
@@ -113,7 +117,11 @@ ctor is not
                     kind = RequestMiddlewareParameterKind.Service;
                 }
 
-                invokeParameters.Add(new RequestMiddlewareParameterInfo(kind, parameterTypeName));
+                invokeParameters.Add(
+                    new RequestMiddlewareParameterInfo(
+                        kind,
+                        parameterTypeName,
+                        isNullable: !parameter.IsNonNullable()));
             }
 
             syntaxInfo = new RequestMiddlewareInfo(
diff --git a/src/HotChocolate/Core/src/Types/SemanticNonNullTypeInterceptor.cs b/src/HotChocolate/Core/src/Types/SemanticNonNullTypeInterceptor.cs
@@ -104,6 +104,11 @@ public override void OnBeforeCompleteType(ITypeCompletionContext completionConte
                     continue;
                 }
 
+                if (field.Name == "id")
+                {
+                    continue;
+                }
+
                 var levels = GetSemanticNonNullLevels(field.Type);
 
                 if (levels.Count < 1)
diff --git a/src/HotChocolate/Core/src/Types/Types/Relay/Serialization/CompositeNodeIdValueSerializer.cs b/src/HotChocolate/Core/src/Types/Types/Relay/Serialization/CompositeNodeIdValueSerializer.cs
@@ -16,6 +16,7 @@ namespace HotChocolate.Types.Relay;
 public abstract class CompositeNodeIdValueSerializer<T> : INodeIdValueSerializer
 {
     private const byte _partSeparator = (byte)':';
+    private const byte _escape = (byte)'\\';
     private static readonly Encoding _utf8 = Encoding.UTF8;
 
     public virtual bool IsSupported(Type type) => type == typeof(T) || type == typeof(T?);
@@ -87,19 +88,21 @@ public NodeIdFormatterResult Format(Span<byte> buffer, object value, out int wri
     /// </returns>
     protected static bool TryFormatIdPart(Span<byte> buffer, string value, out int written)
     {
-        var requiredCapacity = _utf8.GetByteCount(value) + 1;
+        var requiredCapacity = _utf8.GetByteCount(value) * 2 + 1; // * 2 to allow for escaping.
         if (buffer.Length < requiredCapacity)
         {
             written = 0;
             return false;
         }
 
-        var stringBytes = buffer;
-        Utf8GraphQLParser.ConvertToBytes(value, ref stringBytes);
+        Span<byte> utf8Bytes = stackalloc byte[_utf8.GetByteCount(value)];
+        _utf8.GetBytes(value, utf8Bytes);
 
-        buffer = buffer.Slice(stringBytes.Length);
+        var bytesWritten = WriteEscapedBytes(utf8Bytes, buffer);
+
+        buffer = buffer[bytesWritten..];
         buffer[0] = _partSeparator;
-        written = stringBytes.Length + 1;
+        written = bytesWritten + 1;
         return true;
     }
 
@@ -125,7 +128,8 @@ protected static bool TryFormatIdPart(Span<byte> buffer, Guid value, out int wri
     {
         if (compress)
         {
-            if (buffer.Length < 17)
+            const int requiredCapacity = 16 * 2 + 1; // * 2 to allow for escaping.
+            if (buffer.Length < requiredCapacity)
             {
                 written = 0;
                 return false;
@@ -135,16 +139,17 @@ protected static bool TryFormatIdPart(Span<byte> buffer, Guid value, out int wri
 #pragma warning disable CS9191
             MemoryMarshal.TryWrite(span, ref value);
 #pragma warning restore CS9191
-            span.CopyTo(buffer);
-            buffer = buffer.Slice(16);
+            var bytesWritten = WriteEscapedBytes(span, buffer);
+
+            buffer = buffer[bytesWritten..];
             buffer[0] = _partSeparator;
-            written = 17;
+            written = bytesWritten + 1;
             return true;
         }
 
         if (Utf8Formatter.TryFormat(value, buffer, out written, format: 'N'))
         {
-            buffer = buffer.Slice(written);
+            buffer = buffer[written..];
             if (buffer.Length < 1)
             {
                 return false;
@@ -344,8 +349,9 @@ protected static unsafe bool TryParseIdPart(
         [NotNullWhen(true)] out string? value,
         out int consumed)
     {
-        var index = buffer.IndexOf(_partSeparator);
-        var valueSpan = index == -1 ? buffer : buffer.Slice(0, index);
+        var index = IndexOfPartSeparator(buffer);
+        var valueSpan = index == -1 ? buffer : buffer[..index];
+        valueSpan = Unescape(valueSpan);
         fixed (byte* b = valueSpan)
         {
             value = _utf8.GetString(b, valueSpan.Length);
@@ -379,11 +385,13 @@ protected static bool TryParseIdPart(
         out int consumed,
         bool compress = true)
     {
-        var index = buffer.IndexOf(_partSeparator);
-        var valueSpan = index == -1 ? buffer : buffer.Slice(0, index);
+        var index = IndexOfPartSeparator(buffer);
+        var valueSpan = index == -1 ? buffer : buffer[..index];
 
         if (compress)
         {
+            valueSpan = Unescape(valueSpan);
+
             if (valueSpan.Length != 16)
             {
                 value = default;
@@ -396,7 +404,7 @@ protected static bool TryParseIdPart(
             return true;
         }
 
-        if (Utf8Parser.TryParse(valueSpan, out Guid parsedValue, out _))
+        if (Utf8Parser.TryParse(valueSpan, out Guid parsedValue, out _, standardFormat: 'N'))
         {
             value = parsedValue;
             consumed = index + 1;
@@ -547,4 +555,82 @@ protected static bool TryParseIdPart(
         consumed = 0;
         return false;
     }
+
+    /// <summary>
+    /// Writes the given unescaped bytes with the part separator (<c>:</c>) escaped, into the given
+    /// span.
+    /// </summary>
+    /// <param name="unescapedBytes">The unescaped bytes to write as escaped.</param>
+    /// <param name="escapedBytes">The span into which the escaped bytes should be written.</param>
+    /// <returns>The number of bytes written.</returns>
+    private static int WriteEscapedBytes(ReadOnlySpan<byte> unescapedBytes, Span<byte> escapedBytes)
+    {
+        var index = 0;
+
+        foreach (var b in unescapedBytes)
+        {
+            if (b == _partSeparator)
+            {
+                escapedBytes[index++] = _escape;
+            }
+
+            escapedBytes[index++] = b;
+        }
+
+        return index;
+    }
+
+    /// <summary>
+    /// Unescapes part separators (<c>:</c>) in the given span of bytes.
+    /// </summary>
+    /// <param name="escapedBytes">A span with the bytes to be unescaped.</param>
+    /// <returns>A span with the unescaped bytes.</returns>
+    private static ReadOnlySpan<byte> Unescape(ReadOnlySpan<byte> escapedBytes)
+    {
+        Span<byte> unescapedBytes = new byte[escapedBytes.Length];
+
+        var index = 0;
+        var skipNext = false;
+
+        for (var i = 0; i < escapedBytes.Length; i++)
+        {
+            if (skipNext)
+            {
+                skipNext = false;
+                continue;
+            }
+
+            if (escapedBytes[i] == _escape
+                && i + 1 < escapedBytes.Length
+                && escapedBytes[i + 1] == _partSeparator)
+            {
+                unescapedBytes[index++] = _partSeparator;
+                skipNext = true;
+            }
+            else
+            {
+                unescapedBytes[index++] = escapedBytes[i];
+            }
+        }
+
+        return unescapedBytes[..index];
+    }
+
+    /// <summary>
+    /// Finds the index of the first non-escaped part separator (<c>:</c>) in the given buffer.
+    /// </summary>
+    /// <param name="buffer">The buffer to search.</param>
+    /// <returns>The index of the non-escaped part separator.</returns>
+    private static int IndexOfPartSeparator(ReadOnlySpan<byte> buffer)
+    {
+        for (var i = 0; i < buffer.Length; i++)
+        {
+            if (buffer[i] == _partSeparator && (i == 0 || buffer[i - 1] != _escape))
+            {
+                return i;
+            }
+        }
+
+        return -1;
+    }
 }
diff --git a/src/HotChocolate/Core/test/Types.Analyzers.Tests/RequestMiddlewareTests.cs b/src/HotChocolate/Core/test/Types.Analyzers.Tests/RequestMiddlewareTests.cs
@@ -0,0 +1,50 @@
+namespace HotChocolate.Types;
+
+public class RequestMiddlewareTests
+{
+    [Fact]
+    public async Task GenerateSource_RequestMiddleware_MatchesSnapshot()
+    {
+        await TestHelper.GetGeneratedSourceSnapshot(
+            """
+            #nullable enable
+            using System.Threading.Tasks;
+            using HotChocolate;
+            using HotChocolate.Execution;
+            using Microsoft.AspNetCore.Builder;
+            using Microsoft.Extensions.DependencyInjection;
+
+            public class Program
+            {
+                public static void Main(string[] args)
+                {
+                    var builder = WebApplication.CreateBuilder(args);
+                    builder.Services
+                        .AddGraphQLServer()
+                        .UseRequest<SomeRequestMiddleware>();
+                }
+            }
+
+            public class SomeRequestMiddleware(
+                RequestDelegate next,
+                #pragma warning disable CS9113
+                [SchemaService] Service1 service1,
+                [SchemaService] Service2? service2)
+                #pragma warning restore CS9113
+            {
+                public async ValueTask InvokeAsync(
+                    IRequestContext context,
+                    #pragma warning disable CS9113
+                    Service1 service1,
+                    Service2? service2)
+                    #pragma warning restore CS9113
+                {
+                    await next(context);
+                }
+            }
+
+            public class Service1;
+            public class Service2;
+            """).MatchMarkdownAsync();
+    }
+}
diff --git a/src/HotChocolate/Core/test/Types.Analyzers.Tests/TestHelper.cs b/src/HotChocolate/Core/test/Types.Analyzers.Tests/TestHelper.cs
@@ -8,10 +8,14 @@
 using GreenDonut;
 using GreenDonut.Data;
 using HotChocolate.Data.Filters;
+using HotChocolate.Execution;
+using HotChocolate.Execution.Configuration;
 using HotChocolate.Types.Analyzers;
 using HotChocolate.Types.Pagination;
+using Microsoft.AspNetCore.Builder;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace HotChocolate.Types;
 
@@ -33,6 +37,12 @@ public static Snapshot GetGeneratedSourceSnapshot(string[] sourceTexts, string?
 #elif NET9_0
             .. Net90.References.All,
 #endif
+            // HotChocolate.Execution
+            MetadataReference.CreateFromFile(typeof(RequestDelegate).Assembly.Location),
+
+            // HotChocolate.Execution.Abstractions
+            MetadataReference.CreateFromFile(typeof(IRequestExecutorBuilder).Assembly.Location),
+
             // HotChocolate.Types
             MetadataReference.CreateFromFile(typeof(ObjectTypeAttribute).Assembly.Location),
             MetadataReference.CreateFromFile(typeof(Connection).Assembly.Location),
@@ -41,6 +51,10 @@ public static Snapshot GetGeneratedSourceSnapshot(string[] sourceTexts, string?
             // HotChocolate.Abstractions
             MetadataReference.CreateFromFile(typeof(ParentAttribute).Assembly.Location),
 
+            // HotChocolate.AspNetCore
+            MetadataReference.CreateFromFile(
+                typeof(HotChocolateAspNetCoreServiceCollectionExtensions).Assembly.Location),
+
             // GreenDonut
             MetadataReference.CreateFromFile(typeof(DataLoaderBase<,>).Assembly.Location),
             MetadataReference.CreateFromFile(typeof(IDataLoader).Assembly.Location),
@@ -50,7 +64,13 @@ public static Snapshot GetGeneratedSourceSnapshot(string[] sourceTexts, string?
             MetadataReference.CreateFromFile(typeof(IPredicateBuilder).Assembly.Location),
 
             // HotChocolate.Data
-            MetadataReference.CreateFromFile(typeof(IFilterContext).Assembly.Location)
+            MetadataReference.CreateFromFile(typeof(IFilterContext).Assembly.Location),
+
+            // Microsoft.AspNetCore
+            MetadataReference.CreateFromFile(typeof(WebApplication).Assembly.Location),
+
+            // Microsoft.Extensions.DependencyInjection.Abstractions
+            MetadataReference.CreateFromFile(typeof(IServiceCollection).Assembly.Location)
         ];
 
         // Create a Roslyn compilation for the syntax tree.
diff --git a/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/RequestMiddlewareTests.GenerateSource_RequestMiddleware_MatchesSnapshot.md b/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/RequestMiddlewareTests.GenerateSource_RequestMiddleware_MatchesSnapshot.md
@@ -0,0 +1,49 @@
+# GenerateSource_RequestMiddleware_MatchesSnapshot
+
+```csharp
+// <auto-generated/>
+
+#nullable enable
+#pragma warning disable
+
+using System;
+using System.Runtime.CompilerServices;
+using HotChocolate;
+using HotChocolate.Types;
+using HotChocolate.Execution.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace HotChocolate.Execution.Generated
+{
+    public static class TestsTypesMiddlewareFactoriesHASH
+    {
+        // global::SomeRequestMiddleware
+        private static global::HotChocolate.Execution.RequestCoreMiddleware CreateMiddleware0()
+            => (core, next) =>
+                {
+                    var cp1 = core.SchemaServices.GetRequiredService<global::Service1>();
+                    var cp2 = core.SchemaServices.GetService<global::Service2>();
+                    var middleware = new global::SomeRequestMiddleware(next, cp1, cp2);
+                    return async context =>
+                    {
+                        var ip1 = context.Services.GetRequiredService<global::Service1>();
+                        var ip2 = context.Services.GetService<global::Service2>();
+                        await middleware.InvokeAsync(context, ip1, ip2).ConfigureAwait(false);
+                    };
+                };
+
+        [InterceptsLocation("", 15, 14)]
+        public static global::HotChocolate.Execution.Configuration.IRequestExecutorBuilder UseRequestGen0<TMiddleware>(
+            this HotChocolate.Execution.Configuration.IRequestExecutorBuilder builder) where TMiddleware : class
+            => builder.UseRequest(CreateMiddleware0());
+    }
+}
+
+#pragma warning disable CS9113 // Parameter is unread.
+namespace System.Runtime.CompilerServices
+{
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+    file sealed class InterceptsLocationAttribute(string filePath, int line, int column) : Attribute;
+}
+#pragma warning restore CS9113 // Parameter is unread.
+```
diff --git a/src/HotChocolate/Core/test/Types.Tests/SemanticNonNullTests.cs b/src/HotChocolate/Core/test/Types.Tests/SemanticNonNullTests.cs
diff --git a/src/HotChocolate/Core/test/Types.Tests/Types/Relay/DefaultNodeIdSerializerTests.cs b/src/HotChocolate/Core/test/Types.Tests/Types/Relay/DefaultNodeIdSerializerTests.cs
diff --git a/src/HotChocolate/Core/test/Types.Tests/__snapshots__/SemanticNonNullTests.Interface_With_Id_Field.snap b/src/HotChocolate/Core/test/Types.Tests/__snapshots__/SemanticNonNullTests.Interface_With_Id_Field.snap

Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,11 @@ ctor is not`
`87`	`87`	`kind = RequestMiddlewareParameterKind.Service;`
`88`	`88`	`}`
`89`	`89`
`90`		`- ctorParameters.Add(new RequestMiddlewareParameterInfo(kind, parameterTypeName));`
	`90`	`+ ctorParameters.Add(`
	`91`	`+ new RequestMiddlewareParameterInfo(`
	`92`	`+ kind,`
	`93`	`+ parameterTypeName,`
	`94`	`+ isNullable: !parameter.IsNonNullable()));`
`91`	`95`	`}`
`92`	`96`
`93`	`97`	`foreach (var parameter in invokeMethod.Parameters)`
`@@ -113,7 +117,11 @@ ctor is not`
`113`	`117`	`kind = RequestMiddlewareParameterKind.Service;`
`114`	`118`	`}`
`115`	`119`
`116`		`- invokeParameters.Add(new RequestMiddlewareParameterInfo(kind, parameterTypeName));`
	`120`	`+ invokeParameters.Add(`
	`121`	`+ new RequestMiddlewareParameterInfo(`
	`122`	`+ kind,`
	`123`	`+ parameterTypeName,`
	`124`	`+ isNullable: !parameter.IsNonNullable()));`
`117`	`125`	`}`
`118`	`126`
`119`	`127`	`syntaxInfo = new RequestMiddlewareInfo(`