feat: made internal constructors public, removed usage RelationshipProxy when RelationshipAttribute suffices

maurei · maurei · commit 46f50e15e403 · 2019-06-20T08:09:01.000+02:00
diff --git a/src/JsonApiDotNetCore/Hooks/Execution/AffectedRelationships.cs b/src/JsonApiDotNetCore/Hooks/Execution/AffectedRelationships.cs
@@ -30,13 +30,13 @@ public interface IAffectedRelationships<TDependent> : IAffectedRelationships whe
 
     public class AffectedRelationships<TDependent> : IAffectedRelationships<TDependent> where TDependent : class, IIdentifiable
     {
-        private readonly Dictionary<RelationshipProxy, HashSet<TDependent>> _groups;
+        private readonly Dictionary<RelationshipAttribute, HashSet<TDependent>> _groups;
 
         public Dictionary<RelationshipAttribute, HashSet<TDependent>> AllByRelationships()
         {
-            return _groups?.ToDictionary(p => p.Key.Attribute, p => p.Value);
+            return _groups;
         }
-        internal AffectedRelationships(Dictionary<RelationshipProxy, IEnumerable> relationships)
+        public AffectedRelationships(Dictionary<RelationshipAttribute, IEnumerable> relationships)
         {
             _groups = relationships.ToDictionary(kvp => kvp.Key, kvp => new HashSet<TDependent>((IEnumerable<TDependent>)kvp.Value));
         }
@@ -48,7 +48,7 @@ public Dictionary<RelationshipAttribute, HashSet<TDependent>> GetByRelationship<
 
         public Dictionary<RelationshipAttribute, HashSet<TDependent>> GetByRelationship(Type principalType)
         {
-            return _groups?.Where(p => p.Key.PrincipalType == principalType).ToDictionary(p => p.Key.Attribute, p => p.Value);
+            return _groups?.Where(p => p.Key.PrincipalType == principalType).ToDictionary(p => p.Key, p => p.Value);
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Hooks/Execution/AffectedResourceDiff.cs b/src/JsonApiDotNetCore/Hooks/Execution/AffectedResourceDiff.cs
@@ -31,9 +31,9 @@ public  class ResourceDiff<TEntity> : AffectedResources<TEntity>, IAffectedResou
         /// </summary>
         public HashSet<TEntity> DatabaseValues { get => _databaseValues ?? ThrowNoDbValuesError(); }
 
-        internal ResourceDiff(IEnumerable requestEntities,
+        public ResourceDiff(IEnumerable requestEntities,
                           IEnumerable databaseEntities,
-                          Dictionary<RelationshipProxy, IEnumerable> relationships) : base(requestEntities, relationships)
+                          Dictionary<RelationshipAttribute, IEnumerable> relationships) : base(requestEntities, relationships)
         {
             _databaseValues = (HashSet<TEntity>)databaseEntities;
             _databaseValuesLoaded |= _databaseValues != null;
diff --git a/src/JsonApiDotNetCore/Hooks/Execution/AffectedResources.cs b/src/JsonApiDotNetCore/Hooks/Execution/AffectedResources.cs
@@ -19,7 +19,7 @@ public class AffectedResources<TEntity> : AffectedRelationships<TEntity>, IAffec
         public HashSet<TEntity> Entities { get; }
 
         internal AffectedResources(IEnumerable entities,
-                                 Dictionary<RelationshipProxy, IEnumerable> relationships) : base(relationships)
+                                 Dictionary<RelationshipAttribute, IEnumerable> relationships) : base(relationships)
         {
             Entities = new HashSet<TEntity>(entities.Cast<TEntity>());
         }
diff --git a/src/JsonApiDotNetCore/Hooks/Execution/HookExecutorHelper.cs b/src/JsonApiDotNetCore/Hooks/Execution/HookExecutorHelper.cs
@@ -24,7 +24,6 @@ internal class HookExecutorHelper : IHookExecutorHelper
         protected readonly Dictionary<DependentType, IHooksDiscovery> _hookDiscoveries;
         protected readonly List<ResourceHook> _targetedHooksForRelatedEntities;
         protected readonly IJsonApiContext _context;
-        protected Dictionary<PrincipalType, List<RelationshipProxy>> _meta;
 
         public HookExecutorHelper(
             IGenericProcessorFactory genericProcessorFactory,
@@ -35,7 +34,6 @@ IJsonApiContext context
             _genericProcessorFactory = genericProcessorFactory;
             _graph = graph;
             _context = context;
-            _meta = new Dictionary<DependentType, List<RelationshipProxy>>();
             _hookContainers = new Dictionary<DependentType, IResourceHookContainer>();
             _hookDiscoveries = new Dictionary<DependentType, IHooksDiscovery>();
             _targetedHooksForRelatedEntities = new List<ResourceHook>();
@@ -81,9 +79,9 @@ public IResourceHookContainer<TEntity> GetResourceHookContainer<TEntity>(Resourc
             return (IResourceHookContainer<TEntity>)GetResourceHookContainer(typeof(TEntity), hook);
         }
 
-        public IEnumerable LoadDbValues(PrincipalType entityTypeForRepository, IEnumerable entities, ResourceHook hook, params RelationshipProxy[] relationships)
+        public IEnumerable LoadDbValues(PrincipalType entityTypeForRepository, IEnumerable entities, ResourceHook hook, params RelationshipAttribute[] relationships)
         {
-            var paths = relationships.Select(p => p.Attribute.RelationshipPath).ToArray();
+            var paths = relationships.Select(p => p.RelationshipPath).ToArray();
             var idType = GetIdentifierType(entityTypeForRepository);
             var parameterizedGetWhere = GetType()
                     .GetMethod(nameof(GetWhereAndInclude), BindingFlags.NonPublic | BindingFlags.Instance)
@@ -95,7 +93,7 @@ public IEnumerable LoadDbValues(PrincipalType entityTypeForRepository, IEnumerab
             return (IEnumerable)Activator.CreateInstance(typeof(HashSet<>).MakeGenericType(entityTypeForRepository), values.Cast(entityTypeForRepository));
         }
 
-        public HashSet<TEntity> LoadDbValues<TEntity>(IEnumerable<TEntity> entities, ResourceHook hook, params RelationshipProxy[] relationships) where TEntity : class, IIdentifiable
+        public HashSet<TEntity> LoadDbValues<TEntity>(IEnumerable<TEntity> entities, ResourceHook hook, params RelationshipAttribute[] relationships) where TEntity : class, IIdentifiable
         {
             var entityType = typeof(TEntity);
             var dbValues = LoadDbValues(entityType, entities, hook, relationships)?.Cast<TEntity>();
@@ -168,11 +166,11 @@ IEntityReadRepository<TEntity, TId> GetRepository<TEntity, TId>() where TEntity
         }
 
 
-        public Dictionary<RelationshipProxy, IEnumerable> LoadImplicitlyAffected(
-            Dictionary<RelationshipProxy, IEnumerable> principalEntitiesByRelation,
+        public Dictionary<RelationshipAttribute, IEnumerable> LoadImplicitlyAffected(
+            Dictionary<RelationshipAttribute, IEnumerable> principalEntitiesByRelation,
             IEnumerable existingDependentEntities = null)
         {
-            var implicitlyAffected = new Dictionary<RelationshipProxy, IEnumerable>();
+            var implicitlyAffected = new Dictionary<RelationshipAttribute, IEnumerable>();
             foreach (var kvp in principalEntitiesByRelation)
             {
                 if (IsHasManyThrough(kvp, out var principals, out var relationship)) continue;
@@ -212,13 +210,13 @@ public Dictionary<RelationshipProxy, IEnumerable> LoadImplicitlyAffected(
 
         }
 
-        bool IsHasManyThrough(KeyValuePair<RelationshipProxy, IEnumerable> kvp,
+        bool IsHasManyThrough(KeyValuePair<RelationshipAttribute, IEnumerable> kvp,
             out IEnumerable entities,
-            out RelationshipProxy proxy)
+            out RelationshipAttribute attr)
         {
-            proxy = kvp.Key;
+            attr = kvp.Key;
             entities = (kvp.Value);
-            return (kvp.Key.Attribute is HasManyThroughAttribute);
+            return (kvp.Key is HasManyThroughAttribute);
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Hooks/Execution/IHookExecutorHelper.cs b/src/JsonApiDotNetCore/Hooks/Execution/IHookExecutorHelper.cs
@@ -37,12 +37,12 @@ internal interface IHookExecutorHelper
         /// Load the implicitly affected entities from the database for a given set of target target entities and involved relationships
         /// </summary>
         /// <returns>The implicitly affected entities by relationship</returns>
-        Dictionary<RelationshipProxy, IEnumerable> LoadImplicitlyAffected(Dictionary<RelationshipProxy, IEnumerable> principalEntities, IEnumerable existingDependentEntities = null);
+        Dictionary<RelationshipAttribute, IEnumerable> LoadImplicitlyAffected(Dictionary<RelationshipAttribute, IEnumerable> principalEntities, IEnumerable existingDependentEntities = null);
 
         /// <summary>
         /// For a set of entities, loads current values from the database
         /// </summary>
-        IEnumerable LoadDbValues(Type repositoryEntityType, IEnumerable entities, ResourceHook hook, params RelationshipProxy[] relationships);
+        IEnumerable LoadDbValues(Type repositoryEntityType, IEnumerable entities, ResourceHook hook, params RelationshipAttribute[] relationships);
         bool ShouldLoadDbValues(Type containerEntityType, ResourceHook hook);
     }
 }
diff --git a/src/JsonApiDotNetCore/Hooks/ResourceHookExecutor.cs b/src/JsonApiDotNetCore/Hooks/ResourceHookExecutor.cs
@@ -47,7 +47,8 @@ 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 relationships = node.RelationshipsToNextLayer.Select(p => p.Attribute).ToArray();
+                var dbValues = LoadDbValues(typeof(TEntity), (IEnumerable<TEntity>)node.UniqueEntities, ResourceHook.BeforeUpdate, relationships);
                 var diff = new ResourceDiff<TEntity>(node.UniqueEntities, dbValues, node.PrincipalsToNextLayer());
                 IEnumerable<TEntity> updated = container.BeforeUpdate(diff, pipeline);
                 node.UpdateUnique(updated);
@@ -79,7 +80,8 @@ public virtual IEnumerable<TEntity> BeforeDelete<TEntity>(IEnumerable<TEntity> e
         {
             if (GetHook(ResourceHook.BeforeDelete, entities, out var container, out var node))
             {
-                var targetEntities = LoadDbValues(typeof(TEntity), (IEnumerable<TEntity>)node.UniqueEntities, ResourceHook.BeforeDelete, node.RelationshipsToNextLayer) ?? node.UniqueEntities;
+                var relationships = node.RelationshipsToNextLayer.Select(p => p.Attribute).ToArray();
+                var targetEntities = LoadDbValues(typeof(TEntity), (IEnumerable<TEntity>)node.UniqueEntities, ResourceHook.BeforeDelete, relationships) ?? node.UniqueEntities;
                 var affected = new AffectedResources<TEntity>(targetEntities, node.PrincipalsToNextLayer());
 
                 IEnumerable<TEntity> updated = container.BeforeDelete(affected, pipeline);
@@ -251,7 +253,8 @@ void FireNestedBeforeUpdateHooks(ResourcePipeline pipeline, EntityChildLayer lay
                 {
                     if (uniqueEntities.Cast<IIdentifiable>().Any())
                     {
-                        var dbValues = LoadDbValues(entityType, uniqueEntities, ResourceHook.BeforeUpdateRelationship, node.RelationshipsToNextLayer);
+                        var relationships = node.RelationshipsToNextLayer.Select(p => p.Attribute).ToArray();
+                        var dbValues = LoadDbValues(entityType, uniqueEntities, ResourceHook.BeforeUpdateRelationship, relationships);
                         var resourcesByRelationship = CreateRelationshipHelper(entityType, node.RelationshipsFromPreviousLayer.GetDependentEntities(), dbValues);
                         var allowedIds = CallHook(nestedHookcontainer, ResourceHook.BeforeUpdateRelationship, new object[] { GetIds(uniqueEntities), resourcesByRelationship, pipeline }).Cast<string>();
                         var updated = GetAllowedEntities(uniqueEntities, allowedIds);
@@ -281,7 +284,7 @@ void FireNestedBeforeUpdateHooks(ResourcePipeline pipeline, EntityChildLayer lay
         /// Given a source of entities, gets the implicitly affected entities 
         /// from the database and calls the BeforeImplicitUpdateRelationship hook.
         /// </summary>
-        void FireForAffectedImplicits(Type entityTypeToInclude, Dictionary<RelationshipProxy, IEnumerable> implicitsTarget, ResourcePipeline pipeline, IEnumerable existingImplicitEntities = null)
+        void FireForAffectedImplicits(Type entityTypeToInclude, Dictionary<RelationshipAttribute, IEnumerable> implicitsTarget, ResourcePipeline pipeline, IEnumerable existingImplicitEntities = null)
         {
             var container = _executorHelper.GetResourceHookContainer(entityTypeToInclude, ResourceHook.BeforeImplicitUpdateRelationship);
             if (container == null) return;
@@ -310,10 +313,10 @@ void ValidateHookResponse<T>(IEnumerable<T> returnedList, ResourcePipeline pipel
         /// NOTE: in JADNC usage, the root layer is ALWAYS homogenous, so we can be sure that for every 
         /// relationship to the previous layer, the principal type is the same.
         /// </summary>
-        (Dictionary<RelationshipProxy, IEnumerable>, PrincipalType) GetDependentImplicitsTargets(Dictionary<RelationshipProxy, IEnumerable> dependentEntities)
+        (Dictionary<RelationshipAttribute, IEnumerable>, PrincipalType) GetDependentImplicitsTargets(Dictionary<RelationshipAttribute, IEnumerable> dependentEntities)
         {
             PrincipalType principalType = dependentEntities.First().Key.PrincipalType;
-            var byInverseRelationship = dependentEntities.Where(kvp => kvp.Key.Attribute.InverseNavigation != null).ToDictionary(kvp => GetInverseRelationship(kvp.Key), kvp => kvp.Value);
+            var byInverseRelationship = dependentEntities.Where(kvp => kvp.Key.InverseNavigation != null).ToDictionary(kvp => GetInverseRelationship(kvp.Key), kvp => kvp.Value);
             return (byInverseRelationship, principalType);
 
         }
@@ -350,17 +353,17 @@ object ThrowJsonApiExceptionOnError(Func<object> action)
         /// If <paramref name="dbValues"/> are included, the values of the entries in <paramref name="prevLayerRelationships"/> need to be replaced with these values.
         /// </summary>
         /// <returns>The relationship helper.</returns>
-        IAffectedRelationships CreateRelationshipHelper(DependentType entityType, Dictionary<RelationshipProxy, IEnumerable> prevLayerRelationships, IEnumerable dbValues = null)
+        IAffectedRelationships CreateRelationshipHelper(DependentType entityType, Dictionary<RelationshipAttribute, IEnumerable> prevLayerRelationships, IEnumerable dbValues = null)
         {
             if (dbValues != null) ReplaceWithDbValues(prevLayerRelationships, dbValues.Cast<IIdentifiable>());
-            return (IAffectedRelationships)TypeHelper.CreateInstanceOfOpenType(typeof(AffectedRelationships<>), entityType, true, prevLayerRelationships);
+            return (IAffectedRelationships)TypeHelper.CreateInstanceOfOpenType(typeof(AffectedRelationships<>), entityType, prevLayerRelationships);
         }
 
         /// <summary>
         /// Replaces the entities in the values of the prevLayerRelationships dictionary 
         /// with the corresponding entities loaded from the db.
         /// </summary>
-        void ReplaceWithDbValues(Dictionary<RelationshipProxy, IEnumerable> prevLayerRelationships, IEnumerable<IIdentifiable> dbValues)
+        void ReplaceWithDbValues(Dictionary<RelationshipAttribute, IEnumerable> prevLayerRelationships, IEnumerable<IIdentifiable> dbValues)
         {
             foreach (var key in prevLayerRelationships.Keys.ToList())
             {
@@ -379,14 +382,14 @@ HashSet<IIdentifiable> GetAllowedEntities(IEnumerable source, IEnumerable<string
         }
 
         /// <summary>
-        /// Gets the inverse <see cref="RelationshipProxy"/> for <paramref name="proxy"/>
+        /// Gets the inverse <see cref="RelationshipAttribute"/> for <paramref name="attribute"/>
         /// </summary>
-        RelationshipProxy GetInverseRelationship(RelationshipProxy proxy)
+        RelationshipAttribute GetInverseRelationship(RelationshipAttribute attribute)
         {
-            return new RelationshipProxy(_graph.GetInverseRelationship(proxy.Attribute), proxy.PrincipalType, false);
+            return _graph.GetInverseRelationship(attribute);
         }
 
-        IEnumerable LoadDbValues(Type containerEntityType, IEnumerable uniqueEntities, ResourceHook targetHook, RelationshipProxy[] relationshipsToNextLayer) 
+        IEnumerable LoadDbValues(Type containerEntityType, IEnumerable uniqueEntities, ResourceHook targetHook, RelationshipAttribute[] relationshipsToNextLayer) 
         {
             if (!_executorHelper.ShouldLoadDbValues(containerEntityType, targetHook)) return null;
             return _executorHelper.LoadDbValues(containerEntityType, uniqueEntities, targetHook, relationshipsToNextLayer);
diff --git a/src/JsonApiDotNetCore/Hooks/Traversal/RelationshipsFromPreviousLayer.cs b/src/JsonApiDotNetCore/Hooks/Traversal/RelationshipsFromPreviousLayer.cs
@@ -14,12 +14,12 @@ internal interface IRelationshipsFromPreviousLayer
         /// Grouped by relationship to the previous layer, gets all the entities of the current layer
         /// </summary>
         /// <returns>The dependent entities.</returns>
-        Dictionary<RelationshipProxy, IEnumerable> GetDependentEntities();
+        Dictionary<RelationshipAttribute, IEnumerable> GetDependentEntities();
         /// <summary>
         /// Grouped by relationship to the previous layer, gets all the entities of the previous layer
         /// </summary>
         /// <returns>The dependent entities.</returns>
-        Dictionary<RelationshipProxy, IEnumerable> GetPrincipalEntities();
+        Dictionary<RelationshipAttribute, IEnumerable> GetPrincipalEntities();
     }
 
     internal class RelationshipsFromPreviousLayer<TDependent> : IRelationshipsFromPreviousLayer, IEnumerable<RelationshipGroup<TDependent>> where TDependent : class, IIdentifiable
@@ -31,14 +31,14 @@ public RelationshipsFromPreviousLayer(IEnumerable<RelationshipGroup<TDependent>>
             _collection = collection;
         }
 
-        public Dictionary<RelationshipProxy, IEnumerable> GetDependentEntities()
+        public Dictionary<RelationshipAttribute, IEnumerable> GetDependentEntities()
         {
-            return _collection.ToDictionary(rg => rg.Proxy, rg => (IEnumerable)rg.DependentEntities);
+            return _collection.ToDictionary(rg => rg.Proxy.Attribute, rg => (IEnumerable)rg.DependentEntities);
         }
 
-        public Dictionary<RelationshipProxy, IEnumerable> GetPrincipalEntities()
+        public Dictionary<RelationshipAttribute, IEnumerable> GetPrincipalEntities()
         {
-            return _collection.ToDictionary(rg => rg.Proxy, rg => (IEnumerable)rg.PrincipalEntities);
+            return _collection.ToDictionary(rg => rg.Proxy.Attribute, rg => (IEnumerable)rg.PrincipalEntities);
         }
 
         public IEnumerator<RelationshipGroup<TDependent>> GetEnumerator()
diff --git a/src/JsonApiDotNetCore/Hooks/Traversal/RootNode.cs b/src/JsonApiDotNetCore/Hooks/Traversal/RootNode.cs
@@ -17,19 +17,19 @@ internal class RootNode<TEntity> : IEntityNode where TEntity : class, IIdentifia
         public Type EntityType { get; internal set; }
         public IEnumerable UniqueEntities { get { return _uniqueEntities; } }
         public RelationshipProxy[] RelationshipsToNextLayer { get; private set; }
-        public Dictionary<Type, Dictionary<RelationshipProxy, IEnumerable>> PrincipalsToNextLayerByType()
+        public Dictionary<Type, Dictionary<RelationshipAttribute, IEnumerable>> PrincipalsToNextLayerByType()
         {
             return RelationshipsToNextLayer
                     .GroupBy(proxy => proxy.DependentType)
-                    .ToDictionary(gdc => gdc.Key, gdc => gdc.ToDictionary(p => p, p => UniqueEntities));
+                    .ToDictionary(gdc => gdc.Key, gdc => gdc.ToDictionary(p => p.Attribute, p => UniqueEntities));
         }
 
         /// <summary>
         /// The current layer entities grouped by affected relationship to the next layer
         /// </summary>
-        public Dictionary<RelationshipProxy, IEnumerable> PrincipalsToNextLayer()
+        public Dictionary<RelationshipAttribute, IEnumerable> PrincipalsToNextLayer()
         {
-            return RelationshipsToNextLayer.ToDictionary(p => p, p => UniqueEntities);
+            return RelationshipsToNextLayer.ToDictionary(p => p.Attribute, p => UniqueEntities);
         }
 
         /// <summary>
diff --git a/src/JsonApiDotNetCore/Internal/ResourceGraph.cs b/src/JsonApiDotNetCore/Internal/ResourceGraph.cs
@@ -69,6 +69,11 @@ public interface IResourceGraph
         /// </summary>
         /// <param name="internalAttributeName">The internal attribute name for a <see cref="AttrAttribute" />.</param>
         string GetPublicAttributeName<TParent>(string internalAttributeName);
+
+        /// <summary>
+        /// Helper method to get the inverse relationship attribute corresponding 
+        /// to a relationship.
+        /// </summary>
         RelationshipAttribute GetInverseRelationship(RelationshipAttribute relationship);
 
         /// <summary>

Original file line number	Diff line number	Diff line change
`@@ -30,13 +30,13 @@ public interface IAffectedRelationships<TDependent> : IAffectedRelationships whe`
`30`	`30`
`31`	`31`	`public class AffectedRelationships<TDependent> : IAffectedRelationships<TDependent> where TDependent : class, IIdentifiable`
`32`	`32`	`{`
`33`		`- private readonly Dictionary<RelationshipProxy, HashSet<TDependent>> _groups;`
	`33`	`+ private readonly Dictionary<RelationshipAttribute, HashSet<TDependent>> _groups;`
`34`	`34`
`35`	`35`	`public Dictionary<RelationshipAttribute, HashSet<TDependent>> AllByRelationships()`
`36`	`36`	`{`
`37`		`- return _groups?.ToDictionary(p => p.Key.Attribute, p => p.Value);`
	`37`	`+ return _groups;`
`38`	`38`	`}`
`39`		`- internal AffectedRelationships(Dictionary<RelationshipProxy, IEnumerable> relationships)`
	`39`	`+ public AffectedRelationships(Dictionary<RelationshipAttribute, IEnumerable> relationships)`
`40`	`40`	`{`
`41`	`41`	`_groups = relationships.ToDictionary(kvp => kvp.Key, kvp => new HashSet<TDependent>((IEnumerable<TDependent>)kvp.Value));`
`42`	`42`	`}`
`@@ -48,7 +48,7 @@ public Dictionary<RelationshipAttribute, HashSet<TDependent>> GetByRelationship<`
`48`	`48`
`49`	`49`	`public Dictionary<RelationshipAttribute, HashSet<TDependent>> GetByRelationship(Type principalType)`
`50`	`50`	`{`
`51`		`- return _groups?.Where(p => p.Key.PrincipalType == principalType).ToDictionary(p => p.Key.Attribute, p => p.Value);`
	`51`	`+ return _groups?.Where(p => p.Key.PrincipalType == principalType).ToDictionary(p => p.Key, p => p.Value);`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public class AffectedResources<TEntity> : AffectedRelationships<TEntity>, IAffec`
`19`	`19`	`public HashSet<TEntity> Entities { get; }`
`20`	`20`
`21`	`21`	`internal AffectedResources(IEnumerable entities,`
`22`		`- Dictionary<RelationshipProxy, IEnumerable> relationships) : base(relationships)`
	`22`	`+ Dictionary<RelationshipAttribute, IEnumerable> relationships) : base(relationships)`
`23`	`23`	`{`
`24`	`24`	`Entities = new HashSet<TEntity>(entities.Cast<TEntity>());`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,6 @@ internal class HookExecutorHelper : IHookExecutorHelper`
`24`	`24`	`protected readonly Dictionary<DependentType, IHooksDiscovery> _hookDiscoveries;`
`25`	`25`	`protected readonly List<ResourceHook> _targetedHooksForRelatedEntities;`
`26`	`26`	`protected readonly IJsonApiContext _context;`
`27`		`- protected Dictionary<PrincipalType, List<RelationshipProxy>> _meta;`
`28`	`27`
`29`	`28`	`public HookExecutorHelper(`
`30`	`29`	`IGenericProcessorFactory genericProcessorFactory,`
`@@ -35,7 +34,6 @@ IJsonApiContext context`
`35`	`34`	`_genericProcessorFactory = genericProcessorFactory;`
`36`	`35`	`_graph = graph;`
`37`	`36`	`_context = context;`
`38`		`- _meta = new Dictionary<DependentType, List<RelationshipProxy>>();`
`39`	`37`	`_hookContainers = new Dictionary<DependentType, IResourceHookContainer>();`
`40`	`38`	`_hookDiscoveries = new Dictionary<DependentType, IHooksDiscovery>();`
`41`	`39`	`_targetedHooksForRelatedEntities = new List<ResourceHook>();`
`@@ -81,9 +79,9 @@ public IResourceHookContainer<TEntity> GetResourceHookContainer<TEntity>(Resourc`
`81`	`79`	`return (IResourceHookContainer<TEntity>)GetResourceHookContainer(typeof(TEntity), hook);`
`82`	`80`	`}`
`83`	`81`
`84`		`- public IEnumerable LoadDbValues(PrincipalType entityTypeForRepository, IEnumerable entities, ResourceHook hook, params RelationshipProxy[] relationships)`
	`82`	`+ public IEnumerable LoadDbValues(PrincipalType entityTypeForRepository, IEnumerable entities, ResourceHook hook, params RelationshipAttribute[] relationships)`
`85`	`83`	`{`
`86`		`- var paths = relationships.Select(p => p.Attribute.RelationshipPath).ToArray();`
	`84`	`+ var paths = relationships.Select(p => p.RelationshipPath).ToArray();`
`87`	`85`	`var idType = GetIdentifierType(entityTypeForRepository);`
`88`	`86`	`var parameterizedGetWhere = GetType()`
`89`	`87`	`.GetMethod(nameof(GetWhereAndInclude), BindingFlags.NonPublic \| BindingFlags.Instance)`
`@@ -95,7 +93,7 @@ public IEnumerable LoadDbValues(PrincipalType entityTypeForRepository, IEnumerab`
`95`	`93`	`return (IEnumerable)Activator.CreateInstance(typeof(HashSet<>).MakeGenericType(entityTypeForRepository), values.Cast(entityTypeForRepository));`
`96`	`94`	`}`
`97`	`95`
`98`		`- public HashSet<TEntity> LoadDbValues<TEntity>(IEnumerable<TEntity> entities, ResourceHook hook, params RelationshipProxy[] relationships) where TEntity : class, IIdentifiable`
	`96`	`+ public HashSet<TEntity> LoadDbValues<TEntity>(IEnumerable<TEntity> entities, ResourceHook hook, params RelationshipAttribute[] relationships) where TEntity : class, IIdentifiable`
`99`	`97`	`{`
`100`	`98`	`var entityType = typeof(TEntity);`
`101`	`99`	`var dbValues = LoadDbValues(entityType, entities, hook, relationships)?.Cast<TEntity>();`
`@@ -168,11 +166,11 @@ IEntityReadRepository<TEntity, TId> GetRepository<TEntity, TId>() where TEntity`
`168`	`166`	`}`
`169`	`167`
`170`	`168`
`171`		`- public Dictionary<RelationshipProxy, IEnumerable> LoadImplicitlyAffected(`
`172`		`- Dictionary<RelationshipProxy, IEnumerable> principalEntitiesByRelation,`
	`169`	`+ public Dictionary<RelationshipAttribute, IEnumerable> LoadImplicitlyAffected(`
	`170`	`+ Dictionary<RelationshipAttribute, IEnumerable> principalEntitiesByRelation,`
`173`	`171`	`IEnumerable existingDependentEntities = null)`
`174`	`172`	`{`
`175`		`- var implicitlyAffected = new Dictionary<RelationshipProxy, IEnumerable>();`
	`173`	`+ var implicitlyAffected = new Dictionary<RelationshipAttribute, IEnumerable>();`
`176`	`174`	`foreach (var kvp in principalEntitiesByRelation)`
`177`	`175`	`{`
`178`	`176`	`if (IsHasManyThrough(kvp, out var principals, out var relationship)) continue;`
`@@ -212,13 +210,13 @@ public Dictionary<RelationshipProxy, IEnumerable> LoadImplicitlyAffected(`
`212`	`210`
`213`	`211`	`}`
`214`	`212`
`215`		`- bool IsHasManyThrough(KeyValuePair<RelationshipProxy, IEnumerable> kvp,`
	`213`	`+ bool IsHasManyThrough(KeyValuePair<RelationshipAttribute, IEnumerable> kvp,`
`216`	`214`	`out IEnumerable entities,`
`217`		`- out RelationshipProxy proxy)`
	`215`	`+ out RelationshipAttribute attr)`
`218`	`216`	`{`
`219`		`- proxy = kvp.Key;`
	`217`	`+ attr = kvp.Key;`
`220`	`218`	`entities = (kvp.Value);`
`221`		`- return (kvp.Key.Attribute is HasManyThroughAttribute);`
	`219`	`+ return (kvp.Key is HasManyThroughAttribute);`
`222`	`220`	`}`
`223`	`221`	`}`
`224`	`222`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,12 +37,12 @@ internal interface IHookExecutorHelper`
`37`	`37`	`/// Load the implicitly affected entities from the database for a given set of target target entities and involved relationships`
`38`	`38`	`/// </summary>`
`39`	`39`	`/// <returns>The implicitly affected entities by relationship</returns>`
`40`		`- Dictionary<RelationshipProxy, IEnumerable> LoadImplicitlyAffected(Dictionary<RelationshipProxy, IEnumerable> principalEntities, IEnumerable existingDependentEntities = null);`
	`40`	`+ Dictionary<RelationshipAttribute, IEnumerable> LoadImplicitlyAffected(Dictionary<RelationshipAttribute, IEnumerable> principalEntities, IEnumerable existingDependentEntities = null);`
`41`	`41`
`42`	`42`	`/// <summary>`
`43`	`43`	`/// For a set of entities, loads current values from the database`
`44`	`44`	`/// </summary>`
`45`		`- IEnumerable LoadDbValues(Type repositoryEntityType, IEnumerable entities, ResourceHook hook, params RelationshipProxy[] relationships);`
	`45`	`+ IEnumerable LoadDbValues(Type repositoryEntityType, IEnumerable entities, ResourceHook hook, params RelationshipAttribute[] relationships);`
`46`	`46`	`bool ShouldLoadDbValues(Type containerEntityType, ResourceHook hook);`
`47`	`47`	`}`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,8 @@ public virtual IEnumerable<TEntity> BeforeUpdate<TEntity>(IEnumerable<TEntity> e`
`47`	`47`	`{`
`48`	`48`	`if (GetHook(ResourceHook.BeforeUpdate, entities, out var container, out var node))`
`49`	`49`	`{`
`50`		`- var dbValues = LoadDbValues(typeof(TEntity), (IEnumerable<TEntity>)node.UniqueEntities, ResourceHook.BeforeUpdate, node.RelationshipsToNextLayer);`
	`50`	`+ var relationships = node.RelationshipsToNextLayer.Select(p => p.Attribute).ToArray();`
	`51`	`+ var dbValues = LoadDbValues(typeof(TEntity), (IEnumerable<TEntity>)node.UniqueEntities, ResourceHook.BeforeUpdate, relationships);`
`51`	`52`	`var diff = new ResourceDiff<TEntity>(node.UniqueEntities, dbValues, node.PrincipalsToNextLayer());`
`52`	`53`	`IEnumerable<TEntity> updated = container.BeforeUpdate(diff, pipeline);`
`53`	`54`	`node.UpdateUnique(updated);`
`@@ -79,7 +80,8 @@ public virtual IEnumerable<TEntity> BeforeDelete<TEntity>(IEnumerable<TEntity> e`
`79`	`80`	`{`
`80`	`81`	`if (GetHook(ResourceHook.BeforeDelete, entities, out var container, out var node))`
`81`	`82`	`{`
`82`		`- var targetEntities = LoadDbValues(typeof(TEntity), (IEnumerable<TEntity>)node.UniqueEntities, ResourceHook.BeforeDelete, node.RelationshipsToNextLayer) ?? node.UniqueEntities;`
	`83`	`+ var relationships = node.RelationshipsToNextLayer.Select(p => p.Attribute).ToArray();`
	`84`	`+ var targetEntities = LoadDbValues(typeof(TEntity), (IEnumerable<TEntity>)node.UniqueEntities, ResourceHook.BeforeDelete, relationships) ?? node.UniqueEntities;`
`83`	`85`	`var affected = new AffectedResources<TEntity>(targetEntities, node.PrincipalsToNextLayer());`
`84`	`86`
`85`	`87`	`IEnumerable<TEntity> updated = container.BeforeDelete(affected, pipeline);`
`@@ -251,7 +253,8 @@ void FireNestedBeforeUpdateHooks(ResourcePipeline pipeline, EntityChildLayer lay`
`251`	`253`	`{`
`252`	`254`	`if (uniqueEntities.Cast<IIdentifiable>().Any())`
`253`	`255`	`{`
`254`		`- var dbValues = LoadDbValues(entityType, uniqueEntities, ResourceHook.BeforeUpdateRelationship, node.RelationshipsToNextLayer);`
	`256`	`+ var relationships = node.RelationshipsToNextLayer.Select(p => p.Attribute).ToArray();`
	`257`	`+ var dbValues = LoadDbValues(entityType, uniqueEntities, ResourceHook.BeforeUpdateRelationship, relationships);`
`255`	`258`	`var resourcesByRelationship = CreateRelationshipHelper(entityType, node.RelationshipsFromPreviousLayer.GetDependentEntities(), dbValues);`
`256`	`259`	`var allowedIds = CallHook(nestedHookcontainer, ResourceHook.BeforeUpdateRelationship, new object[] { GetIds(uniqueEntities), resourcesByRelationship, pipeline }).Cast<string>();`
`257`	`260`	`var updated = GetAllowedEntities(uniqueEntities, allowedIds);`
`@@ -281,7 +284,7 @@ void FireNestedBeforeUpdateHooks(ResourcePipeline pipeline, EntityChildLayer lay`
`281`	`284`	`/// Given a source of entities, gets the implicitly affected entities`
`282`	`285`	`/// from the database and calls the BeforeImplicitUpdateRelationship hook.`
`283`	`286`	`/// </summary>`
`284`		`- void FireForAffectedImplicits(Type entityTypeToInclude, Dictionary<RelationshipProxy, IEnumerable> implicitsTarget, ResourcePipeline pipeline, IEnumerable existingImplicitEntities = null)`
	`287`	`+ void FireForAffectedImplicits(Type entityTypeToInclude, Dictionary<RelationshipAttribute, IEnumerable> implicitsTarget, ResourcePipeline pipeline, IEnumerable existingImplicitEntities = null)`
`285`	`288`	`{`
`286`	`289`	`var container = _executorHelper.GetResourceHookContainer(entityTypeToInclude, ResourceHook.BeforeImplicitUpdateRelationship);`
`287`	`290`	`if (container == null) return;`
`@@ -310,10 +313,10 @@ void ValidateHookResponse<T>(IEnumerable<T> returnedList, ResourcePipeline pipel`
`310`	`313`	`/// NOTE: in JADNC usage, the root layer is ALWAYS homogenous, so we can be sure that for every`
`311`	`314`	`/// relationship to the previous layer, the principal type is the same.`
`312`	`315`	`/// </summary>`
`313`		`- (Dictionary<RelationshipProxy, IEnumerable>, PrincipalType) GetDependentImplicitsTargets(Dictionary<RelationshipProxy, IEnumerable> dependentEntities)`
	`316`	`+ (Dictionary<RelationshipAttribute, IEnumerable>, PrincipalType) GetDependentImplicitsTargets(Dictionary<RelationshipAttribute, IEnumerable> dependentEntities)`
`314`	`317`	`{`
`315`	`318`	`PrincipalType principalType = dependentEntities.First().Key.PrincipalType;`
`316`		`- var byInverseRelationship = dependentEntities.Where(kvp => kvp.Key.Attribute.InverseNavigation != null).ToDictionary(kvp => GetInverseRelationship(kvp.Key), kvp => kvp.Value);`
	`319`	`+ var byInverseRelationship = dependentEntities.Where(kvp => kvp.Key.InverseNavigation != null).ToDictionary(kvp => GetInverseRelationship(kvp.Key), kvp => kvp.Value);`
`317`	`320`	`return (byInverseRelationship, principalType);`
`318`	`321`
`319`	`322`	`}`
`@@ -350,17 +353,17 @@ object ThrowJsonApiExceptionOnError(Func<object> action)`
`350`	`353`	`/// If <paramref name="dbValues"/> are included, the values of the entries in <paramref name="prevLayerRelationships"/> need to be replaced with these values.`
`351`	`354`	`/// </summary>`
`352`	`355`	`/// <returns>The relationship helper.</returns>`
`353`		`- IAffectedRelationships CreateRelationshipHelper(DependentType entityType, Dictionary<RelationshipProxy, IEnumerable> prevLayerRelationships, IEnumerable dbValues = null)`
	`356`	`+ IAffectedRelationships CreateRelationshipHelper(DependentType entityType, Dictionary<RelationshipAttribute, IEnumerable> prevLayerRelationships, IEnumerable dbValues = null)`
`354`	`357`	`{`
`355`	`358`	`if (dbValues != null) ReplaceWithDbValues(prevLayerRelationships, dbValues.Cast<IIdentifiable>());`
`356`		`- return (IAffectedRelationships)TypeHelper.CreateInstanceOfOpenType(typeof(AffectedRelationships<>), entityType, true, prevLayerRelationships);`
	`359`	`+ return (IAffectedRelationships)TypeHelper.CreateInstanceOfOpenType(typeof(AffectedRelationships<>), entityType, prevLayerRelationships);`
`357`	`360`	`}`
`358`	`361`
`359`	`362`	`/// <summary>`
`360`	`363`	`/// Replaces the entities in the values of the prevLayerRelationships dictionary`
`361`	`364`	`/// with the corresponding entities loaded from the db.`
`362`	`365`	`/// </summary>`
`363`		`- void ReplaceWithDbValues(Dictionary<RelationshipProxy, IEnumerable> prevLayerRelationships, IEnumerable<IIdentifiable> dbValues)`
	`366`	`+ void ReplaceWithDbValues(Dictionary<RelationshipAttribute, IEnumerable> prevLayerRelationships, IEnumerable<IIdentifiable> dbValues)`
`364`	`367`	`{`
`365`	`368`	`foreach (var key in prevLayerRelationships.Keys.ToList())`
`366`	`369`	`{`
`@@ -379,14 +382,14 @@ HashSet<IIdentifiable> GetAllowedEntities(IEnumerable source, IEnumerable<string`
`379`	`382`	`}`
`380`	`383`
`381`	`384`	`/// <summary>`
`382`		`- /// Gets the inverse <see cref="RelationshipProxy"/> for <paramref name="proxy"/>`
	`385`	`+ /// Gets the inverse <see cref="RelationshipAttribute"/> for <paramref name="attribute"/>`
`383`	`386`	`/// </summary>`
`384`		`- RelationshipProxy GetInverseRelationship(RelationshipProxy proxy)`
	`387`	`+ RelationshipAttribute GetInverseRelationship(RelationshipAttribute attribute)`
`385`	`388`	`{`
`386`		`- return new RelationshipProxy(_graph.GetInverseRelationship(proxy.Attribute), proxy.PrincipalType, false);`
	`389`	`+ return _graph.GetInverseRelationship(attribute);`
`387`	`390`	`}`
`388`	`391`
`389`		`- IEnumerable LoadDbValues(Type containerEntityType, IEnumerable uniqueEntities, ResourceHook targetHook, RelationshipProxy[] relationshipsToNextLayer)`
	`392`	`+ IEnumerable LoadDbValues(Type containerEntityType, IEnumerable uniqueEntities, ResourceHook targetHook, RelationshipAttribute[] relationshipsToNextLayer)`
`390`	`393`	`{`
`391`	`394`	`if (!_executorHelper.ShouldLoadDbValues(containerEntityType, targetHook)) return null;`
`392`	`395`	`return _executorHelper.LoadDbValues(containerEntityType, uniqueEntities, targetHook, relationshipsToNextLayer);`
Original file line number	Diff line number	Diff line change
`@@ -14,12 +14,12 @@ internal interface IRelationshipsFromPreviousLayer`
`14`	`14`	`/// Grouped by relationship to the previous layer, gets all the entities of the current layer`
`15`	`15`	`/// </summary>`
`16`	`16`	`/// <returns>The dependent entities.</returns>`
`17`		`- Dictionary<RelationshipProxy, IEnumerable> GetDependentEntities();`
	`17`	`+ Dictionary<RelationshipAttribute, IEnumerable> GetDependentEntities();`
`18`	`18`	`/// <summary>`
`19`	`19`	`/// Grouped by relationship to the previous layer, gets all the entities of the previous layer`
`20`	`20`	`/// </summary>`
`21`	`21`	`/// <returns>The dependent entities.</returns>`
`22`		`- Dictionary<RelationshipProxy, IEnumerable> GetPrincipalEntities();`
	`22`	`+ Dictionary<RelationshipAttribute, IEnumerable> GetPrincipalEntities();`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`internal class RelationshipsFromPreviousLayer<TDependent> : IRelationshipsFromPreviousLayer, IEnumerable<RelationshipGroup<TDependent>> where TDependent : class, IIdentifiable`
`@@ -31,14 +31,14 @@ public RelationshipsFromPreviousLayer(IEnumerable<RelationshipGroup<TDependent>>`
`31`	`31`	`_collection = collection;`
`32`	`32`	`}`
`33`	`33`
`34`		`- public Dictionary<RelationshipProxy, IEnumerable> GetDependentEntities()`
	`34`	`+ public Dictionary<RelationshipAttribute, IEnumerable> GetDependentEntities()`
`35`	`35`	`{`
`36`		`- return _collection.ToDictionary(rg => rg.Proxy, rg => (IEnumerable)rg.DependentEntities);`
	`36`	`+ return _collection.ToDictionary(rg => rg.Proxy.Attribute, rg => (IEnumerable)rg.DependentEntities);`
`37`	`37`	`}`
`38`	`38`
`39`		`- public Dictionary<RelationshipProxy, IEnumerable> GetPrincipalEntities()`
	`39`	`+ public Dictionary<RelationshipAttribute, IEnumerable> GetPrincipalEntities()`
`40`	`40`	`{`
`41`		`- return _collection.ToDictionary(rg => rg.Proxy, rg => (IEnumerable)rg.PrincipalEntities);`
	`41`	`+ return _collection.ToDictionary(rg => rg.Proxy.Attribute, rg => (IEnumerable)rg.PrincipalEntities);`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`public IEnumerator<RelationshipGroup<TDependent>> GetEnumerator()`
Original file line number	Diff line number	Diff line change
`@@ -17,19 +17,19 @@ internal class RootNode<TEntity> : IEntityNode where TEntity : class, IIdentifia`
`17`	`17`	`public Type EntityType { get; internal set; }`
`18`	`18`	`public IEnumerable UniqueEntities { get { return _uniqueEntities; } }`
`19`	`19`	`public RelationshipProxy[] RelationshipsToNextLayer { get; private set; }`
`20`		`- public Dictionary<Type, Dictionary<RelationshipProxy, IEnumerable>> PrincipalsToNextLayerByType()`
	`20`	`+ public Dictionary<Type, Dictionary<RelationshipAttribute, IEnumerable>> PrincipalsToNextLayerByType()`
`21`	`21`	`{`
`22`	`22`	`return RelationshipsToNextLayer`
`23`	`23`	`.GroupBy(proxy => proxy.DependentType)`
`24`		`- .ToDictionary(gdc => gdc.Key, gdc => gdc.ToDictionary(p => p, p => UniqueEntities));`
	`24`	`+ .ToDictionary(gdc => gdc.Key, gdc => gdc.ToDictionary(p => p.Attribute, p => UniqueEntities));`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`/// <summary>`
`28`	`28`	`/// The current layer entities grouped by affected relationship to the next layer`
`29`	`29`	`/// </summary>`
`30`		`- public Dictionary<RelationshipProxy, IEnumerable> PrincipalsToNextLayer()`
	`30`	`+ public Dictionary<RelationshipAttribute, IEnumerable> PrincipalsToNextLayer()`
`31`	`31`	`{`
`32`		`- return RelationshipsToNextLayer.ToDictionary(p => p, p => UniqueEntities);`
	`32`	`+ return RelationshipsToNextLayer.ToDictionary(p => p.Attribute, p => UniqueEntities);`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`/// <summary>`