Merge pull request json-api-dotnet#378 from json-api-dotnet/feat/json-api-dotnet#39

[WIP] Feat/json-api-dotnet#39: Deeply Nested Inclusions

Author: jaredcnance

src/JsonApiDotNetCore/Builders/DocumentBuilder.cs

@@ -192,24 +192,62 @@ private RelationshipData GetRelationshipData(RelationshipAttribute attr, Context
             return relationshipData;
         }
 
-        private List<DocumentData> GetIncludedEntities(List<DocumentData> included, ContextEntity contextEntity, IIdentifiable entity)
+        private List<DocumentData> GetIncludedEntities(List<DocumentData> included, ContextEntity rootContextEntity, IIdentifiable rootResource)
         {
-            contextEntity.Relationships.ForEach(r =>
+            if(_jsonApiContext.IncludedRelationships != null)
             {
-                if (!RelationshipIsIncluded(r.PublicRelationshipName)) return;
+                foreach(var relationshipName in _jsonApiContext.IncludedRelationships)
+                {
+                    var relationshipChain = relationshipName.Split('.');
 
-                var navigationEntity = _jsonApiContext.ContextGraph.GetRelationship(entity, r.InternalRelationshipName);
+                    var contextEntity = rootContextEntity;
+                    var entity = rootResource;
+                    included = IncludeRelationshipChain(included, rootContextEntity, rootResource, relationshipChain, 0);
+                }                
+            }
 
-                if (navigationEntity is IEnumerable hasManyNavigationEntity)
-                    foreach (IIdentifiable includedEntity in hasManyNavigationEntity)
-                        included = AddIncludedEntity(included, includedEntity);
-                else
-                    included = AddIncludedEntity(included, (IIdentifiable)navigationEntity);
-            });
+            return included;
+        }
 
+        private List<DocumentData> IncludeRelationshipChain(
+            List<DocumentData> included, ContextEntity parentEntity, IIdentifiable parentResource, string[] relationshipChain, int relationshipChainIndex)
+        {
+            var requestedRelationship = relationshipChain[relationshipChainIndex];
+            var relationship = parentEntity.Relationships.FirstOrDefault(r => r.PublicRelationshipName == requestedRelationship);
+            var navigationEntity = _jsonApiContext.ContextGraph.GetRelationship(parentResource, relationship.InternalRelationshipName);
+            if (navigationEntity is IEnumerable hasManyNavigationEntity)
+            {
+                foreach (IIdentifiable includedEntity in hasManyNavigationEntity)
+                {
+                    included = AddIncludedEntity(included, includedEntity);
+                    included = IncludeSingleResourceRelationships(included, includedEntity, relationship, relationshipChain, relationshipChainIndex);
+                }
+            }
+            else
+            {
+                included = AddIncludedEntity(included, (IIdentifiable)navigationEntity);
+                included = IncludeSingleResourceRelationships(included, (IIdentifiable)navigationEntity, relationship, relationshipChain, relationshipChainIndex);
+            }
+
+            return included;
+        }
+
+        private List<DocumentData> IncludeSingleResourceRelationships(
+            List<DocumentData> included, IIdentifiable navigationEntity, RelationshipAttribute relationship, string[] relationshipChain, int relationshipChainIndex)
+        {
+            if(relationshipChainIndex < relationshipChain.Length) 
+            {
+                var nextContextEntity = _jsonApiContext.ContextGraph.GetContextEntity(relationship.Type);
+                var resource = (IIdentifiable)navigationEntity;
+                // recursive call
+                if(relationshipChainIndex < relationshipChain.Length - 1)
+                    included = IncludeRelationshipChain(included, nextContextEntity, resource, relationshipChain, relationshipChainIndex + 1);
+            }
+            
             return included;
         }
 
+
         private List<DocumentData> AddIncludedEntity(List<DocumentData> entities, IIdentifiable entity)
         {
             var includedEntity = GetIncludedEntity(entity);
@@ -245,12 +283,6 @@ private DocumentData GetIncludedEntity(IIdentifiable entity)
             return data;
         }
 
