handle attaching HasOne relationships

Author: jaredcnance

src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs

@@ -84,13 +84,19 @@ public virtual async Task<TEntity> GetAndIncludeAsync(TId id, string relationshi
 
         public virtual async Task<TEntity> CreateAsync(TEntity entity)
         {
-            AttachHasManyPointers();
+            AttachRelationships();
             _dbSet.Add(entity);
 
             await _context.SaveChangesAsync();
             return entity;
         }
 
+        protected virtual void AttachRelationships()
+        {
+            AttachHasManyPointers();
+            AttachHasOnePointers();
+        }
+
         /// <summary>
         /// This is used to allow creation of HasMany relationships when the
         /// dependent side of the relationship already exists.
@@ -107,6 +113,18 @@ private void AttachHasManyPointers()
             }
         }
 
+        /// <summary>
+        /// This is used to allow creation of HasOne relationships when the
+        /// independent side of the relationship already exists.
+        /// </summary>
+        private void AttachHasOnePointers()
+        {
+            var relationships = _jsonApiContext.HasOneRelationshipPointers.Get();
+            foreach (var relationship in relationships)
+                if (_context.Entry(relationship.Value).State == EntityState.Detached && _context.EntityIsTracked(relationship.Value) == false)
+                    _context.Entry(relationship.Value).State = EntityState.Unchanged;
+        }
+
         public virtual async Task<TEntity> UpdateAsync(TId id, TEntity entity)
         {
             var oldEntity = await GetAsync(id);

src/JsonApiDotNetCore/Extensions/DbContextExtensions.cs

@@ -1,4 +1,7 @@
 using System;
+using System.Linq;
+using JsonApiDotNetCore.Internal;
+using JsonApiDotNetCore.Models;
 using Microsoft.EntityFrameworkCore;
 
 namespace JsonApiDotNetCore.Extensions
@@ -8,5 +11,23 @@ public static class DbContextExtensions
         [Obsolete("This is no longer required since the introduction of context.Set<T>", error: false)]
         public static DbSet<T> GetDbSet<T>(this DbContext context) where T : class 
             => context.Set<T>();
+
+        /// <summary>
+        /// Determines whether or not EF is already tracking an entity of the same Type and Id
+        /// </summary>
+        public static bool EntityIsTracked(this DbContext context, IIdentifiable entity)
+        {
+            if (entity == null)
+                throw new ArgumentNullException(nameof(entity));
+            
+            var trackedEntries = context.ChangeTracker
+                .Entries()
+                .FirstOrDefault(entry => 
+                    entry.Entity.GetType() == entity.GetType() 
+                    && ((IIdentifiable)entry.Entity).StringId == entity.StringId
+                );
+
+            return trackedEntries != null;
+        }
     }
 }

src/JsonApiDotNetCore/Request/HasOneRelationshipPointers.cs

@@ -0,0 +1,46 @@
+using JsonApiDotNetCore.Models;
+using System;
+using System.Collections.Generic;
+
+namespace JsonApiDotNetCore.Request
+{
+    /// <summary>
+    /// Stores information to set relationships for the request resource. 
+    /// These relationships must already exist and should not be re-created.
+    /// 
+    /// The expected use case is POST-ing or PATCH-ing 
+    /// an entity with HasOne relationships:
+    /// <code>
+    /// {
+    ///    "data": {
+    ///      "type": "photos",
+    ///      "attributes": {
+    ///        "title": "Ember Hamster",
+    ///        "src": "http://example.com/images/productivity.png"
+    ///      },
+    ///      "relationships": {
+    ///        "photographer": {
+    ///          "data": { "type": "people", "id": "2" }
+    ///        }
+    ///      }
+    ///    }
+    ///  }
+    /// </code>
+    /// </summary>
+    public class HasOneRelationshipPointers
+    {
+        private Dictionary<Type, IIdentifiable> _hasOneRelationships = new Dictionary<Type, IIdentifiable>();
+
+        /// <summary>
+        /// Add the relationship to the list of relationships that should be 
+        /// set in the repository layer.
+        /// </summary>
+        public void Add(Type dependentType, IIdentifiable entity)
+            => _hasOneRelationships[dependentType] = entity;
+
+        /// <summary>
+        /// Get all the models that should be associated
+        /// </summary>
+        public Dictionary<Type, IIdentifiable> Get() => _hasOneRelationships;
+    }
+}

