fix(#343): reload relationships from database if included during POST

Author: jaredcnance

src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs

@@ -13,6 +13,7 @@
 
 namespace JsonApiDotNetCore.Data
 {
+    /// <inheritdoc />
     public class DefaultEntityRepository<TEntity>
         : DefaultEntityRepository<TEntity, int>,
         IEntityRepository<TEntity>
@@ -26,6 +27,10 @@ public DefaultEntityRepository(
         { }
     }
 
+    /// <summary>
+    /// Provides a default repository implementation and is responsible for
+    /// abstracting any EF Core APIs away from the service layer.
+    /// </summary>
     public class DefaultEntityRepository<TEntity, TId>
         : IEntityRepository<TEntity, TId>
         where TEntity : class, IIdentifiable<TId>
@@ -48,7 +53,7 @@ public DefaultEntityRepository(
             _genericProcessorFactory = _jsonApiContext.GenericProcessorFactory;
         }
 
-        /// </ inheritdoc>
+        /// <inheritdoc />
         public virtual IQueryable<TEntity> Get()
         {
             if (_jsonApiContext.QuerySet?.Fields != null && _jsonApiContext.QuerySet.Fields.Count > 0)
@@ -57,41 +62,43 @@ public virtual IQueryable<TEntity> Get()
             return _dbSet;
         }
 
-        /// </ inheritdoc>
+        /// <inheritdoc />
         public virtual IQueryable<TEntity> Filter(IQueryable<TEntity> entities, FilterQuery filterQuery)
         {
             return entities.Filter(_jsonApiContext, filterQuery);
         }
 
-        /// </ inheritdoc>
+        /// <inheritdoc />
         public virtual IQueryable<TEntity> Sort(IQueryable<TEntity> entities, List<SortQuery> sortQueries)
         {
             return entities.Sort(sortQueries);
         }
 
-        /// </ inheritdoc>
+        /// <inheritdoc />
         public virtual async Task<TEntity> GetAsync(TId id)
         {
             return await Get().SingleOrDefaultAsync(e => e.Id.Equals(id));
         }
 
-        /// </ inheritdoc>
+        /// <inheritdoc />
         public virtual async Task<TEntity> GetAndIncludeAsync(TId id, string relationshipName)
         {
             _logger.LogDebug($"[JADN] GetAndIncludeAsync({id}, {relationshipName})");
 
-            var result = await Include(Get(), relationshipName).SingleOrDefaultAsync(e => e.Id.Equals(id));
+            var includedSet = await IncludeAsync(Get(), relationshipName);
+            var result = await includedSet.SingleOrDefaultAsync(e => e.Id.Equals(id));
 
             return result;
         }
 
-        /// </ inheritdoc>
+        /// <inheritdoc />
         public virtual async Task<TEntity> CreateAsync(TEntity entity)
         {
             AttachRelationships();
             _dbSet.Add(entity);
 
             await _context.SaveChangesAsync();
+
             return entity;
         }
 
@@ -129,7 +136,7 @@ private void AttachHasOnePointers()
                     _context.Entry(relationship.Value).State = EntityState.Unchanged;
         }
 
-        /// </ inheritdoc>
+        /// <inheritdoc />
         public virtual async Task<TEntity> UpdateAsync(TId id, TEntity entity)
         {
             var oldEntity = await GetAsync(id);
@@ -148,14 +155,14 @@ public virtual async Task<TEntity> UpdateAsync(TId id, TEntity entity)
             return oldEntity;
         }
 
-        /// </ inheritdoc>
+        /// <inheritdoc />
         public async Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds)
         {
             var genericProcessor = _genericProcessorFactory.GetProcessor<IGenericProcessor>(typeof(GenericProcessor<>), relationship.Type);
             await genericProcessor.UpdateRelationshipsAsync(parent, relationship, relationshipIds);
         }
 
-        /// </ inheritdoc>
+        /// <inheritdoc />
         public virtual async Task<bool> DeleteAsync(TId id)
         {
             var entity = await GetAsync(id);
@@ -170,7 +177,8 @@ public virtual async Task<bool> DeleteAsync(TId id)
             return true;
         }
 
