Escaped part separator in composite node ID string and GUID values (ChilliCream#8300)

Author: glen-84

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;
+    }
 }

src/HotChocolate/Core/test/Types.Tests/Types/Relay/DefaultNodeIdSerializerTests.cs

@@ -506,6 +506,24 @@ public void Parse_CompositeId2()
         Assert.Equal(compositeId, parsed.InternalId);
     }
 
+    [Fact]
+    public void Parse_CompositeId_With_Escaping()
+    {
+        var compositeId =
+            new CompositeId(
+                ":foo:bar:",
+                42,
+                // The bytes of this GUID contain a part separator (colon).
+                new Guid("3bc83a67-b494-4c0c-a31a-d1921b077a32"),
+                true);
+        var serializer = CreateSerializer(new CompositeIdNodeIdValueSerializer());
+        var id = serializer.Format("Foo", compositeId);
+
+        var parsed = serializer.Parse(id, typeof(CompositeId));
+
+        Assert.Equal(compositeId, parsed.InternalId);
+    }
+
     [Fact]
     public void Parse_Legacy_StronglyTypedId()
     {