Implements the new @defer draft spec

src/CookieCrumble/src/CookieCrumble.HotChocolate.Language/Extensions/SnapshotExtensions.cs

@@ -0,0 +1,16 @@
+using HotChocolate.Language;
+using SnapshotValueFormatters = CookieCrumble.HotChocolate.Language.Formatters.SnapshotValueFormatters;
+
+namespace CookieCrumble.HotChocolate;
+
+public static class SnapshotExtensions
+{
+    public static void MatchSnapshot(
+        this ISyntaxNode? value,
+        string? postFix = null)
+        => Snapshot.Match(
+            value,
+            postFix,
+            extension: ".graphql",
+            formatter: SnapshotValueFormatters.GraphQLSyntaxNode);
+}

src/CookieCrumble/src/CookieCrumble.HotChocolate.Language/Formatters/GraphQLSnapshotValueFormatter.cs

@@ -9,7 +9,7 @@ internal sealed class GraphQLSyntaxNodeSnapshotValueFormatter : SnapshotValueFor
 {
     protected override void Format(IBufferWriter<byte> snapshot, ISyntaxNode value)
     {
-        var serialized = value.Print().AsSpan();
+        var serialized = value.Print(indented: true).AsSpan();
         var buffer = ArrayPool<char>.Shared.Rent(serialized.Length);
         var span = buffer.AsSpan()[..serialized.Length];
         var written = 0;

src/CookieCrumble/src/CookieCrumble.HotChocolate/CookieCrumbleHotChocolate.cs

@@ -8,12 +8,12 @@ public sealed class CookieCrumbleHotChocolate : SnapshotModule
     protected override IEnumerable<ISnapshotValueFormatter> CreateFormatters()
     {
         yield return SnapshotValueFormatters.ExecutionResult;
-        yield return SnapshotValueFormatters.GraphQL;
         yield return SnapshotValueFormatters.GraphQLHttp;
         yield return SnapshotValueFormatters.OperationResult;
         yield return SnapshotValueFormatters.Schema;
         yield return SnapshotValueFormatters.SchemaError;
         yield return SnapshotValueFormatters.Error;
+        yield return SnapshotValueFormatters.ErrorList;
         yield return SnapshotValueFormatters.ResultElement;
     }
 }

src/CookieCrumble/src/CookieCrumble.HotChocolate/Extensions/SnapshotExtensions.cs

@@ -1,22 +1,12 @@
 using CookieCrumble.HotChocolate.Formatters;
 using HotChocolate;
 using HotChocolate.Execution;
-using HotChocolate.Language;
 using CoreFormatters = CookieCrumble.Formatters.SnapshotValueFormatters;
 
 namespace CookieCrumble.HotChocolate;
 
 public static class SnapshotExtensions
 {
-    public static void MatchSnapshot(
-        this ISyntaxNode? value,
-        string? postFix = null)
-        => Snapshot.Match(
-            value,
-            postFix,
-            extension: ".graphql",
-            formatter: SnapshotValueFormatters.GraphQL);
-
     public static void MatchSnapshot(
         this ISchemaDefinition? value,
         string? postFix = null)

src/CookieCrumble/src/CookieCrumble.HotChocolate/Formatters/ErrorListSnapshotValueFormatter.cs

@@ -0,0 +1,30 @@
+using System.Buffers;
+using System.Text.Encodings.Web;
+using System.Text.Json;
+using CookieCrumble.Formatters;
+using HotChocolate;
+using HotChocolate.Execution;
+using HotChocolate.Text.Json;
+
+namespace CookieCrumble.HotChocolate.Formatters;
+
+internal sealed class ErrorListSnapshotValueFormatter
+    : SnapshotValueFormatter<IReadOnlyList<IError>>
+{
+    protected override void Format(IBufferWriter<byte> snapshot, IReadOnlyList<IError> value)
+    {
+        var writerOptions = new JsonWriterOptions
+        {
+            Indented = true,
+            Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
+        };
+
+        var serializationOptions = new JsonSerializerOptions
+        {
+            WriteIndented = true
+        };
+
+        var writer = new JsonWriter(snapshot, writerOptions);
+        JsonValueFormatter.WriteErrors(writer, value, serializationOptions);
+    }
+}

src/CookieCrumble/src/CookieCrumble.HotChocolate/Formatters/ErrorSnapshotValueFormatter.cs

@@ -13,6 +13,6 @@ internal sealed class ErrorSnapshotValueFormatter()
     protected override void Format(IBufferWriter<byte> snapshot, IError value)
     {
         var jsonWriter = new JsonWriter(snapshot, new JsonWriterOptions { Indented = true });
-        JsonValueFormatter.WriteError(jsonWriter, value, new JsonSerializerOptions { WriteIndented = true }, default);
+        JsonValueFormatter.WriteError(jsonWriter, value, new JsonSerializerOptions { WriteIndented = true });
     }
 }

src/CookieCrumble/src/CookieCrumble.HotChocolate/Formatters/ExecutionResultSnapshotValueFormatter.cs

@@ -101,163 +101,138 @@ private static async Task FormatStreamAsync(
 
 internal sealed class JsonResultPatcher
 {
-    private const string Data = "data";
-    private const string Items = "items";
-    private const string Incremental = "incremental";
-    private const string Path = "path";
+    private const string DataProp = "data";
+    private const string ItemsProp = "items";
+    private const string IncrementalProp = "incremental";
+    private const string PendingProp = "pending";
+    private const string PathProp = "path";
+    private const string SubPathProp = "subPath";
+    private const string IdProp = "id";
     private JsonObject? _json;
+    private readonly Dictionary<string, JsonElement> _pendingPaths = new();
 
     public void SetResponse(JsonDocument response)
     {
         ArgumentNullException.ThrowIfNull(response);
 
         _json = JsonObject.Create(response.RootElement);
+        ProcessPayload(response.RootElement);
     }
 
-    public void WriteResponse(IBufferWriter<byte> snapshot)
+    public void ApplyPatch(JsonDocument patch)
     {
         if (_json is null)
         {
             throw new InvalidOperationException(
                 "You must first set the initial response before you can apply patches.");
         }
 
-        using var writer = new Utf8JsonWriter(snapshot, new JsonWriterOptions { Indented = true });
-
-        _json.Remove("hasNext");
-
-        _json.WriteTo(writer);
-        writer.Flush();
+        ProcessPayload(patch.RootElement);
     }
 
-    public void ApplyPatch(JsonDocument patch)
+    public void WriteResponse(IBufferWriter<byte> snapshot)
     {
         if (_json is null)
         {
             throw new InvalidOperationException(
                 "You must first set the initial response before you can apply patches.");
         }
 
-        if (!patch.RootElement.TryGetProperty(Incremental, out var incremental))
-        {
-            throw new ArgumentException("A patch result must contain a property `incremental`.");
-        }
+        using var writer = new Utf8JsonWriter(snapshot, new JsonWriterOptions { Indented = true });
 
-        foreach (var element in incremental.EnumerateArray())
-        {
-            if (element.TryGetProperty(Data, out var data))
-            {
-                PatchIncrementalData(element, JsonObject.Create(data)!);
-            }
-            else if (element.TryGetProperty(Items, out var items))
-            {
-                PatchIncrementalItems(element, JsonArray.Create(items)!);
-            }
-        }
-    }
+        _json.Remove("hasNext");
+        _json.Remove("pending");
+        _json.Remove("incremental");
+        _json.Remove("completed");
 
-    private void PatchIncrementalData(JsonElement incremental, JsonObject data)
-    {
-        if (incremental.TryGetProperty(Path, out var pathProp))
-        {
-            var (current, last) = SelectNodeToPatch(_json![Data]!, pathProp);
-            ApplyPatch(current, last, data);
-        }
+        _json.WriteTo(writer);
+        writer.Flush();
     }
 
-    private void PatchIncrementalItems(JsonElement incremental, JsonArray items)
+    private void ProcessPayload(JsonElement root)
     {
-        if (incremental.TryGetProperty(Path, out var pathProp))
+        if (root.TryGetProperty(PendingProp, out var pending))
         {
-            var (current, last) = SelectNodeToPatch(_json![Data]!, pathProp);
-            var i = last.GetInt32();
-            var target = current.AsArray();
-
-            while (items.Count > 0)
+            foreach (var entry in pending.EnumerateArray())
             {
-                var item = items[0];
-                items.RemoveAt(0);
-                target.Insert(i++, item);
+                if (entry.TryGetProperty(IdProp, out var id)
+                    && entry.TryGetProperty(PathProp, out var path))
+                {
+                    _pendingPaths[id.GetString()!] = path.Clone();
+                }
             }
         }
-    }
 
-    private static void ApplyPatch(JsonNode current, JsonElement last, JsonObject patchData)
-    {
-        if (last.ValueKind is JsonValueKind.Undefined)
+        if (root.TryGetProperty(IncrementalProp, out var incremental))
         {
-            foreach (var prop in patchData.ToArray())
+            foreach (var element in incremental.EnumerateArray())
             {
-                patchData.Remove(prop.Key);
-                current[prop.Key] = prop.Value;
-            }
-        }
-        else if (last.ValueKind is JsonValueKind.String)
-        {
-            current = current[last.GetString()!]!;
+                if (!element.TryGetProperty(IdProp, out var idElement))
+                {
+                    continue;
+                }
 
-            foreach (var prop in patchData.ToArray())
-            {
-                patchData.Remove(prop.Key);
-                current[prop.Key] = prop.Value;
-            }
-        }
-        else if (last.ValueKind is JsonValueKind.Number)
-        {
-            var index = last.GetInt32();
-            var element = current[index];
+                var id = idElement.GetString()!;
 
-            if (element is null)
-            {
-                current[index] = patchData;
-            }
-            else
-            {
-                foreach (var prop in patchData.ToArray())
+                if (!_pendingPaths.TryGetValue(id, out var basePath))
+                {
+                    continue;
+                }
+
+                if (element.TryGetProperty(DataProp, out var data))
+                {
+                    PatchData(basePath, element, JsonObject.Create(data)!);
+                }
+                else if (element.TryGetProperty(ItemsProp, out var items))
                 {
-                    patchData.Remove(prop.Key);
-                    element[prop.Key] = prop.Value;
+                    PatchItems(basePath, JsonArray.Create(items)!);
                 }
             }
         }
-        else
+    }
+
+    private void PatchData(JsonElement basePath, JsonElement incremental, JsonObject data)
+    {
+        var current = NavigatePath(_json![DataProp]!, basePath);
+
+        if (incremental.TryGetProperty(SubPathProp, out var subPath))
         {
-            throw new NotSupportedException("Path segment must be int or string.");
+            current = NavigatePath(current, subPath);
+        }
+
+        foreach (var prop in data.ToArray())
+        {
+            data.Remove(prop.Key);
+            current[prop.Key] = prop.Value;
         }
     }
 
-    private static (JsonNode Node, JsonElement PathSegment) SelectNodeToPatch(
-        JsonNode root,
-        JsonElement path)
+    private void PatchItems(JsonElement basePath, JsonArray items)
     {
-        if (path.GetArrayLength() == 0)
+        var target = NavigatePath(_json![DataProp]!, basePath).AsArray();
+
+        while (items.Count > 0)
         {
-            return (root, default);
+            var item = items[0];
+            items.RemoveAt(0);
+            target.Add(item);
         }
+    }
 
+    private static JsonNode NavigatePath(JsonNode root, JsonElement path)
+    {
         var current = root;
-        JsonElement? last = null;
 
-        foreach (var element in path.EnumerateArray())
+        foreach (var segment in path.EnumerateArray())
         {
-            if (last is not null)
+            current = segment.ValueKind switch
             {
-                current = last.Value.ValueKind switch
-                {
-                    JsonValueKind.String => current[last.Value.GetString()!]!,
-                    JsonValueKind.Number => current[last.Value.GetInt32()]!,
-                    _ => throw new NotSupportedException("Path segment must be int or string.")
-                };
-            }
-
-            last = element;
-        }
-
-        if (current is null || last is null)
-        {
-            throw new InvalidOperationException("Patch had invalid structure.");
+                JsonValueKind.String => current[segment.GetString()!]!,
+                JsonValueKind.Number => current[segment.GetInt32()]!,
+                _ => throw new NotSupportedException("Path segment must be int or string.")
+            };
         }
 
-        return (current, last.Value);
+        return current;
     }
 }

src/CookieCrumble/src/CookieCrumble.HotChocolate/Formatters/ResultElementSnapshotValueFormatter.cs

@@ -8,5 +8,5 @@ internal sealed class ResultElementSnapshotValueFormatter
     : SnapshotValueFormatter<ResultElement>
 {
     protected override void Format(IBufferWriter<byte> snapshot, ResultElement element)
-    => element.WriteTo(snapshot, indented: true);
+        => element.WriteTo(snapshot, indented: true);
 }