refactor: rename entitydiff to resourcediff

Author: maurei

docs/usage/resources/hooks.md

@@ -260,13 +260,13 @@ public class ArticleResource : ResourceDefinition<Article>
         _context = context;  
     } 
 
-    public override IEnumerable<Article> BeforeUpdate(IEntityDiff<Article> entityDiff, ResourcePipeline pipeline)
+    public override IEnumerable<Article> BeforeUpdate(IResourceDiff<Article> entityDiff, ResourcePipeline pipeline)
     {
         // PropertyGetter is a helper class that takes care of accessing the values on an instance of Article using reflection.
         var getter = new PropertyGetter<Article>();
 
-        // EntityDiff<T> is a class that is like a list that contains EntityDiffPair<T> elements
-        foreach (EntityDiffPair<Article> affected in entityDiff)
+        // ResourceDiff<T> is a class that is like a list that contains ResourceDiffPair<T> elements
+        foreach (ResourceDiffPair<Article> affected in entityDiff)
         {
             var currentDatabaseState = affected.DatabaseValue; // the current state in the database
             var proposedValueFromRequest = affected.Entity; // the value from the request
@@ -288,7 +288,7 @@ public class ArticleResource : ResourceDefinition<Article>
     }
 }
 ```
-In this case the `EntityDiffPair<T>.DatabaseValue` is `null`.  If you try to access all database values at once (`EntityDiff.DatabaseValues`) when it they are turned off, an exception will be thrown.
+In this case the `ResourceDiffPair<T>.DatabaseValue` is `null`.  If you try to access all database values at once (`ResourceDiff.DatabaseValues`) when it they are turned off, an exception will be thrown.
 
 Note that database values are turned on by default. They can be turned of globally by configuring the startup as follows:
 ```c#
