Updated IApiResourceProvider to care about relationship\include cases (#244)

Co-authored-by: Sergey Litvinov <[email protected]>

Author: sergey-litvinov-work

Saule/Resources/DefaultApiResourceProvider.cs

@@ -24,5 +24,11 @@ public virtual ApiResource Resolve(object dataObject)
         {
             return ApiResource;
         }
+
+        /// <inheritdoc/>
+        public virtual ApiResource ResolveRelationship(object dataObject, ApiResource relationship)
+        {
+            return relationship;
+        }
     }
 }

Saule/Resources/IApiResourceProvider.cs

@@ -11,5 +11,13 @@ public interface IApiResourceProvider
         /// <param name="dataObject">Data object that is serialized. If it's an array, then it will be called for each item in the array</param>
         /// <returns>ApiResource that should be used for specific data object</returns>
         ApiResource Resolve(object dataObject);
+
+        /// <summary>
+        /// Returns ApiResource based on the data object and specific relationship
+        /// </summary>
+        /// <param name="dataObject">Data object that is serialized. If it's an array, then it will be called for each item in the array</param>
+        /// <param name="relationship">Relationship resource for which we are resolving api resource</param>
+        /// <returns>ApiResource that should be used for specific data object and relationship</returns>
+        ApiResource ResolveRelationship(object dataObject, ApiResource relationship);
     }
 }

Saule/Serialization/ResourceGraph.cs

@@ -52,7 +52,7 @@ public IEnumerable<ResourceGraphNode> IncludedNodes
 
         private void Build(
             object obj,
-            ApiResource resource,
+            ApiResource relatedResource,
             ResourceGraphPathSet includePaths,
             int depth,
             string propertyName = null)
@@ -73,10 +73,18 @@ private void Build(
                 return;
             }
 
-            if (resource == null)
+            ApiResource resource;
+
+            // if we are serializing top object, then we just resolve it based on api resource of the endpoint
+            // but if are processing relationship's includes, then we need to resolve it based on the relationship itself
+            if (relatedResource == null)
             {
                 resource = _apiResourceProvider.Resolve(obj);
             }
+            else
+            {
+                resource = _apiResourceProvider.ResolveRelationship(obj, relatedResource);
+            }
 
             // keys (type & id pair) uniquely identifier each resource in a compount document
             var key = new ResourceGraphNodeKey(obj, resource);

Saule/Serialization/ResourceSerializer.cs

@@ -424,7 +424,8 @@ private JToken SerializeRelationshipData(ResourceGraphNode node, ResourceGraphRe
 
                 foreach (var sourceObject in (IEnumerable)relationship.SourceObject ?? new JArray())
                 {
-                    content.Add(JObject.FromObject(new ResourceGraphNodeKey(sourceObject, relationship.Relationship.RelatedResource)));
+                    var resource = _apiResourceProvider.ResolveRelationship(sourceObject, relationship.Relationship.RelatedResource);
+                    content.Add(JObject.FromObject(new ResourceGraphNodeKey(sourceObject, resource)));
                 }
 
                 return content;

Tests/Controllers/ShapeController.cs

@@ -6,13 +6,13 @@
 
 namespace Tests.Controllers
 {
-    [ReturnsResource(typeof(ShapeResource))]
     [RoutePrefix("api")]
     public class ShapeController : ApiController
     {
         [HttpGet]
         [Route("shapes")]
         [AllowsQuery]
+        [ReturnsResource(typeof(ShapeResource))]
         public IEnumerable<Shape> GetAllShapes()
         {
             return new Shape[]
@@ -28,9 +28,26 @@ public IEnumerable<Shape> GetAllShapes()
 
         [HttpGet]
         [Route("shape/{id}")]
+        [ReturnsResource(typeof(ShapeResource))]
         public Shape GetShape(string id)
         {
             return GetAllShapes().FirstOrDefault(s => s.Id == id);
         }
+
+        [HttpGet]
+        [Route("groups")]
+        [AllowsQuery]
+        [DisableDefaultIncluded]
+        [ReturnsResource(typeof(GroupResource))]
+        public IEnumerable<Group> GetGroup()
+        {
+            return new[]
+            {
+                new Group(true, "1")
+                {
+                    Shapes = GetAllShapes().ToList()
+                }
+            };
+        }
     }
 }

Tests/Integration/JsonApiFormatterInheritenceTests.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System.Collections;
+using System.Collections.Generic;
 using System.Linq;
 using System.Net;
 using System.Net.Http;
@@ -170,6 +171,60 @@ public async Task GetSpecificRectangle()
                 ValidateRectangle(rectangle, "2");
             }
         }