-        /// </ inheritdoc>
+        /// <inheritdoc />
+        [Obsolete("Use IncludeAsync")]
         public virtual IQueryable<TEntity> Include(IQueryable<TEntity> entities, string relationshipName)
         {
             var entity = _jsonApiContext.RequestEntity;
@@ -185,10 +193,57 @@ public virtual IQueryable<TEntity> Include(IQueryable<TEntity> entities, string
             {
                 throw new JsonApiException(400, $"Including the relationship {relationshipName} on {entity.EntityName} is not allowed");
             }
+
+            return entities.Include(relationship.InternalRelationshipName);
+        }
+
+        /// <inheritdoc />
+        public virtual async Task<IQueryable<TEntity>> IncludeAsync(IQueryable<TEntity> entities, string relationshipName)
+        {
+            var entity = _jsonApiContext.RequestEntity;
+            var relationship = entity.Relationships.FirstOrDefault(r => r.PublicRelationshipName == relationshipName);
+            if (relationship == null)
+            {
+                throw new JsonApiException(400, $"Invalid relationship {relationshipName} on {entity.EntityName}",
+                    $"{entity.EntityName} does not have a relationship named {relationshipName}");
+            }
+
+            if (!relationship.CanInclude)
+            {
+                throw new JsonApiException(400, $"Including the relationship {relationshipName} on {entity.EntityName} is not allowed");
+            }
+
+            await ReloadPointerAsync(relationship);
+
             return entities.Include(relationship.InternalRelationshipName);
         }
 
-        /// </ inheritdoc>
+        /// <summary>
+        /// Ensure relationships on the provided entity have been fully loaded from the database.
+        /// </summary>
+        /// <remarks>
+        /// The only known case when this should be called is when a POST request is
+        /// sent with an ?include query.
+        /// 
+        /// See https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/343
+        /// </remarks>
+        private async Task ReloadPointerAsync(RelationshipAttribute relationshipAttr)
+        {
+            if (relationshipAttr.IsHasOne && _jsonApiContext.HasOneRelationshipPointers.Get().TryGetValue(relationshipAttr, out var pointer))
+            {
+                await _context.Entry(pointer).ReloadAsync();
+            }
+
+            if (relationshipAttr.IsHasMany && _jsonApiContext.HasManyRelationshipPointers.Get().TryGetValue(relationshipAttr, out var pointers))
+            {
+                foreach (var hasManyPointer in pointers)
+                {
+                    await _context.Entry(hasManyPointer).ReloadAsync();
+                }
+            }
+        }
+
+        /// <inheritdoc />
         public virtual async Task<IEnumerable<TEntity>> PageAsync(IQueryable<TEntity> entities, int pageSize, int pageNumber)
         {
             if (pageNumber >= 0)
@@ -209,23 +264,23 @@ public virtual async Task<IEnumerable<TEntity>> PageAsync(IQueryable<TEntity> en
                     .ToListAsync();
         }
 
-        /// </ inheritdoc>
+        /// <inheritdoc />
         public async Task<int> CountAsync(IQueryable<TEntity> entities)
         {
             return (entities is IAsyncEnumerable<TEntity>)
                  ? await entities.CountAsync()
                  : entities.Count();
         }
 
-        /// </ inheritdoc>
+        /// <inheritdoc />
         public async Task<TEntity> FirstOrDefaultAsync(IQueryable<TEntity> entities)
         {
             return (entities is IAsyncEnumerable<TEntity>)
                ? await entities.FirstOrDefaultAsync()
                : entities.FirstOrDefault();
         }
 
-        /// </ inheritdoc>
+        /// <inheritdoc />
         public async Task<IReadOnlyList<TEntity>> ToListAsync(IQueryable<TEntity> entities)
         {
             return (entities is IAsyncEnumerable<TEntity>)

src/JsonApiDotNetCore/Data/IEntityReadRepository.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
@@ -20,6 +21,9 @@ public interface IEntityReadRepository<TEntity, in TId>
         /// </summary>
         IQueryable<TEntity> Get();
 
+        [Obsolete("Use IncludeAsync")]
+        IQueryable<TEntity> Include(IQueryable<TEntity> entities, string relationshipName);
+
         /// <summary>
         /// Include a relationship in the query
         /// </summary>
@@ -28,7 +32,7 @@ public interface IEntityReadRepository<TEntity, in TId>
         /// _todoItemsRepository.GetAndIncludeAsync(1, "achieved-date");
         /// </code>
         /// </example>
-        IQueryable<TEntity> Include(IQueryable<TEntity> entities, string relationshipName);
+        Task<IQueryable<TEntity>> IncludeAsync(IQueryable<TEntity> entities, string relationshipName);
 
         /// <summary>
         /// Apply a filter to the provided queryable

src/JsonApiDotNetCore/Services/EntityResourceService.cs

@@ -77,6 +77,12 @@ public virtual async Task<TResource> CreateAsync(TResource resource)
 
             entity = await _entities.CreateAsync(entity);
 
+            // this ensures relationships get reloaded from the database if they have
+            // been requested
+            // https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/343
+            if (ShouldIncludeRelationships())
+                return await GetWithRelationshipsAsync(entity.Id);
+
             return MapOut(entity);
         }
 
@@ -92,7 +98,7 @@ public virtual async Task<IEnumerable<TResource>> GetAsync()
             entities = ApplySortAndFilterQuery(entities);
 
             if (ShouldIncludeRelationships())
-                entities = IncludeRelationships(entities, _jsonApiContext.QuerySet.IncludedRelationships);
+                entities = await IncludeRelationshipsAsync(entities, _jsonApiContext.QuerySet.IncludedRelationships);
 
             if (_jsonApiContext.Options.IncludeTotalRecordCount)
                 _jsonApiContext.PageManager.TotalRecords = await _entities.CountAsync(entities);
@@ -218,7 +224,8 @@ protected virtual IQueryable<TEntity> ApplySortAndFilterQuery(IQueryable<TEntity
             return entities;
         }
 
-        protected virtual IQueryable<TEntity> IncludeRelationships(IQueryable<TEntity> entities, List<string> relationships)
+        [Obsolete("Use IncludeRelationshipsAsync")]
+        protected IQueryable<TEntity> IncludeRelationships(IQueryable<TEntity> entities, List<string> relationships)
         {
             _jsonApiContext.IncludedRelationships = relationships;
 
@@ -228,14 +235,24 @@ protected virtual IQueryable<TEntity> IncludeRelationships(IQueryable<TEntity> e
             return entities;
         }
 
+        protected virtual async Task<IQueryable<TEntity>> IncludeRelationshipsAsync(IQueryable<TEntity> entities, List<string> relationships)
+        {
+            _jsonApiContext.IncludedRelationships = relationships;
+
+            foreach (var r in relationships)
+                entities = await _entities.IncludeAsync(entities, r);
+
+            return entities;
+        }
+
         private async Task<TResource> GetWithRelationshipsAsync(TId id)
         {
             var query = _entities.Get().Where(e => e.Id.Equals(id));
 
-            _jsonApiContext.QuerySet.IncludedRelationships.ForEach(r =>
+            foreach (var r in _jsonApiContext.QuerySet.IncludedRelationships)
             {
-                query = _entities.Include(query, r);
-            });
+                query = await _entities.IncludeAsync(query, r);
+            }
 
             var value = await _entities.FirstOrDefaultAsync(query);