src/JsonApiDotNetCore/Serialization/JsonApiDeSerializer.cs

@@ -241,6 +241,11 @@ private object SetHasOneRelationship(object entity,
                 var includedRelationshipObject = GetIncludedRelationship(rio, included, relationshipAttr);
                 if (includedRelationshipObject != null)
                     relationshipAttr.SetValue(entity, includedRelationshipObject);
+
+                // we need to store the fact that this relationship was included in the payload
+                // for EF, the repository will use these pointers to make ensure we don't try to
+                // create resources if they already exist, we just need to create the relationship
+                _jsonApiContext.HasOneRelationshipPointers.Add(attr.Type, includedRelationshipObject);
             }
 
             return entity;

src/JsonApiDotNetCore/Services/IJsonApiContext.cs

@@ -81,6 +81,31 @@ public interface IJsonApiRequest : IJsonApiApplication, IUpdateRequest, IQueryRe
         /// </summary>
         HasManyRelationshipPointers HasManyRelationshipPointers { get; }
 
+        /// <summary>
+        /// Stores information to set relationships for the request resource. 
+        /// These relationships must already exist and should not be re-created.
+        /// 
+        /// The expected use case is POST-ing or PATCH-ing 
+        /// an entity with HasOne relationships:
+        /// <code>
+        /// {
+        ///    "data": {
+        ///      "type": "photos",
+        ///      "attributes": {
+        ///        "title": "Ember Hamster",
+        ///        "src": "http://example.com/images/productivity.png"
+        ///      },
+        ///      "relationships": {
+        ///        "photographer": {
+        ///          "data": { "type": "people", "id": "2" }
+        ///        }
+        ///      }
+        ///    }
+        ///  }
+        /// </code>
+        /// </summary>
+        HasOneRelationshipPointers HasOneRelationshipPointers { get; }
+
         /// <summary>
         /// If the request is a bulk json:api v1.1 operations request.
         /// This is determined by the `

src/JsonApiDotNetCore/Services/JsonApiContext.cs

@@ -53,6 +53,7 @@ public JsonApiContext(
         public Dictionary<string, object> DocumentMeta { get; set; }
         public bool IsBulkOperationRequest { get; set; }
         public HasManyRelationshipPointers HasManyRelationshipPointers { get; } = new HasManyRelationshipPointers();
+        public HasOneRelationshipPointers HasOneRelationshipPointers { get; } = new HasOneRelationshipPointers();
 
         public IJsonApiContext ApplyContext<T>(object controller)
         {

test/JsonApiDotNetCoreExampleTests/Acceptance/TodoItemsControllerTests.cs

@@ -294,11 +294,12 @@ public async Task Can_Post_TodoItem()
 
             // Act
             var response = await _fixture.Client.SendAsync(request);
-            var body = await response.Content.ReadAsStringAsync();
-            var deserializedBody = (TodoItem)_fixture.GetService<IJsonApiDeSerializer>().Deserialize(body);
 
             // Assert
             Assert.Equal(HttpStatusCode.Created, response.StatusCode);
+            var body = await response.Content.ReadAsStringAsync();
+            var deserializedBody = (TodoItem)_fixture.GetService<IJsonApiDeSerializer>().Deserialize(body);
+            Assert.Equal(HttpStatusCode.Created, response.StatusCode);
             Assert.Equal(todoItem.Description, deserializedBody.Description);
             Assert.Equal(todoItem.CreatedDate.ToString("G"), deserializedBody.CreatedDate.ToString("G"));
             Assert.Null(deserializedBody.AchievedDate);

test/UnitTests/Serialization/JsonApiDeSerializerTests.cs

@@ -477,6 +477,7 @@ public void Sets_Attribute_Values_On_Included_HasOne_Relationships()
             jsonApiContextMock.Setup(m => m.AttributesToUpdate).Returns(new Dictionary<AttrAttribute, object>());
             jsonApiContextMock.Setup(m => m.RelationshipsToUpdate).Returns(new Dictionary<RelationshipAttribute, object>());
             jsonApiContextMock.Setup(m => m.HasManyRelationshipPointers).Returns(new HasManyRelationshipPointers());
+            jsonApiContextMock.Setup(m => m.HasOneRelationshipPointers).Returns(new HasOneRelationshipPointers());
 
             var jsonApiOptions = new JsonApiOptions();
             jsonApiContextMock.Setup(m => m.Options).Returns(jsonApiOptions);