+        
+        [Fact(DisplayName = "Get a group and validation relationship")]
+        public async Task GetGroup()
+        {
+            using (var server = CreateServer())
+            {
+                var client = server.GetClient();
+                var result = await client.GetJsonResponseAsync("api/groups");
+                _output.WriteLine(result.ToString());
+
+                var items = result["data"] as JArray;
+                Assert.Equal(1, items.Count);
+
+                var group = items[0];
+                Assert.Equal("group", group["type"]);
+                Assert.Equal("1", group["id"]);
+                Assert.Equal("Group 1", group["attributes"]["name"]);
+
+                var relationships = group["relationships"]["shapes"]["data"] as JArray;
+                Assert.Equal(3, relationships.Count);
+                Assert.Equal("circle", relationships[0]["type"]);
+                Assert.Equal("1", relationships[0]["id"]);
+                
+                Assert.Equal("rectangle", relationships[1]["type"]);
+                Assert.Equal("2", relationships[1]["id"]);
+                
+                Assert.Equal("circle", relationships[2]["type"]);
+                Assert.Equal("3", relationships[2]["id"]);
+            }
+        }
+        
+        [Fact(DisplayName = "Get a group with included shapes and validate types and shapes itself")]
+        public async Task GetGroupWithIncludes()
+        {
+            using (var server = CreateServer())
+            {
+                var client = server.GetClient();
+                var result = await client.GetJsonResponseAsync("api/groups?include=shapes");
+                _output.WriteLine(result.ToString());
+
+                var items = result["data"] as JArray;
+                var included = result["included"] as JArray; 
+                Assert.Equal(1, items.Count);
+                Assert.Equal(3, included.Count);
+                
+                var circle1 = included[0];
+                var rectangle2 = included[1];
+                var circle3 = included[2];
+                
+                ValidateCircle(circle1,"1");
+                ValidateRectangle(rectangle2, "2");
+                ValidateCircle(circle3,"3");
+            }
+        }
 
 
         private static void ValidateRectangle(JToken rectangle, string expectedId)
@@ -222,18 +277,38 @@ public class ShapeApiResourceProvider : IApiResourceProvider
         {
             public ApiResource Resolve(object dataObject)
             {
-                if (dataObject is Circle)
+                var type = dataObject.GetType();
+
+                if (type.IsEnumerable() || type.IsArray)
+                    type = type.GetGenericTypeParameterOfCollection();
+                
+                if (type == typeof(Group))
+                {
+                    return new GroupResource();
+                }
+
+                if (type == typeof(Circle))
                 {
                     return new CircleResource();
                 }
 
-                if (dataObject is Rectangle)
+                if (type == typeof(Rectangle))
                 {
                     return new RectangleResource();
                 }
 
                 return new ShapeResource();
             }
+
+            public ApiResource ResolveRelationship(object dataObject, ApiResource relationship)
+            {
+                if (relationship is ShapeResource)
+                {
+                    return Resolve(dataObject);
+                }
+
+                return new GroupResource();
+            }
         }
     }
 }

Tests/Models/Inheritance/Group.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+
+namespace Tests.Models.Inheritance
+{
+    public class Group
+    {
+        public Group(bool prefill = false, string id = "123")
+        {
+            Id = id;
+            if (!prefill) return;
+
+            Name = $"Group {id}";
+        }
+        
+        public string Id { get; set; }
+        public string Name { get; set; }
+        public List<Shape> Shapes { get; set; }
+    }
+}

Tests/Models/Inheritance/GroupResource.cs

@@ -0,0 +1,14 @@
+using Saule;
+
+namespace Tests.Models.Inheritance
+{
+    public class GroupResource : ApiResource
+    {
+        public GroupResource()
+        {
+            WithId(nameof(Group.Id));
+            Attribute(nameof(Group.Name));
+            HasMany<ShapeResource>(nameof(Group.Shapes));
+        }
+    }
+}

Tests/Tests.csproj

@@ -141,6 +141,8 @@
     <Compile Include="Helpers\Paths.cs" />
     <Compile Include="Models\Inheritance\Circle.cs" />
     <Compile Include="Models\Inheritance\CircleResource.cs" />
+    <Compile Include="Models\Inheritance\Group.cs" />
+    <Compile Include="Models\Inheritance\GroupResource.cs" />
     <Compile Include="Models\Inheritance\Rectangle.cs" />
     <Compile Include="Models\Inheritance\RectangleResource.cs" />
     <Compile Include="Models\Inheritance\Shape.cs" />