don't reload individual relationships, just detach and then fetch

Author: jaredcnance

src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs

@@ -85,7 +85,7 @@ public virtual async Task<TEntity> GetAndIncludeAsync(TId id, string relationshi
         {
             _logger.LogDebug($"[JADN] GetAndIncludeAsync({id}, {relationshipName})");
 
-            var includedSet = await IncludeAsync(Get(), relationshipName);
+            var includedSet = Include(Get(), relationshipName);
             var result = await includedSet.SingleOrDefaultAsync(e => e.Id.Equals(id));
 
             return result;
@@ -108,6 +108,28 @@ protected virtual void AttachRelationships()
             AttachHasOnePointers();
         }
 
+        /// <inheritdoc />
+        public void DetachRelationshipPointers(TEntity entity)
+        {
+            foreach (var hasOneRelationship in _jsonApiContext.HasOneRelationshipPointers.Get())
+            {
+                _context.Entry(hasOneRelationship.Value).State = EntityState.Detached;
+            }
+
+            foreach (var hasManyRelationship in _jsonApiContext.HasManyRelationshipPointers.Get())
+            {
+                foreach (var pointer in hasManyRelationship.Value)
+                {
+                    _context.Entry(pointer).State = EntityState.Detached;
+                }
+
+                // HACK: detaching has many relationships doesn't appear to be sufficient
+                // the navigation property actually needs to be nulled out, otherwise
+                // EF adds duplicate instances to the collection
+                hasManyRelationship.Key.SetValue(entity, null);
+            }
+        }
+
         /// <summary>
         /// This is used to allow creation of HasMany relationships when the
         /// dependent side of the relationship already exists.
@@ -178,7 +200,6 @@ public virtual async Task<bool> DeleteAsync(TId id)
         }
 
         /// <inheritdoc />
-        [Obsolete("Use IncludeAsync")]
         public virtual IQueryable<TEntity> Include(IQueryable<TEntity> entities, string relationshipName)
         {
             var entity = _jsonApiContext.RequestEntity;
@@ -197,52 +218,6 @@ public virtual IQueryable<TEntity> Include(IQueryable<TEntity> entities, string
             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);
-        }
-
-        /// <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)
         {

src/JsonApiDotNetCore/Data/IEntityReadRepository.cs

@@ -21,9 +21,6 @@ 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>
@@ -32,7 +29,7 @@ public interface IEntityReadRepository<TEntity, in TId>
         /// _todoItemsRepository.GetAndIncludeAsync(1, "achieved-date");
         /// </code>
         /// </example>
-        Task<IQueryable<TEntity>> IncludeAsync(IQueryable<TEntity> entities, string relationshipName);
+        IQueryable<TEntity> Include(IQueryable<TEntity> entities, string relationshipName);
 
         /// <summary>
         /// Apply a filter to the provided queryable

src/JsonApiDotNetCore/Data/IEntityRepository.cs

@@ -8,7 +8,7 @@ public interface IEntityRepository<TEntity>
     { }
 
     public interface IEntityRepository<TEntity, in TId>
-        : IEntityReadRepository<TEntity, TId>,  
+        : IEntityReadRepository<TEntity, TId>,
         IEntityWriteRepository<TEntity, TId>
         where TEntity : class, IIdentifiable<TId>
     { }

src/JsonApiDotNetCore/Data/IEntityWriteRepository.cs

@@ -19,5 +19,19 @@ public interface IEntityWriteRepository<TEntity, in TId>
         Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds);
 
         Task<bool> DeleteAsync(TId id);
+
+        /// <summary>
+        /// Ensures that any relationship pointers created during a POST or PATCH
+        /// request are detached from the DbContext.
+        /// This allows the relationships to be 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>
+        void DetachRelationshipPointers(TEntity entity);
     }
 }

src/JsonApiDotNetCore/Services/EntityResourceService.cs

@@ -81,7 +81,10 @@ public virtual async Task<TResource> CreateAsync(TResource resource)
             // been requested
             // https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/343
             if (ShouldIncludeRelationships())
+            {
+                _entities.DetachRelationshipPointers(entity);
                 return await GetWithRelationshipsAsync(entity.Id);
+            }
 
             return MapOut(entity);
         }
@@ -98,7 +101,7 @@ public virtual async Task<IEnumerable<TResource>> GetAsync()
             entities = ApplySortAndFilterQuery(entities);
 
             if (ShouldIncludeRelationships())
-                entities = await IncludeRelationshipsAsync(entities, _jsonApiContext.QuerySet.IncludedRelationships);
+                entities = IncludeRelationships(entities, _jsonApiContext.QuerySet.IncludedRelationships);
 
             if (_jsonApiContext.Options.IncludeTotalRecordCount)
                 _jsonApiContext.PageManager.TotalRecords = await _entities.CountAsync(entities);
@@ -224,7 +227,6 @@ protected virtual IQueryable<TEntity> ApplySortAndFilterQuery(IQueryable<TEntity
             return entities;
         }
 
-        [Obsolete("Use IncludeRelationshipsAsync")]
         protected IQueryable<TEntity> IncludeRelationships(IQueryable<TEntity> entities, List<string> relationships)
         {
             _jsonApiContext.IncludedRelationships = relationships;
@@ -235,23 +237,13 @@ protected IQueryable<TEntity> IncludeRelationships(IQueryable<TEntity> entities,
             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));
 
             foreach (var r in _jsonApiContext.QuerySet.IncludedRelationships)
             {
-                query = await _entities.IncludeAsync(query, r);
+                query = _entities.Include(query, r);
             }
 
             var value = await _entities.FirstOrDefaultAsync(query);