chore: updated entity helpers

Author: maurei

src/JsonApiDotNetCore/Hooks/Execution/EntityDiffs.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
 using JsonApiDotNetCore.Internal;
 using JsonApiDotNetCore.Models;
@@ -12,40 +13,38 @@ namespace JsonApiDotNetCore.Hooks
     /// Contains the resources from the request and the corresponding database values.
     /// 
     /// Also contains information about updated relationships through 
-    /// implementation of IRelationshipsDictionary<typeparamref name="TEntity"/>>
+    /// implementation of IRelationshipsDictionary<typeparamref name="TResource"/>>
     /// </summary>
-    public interface IEntityDiff<TEntity> : IExposeRelationshipsDictionary<TEntity>, IEnumerable<EntityDiffPair<TEntity>> where TEntity : class, IIdentifiable
+    public interface IEntityDiffs<TResource> :  IEnumerable<EntityDiffPair<TResource>> where TResource : class, IIdentifiable
     {
         /// <summary>
         /// The database values of the resources affected by the request.
         /// </summary>
-        HashSet<TEntity> DatabaseValues { get; }
+        HashSet<TResource> DatabaseValues { get; }
 
         /// <summary>
         /// The resources that were affected by the request.
         /// </summary>
-        HashSet<TEntity> Entities { get; }
+        EntityHashSet<TResource> Entities { get; }
+
     }
 
     /// <inheritdoc />
