Change tracking for patch updates, to improve json:api spec compliance (#704)

Change tracking for patch updates, to improve json:api spec compliance

I have added some calculated properties to the examples, in order to have tests for:
- nothing outside the patch request changed (returns empty data)
  - `KebabCaseFormatterTests.KebabCaseFormatter_Update_IsUpdated` has no side effects in updating `KebabCasedModel` attributes
  - `ManyToManyTests.Can_Update_Many_To_Many` has no side effects in updating `Article` tags
  - `ManyToManyTests.Can_Update_Many_To_Many_With_Complete_Replacement` has no side effects in updating `Article` tags
  - `ManyToManyTests.Can_Update_Many_To_Many_With_Complete_Replacement_With_Overlap` has no side effects in updating `Article` tags
- exposed attribute that was not in PATCH request changed (returns attributes)
  - `UpdatingDataTests.PatchResource_ModelWithEntityFrameworkInheritance_IsPatched` updates `User.Password` property, which updates exposed `LastPasswordChange` attribute
  - `UpdatingDataTests.Patch_Entity_With_HasMany_Does_Not_Include_Relationships` updates `Person.FirstName` property, which updates exposed `Initials` attribute
  - `TodoItemsControllerTests.Can_Patch_TodoItemWithNullable` does not update exposed `TodoItem.AlwaysChangingValue` attribute
- exposed attribute that was in PATCH request changed (returns attributes)
  - `TodoItemsControllerTests.Can_Patch_TodoItem` updates `TodoItem.AlwaysChangingValue` attribute

Also updated a few places where an empty list was allocated each time with a cached empty array instance.

Author: Bart Koelman

src/Examples/JsonApiDotNetCoreExample/Models/Passport.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations.Schema;
 using System.Linq;
@@ -7,8 +8,24 @@ namespace JsonApiDotNetCoreExample.Models
 {
     public class Passport : Identifiable
     {
+        private int? _socialSecurityNumber;
+
+        [Attr]
+        public int? SocialSecurityNumber
+        {
+            get => _socialSecurityNumber;
+            set
+            {
+                if (value != _socialSecurityNumber)
+                {
+                    LastSocialSecurityNumberChange = DateTime.Now;
+                    _socialSecurityNumber = value;
+                }
+            }
+        }
+
         [Attr]
-        public int? SocialSecurityNumber { get; set; }
+        public DateTime LastSocialSecurityNumberChange { get; set; }
 
         [Attr]
         public bool IsLocked { get; set; }

src/Examples/JsonApiDotNetCoreExample/Models/Person.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Linq;
 using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Models.Links;
 
@@ -12,10 +13,26 @@ public sealed class PersonRole : Identifiable
 
     public sealed class Person : Identifiable, IIsLockable
     {
+        private string _firstName;
+
         public bool IsLocked { get; set; }
 
         [Attr]
-        public string FirstName { get; set; }
+        public string FirstName
+        {
+            get => _firstName;
+            set
+            {
+                if (value != _firstName)
+                {
+                    _firstName = value;
+                    Initials = string.Concat(value.Split(' ').Select(x => char.ToUpperInvariant(x[0])));
+                }
+            }
+        }
+
+        [Attr]
+        public string Initials { get; set; }
 
         [Attr]
         public string LastName { get; set; }

src/Examples/JsonApiDotNetCoreExample/Models/TodoItem.cs

@@ -22,6 +22,13 @@ public TodoItem()
         [Attr]
         public Guid GuidProperty { get; set; }
 
+        [Attr]
+        public string AlwaysChangingValue
+        {
+            get => Guid.NewGuid().ToString();
+            set { }
+        }
+
         [Attr]
         public DateTime CreatedDate { get; set; }
 

src/Examples/JsonApiDotNetCoreExample/Models/User.cs

@@ -1,11 +1,29 @@
+using System;
 using JsonApiDotNetCore.Models;
 
 namespace JsonApiDotNetCoreExample.Models
 {
     public class User : Identifiable
     {
+        private string _password;
+
         [Attr] public string Username { get; set; }
-        [Attr] public string Password { get; set; }
+
+        [Attr]
+        public string Password
+        {
+            get => _password;
+            set
+            {
+                if (value != _password)
+                {
+                    _password = value;
+                    LastPasswordChange = DateTime.Now;
+                }
+            }
+        }
+
+        [Attr] public DateTime LastPasswordChange { get; set; }
     }
 
     public sealed class SuperUser : User

src/Examples/JsonApiDotNetCoreExample/Services/CustomArticleService.cs

@@ -8,6 +8,7 @@
 using Microsoft.Extensions.Logging;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using JsonApiDotNetCore.RequestServices;
 
 namespace JsonApiDotNetCoreExample.Services
 {
@@ -19,8 +20,9 @@ public CustomArticleService(
             ILoggerFactory loggerFactory,
             IResourceRepository<Article, int> repository,
             IResourceContextProvider provider,
+            IResourceChangeTracker<Article> resourceChangeTracker,
             IResourceHookExecutor hookExecutor = null)
-            : base(queryParameters, options, loggerFactory, repository, provider, hookExecutor)
+            : base(queryParameters, options, loggerFactory, repository, provider, resourceChangeTracker, hookExecutor)
         { }
 
         public override async Task<Article> GetAsync(int id)

src/JsonApiDotNetCore/Builders/JsonApiApplicationBuilder.cs

@@ -21,6 +21,7 @@
 using JsonApiDotNetCore.Serialization.Server;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using JsonApiDotNetCore.QueryParameterServices.Common;
+using JsonApiDotNetCore.RequestServices;
 
 namespace JsonApiDotNetCore.Builders
 {
@@ -161,6 +162,7 @@ public void ConfigureServices()
             _services.AddScoped<ITargetedFields, TargetedFields>();
             _services.AddScoped<IResourceDefinitionProvider, ResourceDefinitionProvider>();
             _services.AddScoped<IFieldsToSerialize, FieldsToSerialize>();
+            _services.AddScoped(typeof(IResourceChangeTracker<>), typeof(DefaultResourceChangeTracker<>));
             _services.AddScoped<IQueryParameterActionFilter, QueryParameterActionFilter>();
 
             AddServerSerialization();

src/JsonApiDotNetCore/Controllers/BaseJsonApiController.cs

@@ -133,7 +133,7 @@ public virtual async Task<IActionResult> PatchAsync(TId id, [FromBody] T entity)
                 throw new InvalidModelStateException(ModelState, typeof(T), _jsonApiOptions.IncludeExceptionStackTraceInErrors);
 
             var updatedEntity = await _update.UpdateAsync(id, entity);
-            return Ok(updatedEntity);
+            return updatedEntity == null ? Ok(null) : Ok(updatedEntity);
         }
 
         public virtual async Task<IActionResult> PatchRelationshipsAsync(TId id, string relationshipName, [FromBody] object relationships)

src/JsonApiDotNetCore/Data/DefaultResourceRepository.cs

@@ -195,16 +195,12 @@ private void DetachRelationships(TResource entity)
         }
 
         /// <inheritdoc />
-        public virtual async Task<TResource> UpdateAsync(TResource updatedEntity)
+        public virtual async Task UpdateAsync(TResource requestEntity, TResource databaseEntity)
         {
-            _logger.LogTrace($"Entering {nameof(UpdateAsync)}({(updatedEntity == null ? "null" : "object")}).");
-
-            var databaseEntity = await Get(updatedEntity.Id).FirstOrDefaultAsync();
-            if (databaseEntity == null)
-                return null;
+            _logger.LogTrace($"Entering {nameof(UpdateAsync)}({(requestEntity == null ? "null" : "object")}, {(databaseEntity == null ? "null" : "object")}).");
 
             foreach (var attribute in _targetedFields.Attributes)
-                attribute.SetValue(databaseEntity, attribute.GetValue(updatedEntity));
+                attribute.SetValue(databaseEntity, attribute.GetValue(requestEntity));
 
             foreach (var relationshipAttr in _targetedFields.Relationships)
             {
@@ -213,7 +209,7 @@ public virtual async Task<TResource> UpdateAsync(TResource updatedEntity)
                 // trackedRelationshipValue is either equal to updatedPerson.todoItems,
                 // or replaced with the same set (same ids) of todoItems from the EF Core change tracker,
                 // which is the case if they were already tracked
-                object trackedRelationshipValue = GetTrackedRelationshipValue(relationshipAttr, updatedEntity, out _);
+                object trackedRelationshipValue = GetTrackedRelationshipValue(relationshipAttr, requestEntity, out _);
                 // loads into the db context any persons currently related
                 // to the todoItems in trackedRelationshipValue
                 LoadInverseRelationships(trackedRelationshipValue, relationshipAttr);
@@ -223,7 +219,6 @@ public virtual async Task<TResource> UpdateAsync(TResource updatedEntity)
             }
 
             await _context.SaveChangesAsync();
-            return databaseEntity;
         }
 
         /// <summary>
@@ -303,6 +298,13 @@ public virtual async Task<bool> DeleteAsync(TId id)
             return true;
         }
 
+        public virtual void FlushFromCache(TResource entity)
+        {
+            _logger.LogTrace($"Entering {nameof(FlushFromCache)}({nameof(entity)}).");
+
+            _context.Entry(entity).State = EntityState.Detached;
+        }
+
         private IQueryable<TResource> EagerLoad(IQueryable<TResource> entities, IEnumerable<EagerLoadAttribute> attributes, string chainPrefix = null)
         {
             foreach (var attribute in attributes)

src/JsonApiDotNetCore/Data/IResourceWriteRepository.cs

@@ -14,10 +14,12 @@ public interface IResourceWriteRepository<TResource, in TId>
     {
         Task<TResource> CreateAsync(TResource entity);
 
-        Task<TResource> UpdateAsync(TResource entity);
+        Task UpdateAsync(TResource requestEntity, TResource databaseEntity);
 
         Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds);
 
         Task<bool> DeleteAsync(TId id);
+
+        void FlushFromCache(TResource entity);
     }
 }

src/JsonApiDotNetCore/Middleware/DefaultTypeMatchFilter.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Linq;
 using System.Net.Http;
 using JsonApiDotNetCore.Exceptions;

src/JsonApiDotNetCore/RequestServices/Contracts/IUpdatedFields.cs renamed to src/JsonApiDotNetCore/RequestServices/Contracts/ITargetedFields.cs

@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using JsonApiDotNetCore.Models;
 
 namespace JsonApiDotNetCore.Serialization

src/JsonApiDotNetCore/RequestServices/DefaultResourceChangeTracker.cs

@@ -0,0 +1,120 @@
+using System.Collections.Generic;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Internal.Contracts;
+using JsonApiDotNetCore.Models;
+using JsonApiDotNetCore.Serialization;
+using Newtonsoft.Json;
+
+namespace JsonApiDotNetCore.RequestServices
+{
+    /// <summary>
+    /// Used to determine whether additional changes to a resource, not specified in a PATCH request, have been applied.
+    /// </summary>
+    public interface IResourceChangeTracker<in TResource> where TResource : class, IIdentifiable
+    {
+        /// <summary>
+        /// Sets the exposed entity attributes as stored in database, before applying changes.
+        /// </summary>
+        void SetInitiallyStoredAttributeValues(TResource entity);
+
+        /// <summary>
+        /// Sets the subset of exposed attributes from the PATCH request.
+        /// </summary>
+        void SetRequestedAttributeValues(TResource entity);
+
+        /// <summary>
+        /// Sets the exposed entity attributes as stored in database, after applying changes.
+        /// </summary>
+        void SetFinallyStoredAttributeValues(TResource entity);
+
+        /// <summary>
+        /// Validates if any exposed entity attributes that were not in the PATCH request have been changed.
+        /// And validates if the values from the PATCH request are stored without modification.
+        /// </summary>
+        /// <returns>
+        /// <c>true</c> if the attribute values from the PATCH request were the only changes; <c>false</c>, otherwise.
+        /// </returns>
+        bool HasImplicitChanges();
+    }
+
+    public sealed class DefaultResourceChangeTracker<TResource> : IResourceChangeTracker<TResource> where TResource : class, IIdentifiable
+    {
+        private readonly IJsonApiOptions _options;
+        private readonly IResourceContextProvider _contextProvider;
+        private readonly ITargetedFields _targetedFields;
+
+        private IDictionary<string, string> _initiallyStoredAttributeValues;
+        private IDictionary<string, string> _requestedAttributeValues;
+        private IDictionary<string, string> _finallyStoredAttributeValues;
+
+        public DefaultResourceChangeTracker(IJsonApiOptions options, IResourceContextProvider contextProvider,
+            ITargetedFields targetedFields)
+        {
+            _options = options;
+            _contextProvider = contextProvider;
+            _targetedFields = targetedFields;
+        }
+
+        public void SetInitiallyStoredAttributeValues(TResource entity)
+        {
+            var resourceContext = _contextProvider.GetResourceContext<TResource>();
+            _initiallyStoredAttributeValues = CreateAttributeDictionary(entity, resourceContext.Attributes);
+        }
+
+        public void SetRequestedAttributeValues(TResource entity)
+        {
+            _requestedAttributeValues = CreateAttributeDictionary(entity, _targetedFields.Attributes);
+        }
+
+        public void SetFinallyStoredAttributeValues(TResource entity)
+        {
+            var resourceContext = _contextProvider.GetResourceContext<TResource>();
+            _finallyStoredAttributeValues = CreateAttributeDictionary(entity, resourceContext.Attributes);
+        }
+
+        private IDictionary<string, string> CreateAttributeDictionary(TResource resource,
+            IEnumerable<AttrAttribute> attributes)
+        {
+            var result = new Dictionary<string, string>();
+
+            foreach (var attribute in attributes)
+            {
+                object value = attribute.GetValue(resource);
+                // TODO: Remove explicit cast to JsonApiOptions after https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/687 has been fixed.
+                var json = JsonConvert.SerializeObject(value, ((JsonApiOptions) _options).SerializerSettings);
+                result.Add(attribute.PublicAttributeName, json);
+            }
+
+            return result;
+        }
+
+        public bool HasImplicitChanges()
+        {
+            foreach (var key in _initiallyStoredAttributeValues.Keys)
+            {
+                if (_requestedAttributeValues.ContainsKey(key))
+                {
+                    var requestedValue = _requestedAttributeValues[key];
+                    var actualValue = _finallyStoredAttributeValues[key];
+
+                    if (requestedValue != actualValue)
+                    {
+                        return true;
+                    }
+                }
+                else
+                {
+                    var initiallyStoredValue = _initiallyStoredAttributeValues[key];
+                    var finallyStoredValue = _finallyStoredAttributeValues[key];
+
+                    if (initiallyStoredValue != finallyStoredValue)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+    }
+}

src/JsonApiDotNetCore/Serialization/Client/RequestSerializer.cs

@@ -29,7 +29,7 @@ public string Serialize(IIdentifiable entity)
         {
             if (entity == null)
             {
-                var empty = Build((IIdentifiable) null, new List<AttrAttribute>(), new List<RelationshipAttribute>());
+                var empty = Build((IIdentifiable) null, Array.Empty<AttrAttribute>(), Array.Empty<RelationshipAttribute>());
                 return SerializeObject(empty, _jsonSerializerSettings);
             }
 
@@ -52,7 +52,7 @@ public string Serialize(IEnumerable entities)
 
             if (entity == null)
             {
-                var result = Build(entities, new List<AttrAttribute>(), new List<RelationshipAttribute>());
+                var result = Build(entities, Array.Empty<AttrAttribute>(), Array.Empty<RelationshipAttribute>());
                 return SerializeObject(result, _jsonSerializerSettings);
             }
 

src/JsonApiDotNetCore/Serialization/Client/ResponseDeserializer.cs

@@ -37,7 +37,7 @@ public DeserializedListResponse<TResource> DeserializeList<TResource>(string bod
             {
                 Links = _document.Links,
                 Meta = _document.Meta,
-                Data = ((List<IIdentifiable>) entities)?.Cast<TResource>().ToList(),
+                Data = ((ICollection<IIdentifiable>) entities)?.Cast<TResource>().ToList(),
                 JsonApi = null,
                 Errors = null
             };

src/JsonApiDotNetCore/Serialization/Common/BaseDocumentParser.cs

@@ -51,7 +51,7 @@ protected object Deserialize(string body)
             if (_document.IsManyData)
             {
                 if (_document.ManyData.Count == 0)
-                    return new List<IIdentifiable>();
+                    return Array.Empty<IIdentifiable>();
 
                 return _document.ManyData.Select(ParseResourceObject).ToList();
             }