-        private bool RelationshipIsIncluded(string relationshipName)
-        {
-            return _jsonApiContext.IncludedRelationships != null &&
-                _jsonApiContext.IncludedRelationships.Contains(relationshipName);
-        }
-
         private List<ResourceIdentifierObject> GetRelationships(IEnumerable<object> entities)
         {
             var objType = entities.GetElementType();

src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs

@@ -203,20 +203,38 @@ public virtual async Task<bool> DeleteAsync(TId id)
         /// <inheritdoc />
         public virtual IQueryable<TEntity> Include(IQueryable<TEntity> entities, string relationshipName)
         {
+            if(string.IsNullOrWhiteSpace(relationshipName)) throw new JsonApiException(400, "Include parameter must not be empty if provided");
+
+            var relationshipChain = relationshipName.Split('.');
+
+            // variables mutated in recursive loop
+            // TODO: make recursive method
+            string internalRelationshipPath = null;
             var entity = _jsonApiContext.RequestEntity;
-            var relationship = entity.Relationships.FirstOrDefault(r => r.PublicRelationshipName == relationshipName);
-            if (relationship == null)
+            for(var i = 0; i < relationshipChain.Length; i++)
             {
-                throw new JsonApiException(400, $"Invalid relationship {relationshipName} on {entity.EntityName}",
-                    $"{entity.EntityName} does not have a relationship named {relationshipName}");
-            }
+                var requestedRelationship = relationshipChain[i];
+                var relationship = entity.Relationships.FirstOrDefault(r => r.PublicRelationshipName == requestedRelationship);
+                if (relationship == null)
+                {
+                    throw new JsonApiException(400, $"Invalid relationship {requestedRelationship} on {entity.EntityName}",
+                        $"{entity.EntityName} does not have a relationship named {requestedRelationship}");
+                }
 
-            if (!relationship.CanInclude)
-            {
-                throw new JsonApiException(400, $"Including the relationship {relationshipName} on {entity.EntityName} is not allowed");
+                if (relationship.CanInclude == false)
+                {
+                    throw new JsonApiException(400, $"Including the relationship {requestedRelationship} on {entity.EntityName} is not allowed");
+                }
+
+                internalRelationshipPath = (internalRelationshipPath == null)
+                    ? relationship.InternalRelationshipName
+                    : $"{internalRelationshipPath}.{relationship.InternalRelationshipName}";
+                
+                if(i < relationshipChain.Length)
+                    entity = _jsonApiContext.ContextGraph.GetContextEntity(relationship.Type);
             }
 
-            return entities.Include(relationship.InternalRelationshipName);
+            return entities.Include(internalRelationshipPath);
         }
 
         /// <inheritdoc />

src/JsonApiDotNetCore/Models/RelationshipAttribute.cs

@@ -54,6 +54,11 @@ public bool TryGetHasMany(out HasManyAttribute result)
 
         public abstract void SetValue(object entity, object newValue);
 
+        public object GetValue(object entity) => entity
+            ?.GetType()
+            .GetProperty(InternalRelationshipName)
+            .GetValue(entity);
+
         public override string ToString()
         {
             return base.ToString() + ":" + PublicRelationshipName;

src/JsonApiDotNetCore/Serialization/JsonApiDeSerializer.cs

@@ -214,6 +214,19 @@ private object SetHasOneRelationship(object entity,
             SetHasOneForeignKeyValue(entity, attr, foreignKeyProperty, rio);
             SetHasOneNavigationPropertyValue(entity, attr, rio, included);
 
+            // recursive call ...
+            if(included != null) 
+            {
+                var navigationPropertyValue = attr.GetValue(entity);
+                var contextGraphEntity = _jsonApiContext.ContextGraph.GetContextEntity(attr.Type);
+                if(navigationPropertyValue != null && contextGraphEntity != null)
+                {
+                    var includedResource = included.SingleOrDefault(r => r.Type == rio.Type && r.Id == rio.Id);
+                    if(includedResource != null) 
+                        SetRelationships(navigationPropertyValue, contextGraphEntity, includedResource.Relationships, included);
+                }
+            }
+
             return entity;
         }
 

src/JsonApiDotNetCore/Services/QueryParser.cs

@@ -179,10 +179,6 @@ protected virtual List<SortQuery> ParseSortParameters(string value)
 
         protected virtual List<string> ParseIncludedRelationships(string value)
         {
-            const string NESTED_DELIMITER = ".";
-            if (value.Contains(NESTED_DELIMITER))
-                throw new JsonApiException(400, "Deeply nested relationships are not supported");
-
             return value
                 .Split(QueryConstants.COMMA)
                 .ToList();