Add internal-only extensibility for validating/writing JSON:API extensions during serialization (needed for OpenAPI support)

Author: bkoelman

src/JsonApiDotNetCore/Serialization/JsonConverters/ResourceObjectConverter.cs

@@ -13,7 +13,7 @@ namespace JsonApiDotNetCore.Serialization.JsonConverters;
 /// Converts <see cref="ResourceObject" /> to/from JSON.
 /// </summary>
 [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
-public sealed class ResourceObjectConverter : JsonObjectConverter<ResourceObject>
+public class ResourceObjectConverter : JsonObjectConverter<ResourceObject>
 {
     private static readonly JsonEncodedText TypeText = JsonEncodedText.Encode("type");
     private static readonly JsonEncodedText IdText = JsonEncodedText.Encode("id");
@@ -99,7 +99,7 @@ public override ResourceObject Read(ref Utf8JsonReader reader, Type typeToConver
                         }
                         case "relationships":
                         {
-                            resourceObject.Relationships = ReadSubTree<IDictionary<string, RelationshipObject?>>(ref reader, options);
+                            resourceObject.Relationships = ReadRelationships(ref reader, options);
                             break;
                         }
                         case "links":
@@ -157,7 +157,7 @@ public override ResourceObject Read(ref Utf8JsonReader reader, Type typeToConver
         return null;
     }
 
-    private static Dictionary<string, object?> ReadAttributes(ref Utf8JsonReader reader, JsonSerializerOptions options, ResourceType resourceType)
+    private Dictionary<string, object?> ReadAttributes(ref Utf8JsonReader reader, JsonSerializerOptions options, ResourceType resourceType)
     {
         var attributes = new Dictionary<string, object?>();
 
@@ -174,6 +174,18 @@ public override ResourceObject Read(ref Utf8JsonReader reader, Type typeToConver
                     string attributeName = reader.GetString() ?? string.Empty;
                     reader.Read();
 
+                    int extensionSeparatorIndex = attributeName.IndexOf(':');
+
+                    if (extensionSeparatorIndex != -1)
+                    {
+                        string extensionNamespace = attributeName[..extensionSeparatorIndex];
+                        string extensionName = attributeName[(extensionSeparatorIndex + 1)..];
+
+                        ValidateExtensionInAttributes(extensionNamespace, extensionName, reader);
+                        reader.Skip();
+                        continue;
+                    }
+
                     AttrAttribute? attribute = resourceType.FindAttributeByPublicName(attributeName);
                     PropertyInfo? property = attribute?.Property;
 
@@ -219,6 +231,57 @@ public override ResourceObject Read(ref Utf8JsonReader reader, Type typeToConver
         throw GetEndOfStreamError();
     }
 
+    // Currently exposed for internal use only, so we don't need a breaking change when adding support for multiple extensions.
+    private protected virtual void ValidateExtensionInAttributes(string extensionNamespace, string extensionName, Utf8JsonReader reader)
+    {
+        throw new JsonException($"Unsupported usage of JSON:API extension '{extensionNamespace}' in attributes.");
+    }
+
+    private Dictionary<string, RelationshipObject?> ReadRelationships(ref Utf8JsonReader reader, JsonSerializerOptions options)
+    {
+        var relationships = new Dictionary<string, RelationshipObject?>();
+
+        while (reader.Read())
+        {
+            switch (reader.TokenType)
+            {
+                case JsonTokenType.EndObject:
+                {
+                    return relationships;
+                }
+                case JsonTokenType.PropertyName:
+                {
+                    string relationshipName = reader.GetString() ?? string.Empty;
+                    reader.Read();
+
+                    int extensionSeparatorIndex = relationshipName.IndexOf(':');
+
+                    if (extensionSeparatorIndex != -1)
+                    {
+                        string extensionNamespace = relationshipName[..extensionSeparatorIndex];
+                        string extensionName = relationshipName[(extensionSeparatorIndex + 1)..];
+
+                        ValidateExtensionInRelationships(extensionNamespace, extensionName, reader);
+                        reader.Skip();
+                        continue;
+                    }
+
+                    var relationshipObject = ReadSubTree<RelationshipObject?>(ref reader, options);
+                    relationships[relationshipName] = relationshipObject;
+                    break;
+                }
+            }
+        }
+
+        throw GetEndOfStreamError();
+    }
+
+    // Currently exposed for internal use only, so we don't need a breaking change when adding support for multiple extensions.
+    private protected virtual void ValidateExtensionInRelationships(string extensionNamespace, string extensionName, Utf8JsonReader reader)
+    {
+        throw new JsonException($"Unsupported usage of JSON:API extension '{extensionNamespace}' in relationships.");
+    }
+
     /// <summary>
     /// Ensures that attribute values are not wrapped in <see cref="JsonElement" />s.
     /// </summary>
@@ -244,13 +307,33 @@ public override void Write(Utf8JsonWriter writer, ResourceObject value, JsonSeri
         if (!value.Attributes.IsNullOrEmpty())
         {
             writer.WritePropertyName(AttributesText);
-            WriteSubTree(writer, value.Attributes, options);
+            writer.WriteStartObject();
+
+            WriteExtensionInAttributes(writer, value);
+
+            foreach ((string attributeName, object? attributeValue) in value.Attributes)
+            {
+                writer.WritePropertyName(attributeName);
+                WriteSubTree(writer, attributeValue, options);
+            }
+
+            writer.WriteEndObject();
         }
 
         if (!value.Relationships.IsNullOrEmpty())
         {
             writer.WritePropertyName(RelationshipsText);
-            WriteSubTree(writer, value.Relationships, options);
+            writer.WriteStartObject();
+
+            WriteExtensionInRelationships(writer, value);
+
+            foreach ((string relationshipName, RelationshipObject? relationshipValue) in value.Relationships)
+            {
+                writer.WritePropertyName(relationshipName);
+                WriteSubTree(writer, relationshipValue, options);
+            }
+
+            writer.WriteEndObject();
         }
 
         if (value.Links != null && value.Links.HasValue())
@@ -267,4 +350,14 @@ public override void Write(Utf8JsonWriter writer, ResourceObject value, JsonSeri
 
         writer.WriteEndObject();
     }
+
+    // Currently exposed for internal use only, so we don't need a breaking change when adding support for multiple extensions.
+    private protected virtual void WriteExtensionInAttributes(Utf8JsonWriter writer, ResourceObject value)
+    {
+    }
+
+    // Currently exposed for internal use only, so we don't need a breaking change when adding support for multiple extensions.
+    private protected virtual void WriteExtensionInRelationships(Utf8JsonWriter writer, ResourceObject value)
+    {
+    }
 }