feat: decoupled IJsonApiContext from repository wrt updating resources

Author: maurei

src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs

@@ -171,44 +171,34 @@ public virtual async Task<TEntity> CreateAsync(TEntity entity)
         /// <inheritdoc />
         public void DetachRelationshipPointers(TEntity entity)
         {
-            foreach (var hasOneRelationship in _jsonApiContext.HasOneRelationshipPointers.Get())
-            {
-                var hasOne = (HasOneAttribute)hasOneRelationship.Key;
-                if (hasOne.EntityPropertyName != null)
-                {
-                    var relatedEntity = entity.GetType().GetProperty(hasOne.EntityPropertyName)?.GetValue(entity);
-                    if (relatedEntity != null)
-                        _context.Entry(relatedEntity).State = EntityState.Detached;
-                }
-                else
-                {
-                    _context.Entry(hasOneRelationship.Value).State = EntityState.Detached;
-                }
-            }
 
-            foreach (var hasManyRelationship in _jsonApiContext.HasManyRelationshipPointers.Get())
+            foreach (var relationshipAttr in _jsonApiContext.RelationshipsToUpdate.Keys)
             {
-                var hasMany = (HasManyAttribute)hasManyRelationship.Key;
-                if (hasMany.EntityPropertyName != null)
+                if (relationshipAttr is HasOneAttribute hasOneAttr) 
                 {
-                    var relatedList = (IList)entity.GetType().GetProperty(hasMany.EntityPropertyName)?.GetValue(entity);
-                    foreach (var related in relatedList)
-                    {
-                        _context.Entry(related).State = EntityState.Detached;
-                    }
+                    var relationshipValue = GetEntityResourceSeparationValue(entity, hasOneAttr) ?? (IIdentifiable)hasOneAttr.GetValue(entity);
+                    if (relationshipValue == null) continue;
+                    _context.Entry(relationshipValue).State = EntityState.Detached;
+
                 }
-                else
+                else 
                 {
-                    foreach (var pointer in hasManyRelationship.Value)
+                    IEnumerable<IIdentifiable> relationshipValueList = (IEnumerable<IIdentifiable>)relationshipAttr.GetValue(entity);
+                    /// This adds support for resource-entity separation in the case of one-to-many. 
+                    /// todo: currently there is no support for many to many relations.
+                    if (relationshipAttr is HasManyAttribute hasMany)
+                        relationshipValueList = GetEntityResourceSeparationValue(entity, hasMany) ?? relationshipValueList;
+                    if (relationshipValueList == null) continue;
+                    foreach (var pointer in relationshipValueList)
                     {
                         _context.Entry(pointer).State = EntityState.Detached;
                     }
+                    /// detaching has many relationships is not sufficient to 
+                    /// trigger a full reload of relationships: the navigation 
+                    /// property actually needs to be nulled out, otherwise
+                    /// EF will still add duplicate instances to the collection
+                    relationshipAttr.SetValue(entity, null);
                 }
-
-                // 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);
             }
         }
 

src/JsonApiDotNetCore/Serialization/JsonApiDeSerializer.cs

@@ -155,7 +155,11 @@ private object SetEntityAttributes(
                         continue;
                     var convertedValue = ConvertAttrValue(newValue, attr.PropertyInfo.PropertyType);
                     attr.SetValue(entity, convertedValue);
-                    _jsonApiContext.AttributesToUpdate[attr] = convertedValue;
+                    /// todo: as a part of the process of decoupling JADNC (specifically 
+                    /// through the decoupling IJsonApiContext), we now no longer need to 
+                    /// store the updated relationship values in this property. For now 
+                    /// just assigning null as value, will remove this property later as a whole.
+                    _jsonApiContext.AttributesToUpdate[attr] = null;
                 }
             }
 
@@ -249,7 +253,10 @@ private void SetHasOneForeignKeyValue(object entity, HasOneAttribute hasOneAttr,
                     throw new JsonApiException(400, $"Cannot set required relationship identifier '{hasOneAttr.IdentifiablePropertyName}' to null because it is a non-nullable type.");
 
                 var convertedValue = TypeHelper.ConvertType(foreignKeyPropertyValue, foreignKeyProperty.PropertyType);
-                foreignKeyProperty.SetValue(entity, convertedValue);
+                /// todo: as a part of the process of decoupling JADNC (specifically 
+                /// through the decoupling IJsonApiContext), we now no longer need to 
+                /// store the updated relationship values in this property. For now 
+                /// just assigning null as value, will remove this property later as a whole.
                 if (convertedValue == null )  _jsonApiContext.HasOneRelationshipPointers.Add(hasOneAttr, null); 
             }
         }
@@ -270,10 +277,11 @@ private void SetHasOneNavigationPropertyValue(object entity, HasOneAttribute has
                 if (includedRelationshipObject != null)
                     hasOneAttr.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(hasOneAttr, includedRelationshipObject);
+                /// todo: as a part of the process of decoupling JADNC (specifically 
+                /// through the decoupling IJsonApiContext), we now no longer need to 
+                /// store the updated relationship values in this property. For now 
+                /// just assigning null as value, will remove this property later as a whole.
+                _jsonApiContext.HasOneRelationshipPointers.Add(hasOneAttr, null);
             }
         }
 
@@ -300,8 +308,11 @@ private object SetHasManyRelationship(object entity,
                 var convertedCollection = TypeHelper.ConvertCollection(relatedResources, attr.Type);
 
                 attr.SetValue(entity, convertedCollection);
-                //_jsonApiContext.RelationshipsToUpdate[attr] = convertedCollection; // WHAT exactly is the use of these two different collections..?
-                _jsonApiContext.HasManyRelationshipPointers.Add(attr, convertedCollection);
+                /// todo: as a part of the process of decoupling JADNC (specifically 
+                /// through the decoupling IJsonApiContext), we now no longer need to 
+                /// store the updated relationship values in this property. For now 
+                /// just assigning null as value, will remove this property later as a whole.
+                _jsonApiContext.HasManyRelationshipPointers.Add(attr, null); 
             }
 
             return entity;