-    public class EntityDiffs<TEntity> : IEntityDiff<TEntity> where TEntity : class, IIdentifiable
+    public class EntityDiffs<TResource> : IEntityDiffs<TResource> where TResource : class, IIdentifiable
     {
         /// <inheritdoc />
-        public HashSet<TEntity> DatabaseValues { get => _databaseValues ?? ThrowNoDbValuesError(); }
-        private readonly HashSet<TEntity> _databaseValues;
-        private readonly bool _databaseValuesLoaded;
-
-        /// <inheritdoc />
-        public HashSet<TEntity> Entities { get; private set; }
+        public HashSet<TResource> DatabaseValues { get => _databaseValues ?? ThrowNoDbValuesError(); }
         /// <inheritdoc />
-        public RelationshipsDictionary<TEntity> AffectedRelationships { get; private set; }
+        public EntityHashSet<TResource> Entities { get; private set; }
 
-        public EntityDiffs(HashSet<TEntity> requestEntities,
-                          HashSet<TEntity> databaseEntities,
-                          Dictionary<RelationshipAttribute, HashSet<TEntity>> relationships)
+        private readonly HashSet<TResource> _databaseValues;
+        private readonly bool _databaseValuesLoaded;
+
+        public EntityDiffs(HashSet<TResource> requestEntities,
+                          HashSet<TResource> databaseEntities,
+                          Dictionary<RelationshipAttribute, HashSet<TResource>> relationships)
         {
-            Entities = requestEntities;
-            AffectedRelationships = new RelationshipsDictionary<TEntity>(relationships);
+            Entities = new EntityHashSet<TResource>(requestEntities, relationships);
             _databaseValues = databaseEntities;
             _databaseValuesLoaded |= _databaseValues != null;
         }
@@ -56,38 +55,26 @@ public EntityDiffs(HashSet<TEntity> requestEntities,
         internal EntityDiffs(IEnumerable requestEntities,
                   IEnumerable databaseEntities,
                   Dictionary<RelationshipAttribute, IEnumerable> relationships)
-            : this((HashSet<TEntity>)requestEntities, (HashSet<TEntity>)databaseEntities, TypeHelper.ConvertRelationshipDictionary<TEntity>(relationships)) { }
-
+            : this((HashSet<TResource>)requestEntities, (HashSet<TResource>)databaseEntities, TypeHelper.ConvertRelationshipDictionary<TResource>(relationships)) { }
 
-        /// <inheritdoc />
-        public Dictionary<RelationshipAttribute, HashSet<TEntity>> GetByRelationship<TPrincipalResource>() where TPrincipalResource : class, IIdentifiable
-        {
-            return GetByRelationship(typeof(TPrincipalResource));
-        }
-
-        /// <inheritdoc />
-        public Dictionary<RelationshipAttribute, HashSet<TEntity>> GetByRelationship(Type principalType)
-        {
-            return AffectedRelationships.GetByRelationship(principalType);
-        }
 
         /// <inheritdoc />
-        public IEnumerator<EntityDiffPair<TEntity>> GetEnumerator()
+        public IEnumerator<EntityDiffPair<TResource>> GetEnumerator()
         {
             if (!_databaseValuesLoaded) ThrowNoDbValuesError();
 
             foreach (var entity in Entities)
             {
-                TEntity currentValueInDatabase = null;
+                TResource currentValueInDatabase = null;
                 currentValueInDatabase = _databaseValues.Single(e => entity.StringId == e.StringId);
-                yield return new EntityDiffPair<TEntity>(entity, currentValueInDatabase);
+                yield return new EntityDiffPair<TResource>(entity, currentValueInDatabase);
             }
         }
 
         /// <inheritdoc />
         IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
-        private HashSet<TEntity> ThrowNoDbValuesError()
+        private HashSet<TResource> ThrowNoDbValuesError()
         {
             throw new MemberAccessException("Cannot access database entities if the LoadDatabaseValues option is set to false");
         }
@@ -97,9 +84,9 @@ private HashSet<TEntity> ThrowNoDbValuesError()
     /// A wrapper that contains an entity that is affected by the request, 
     /// matched to its current database value
     /// </summary>
-    public class EntityDiffPair<TEntity> where TEntity : class, IIdentifiable
+    public class EntityDiffPair<TResource> where TResource : class, IIdentifiable
     {
-        public EntityDiffPair(TEntity entity, TEntity databaseValue)
+        public EntityDiffPair(TResource entity, TResource databaseValue)
         {
             Entity = entity;
             DatabaseValue = databaseValue;
@@ -108,10 +95,10 @@ public EntityDiffPair(TEntity entity, TEntity databaseValue)
         /// <summary>
         /// The resource from the request matching the resource from the database.
         /// </summary>
-        public TEntity Entity { get; private set; }
+        public TResource Entity { get; private set; }
         /// <summary>
         /// The resource from the database matching the resource from the request.
         /// </summary>
-        public TEntity DatabaseValue { get; private set; }
+        public TResource DatabaseValue { get; private set; }
     }
 }

src/JsonApiDotNetCore/Hooks/Execution/EntityHashSet.cs

@@ -3,6 +3,8 @@
 using System.Collections;
 using JsonApiDotNetCore.Internal;
 using System;
+using System.Collections.ObjectModel;
+using System.Collections.Immutable;
 
 namespace JsonApiDotNetCore.Hooks
 {
@@ -12,7 +14,7 @@ namespace JsonApiDotNetCore.Hooks
     /// Also contains information about updated relationships through 
     /// implementation of IAffectedRelationshipsDictionary<typeparamref name="TResource"/>>
     /// </summary>
-    public interface IEntityHashSet<TResource> : IExposeRelationshipsDictionary<TResource>, IEnumerable<TResource> where TResource : class, IIdentifiable { }
+    public interface IEntityHashSet<TResource> : IByAffectedRelationships<TResource>, IReadOnlyCollection<TResource> where TResource : class, IIdentifiable { }
 
     /// <summary>
     /// Implementation of IResourceHashSet{TResource}.
@@ -24,13 +26,16 @@ public interface IEntityHashSet<TResource> : IExposeRelationshipsDictionary<TRes
     /// </summary>
     public class EntityHashSet<TResource> : HashSet<TResource>, IEntityHashSet<TResource> where TResource : class, IIdentifiable
     {
+    
+
         /// <inheritdoc />
-        public RelationshipsDictionary<TResource> AffectedRelationships { get; private set; }
+        public Dictionary<RelationshipAttribute, HashSet<TResource>> AffectedRelationships { get => _relationships; }
+        private readonly RelationshipsDictionary<TResource> _relationships;
 
         public EntityHashSet(HashSet<TResource> entities,
                         Dictionary<RelationshipAttribute, HashSet<TResource>> relationships) : base(entities)
         {
-            AffectedRelationships = new RelationshipsDictionary<TResource>(relationships);
+            _relationships = new RelationshipsDictionary<TResource>(relationships);
         }
 
         /// <summary>
@@ -44,13 +49,13 @@ internal EntityHashSet(IEnumerable entities,
         /// <inheritdoc />
         public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship(Type principalType)
         {
-            return AffectedRelationships.GetByRelationship(principalType);
+            return _relationships.GetByRelationship(principalType);
         }
 
         /// <inheritdoc />
-        public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship<TPrincipalResource>()  where TPrincipalResource : class, IIdentifiable
+        public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship<TRelatedResource>()  where TRelatedResource : class, IIdentifiable
         {
-            return GetByRelationship<TPrincipalResource>();
+            return GetByRelationship(typeof(TRelatedResource));
         }
     }
 }

src/JsonApiDotNetCore/Hooks/Execution/RelationshipsDictionary.cs

@@ -1,39 +1,45 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Linq;
 using JsonApiDotNetCore.Internal;
 using JsonApiDotNetCore.Models;
 
 namespace JsonApiDotNetCore.Hooks
 {
+
+
+
+    /// <summary>
+    /// A dummy interface used internally by the hook executor.
+    /// </summary>
     public interface IRelationshipsDictionary { }
 
+
     /// <summary>
     /// An interface that is implemented to expose a relationship dictionary on another class.
     /// </summary>
-    public interface IExposeRelationshipsDictionary<TDependentResource> : 
-        IRelationshipsDictionaryGetters<TDependentResource> where TDependentResource : class, IIdentifiable
+    public interface IByAffectedRelationships<TDependentResource> : 
+        IRelationshipGetters<TDependentResource> where TDependentResource : class, IIdentifiable
     {
         /// <summary>
         /// Gets a dictionary of affected resources grouped by affected relationships.
         /// </summary>
-        RelationshipsDictionary<TDependentResource> AffectedRelationships { get; }
+        Dictionary<RelationshipAttribute, HashSet<TDependentResource>> AffectedRelationships { get; }
     }
 
     /// <summary>
     /// A helper class that provides insights in which relationships have been updated for which entities.
     /// </summary>
     public interface IRelationshipsDictionary<TDependentResource> : 
-        IRelationshipsDictionaryGetters<TDependentResource>, 
+        IRelationshipGetters<TDependentResource>, 
         IReadOnlyDictionary<RelationshipAttribute, HashSet<TDependentResource>>, 
         IRelationshipsDictionary where TDependentResource : class, IIdentifiable { }
 
     /// <summary>
     /// A helper class that provides insights in which relationships have been updated for which entities.
     /// </summary>
-    public interface IRelationshipsDictionaryGetters<TDependentResource> where TDependentResource : class, IIdentifiable
+    public interface IRelationshipGetters<TDependentResource> where TDependentResource : class, IIdentifiable
     {
         /// <summary>
         /// Gets a dictionary of all entities that have an affected relationship to type <typeparamref name="TPrincipalResource"/>
@@ -51,38 +57,32 @@ public interface IRelationshipsDictionaryGetters<TDependentResource> where TDepe
     /// It is practically a ReadOnlyDictionary{RelationshipAttribute, HashSet{TDependentResource}} dictionary
     /// with the two helper methods defined on IAffectedRelationships{TDependentResource}.
     /// </summary>
-    public class RelationshipsDictionary<TDependentResource> : 
-        ReadOnlyDictionary<RelationshipAttribute, HashSet<TDependentResource>>, 
-        IRelationshipsDictionary<TDependentResource> where TDependentResource : class, IIdentifiable
+    public class RelationshipsDictionary<TResource> :
+        Dictionary<RelationshipAttribute, HashSet<TResource>>, 
+        IRelationshipsDictionary<TResource> where TResource : class, IIdentifiable
     {
         /// <summary>
-        /// a dictionary with affected relationships as keys and values being the corresponding resources
-        /// that were affected
+        /// Initializes a new instance of the <see cref="T:JsonApiDotNetCore.Hooks.RelationshipsDictionary`1"/> class.
         /// </summary>
-        private readonly Dictionary<RelationshipAttribute, HashSet<TDependentResource>> _groups;
-
-        /// <inheritdoc />
-        public RelationshipsDictionary(Dictionary<RelationshipAttribute, HashSet<TDependentResource>> relationships) : base(relationships)
-        {
-            _groups = relationships;
-        }
+        /// <param name="relationships">Relationships.</param>
+        public RelationshipsDictionary(Dictionary<RelationshipAttribute, HashSet<TResource>> relationships) : base(relationships) { }
 
         /// <summary>
         /// Used internally by the ResourceHookExecutor to make live a bit easier with generics
         /// </summary>
         internal RelationshipsDictionary(Dictionary<RelationshipAttribute, IEnumerable> relationships) 
-            : this(TypeHelper.ConvertRelationshipDictionary<TDependentResource>(relationships)) { }
+            : this(TypeHelper.ConvertRelationshipDictionary<TResource>(relationships)) { }
 
         /// <inheritdoc />
-        public Dictionary<RelationshipAttribute, HashSet<TDependentResource>> GetByRelationship<TPrincipalResource>() where TPrincipalResource : class, IIdentifiable
+        public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship<TRelatedResource>() where TRelatedResource : class, IIdentifiable
         {
-            return GetByRelationship(typeof(TPrincipalResource));
+            return GetByRelationship(typeof(TRelatedResource));
         }
 
         /// <inheritdoc />
-        public Dictionary<RelationshipAttribute, HashSet<TDependentResource>> GetByRelationship(Type principalType)
+        public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship(Type relatedType)
         {
-            return this.Where(p => p.Key.PrincipalType == principalType).ToDictionary(p => p.Key, p => p.Value);
+            return this.Where(p => p.Key.PrincipalType == relatedType).ToDictionary(p => p.Key, p => p.Value);
         }
     }
 }

src/JsonApiDotNetCore/Hooks/IResourceHookContainer.cs

@@ -77,7 +77,7 @@ public interface IBeforeHooks<TResource> where TResource : class, IIdentifiable
         /// <returns>The transformed entity set</returns>
         /// <param name="entityDiff">The entity diff.</param>
         /// <param name="pipeline">An enum indicating from where the hook was triggered.</param>
-        IEnumerable<TResource> BeforeUpdate(IEntityDiff<TResource> entityDiff, ResourcePipeline pipeline);
+        IEnumerable<TResource> BeforeUpdate(IEntityDiffs<TResource> entityDiff, ResourcePipeline pipeline);
 
         /// <summary>
         /// Implement this hook to run custom logic in the <see cref=" EntityResourceService{T}"/> 

src/JsonApiDotNetCore/Internal/TypeHelper.cs

@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using JsonApiDotNetCore.Hooks;
 using JsonApiDotNetCore.Models;
 
 namespace JsonApiDotNetCore.Internal
@@ -113,9 +114,9 @@ public static object CreateInstanceOfOpenType(Type openType, Type[] parameters,
         /// <summary>
         /// Helper method that "unboxes" the TValue from the relationship dictionary into  
         /// </summary>
-        public static Dictionary<RelationshipAttribute, HashSet<TDependentResource>> ConvertRelationshipDictionary<TDependentResource>(Dictionary<RelationshipAttribute, IEnumerable> relationships)
+        public static Dictionary<RelationshipAttribute, HashSet<TValueOut>> ConvertRelationshipDictionary<TValueOut>(Dictionary<RelationshipAttribute, IEnumerable> relationships) 
         {
-            return relationships.ToDictionary(pair => pair.Key, pair => (HashSet<TDependentResource>)pair.Value);
+            return relationships.ToDictionary(pair => pair.Key, pair => (HashSet<TValueOut>)pair.Value);
         }
 
         /// <summary>

src/JsonApiDotNetCore/Models/ResourceDefinition.cs

@@ -179,7 +179,7 @@ public virtual void AfterUpdateRelationship(IRelationshipsDictionary<T> entities
         /// <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(IEntityDiffs<T> entityDiff, ResourcePipeline pipeline) { return entityDiff.Entities; }
         /// <inheritdoc/>
         public virtual IEnumerable<T> BeforeDelete(IEntityHashSet<T> entities, ResourcePipeline pipeline) { return entities; }
         /// <inheritdoc/>