@@ -310,7 +310,7 @@ The global setting can be used together with per-hook configuration hooks using
 public class ArticleResource : ResourceDefinition<Article>
 {
   [LoadDatabaseValues(true)]
-    public override IEnumerable<Article> BeforeUpdate(IEntityDiff<Article> entityDiff, ResourcePipeline pipeline)
+    public override IEnumerable<Article> BeforeUpdate(IResourceDiff<Article> entityDiff, ResourcePipeline pipeline)
     {
       ....
     }
@@ -389,7 +389,7 @@ This authorization requirement can be fulfilled as follows.
 
 For checking the permissions for the explicitly affected resources, `New Article` and `Alice`, we may implement the `BeforeUpdate` hook for `Article`:
 ```c#
-public override IEnumerable<Article> BeforeUpdate(IEntityDiff<Article> entityDiff, ResourcePipeline pipeline)
+public override IEnumerable<Article> BeforeUpdate(IResourceDiff<Article> entityDiff, ResourcePipeline pipeline)
 {
     if (pipeline == ResourcePipeline.Patch)
     {

src/Examples/JsonApiDotNetCoreExample/Resources/PersonResource.cs

@@ -17,7 +17,7 @@ public override IEnumerable<string> BeforeUpdateRelationship(HashSet<string> ids
         }
 
         //[LoadDatabaseValues(true)]
-        //public override IEnumerable<Person> BeforeUpdate(IEntityDiff<Person> entityDiff, ResourcePipeline pipeline)
+        //public override IEnumerable<Person> BeforeUpdate(IResourceDiff<Person> entityDiff, ResourcePipeline pipeline)
         //{
         //    return entityDiff.Entities;
         //}

src/JsonApiDotNetCore/Hooks/Execution/AffectedResources.cs

@@ -14,12 +14,12 @@ public interface IAffectedResources<TEntity> : IAffectedResourcesBase<TEntity>,
     /// NOTE: you might wonder why there is a separate AffectedResourceBase and AffectedResource.
     /// If we merge them together, ie get rid of the base and just let the AffectedResource directly implement IEnumerable{TEntity},
     /// we will run in to problems with the following:
-    /// EntityDiff{<typeparam name="TEntity"/>} inherits from AffectedResource{TEntity},
-    /// but EntityDiff also implements IEnumerable{EntityDiffPair{TEntity}}. This means that
-    /// EntityDiff will implement two IEnumerable{x} where (x1 = TEntity and x2 = EntityDiffPair{TEntity} )
+    /// ResourceDiff{<typeparam name="TEntity"/>} inherits from AffectedResource{TEntity},
+    /// but ResourceDiff also implements IEnumerable{ResourceDiffPair{TEntity}}. This means that
+    /// ResourceDiff will implement two IEnumerable{x} where (x1 = TEntity and x2 = ResourceDiffPair{TEntity} )
     /// The problem with this is that when you then try to do a simple foreach loop over
-    /// a EntityDiff instance, it will throw an error, because it does not know which of the two enumerators to pick.
-    /// We want EntityDiff to only loop over the EntityDiffPair, so we can do that by making sure
+    /// a ResourceDiff instance, it will throw an error, because it does not know which of the two enumerators to pick.
+    /// We want ResourceDiff to only loop over the ResourceDiffPair, so we can do that by making sure
     /// it doesn't inherit the IEnumerable{TEntity} part from AffectedResources.
     public interface IAffectedResourcesBase<TEntity>  where TEntity : class, IIdentifiable
     {

src/JsonApiDotNetCore/Hooks/Execution/EntityDiff.cs

@@ -8,24 +8,24 @@ namespace JsonApiDotNetCore.Hooks
 {
     /// <summary>
     /// A helper class that provides insight in what is to be updated. The 
-    /// <see cref="IEntityDiff{TEntity}.RequestEntities"/> property reflects what was parsed from the incoming request,
-    /// where the <see cref="IEntityDiff{TEntity}.DatabaseValues"/> reflects what is the current state in the database.
+    /// <see cref="IResourceDiff{TEntity}.RequestEntities"/> property reflects what was parsed from the incoming request,
+    /// where the <see cref="IResourceDiff{TEntity}.DatabaseValues"/> reflects what is the current state in the database.
     /// 
     /// Any relationships that are updated can be retrieved via the methods implemented on 
     /// <see cref="IAffectedRelationships{TDependent}"/>.
     /// </summary>
-    public interface IEntityDiff<TEntity> : IEnumerable<EntityDiffPair<TEntity>>, IAffectedResourcesBase<TEntity> where TEntity : class, IIdentifiable
+    public interface IResourceDiff<TEntity> : IEnumerable<ResourceDiffPair<TEntity>>, IAffectedResourcesBase<TEntity> where TEntity : class, IIdentifiable
     {
         HashSet<TEntity> DatabaseValues { get; }
     }
 
-    public  class EntityDiff<TEntity> : AffectedResourcesBase<TEntity>, IEntityDiff<TEntity> where TEntity : class, IIdentifiable
+    public  class ResourceDiff<TEntity> : AffectedResourcesBase<TEntity>, IResourceDiff<TEntity> where TEntity : class, IIdentifiable
     {
         private readonly HashSet<TEntity> _databaseEntities;
         private readonly bool _databaseValuesLoaded;
         public HashSet<TEntity> DatabaseValues { get => _databaseEntities ?? ThrowNoDbValuesError(); }
 
-        internal EntityDiff(IEnumerable requestEntities,
+        internal ResourceDiff(IEnumerable requestEntities,
                           IEnumerable databaseEntities,
                           Dictionary<RelationshipProxy, IEnumerable> relationships) : base(requestEntities, relationships)
         {
@@ -38,13 +38,13 @@ private HashSet<TEntity> ThrowNoDbValuesError()
             throw new MemberAccessException("Cannot access database entities if the LoadDatabaseValues option is set to false");
         }
 
-        public IEnumerator<EntityDiffPair<TEntity>> GetEnumerator()
+        public IEnumerator<ResourceDiffPair<TEntity>> GetEnumerator()
         {
             foreach (var entity in Entities)
             {
                 TEntity currentValueInDatabase = null;
                 if (_databaseValuesLoaded) currentValueInDatabase = _databaseEntities.Single(e => entity.StringId == e.StringId);
-                yield return new EntityDiffPair<TEntity>(entity, currentValueInDatabase);
+                yield return new ResourceDiffPair<TEntity>(entity, currentValueInDatabase);
             }
         }
 
@@ -54,9 +54,9 @@ IEnumerator IEnumerable.GetEnumerator()
         }
     }
 
-    public class EntityDiffPair<TEntity> where TEntity : class, IIdentifiable
+    public class ResourceDiffPair<TEntity> where TEntity : class, IIdentifiable
     {
-        internal EntityDiffPair(TEntity entity, TEntity databaseValue)
+        internal ResourceDiffPair(TEntity entity, TEntity databaseValue)
         {
             Entity = entity;
             DatabaseValue = databaseValue;

src/JsonApiDotNetCore/Hooks/IResourceHookContainer.cs

@@ -110,12 +110,12 @@ public interface IBeforeHooks<TEntity> where TEntity : class, IIdentifiable
         /// layer just before updating entities of type <typeparamref name="TEntity"/>.
         /// <para />
         /// For the <see cref="ResourcePipeline.Patch"/> pipeline, the
-        /// <paramref name="entityDiff" /> will typically contain one entity. 
+        /// <paramref name="ResourceDiff" /> will typically contain one entity. 
         /// For <see cref="ResourcePipeline.BulkPatch"/>, this it may contain 
         /// multiple entities.
         /// <para />
         /// The returned <see cref="IEnumerable{TEntity}"/> may be a subset 
-        /// of the <see cref="EntityDiff{TEntity}.RequestEntities"/> property in parameter <paramref name="entityDiff"/>, 
+        /// of the <see cref="ResourceDiff{TEntity}.RequestEntities"/> property in parameter <paramref name="ResourceDiff"/>, 
         /// in which case the operation of the  pipeline will not be executed 
         /// for the omitted entities. The returned set may also contain custom 
         /// changes of the properties on the entities.
@@ -131,9 +131,9 @@ public interface IBeforeHooks<TEntity> where TEntity : class, IIdentifiable
         /// hook is fired for these.
         /// </summary>
         /// <returns>The transformed entity set</returns>
-        /// <param name="entityDiff">The entity diff.</param>
+        /// <param name="ResourceDiff">The entity diff.</param>
         /// <param name="pipeline">An enum indicating from where the hook was triggered.</param>
-        IEnumerable<TEntity> BeforeUpdate(IEntityDiff<TEntity> entityDiff, ResourcePipeline pipeline);
+        IEnumerable<TEntity> BeforeUpdate(IResourceDiff<TEntity> ResourceDiff, ResourcePipeline pipeline);
         /// <summary>
         /// Implement this hook to run custom logic in the <see cref=" EntityResourceService{T}"/> 
         /// layer just before deleting entities of type <typeparamref name="TEntity"/>.

src/JsonApiDotNetCore/Hooks/ResourceHookExecutor.cs

@@ -48,7 +48,7 @@ public virtual IEnumerable<TEntity> BeforeUpdate<TEntity>(IEnumerable<TEntity> e
             if (GetHook(ResourceHook.BeforeUpdate, entities, out var container, out var node))
             {
                 var dbValues = LoadDbValues(typeof(TEntity), (IEnumerable<TEntity>)node.UniqueEntities, ResourceHook.BeforeUpdate, node.RelationshipsToNextLayer);
-                var diff = new EntityDiff<TEntity>(node.UniqueEntities, dbValues, node.PrincipalsToNextLayer());
+                var diff = new ResourceDiff<TEntity>(node.UniqueEntities, dbValues, node.PrincipalsToNextLayer());
                 IEnumerable<TEntity> updated = container.BeforeUpdate(diff, pipeline);
                 node.UpdateUnique(updated);
                 node.Reassign(entities);

src/JsonApiDotNetCore/Models/ResourceDefinition.cs

@@ -179,7 +179,7 @@ public virtual void AfterUpdateRelationship(IAffectedRelationships<T> resourcesB
         /// <inheritdoc/>
         public virtual void BeforeRead(ResourcePipeline pipeline, bool isIncluded = false, string stringId = null) { }
         /// <inheritdoc/>
-        public virtual IEnumerable<T> BeforeUpdate(IEntityDiff<T> entityDiff, ResourcePipeline pipeline) { return entityDiff.Entities; }
+        public virtual IEnumerable<T> BeforeUpdate(IResourceDiff<T> ResourceDiff, ResourcePipeline pipeline) { return ResourceDiff.Entities; }
         /// <inheritdoc/>
         public virtual IEnumerable<T> BeforeDelete(IAffectedResources<T> affected, ResourcePipeline pipeline) { return affected; }
         /// <inheritdoc/>

test/UnitTests/ResourceHooks/ResourceHookExecutor/Update/BeforeUpdateTests.cs

@@ -24,7 +24,7 @@ public void BeforeUpdate()
             hookExecutor.BeforeUpdate(todoList, ResourcePipeline.Patch);
 
             // assert
-            todoResourceMock.Verify(rd => rd.BeforeUpdate(It.IsAny<IEntityDiff<TodoItem>>(), ResourcePipeline.Patch), Times.Once());
+            todoResourceMock.Verify(rd => rd.BeforeUpdate(It.IsAny<IResourceDiff<TodoItem>>(), ResourcePipeline.Patch), Times.Once());
             ownerResourceMock.Verify(rd => rd.BeforeUpdateRelationship(It.IsAny<HashSet<string>>(), It.IsAny<IAffectedRelationships<Person>>(), ResourcePipeline.Patch), Times.Once());
             VerifyNoOtherCalls(todoResourceMock, ownerResourceMock);
         }
@@ -62,7 +62,7 @@ public void BeforeUpdate_Without_Child_Hook_Implemented()
             hookExecutor.BeforeUpdate(todoList, ResourcePipeline.Patch);
 
             // assert
-            todoResourceMock.Verify(rd => rd.BeforeUpdate(It.IsAny<IEntityDiff<TodoItem>>(), ResourcePipeline.Patch), Times.Once());
+            todoResourceMock.Verify(rd => rd.BeforeUpdate(It.IsAny<IResourceDiff<TodoItem>>(), ResourcePipeline.Patch), Times.Once());
             VerifyNoOtherCalls(todoResourceMock, ownerResourceMock);
         }
 

test/UnitTests/ResourceHooks/ResourceHookExecutor/Update/BeforeUpdate_WithDbValues_Tests.cs

@@ -59,7 +59,7 @@ public void BeforeUpdate()
             hookExecutor.BeforeUpdate(todoList, ResourcePipeline.Patch);
 
             // assert
-            todoResourceMock.Verify(rd => rd.BeforeUpdate(It.Is<IEntityDiff<TodoItem>>((diff) => TodoCheck(diff, description)), ResourcePipeline.Patch), Times.Once());
+            todoResourceMock.Verify(rd => rd.BeforeUpdate(It.Is<IResourceDiff<TodoItem>>((diff) => TodoCheck(diff, description)), ResourcePipeline.Patch), Times.Once());
             ownerResourceMock.Verify(rd => rd.BeforeUpdateRelationship(
                 It.Is<HashSet<string>>(ids => PersonIdCheck(ids, personId)),
                 It.Is<IAffectedRelationships<Person>>(rh => PersonCheck(lastName, rh)),
@@ -93,7 +93,7 @@ public void BeforeUpdate_Deleting_Relationship()
             hookExecutor.BeforeUpdate(_todoList, ResourcePipeline.Patch);
 
             // assert
-            todoResourceMock.Verify(rd => rd.BeforeUpdate(It.Is<IEntityDiff<TodoItem>>((diff) => TodoCheck(diff, description)), ResourcePipeline.Patch), Times.Once());
+            todoResourceMock.Verify(rd => rd.BeforeUpdate(It.Is<IResourceDiff<TodoItem>>((diff) => TodoCheck(diff, description)), ResourcePipeline.Patch), Times.Once());
             ownerResourceMock.Verify(rd => rd.BeforeImplicitUpdateRelationship(
                 It.Is<IAffectedRelationships<Person>>(rh => PersonCheck(lastName + lastName, rh)),
                 ResourcePipeline.Patch),
@@ -140,7 +140,7 @@ public void BeforeUpdate_Without_Child_Hook_Implemented()
             hookExecutor.BeforeUpdate(todoList, ResourcePipeline.Patch);
 
             // assert
-            todoResourceMock.Verify(rd => rd.BeforeUpdate(It.Is<IEntityDiff<TodoItem>>((diff) => TodoCheck(diff, description)), ResourcePipeline.Patch), Times.Once());
+            todoResourceMock.Verify(rd => rd.BeforeUpdate(It.Is<IResourceDiff<TodoItem>>((diff) => TodoCheck(diff, description)), ResourcePipeline.Patch), Times.Once());
             todoResourceMock.Verify(rd => rd.BeforeImplicitUpdateRelationship(
                 It.Is<IAffectedRelationships<TodoItem>>(rh => TodoCheck(rh, description + description)),
                 ResourcePipeline.Patch),
@@ -161,7 +161,7 @@ public void BeforeUpdate_NoImplicit()
             hookExecutor.BeforeUpdate(todoList, ResourcePipeline.Patch);
 
             // assert
-            todoResourceMock.Verify(rd => rd.BeforeUpdate(It.Is<IEntityDiff<TodoItem>>((diff) => TodoCheck(diff, description)), ResourcePipeline.Patch), Times.Once());
+            todoResourceMock.Verify(rd => rd.BeforeUpdate(It.Is<IResourceDiff<TodoItem>>((diff) => TodoCheck(diff, description)), ResourcePipeline.Patch), Times.Once());
             ownerResourceMock.Verify(rd => rd.BeforeUpdateRelationship(
                 It.Is<HashSet<string>>(ids => PersonIdCheck(ids, personId)),
                 It.IsAny<IAffectedRelationships<Person>>(),
@@ -204,11 +204,11 @@ public void BeforeUpdate_NoImplicit_Without_Child_Hook_Implemented()
             hookExecutor.BeforeUpdate(todoList, ResourcePipeline.Patch);
 
             // assert
-            todoResourceMock.Verify(rd => rd.BeforeUpdate(It.Is<IEntityDiff<TodoItem>>((diff) => TodoCheck(diff, description)), ResourcePipeline.Patch), Times.Once());
+            todoResourceMock.Verify(rd => rd.BeforeUpdate(It.Is<IResourceDiff<TodoItem>>((diff) => TodoCheck(diff, description)), ResourcePipeline.Patch), Times.Once());
             VerifyNoOtherCalls(todoResourceMock, ownerResourceMock);
         }
 
-        private bool TodoCheck(IEntityDiff<TodoItem> diff, string checksum)
+        private bool TodoCheck(IResourceDiff<TodoItem> diff, string checksum)
         {
             var dbCheck = diff.DatabaseValues.Single().Description == checksum;
             var reqCheck = diff.Single().Entity.Description == null;

test/UnitTests/ResourceHooks/ResourceHooksTestsSetup.cs

@@ -261,8 +261,8 @@ void MockHooks<TModel>(Mock<IResourceHookContainer<TModel>> resourceDefinition)
             .Setup(rd => rd.BeforeRead(It.IsAny<ResourcePipeline>(), It.IsAny<bool>(), It.IsAny<string>()))
             .Verifiable();
             resourceDefinition
-            .Setup(rd => rd.BeforeUpdate(It.IsAny<IEntityDiff<TModel>>(), It.IsAny<ResourcePipeline>()))
-            .Returns<EntityDiff<TModel>, ResourcePipeline>((entityDiff, context) => entityDiff.Entities)
+            .Setup(rd => rd.BeforeUpdate(It.IsAny<IResourceDiff<TModel>>(), It.IsAny<ResourcePipeline>()))
+            .Returns<ResourceDiff<TModel>, ResourcePipeline>((entityDiff, context) => entityDiff.Entities)
             .Verifiable();
             resourceDefinition
             .Setup(rd => rd.BeforeDelete(It.IsAny<IAffectedResources<TModel>>(), It.IsAny<ResourcePipeline>()))