feat: relationshipdictionary now actually inherits from dictionary

Author: maurei

src/Examples/JsonApiDotNetCoreExample/Resources/PassportResource.cs

@@ -22,7 +22,7 @@ public override void BeforeRead(ResourcePipeline pipeline, bool isIncluded = fal
             }
         }
 
-        public override void BeforeImplicitUpdateRelationship(IAffectedRelationships<Passport> resourcesByRelationship, ResourcePipeline pipeline)
+        public override void BeforeImplicitUpdateRelationship(IRelationshipsDictionary<Passport> resourcesByRelationship, ResourcePipeline pipeline)
         {
             resourcesByRelationship.GetByRelationship<Person>().ToList().ForEach(kvp => DoesNotTouchLockedPassports(kvp.Value));
         }

src/Examples/JsonApiDotNetCoreExample/Resources/PersonResource.cs

@@ -10,7 +10,7 @@ public class PersonResource : LockableResourceBase<Person>
     {
         public PersonResource(IResourceGraph graph) : base(graph) { }
 
-        public override IEnumerable<string> BeforeUpdateRelationship(HashSet<string> ids, IAffectedRelationships<Person> resourcesByRelationship, ResourcePipeline pipeline)
+        public override IEnumerable<string> BeforeUpdateRelationship(HashSet<string> ids, IRelationshipsDictionary<Person> resourcesByRelationship, ResourcePipeline pipeline)
         {
             BeforeImplicitUpdateRelationship(resourcesByRelationship, pipeline);
             return ids;
@@ -22,7 +22,7 @@ public override IEnumerable<string> BeforeUpdateRelationship(HashSet<string> ids
         //    return entityDiff.Entities;
         //}
 
-        public override void BeforeImplicitUpdateRelationship(IAffectedRelationships<Person> resourcesByRelationship, ResourcePipeline pipeline)
+        public override void BeforeImplicitUpdateRelationship(IRelationshipsDictionary<Person> resourcesByRelationship, ResourcePipeline pipeline)
         {
             resourcesByRelationship.GetByRelationship<Passport>().ToList().ForEach(kvp => DisallowLocked(kvp.Value));
         }

src/Examples/JsonApiDotNetCoreExample/Resources/TodoResource.cs

@@ -19,7 +19,7 @@ public override void BeforeRead(ResourcePipeline pipeline, bool isIncluded = fal
             }
         }
 
-        public override void BeforeImplicitUpdateRelationship(IAffectedRelationships<TodoItem> resourcesByRelationship, ResourcePipeline pipeline)
+        public override void BeforeImplicitUpdateRelationship(IRelationshipsDictionary<TodoItem> resourcesByRelationship, ResourcePipeline pipeline)
         {
             List<TodoItem> todos = resourcesByRelationship.GetByRelationship<Person>().SelectMany(kvp => kvp.Value).ToList();
             DisallowLocked(todos);

src/JsonApiDotNetCore/Hooks/Execution/AffectedResources.cs

@@ -2,49 +2,56 @@
 using JsonApiDotNetCore.Models;
 using System.Linq;
 using System.Collections;
+using JsonApiDotNetCore.Internal;
+using System;
 
 namespace JsonApiDotNetCore.Hooks
 {
     /// <summary>
-    /// Basically just a list of <typeparamref name="TResource"/>, but also contains information
-    /// about updated relationships through inheritance of IAffectedRelationships<typeparamref name="TResource"/>>
+    /// Basically a enumerable of <typeparamref name="TResource"/> of resources that were affected by the request. 
+    /// 
+    /// Also contains information about updated relationships through 
+    /// implementation of IAffectedRelationshipsDictionary<typeparamref name="TResource"/>>
     /// </summary>
-    public interface IAffectedResources<TResource> : IAffectedRelationships<TResource>, IEnumerable<TResource> where TResource : class, IIdentifiable 
+    public interface IAffectedResources<TResource> : IRelationshipsDictionary<TResource>, IEnumerable<TResource> where TResource : class, IIdentifiable
     {
-        /// <summary>
-        /// The entities that are affected by the request.
-        /// </summary>
-        HashSet<TResource> Resources { get; }
+
     }
 
-    public class AffectedResources<TResource> : AffectedRelationships<TResource>, IAffectedResources<TResource> where TResource : class, IIdentifiable
+    /// <summary>
+    /// Implementation of IAffectedResources{TResource}.
+    /// 
+    /// It is basically just a HashSet{TResource} that also stores the 
+    /// RelationshipDictionary{TResource} and the same helper methods to access this 
+    /// dictionary as defined on IAffectedRelationshipsDictionary{TResource}.
+    /// </summary>
+    public class AffectedResources<TResource> : HashSet<TResource>, IAffectedResources<TResource> where TResource : class, IIdentifiable
     {
         /// <inheritdoc />
-        public HashSet<TResource> Resources { get; }
+        public RelationshipsDictionary<TResource> AffectedRelationships { get; private set; }
 
         public AffectedResources(HashSet<TResource> entities,
-                        Dictionary<RelationshipAttribute, HashSet<TResource>> relationships) : base(relationships)
+                        Dictionary<RelationshipAttribute, HashSet<TResource>> relationships) : base(entities)
         {
-            Resources = new HashSet<TResource>(entities.Cast<TResource>());
+            AffectedRelationships = new RelationshipsDictionary<TResource>(relationships);
         }
 
         /// <summary>
         /// Used internally by the ResourceHookExecutor to make live a bit easier with generics
         /// </summary>
         internal AffectedResources(IEnumerable entities,
                         Dictionary<RelationshipAttribute, IEnumerable> relationships)
-            : this((HashSet<TResource>)entities, ConvertRelationshipDictionary(relationships)) { }
+            : this((HashSet<TResource>)entities, TypeHelper.ConvertRelationshipDictionary<TResource>(relationships)) { }
 
-        /// <inheritdoc />
-        public IEnumerator<TResource> GetEnumerator()
+
+        public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship(Type principalType)
         {
-            return Resources.GetEnumerator();
+            return AffectedRelationships.GetByRelationship(principalType);
         }
 
-        /// <inheritdoc />
-        IEnumerator IEnumerable.GetEnumerator()
+        public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship<TPrincipalResource>()  where TPrincipalResource : class, IIdentifiable
         {
-            return GetEnumerator();
+            return GetByRelationship<TPrincipalResource>();
         }
     }
 }

src/JsonApiDotNetCore/Hooks/Execution/AffectedResourceDiff.cs renamed to src/JsonApiDotNetCore/Hooks/Execution/AffectedResourcesDiffs.cs

@@ -2,57 +2,77 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using JsonApiDotNetCore.Internal;
 using JsonApiDotNetCore.Models;
 
 namespace JsonApiDotNetCore.Hooks
 {
     /// <summary>
-    /// A helper class that provides insight in what is to be updated. The 
-    /// <see cref="IAffectedResourcesDiff{TEntity}.RequestEntities"/> property reflects what was parsed from the incoming request,
-    /// where the <see cref="IAffectedResourcesDiff{TEntity}.DatabaseValues"/> reflects what is the current state in the database.
+    /// A wrapper class that contains information about the resources that are updated by the request.
+    /// Contains the resources from the request and the corresponding database values.
     /// 
-    /// Any relationships that are updated can be retrieved via the methods implemented on 
-    /// <see cref="IAffectedRelationships{TDependent}"/>.
+    /// Also contains information about updated relationships through 
+    /// implementation of IAffectedRelationshipsDictionary<typeparamref name="TResource"/>>
     /// </summary>
-    public interface IAffectedResourcesDiff<TResource> :  IAffectedResources<TResource> where TResource : class, IIdentifiable
+    public interface IAffectedResourcesDiffs<TResource> : IRelationshipsDictionary<TResource>, IEnumerable<ResourceDiffPair<TResource>> where TResource : class, IIdentifiable
     {
         /// <summary>
-        /// the current database values of the affected resources collection.
+        /// The database values of the resources affected by the request.
         /// </summary>
         HashSet<TResource> DatabaseValues { get; }
 
         /// <summary>
-        /// Matches the resources from the request to the database values that have been loaded
-        /// and exposes them in ResourceDiffPair wrapper
+        /// The resources that were affected by the request.
         /// </summary>
-        IEnumerable<ResourceDiffPair<TResource>> GetDiffs();
+        HashSet<TResource> Resources { get; }
     }
 
-    public  class AffectedResourceDiff<TResource> : AffectedResources<TResource>, IAffectedResourcesDiff<TResource> where TResource : class, IIdentifiable
+    /// <inheritdoc />
+    public class AffectedResourcesDiffs<TResource> : IAffectedResourcesDiffs<TResource> where TResource : class, IIdentifiable
     {
         private readonly HashSet<TResource> _databaseValues;
         private readonly bool _databaseValuesLoaded;
+
         /// <inheritdoc />
         public HashSet<TResource> DatabaseValues { get => _databaseValues ?? ThrowNoDbValuesError(); }
+        /// <inheritdoc />
+        public HashSet<TResource> Resources { get; private set; }
+        /// <inheritdoc />
+        public RelationshipsDictionary<TResource> AffectedRelationships { get; private set; }
 
-        public AffectedResourceDiff(HashSet<TResource> requestEntities,
+        public AffectedResourcesDiffs(HashSet<TResource> requestEntities,
                           HashSet<TResource> databaseEntities,
-                          Dictionary<RelationshipAttribute, HashSet<TResource>> relationships) : base(requestEntities, relationships)
+                          Dictionary<RelationshipAttribute, HashSet<TResource>> relationships) 
         {
+            Resources = requestEntities;
+            AffectedRelationships = new RelationshipsDictionary<TResource>(relationships);
             _databaseValues = databaseEntities;
             _databaseValuesLoaded |= _databaseValues != null;
         }
 
         /// <summary>
         /// Used internally by the ResourceHookExecutor to make live a bit easier with generics
         /// </summary>
-        internal AffectedResourceDiff(IEnumerable requestEntities,
+        internal AffectedResourcesDiffs(IEnumerable requestEntities,
                   IEnumerable databaseEntities,
                   Dictionary<RelationshipAttribute, IEnumerable> relationships) 
-            : this((HashSet<TResource>)requestEntities, (HashSet<TResource>)databaseEntities, ConvertRelationshipDictionary(relationships)) { }
+            : this((HashSet<TResource>)requestEntities, (HashSet<TResource>)databaseEntities, TypeHelper.ConvertRelationshipDictionary<TResource>(relationships)) { }
+
+
+        /// <inheritdoc />
+        public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship<TPrincipalResource>() where TPrincipalResource : class, IIdentifiable
+        {
+            return GetByRelationship(typeof(TPrincipalResource));
+        }
 
         /// <inheritdoc />
-        public IEnumerable<ResourceDiffPair<TResource>> GetDiffs()
+        public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship(Type principalType)
+        {
+            return AffectedRelationships.GetByRelationship(principalType);
+        }
+
+        /// <inheritdoc />
+        public IEnumerator<ResourceDiffPair<TResource>> GetEnumerator()
         {
             if (!_databaseValuesLoaded) ThrowNoDbValuesError();
 
@@ -64,14 +84,18 @@ public IEnumerable<ResourceDiffPair<TResource>> GetDiffs()
             }
         }
 
+        /// <inheritdoc />
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
         private HashSet<TResource> ThrowNoDbValuesError()
         {
             throw new MemberAccessException("Cannot access database entities if the LoadDatabaseValues option is set to false");
         }
     }
 
     /// <summary>
-    /// A wrapper that contains a resource from the request matches to its current database value
+    /// A wrapper that contains an resource that is affected by the request, 
+    /// matched to its current database value
     /// </summary>
     public class ResourceDiffPair<TResource> where TResource : class, IIdentifiable
     {

src/JsonApiDotNetCore/Hooks/Execution/AffectedRelationships.cs renamed to src/JsonApiDotNetCore/Hooks/Execution/RelationshipsDictionary.cs

@@ -3,21 +3,29 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
+using JsonApiDotNetCore.Internal;
 using JsonApiDotNetCore.Models;
 
 namespace JsonApiDotNetCore.Hooks
 {
     public interface IAffectedRelationships { }
 
     /// <summary>
-    /// A helper class that provides insights in which relationships have been updated for which entities.
+    /// An interface that is implemented to expose a relationship dictionary on another class.
     /// </summary>
-    public interface IAffectedRelationships<TDependentResource> : IAffectedRelationships where TDependentResource : class, IIdentifiable
+    public interface IRelationshipsDictionary<TDependentResource> : IRelationshipsDictionaryGetters<TDependentResource> where TDependentResource : class, IIdentifiable
     {
         /// <summary>
-        /// Gets a dictionary of all entities grouped by affected relationship.
+        /// Gets a dictionary of affected resources grouped by affected relationships.
         /// </summary>
-        Dictionary<RelationshipAttribute, HashSet<TDependentResource>> AllByRelationships();
+        RelationshipsDictionary<TDependentResource> AffectedRelationships { get; }
+    }
+
+    /// <summary>
+    /// A helper class that provides insights in which relationships have been updated for which entities.
+    /// </summary>
+    public interface IRelationshipsDictionaryGetters<TDependentResource> : IAffectedRelationships where TDependentResource : class, IIdentifiable
+    {
         /// <summary>
         /// Gets a dictionary of all entities that have an affected relationship to type <typeparamref name="TPrincipalResource"/>
         /// </summary>
@@ -28,38 +36,32 @@ public interface IAffectedRelationships<TDependentResource> : IAffectedRelations
         Dictionary<RelationshipAttribute, HashSet<TDependentResource>> GetByRelationship(Type principalType);
     }
 
-    /// <inheritdoc />
-    public class AffectedRelationships<TDependentResource> :  IAffectedRelationships<TDependentResource> where TDependentResource : class, IIdentifiable
+    /// <summary>
+    /// Implementation of IAffectedRelationships{TDependentResource}
+    /// 
+    /// 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>>, IRelationshipsDictionaryGetters<TDependentResource> where TDependentResource : class, IIdentifiable
     {
-        /// <summary>
-        /// Helper method that "unboxes" the TValue from the relationship dictionary 
-        /// </summary>
-        internal static Dictionary<RelationshipAttribute, HashSet<TDependentResource>> ConvertRelationshipDictionary(Dictionary<RelationshipAttribute, IEnumerable> relationships)
-        {
-            return relationships.ToDictionary(pair => pair.Key, pair => (HashSet<TDependentResource>)pair.Value);
-        }
-
         /// <summary>
         /// a dictionary with affected relationships as keys and values being the corresponding resources
         /// that were affected
         /// </summary>
         private readonly Dictionary<RelationshipAttribute, HashSet<TDependentResource>> _groups;
 
         /// <inheritdoc />
-        public AffectedRelationships(Dictionary<RelationshipAttribute, HashSet<TDependentResource>> relationships)
+        public RelationshipsDictionary(Dictionary<RelationshipAttribute, HashSet<TDependentResource>> relationships) : base(relationships)
         {
             _groups = relationships;
         }
 
         /// <summary>
         /// Used internally by the ResourceHookExecutor to make live a bit easier with generics
         /// </summary>
-        internal AffectedRelationships(Dictionary<RelationshipAttribute, IEnumerable> relationships) : this(ConvertRelationshipDictionary(relationships)) { }
+        internal RelationshipsDictionary(Dictionary<RelationshipAttribute, IEnumerable> relationships) 
+            : this(TypeHelper.ConvertRelationshipDictionary<TDependentResource>(relationships)) { }
 
-        public Dictionary<RelationshipAttribute, HashSet<TDependentResource>> AllByRelationships()
-        {
-            return _groups;
-        }
 
         /// <inheritdoc />
         public Dictionary<RelationshipAttribute, HashSet<TDependentResource>> GetByRelationship<TPrincipalResource>() where TPrincipalResource : class, IIdentifiable
@@ -70,7 +72,7 @@ public Dictionary<RelationshipAttribute, HashSet<TDependentResource>> GetByRelat
         /// <inheritdoc />
         public Dictionary<RelationshipAttribute, HashSet<TDependentResource>> GetByRelationship(Type principalType)
         {
-            return _groups?.Where(p => p.Key.PrincipalType == principalType).ToDictionary(p => p.Key, p => p.Value);
+            return this.Where(p => p.Key.PrincipalType == principalType).ToDictionary(p => p.Key, p => p.Value);
         }
     }
 }