feat: improved loaddbvalues attribute error handling, refactored a bit

maurei · maurei · commit b8df7494b3b6 · 2019-06-05T18:37:54.000+02:00
diff --git a/src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs b/src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs
@@ -10,7 +10,6 @@
 using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Services;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.Extensions.Logging;
 namespace JsonApiDotNetCore.Data
 {
@@ -378,22 +377,14 @@ public async Task UpdateRelationshipsAsync(object parent, RelationshipAttribute
             await genericProcessor.UpdateRelationshipsAsync(parent, relationship, relationshipIds);
         }
 
+
         /// <inheritdoc />
         public virtual async Task<bool> DeleteAsync(TId id)
         {
-            return await DeleteAsync(await GetAsync(id));
-          
-        }
-
-        public virtual async Task<bool> DeleteAsync(TEntity entity)
-        {
-            if (entity == null)
-                return false;
-
-
+            var entity = await GetAsync(id);
+            if (entity == null) return false;
             _dbSet.Remove(entity);
             await _context.SaveChangesAsync();
-
             return true;
         }
 
diff --git a/src/JsonApiDotNetCore/Data/IEntityWriteRepository.cs b/src/JsonApiDotNetCore/Data/IEntityWriteRepository.cs
@@ -19,8 +19,6 @@ public interface IEntityWriteRepository<TEntity, in TId>
 
         Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds);
 
-        Task<bool> DeleteAsync(TEntity entity);
-
         Task<bool> DeleteAsync(TId id);
     }
 }
diff --git a/src/JsonApiDotNetCore/Hooks/Discovery/HooksDiscovery.cs b/src/JsonApiDotNetCore/Hooks/Discovery/HooksDiscovery.cs
@@ -14,11 +14,16 @@ namespace JsonApiDotNetCore.Hooks
     public class HooksDiscovery<TEntity> : IHooksDiscovery<TEntity> where TEntity : class, IIdentifiable
     {
         private readonly ResourceHook[] _allHooks;
-
+        private readonly ResourceHook[] _databaseValuesAttributeAllowed =
+        {
+            ResourceHook.BeforeUpdate,
+            ResourceHook.BeforeUpdateRelationship,
+            ResourceHook.BeforeDelete
+        };
         /// <inheritdoc/>
         public ResourceHook[] ImplementedHooks { get; private set; }
-        public ResourceHook[] DatabaseDiffEnabledHooks { get; private set; }
-        public ResourceHook[] DatabaseDiffDisabledHooks { get; private set; }
+        public ResourceHook[] DatabaseValuesEnabledHooks { get; private set; }
+        public ResourceHook[] DatabaseValuesDisabledHooks { get; private set; }
 
 
         public HooksDiscovery()
@@ -38,43 +43,47 @@ void DiscoverImplementedHooksForModel()
         {
             Type parameterizedResourceDefinition = typeof(ResourceDefinition<TEntity>);
             var derivedTypes = TypeLocator.GetDerivedTypes(typeof(TEntity).Assembly, parameterizedResourceDefinition).ToList();
+
+
+            var implementedHooks = new List<ResourceHook>();
+            var enabledHooks = new List<ResourceHook>() { ResourceHook.BeforeImplicitUpdateRelationship } ;
+            var disabledHooks = new List<ResourceHook>();
+            Type targetType = null;
             try
             {
-                var implementedHooks = new List<ResourceHook>();
-                var diffEnabledHooks = new List<ResourceHook>();
-                var diffDisabledHooks = new List<ResourceHook>();
-                Type targetType = derivedTypes.SingleOrDefault(); // multiple containers is not supported
-                if (targetType != null)
+                targetType = derivedTypes.SingleOrDefault(); // multiple containers is not supported
+            }
+            catch
+            {
+                throw new JsonApiSetupException($"It is currently not supported to" +
+                	"implement hooks across multiple implementations of ResourceDefinition<T>");
+            }
+            if (targetType != null)
+            {
+                foreach (var hook in _allHooks)
                 {
-                    foreach (var hook in _allHooks)
+                    var method = targetType.GetMethod(hook.ToString("G"));
+                    if (method.DeclaringType != parameterizedResourceDefinition)
                     {
-                        var method = targetType.GetMethod(hook.ToString("G"));
-                        if (method.DeclaringType != parameterizedResourceDefinition)
+                        implementedHooks.Add(hook);
+                        var attr = method.GetCustomAttributes(true).OfType<LoadDatabaseValues>().SingleOrDefault();
+                        if (attr != null)
                         {
-                            implementedHooks.Add(hook);
-                            if (hook == ResourceHook.BeforeImplicitUpdateRelationship)
-                            {
-                                diffEnabledHooks.Add(hook);
-                                continue;
-                            }
-                            var attr = method.GetCustomAttributes(true).OfType<LoadDatabaseValues>().SingleOrDefault();
-                            if (attr != null)
+                            if (!_databaseValuesAttributeAllowed.Contains(hook))
                             {
-                                var targetList = attr.value ? diffEnabledHooks : diffDisabledHooks;
-                                targetList.Add(hook);
+                                throw new JsonApiSetupException($"DatabaseValuesAttribute cannot be used on hook" +
+                                    $"{hook.ToString("G")} in resource definition  {parameterizedResourceDefinition.Name}");
                             }
-                         }
-                    }
-
+                            var targetList = attr.value ? enabledHooks : disabledHooks;
+                            targetList.Add(hook);
+                        }
+                     }
                 }
-                ImplementedHooks = implementedHooks.ToArray();
-                DatabaseDiffDisabledHooks = diffDisabledHooks.ToArray();
-                DatabaseDiffEnabledHooks = diffEnabledHooks.ToArray();
-            } catch (Exception e)
-            {
-                throw new JsonApiSetupException($@"Incorrect resource hook setup. For a given model of type TEntity, 
-                only one class may implement IResourceHookContainer<TEntity>");
+
             }
+            ImplementedHooks = implementedHooks.ToArray();
+            DatabaseValuesDisabledHooks = disabledHooks.ToArray();
+            DatabaseValuesEnabledHooks = enabledHooks.ToArray();
 
         }
     }
diff --git a/src/JsonApiDotNetCore/Hooks/Discovery/IHooksDiscovery.cs b/src/JsonApiDotNetCore/Hooks/Discovery/IHooksDiscovery.cs
@@ -21,8 +21,8 @@ public interface IHooksDiscovery
         /// </summary>
         /// <value>The implemented hooks.</value>
         ResourceHook[] ImplementedHooks { get; }
-        ResourceHook[] DatabaseDiffEnabledHooks { get; }
-        ResourceHook[] DatabaseDiffDisabledHooks { get; }
+        ResourceHook[] DatabaseValuesEnabledHooks { get; }
+        ResourceHook[] DatabaseValuesDisabledHooks { get; }
     }
 
 }
diff --git a/src/JsonApiDotNetCore/Hooks/Execution/HookExecutorHelper.cs b/src/JsonApiDotNetCore/Hooks/Execution/HookExecutorHelper.cs
@@ -29,7 +29,7 @@ internal class HookExecutorHelper : IHookExecutorHelper
         public HookExecutorHelper(
             IGenericProcessorFactory genericProcessorFactory,
             IResourceGraph graph,
-            IJsonApiContext context = null
+            IJsonApiContext context
             )
         {
             _genericProcessorFactory = genericProcessorFactory;
@@ -81,39 +81,38 @@ public IResourceHookContainer<TEntity> GetResourceHookContainer<TEntity>(Resourc
             return (IResourceHookContainer<TEntity>)GetResourceHookContainer(typeof(TEntity), hook);
         }
 
-        public IEnumerable LoadDbValues(PrincipalType repositoryEntityType, Type affectedHookEntityType, IEnumerable entities, ResourceHook hook, params RelationshipProxy[] relationships)
+        public IEnumerable LoadDbValues(PrincipalType entityTypeForRepository, IEnumerable entities, ResourceHook hook, params RelationshipProxy[] relationships)
         {
-            if (!ShouldLoadDbValues(affectedHookEntityType, hook)) return null;
-
             var paths = relationships.Select(p => p.Attribute.RelationshipPath).ToArray();
-            var idType = GetIdentifierType(repositoryEntityType);
+            var idType = GetIdentifierType(entityTypeForRepository);
             var parameterizedGetWhere = GetType()
                     .GetMethod(nameof(GetWhereAndInclude), BindingFlags.NonPublic | BindingFlags.Instance)
-                    .MakeGenericMethod(repositoryEntityType, idType);
+                    .MakeGenericMethod(entityTypeForRepository, idType);
             var casted = ((IEnumerable<object>)entities).Cast<IIdentifiable>();
             var ids = casted.Select(e => e.StringId).Cast(idType);
             var values = (IEnumerable)parameterizedGetWhere.Invoke(this, new object[] { ids, paths });
-            return values;
+            if (values == null) return null;
+            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
         {
             var entityType = typeof(TEntity);
-            var dbValues = LoadDbValues(entityType, entityType, entities, hook, relationships)?.Cast<TEntity>();
+            var dbValues = LoadDbValues(entityType, entities, hook, relationships)?.Cast<TEntity>();
             if (dbValues == null) return null;
             return new HashSet<TEntity>(dbValues);
         }
 
 
-        bool ShouldLoadDbValues(DependentType entityType, ResourceHook hook)
+        public bool ShouldLoadDbValues(Type entityType, ResourceHook hook)
         {
             var discovery = GetHookDiscovery(entityType);
 
-            if (discovery.DatabaseDiffDisabledHooks.Contains(hook))
+            if (discovery.DatabaseValuesDisabledHooks.Contains(hook))
             {
                 return false;
             }
-            else if (discovery.DatabaseDiffEnabledHooks.Contains(hook))
+            else if (discovery.DatabaseValuesEnabledHooks.Contains(hook))
             {
                 return true;
             }
@@ -177,7 +176,9 @@ public Dictionary<RelationshipProxy, IEnumerable> LoadImplicitlyAffected(
             foreach (var kvp in principalEntitiesByRelation)
             {
                 if (IsHasManyThrough(kvp, out var principals, out var relationship)) continue;
-                var includedPrincipals = LoadDbValues(relationship.PrincipalType, relationship.DependentType, principals, ResourceHook.BeforeImplicitUpdateRelationship, relationship);
+
+                // note that we dont't have to check if BeforeImplicitUpdate hook is implemented. If not, it wont ever get here.
+                var includedPrincipals = LoadDbValues(relationship.PrincipalType, principals, ResourceHook.BeforeImplicitUpdateRelationship, relationship);
 
                 foreach (IIdentifiable ip in includedPrincipals)
                 {
diff --git a/src/JsonApiDotNetCore/Hooks/Execution/IHookExecutorHelper.cs b/src/JsonApiDotNetCore/Hooks/Execution/IHookExecutorHelper.cs
@@ -42,10 +42,7 @@ internal interface IHookExecutorHelper
         /// <summary>
         /// For a set of entities, loads current values from the database
         /// </summary>
-        IEnumerable LoadDbValues(Type repositoryEntityType, Type affectedHookEntityType,  IEnumerable entities, ResourceHook hook, params RelationshipProxy[] relationships);
-        /// <summary>
-        /// For a set of entities, loads current values from the database
-        /// </summary>
-        HashSet<TEntity> LoadDbValues<TEntity>(IEnumerable<TEntity> entities, ResourceHook hook, params RelationshipProxy[] relationships) where TEntity : class, IIdentifiable;
+        IEnumerable LoadDbValues(Type repositoryEntityType, IEnumerable entities, ResourceHook hook, params RelationshipProxy[] relationships);
+        bool ShouldLoadDbValues(Type containerEntityType, ResourceHook hook);
     }
 }
diff --git a/src/JsonApiDotNetCore/Hooks/Execution/UpdatedRelationshipHelper.cs b/src/JsonApiDotNetCore/Hooks/Execution/UpdatedRelationshipHelper.cs
@@ -16,7 +16,8 @@ public interface IAffectedRelationships<TDependent> : IAffectedRelationships whe
         /// <summary>
         /// Gets a dictionary of all entities grouped by affected relationship.
         /// </summary>
-        Dictionary<RelationshipAttribute, HashSet<TDependent>> All { get; }
+        Dictionary<RelationshipAttribute, HashSet<TDependent>> AllByRelationships();
+
         /// <summary>
         /// Gets a dictionary of all entities that have an affected relationship to type <typeparamref name="TPrincipal"/>
         /// </summary>
@@ -31,9 +32,9 @@ public class UpdatedRelationshipHelper<TDependent> : IAffectedRelationships<TDep
     {
         private readonly Dictionary<RelationshipProxy, HashSet<TDependent>> _groups;
 
-        public Dictionary<RelationshipAttribute, HashSet<TDependent>> All
+        public Dictionary<RelationshipAttribute, HashSet<TDependent>> AllByRelationships()
         {
-            get { return _groups?.ToDictionary(p => p.Key.Attribute, p => p.Value); }
+            return _groups?.ToDictionary(p => p.Key.Attribute, p => p.Value);
         }
         public UpdatedRelationshipHelper(Dictionary<RelationshipProxy, IEnumerable> relationships)
         {
diff --git a/src/JsonApiDotNetCore/Hooks/ResourceHookExecutor.cs b/src/JsonApiDotNetCore/Hooks/ResourceHookExecutor.cs
@@ -47,7 +47,7 @@ public virtual IEnumerable<TEntity> BeforeUpdate<TEntity>(IEnumerable<TEntity> e
         {
             if (GetHook(ResourceHook.BeforeUpdate, entities, out var container, out var node))
             {
-                var dbValues = _executorHelper.LoadDbValues((IEnumerable<TEntity>)node.UniqueEntities, ResourceHook.BeforeUpdate, node.RelationshipsToNextLayer);
+                var dbValues = LoadDbValues(typeof(TEntity), (IEnumerable<TEntity>)node.UniqueEntities, ResourceHook.BeforeUpdate, node.RelationshipsToNextLayer);
                 var diff = new EntityDiff<TEntity>(node.UniqueEntities, dbValues, node.PrincipalsToNextLayer());
                 IEnumerable<TEntity> updated = container.BeforeUpdate(diff, pipeline);
                 node.UpdateUnique(updated);
@@ -58,6 +58,7 @@ public virtual IEnumerable<TEntity> BeforeUpdate<TEntity>(IEnumerable<TEntity> e
             return entities;
         }
 
+
         /// <inheritdoc/>
         public virtual IEnumerable<TEntity> BeforeCreate<TEntity>(IEnumerable<TEntity> entities, ResourcePipeline pipeline) where TEntity : class, IIdentifiable
         {
@@ -77,7 +78,8 @@ public virtual IEnumerable<TEntity> BeforeDelete<TEntity>(IEnumerable<TEntity> e
         {
             if (GetHook(ResourceHook.BeforeDelete, entities, out var container, out var node))
             {
-                IEnumerable<TEntity> updated = container.BeforeDelete((HashSet<TEntity>)node.UniqueEntities, pipeline);
+                var targetEntities = (LoadDbValues(typeof(TEntity), (IEnumerable<TEntity>)node.UniqueEntities, ResourceHook.BeforeDelete, node.RelationshipsToNextLayer) ?? node.UniqueEntities);
+                IEnumerable<TEntity> updated = container.BeforeDelete((HashSet<TEntity>)targetEntities, pipeline);
                 node.UpdateUnique(updated);
                 node.Reassign(entities);
             }
@@ -246,7 +248,7 @@ void FireNestedBeforeUpdateHooks(ResourcePipeline pipeline, EntityChildLayer lay
                 {
                     if (uniqueEntities.Cast<IIdentifiable>().Any())
                     {
-                        var dbValues = _executorHelper.LoadDbValues(entityType, entityType, uniqueEntities, ResourceHook.BeforeUpdateRelationship, node.RelationshipsToNextLayer);
+                        var dbValues = LoadDbValues(entityType, uniqueEntities, ResourceHook.BeforeUpdateRelationship, node.RelationshipsToNextLayer);
                         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);
@@ -381,6 +383,12 @@ RelationshipProxy GetInverseRelationship(RelationshipProxy proxy)
             return new RelationshipProxy(_graph.GetInverseRelationship(proxy.Attribute), proxy.PrincipalType, false);
         }
 
+        IEnumerable LoadDbValues(Type containerEntityType, IEnumerable uniqueEntities, ResourceHook targetHook, RelationshipProxy[] relationshipsToNextLayer) 
+        {
+            if (!_executorHelper.ShouldLoadDbValues(containerEntityType, targetHook)) return null;
+            return _executorHelper.LoadDbValues(containerEntityType, uniqueEntities, targetHook, relationshipsToNextLayer);
+        }
+
         void FireAfterUpdateRelationship(IResourceHookContainer container, IEntityNode node, ResourcePipeline pipeline)
         {
             var resourcesByRelationship = CreateRelationshipHelper(node.EntityType, node.RelationshipsFromPreviousLayer.GetDependentEntities());
diff --git a/src/JsonApiDotNetCore/Services/EntityResourceService.cs b/src/JsonApiDotNetCore/Services/EntityResourceService.cs
@@ -116,9 +116,10 @@ public virtual async Task<TResource> CreateAsync(TResource resource)
         }
         public virtual async Task<bool> DeleteAsync(TId id)
         {
-            var entity = await _entities.GetAsync(id);
+            var entity = (TEntity)Activator.CreateInstance(typeof(TEntity));
+            entity.Id = id;
             if (!IsNull(_hookExecutor, entity)) _hookExecutor.BeforeDelete(AsList(entity), ResourcePipeline.Delete);
-            var succeeded = await _entities.DeleteAsync(entity);
+            var succeeded = await _entities.DeleteAsync(entity.Id);
             if (!IsNull(_hookExecutor, entity)) _hookExecutor.AfterDelete(AsList(entity), ResourcePipeline.Delete, succeeded);
             return succeeded;
         }
diff --git a/test/UnitTests/ResourceHooks/DiscoveryTests.cs b/test/UnitTests/ResourceHooks/DiscoveryTests.cs
@@ -52,5 +52,52 @@ public void Hook_Discovery_With_Inheritance()
             Assert.Contains(ResourceHook.BeforeDelete, hookConfig.ImplementedHooks);
             Assert.Contains(ResourceHook.AfterDelete, hookConfig.ImplementedHooks);
         }
+
+
+        public class YetAnotherDummy : Identifiable { }
+        public class YetAnotherDummyResourceDefinition : ResourceDefinition<YetAnotherDummy>
+        {
+            public YetAnotherDummyResourceDefinition() : base(new ResourceGraphBuilder().AddResource<YetAnotherDummy>().Build()) { }
+
+            public override IEnumerable<YetAnotherDummy> BeforeDelete(HashSet<YetAnotherDummy> entities, ResourcePipeline pipeline) { return entities; }
+
+            [LoadDatabaseValues(false)]
+            public override void AfterDelete(HashSet<YetAnotherDummy> entities, ResourcePipeline pipeline, bool succeeded) { }
+        }
+        [Fact]
+        public void LoadDatabaseValues_Attribute_Not_Allowed()
+        {
+            //  assert
+            Assert.Throws<JsonApiSetupException>(() =>
+            {
+                // arrange & act
+                var hookConfig = new HooksDiscovery<YetAnotherDummy>();
+            });
+
+        }
+
+        public class DoubleDummy : Identifiable { }
+        public class DoubleDummyResourceDefinition1 : ResourceDefinition<DoubleDummy>
+        {
+            public DoubleDummyResourceDefinition1() : base(new ResourceGraphBuilder().AddResource<DoubleDummy>().Build()) { }
+
+            public override IEnumerable<DoubleDummy> BeforeDelete(HashSet<DoubleDummy> entities, ResourcePipeline pipeline) { return entities; }
+        }
+        public class DoubleDummyResourceDefinition2 : ResourceDefinition<DoubleDummy>
+        {
+            public DoubleDummyResourceDefinition2() : base(new ResourceGraphBuilder().AddResource<DoubleDummy>().Build()) { }
+
+            public override void AfterDelete(HashSet<DoubleDummy> entities, ResourcePipeline pipeline, bool succeeded) { }
+        }
+        [Fact]
+        public void Multiple_Implementations_Of_ResourceDefinitions()
+        {
+            //  assert
+            Assert.Throws<JsonApiSetupException>(() =>
+            {
+                // arrange & act
+                var hookConfig = new HooksDiscovery<DoubleDummy>();
+            });
+        }
     }
 }
diff --git a/test/UnitTests/ResourceHooks/ResourceHooksTestsSetup.cs b/test/UnitTests/ResourceHooks/ResourceHooksTestsSetup.cs

Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,6 @@ public interface IEntityWriteRepository<TEntity, in TId>`
`19`	`19`
`20`	`20`	`Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds);`
`21`	`21`
`22`		`- Task<bool> DeleteAsync(TEntity entity);`
`23`		`-`
`24`	`22`	`Task<bool> DeleteAsync(TId id);`
`25`	`23`	`}`
`26`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,8 +21,8 @@ public interface IHooksDiscovery`
`21`	`21`	`/// </summary>`
`22`	`22`	`/// <value>The implemented hooks.</value>`
`23`	`23`	`ResourceHook[] ImplementedHooks { get; }`
`24`		`- ResourceHook[] DatabaseDiffEnabledHooks { get; }`
`25`		`- ResourceHook[] DatabaseDiffDisabledHooks { get; }`
	`24`	`+ ResourceHook[] DatabaseValuesEnabledHooks { get; }`
	`25`	`+ ResourceHook[] DatabaseValuesDisabledHooks { get; }`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ internal class HookExecutorHelper : IHookExecutorHelper`
`29`	`29`	`public HookExecutorHelper(`
`30`	`30`	`IGenericProcessorFactory genericProcessorFactory,`
`31`	`31`	`IResourceGraph graph,`
`32`		`- IJsonApiContext context = null`
	`32`	`+ IJsonApiContext context`
`33`	`33`	`)`
`34`	`34`	`{`
`35`	`35`	`_genericProcessorFactory = genericProcessorFactory;`
`@@ -81,39 +81,38 @@ public IResourceHookContainer<TEntity> GetResourceHookContainer<TEntity>(Resourc`
`81`	`81`	`return (IResourceHookContainer<TEntity>)GetResourceHookContainer(typeof(TEntity), hook);`
`82`	`82`	`}`
`83`	`83`
`84`		`- public IEnumerable LoadDbValues(PrincipalType repositoryEntityType, Type affectedHookEntityType, IEnumerable entities, ResourceHook hook, params RelationshipProxy[] relationships)`
	`84`	`+ public IEnumerable LoadDbValues(PrincipalType entityTypeForRepository, IEnumerable entities, ResourceHook hook, params RelationshipProxy[] relationships)`
`85`	`85`	`{`
`86`		`- if (!ShouldLoadDbValues(affectedHookEntityType, hook)) return null;`
`87`		`-`
`88`	`86`	`var paths = relationships.Select(p => p.Attribute.RelationshipPath).ToArray();`
`89`		`- var idType = GetIdentifierType(repositoryEntityType);`
	`87`	`+ var idType = GetIdentifierType(entityTypeForRepository);`
`90`	`88`	`var parameterizedGetWhere = GetType()`
`91`	`89`	`.GetMethod(nameof(GetWhereAndInclude), BindingFlags.NonPublic \| BindingFlags.Instance)`
`92`		`- .MakeGenericMethod(repositoryEntityType, idType);`
	`90`	`+ .MakeGenericMethod(entityTypeForRepository, idType);`
`93`	`91`	`var casted = ((IEnumerable<object>)entities).Cast<IIdentifiable>();`
`94`	`92`	`var ids = casted.Select(e => e.StringId).Cast(idType);`
`95`	`93`	`var values = (IEnumerable)parameterizedGetWhere.Invoke(this, new object[] { ids, paths });`
`96`		`- return values;`
	`94`	`+ if (values == null) return null;`
	`95`	`+ return (IEnumerable)Activator.CreateInstance(typeof(HashSet<>).MakeGenericType(entityTypeForRepository), values.Cast(entityTypeForRepository));`
`97`	`96`	`}`
`98`	`97`
`99`	`98`	`public HashSet<TEntity> LoadDbValues<TEntity>(IEnumerable<TEntity> entities, ResourceHook hook, params RelationshipProxy[] relationships) where TEntity : class, IIdentifiable`
`100`	`99`	`{`
`101`	`100`	`var entityType = typeof(TEntity);`
`102`		`- var dbValues = LoadDbValues(entityType, entityType, entities, hook, relationships)?.Cast<TEntity>();`
	`101`	`+ var dbValues = LoadDbValues(entityType, entities, hook, relationships)?.Cast<TEntity>();`
`103`	`102`	`if (dbValues == null) return null;`
`104`	`103`	`return new HashSet<TEntity>(dbValues);`
`105`	`104`	`}`
`106`	`105`
`107`	`106`
`108`		`- bool ShouldLoadDbValues(DependentType entityType, ResourceHook hook)`
	`107`	`+ public bool ShouldLoadDbValues(Type entityType, ResourceHook hook)`
`109`	`108`	`{`
`110`	`109`	`var discovery = GetHookDiscovery(entityType);`
`111`	`110`
`112`		`- if (discovery.DatabaseDiffDisabledHooks.Contains(hook))`
	`111`	`+ if (discovery.DatabaseValuesDisabledHooks.Contains(hook))`
`113`	`112`	`{`
`114`	`113`	`return false;`
`115`	`114`	`}`
`116`		`- else if (discovery.DatabaseDiffEnabledHooks.Contains(hook))`
	`115`	`+ else if (discovery.DatabaseValuesEnabledHooks.Contains(hook))`
`117`	`116`	`{`
`118`	`117`	`return true;`
`119`	`118`	`}`
`@@ -177,7 +176,9 @@ public Dictionary<RelationshipProxy, IEnumerable> LoadImplicitlyAffected(`
`177`	`176`	`foreach (var kvp in principalEntitiesByRelation)`
`178`	`177`	`{`
`179`	`178`	`if (IsHasManyThrough(kvp, out var principals, out var relationship)) continue;`
`180`		`- var includedPrincipals = LoadDbValues(relationship.PrincipalType, relationship.DependentType, principals, ResourceHook.BeforeImplicitUpdateRelationship, relationship);`
	`179`	`+`
	`180`	`+ // note that we dont't have to check if BeforeImplicitUpdate hook is implemented. If not, it wont ever get here.`
	`181`	`+ var includedPrincipals = LoadDbValues(relationship.PrincipalType, principals, ResourceHook.BeforeImplicitUpdateRelationship, relationship);`
`181`	`182`
`182`	`183`	`foreach (IIdentifiable ip in includedPrincipals)`
`183`	`184`	`{`
Original file line number	Diff line number	Diff line change
`@@ -42,10 +42,7 @@ internal interface IHookExecutorHelper`
`42`	`42`	`/// <summary>`
`43`	`43`	`/// For a set of entities, loads current values from the database`
`44`	`44`	`/// </summary>`
`45`		`- IEnumerable LoadDbValues(Type repositoryEntityType, Type affectedHookEntityType, IEnumerable entities, ResourceHook hook, params RelationshipProxy[] relationships);`
`46`		`- /// <summary>`
`47`		`- /// For a set of entities, loads current values from the database`
`48`		`- /// </summary>`
`49`		`- HashSet<TEntity> LoadDbValues<TEntity>(IEnumerable<TEntity> entities, ResourceHook hook, params RelationshipProxy[] relationships) where TEntity : class, IIdentifiable;`
	`45`	`+ IEnumerable LoadDbValues(Type repositoryEntityType, IEnumerable entities, ResourceHook hook, params RelationshipProxy[] relationships);`
	`46`	`+ bool ShouldLoadDbValues(Type containerEntityType, ResourceHook hook);`
`50`	`47`	`}`
`51`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,8 @@ public interface IAffectedRelationships<TDependent> : IAffectedRelationships whe`
`16`	`16`	`/// <summary>`
`17`	`17`	`/// Gets a dictionary of all entities grouped by affected relationship.`
`18`	`18`	`/// </summary>`
`19`		`- Dictionary<RelationshipAttribute, HashSet<TDependent>> All { get; }`
	`19`	`+ Dictionary<RelationshipAttribute, HashSet<TDependent>> AllByRelationships();`
	`20`	`+`
`20`	`21`	`/// <summary>`
`21`	`22`	`/// Gets a dictionary of all entities that have an affected relationship to type <typeparamref name="TPrincipal"/>`
`22`	`23`	`/// </summary>`
`@@ -31,9 +32,9 @@ public class UpdatedRelationshipHelper<TDependent> : IAffectedRelationships<TDep`
`31`	`32`	`{`
`32`	`33`	`private readonly Dictionary<RelationshipProxy, HashSet<TDependent>> _groups;`
`33`	`34`
`34`		`- public Dictionary<RelationshipAttribute, HashSet<TDependent>> All`
	`35`	`+ public Dictionary<RelationshipAttribute, HashSet<TDependent>> AllByRelationships()`
`35`	`36`	`{`
`36`		`- get { return _groups?.ToDictionary(p => p.Key.Attribute, p => p.Value); }`
	`37`	`+ return _groups?.ToDictionary(p => p.Key.Attribute, p => p.Value);`
`37`	`38`	`}`
`38`	`39`	`public UpdatedRelationshipHelper(Dictionary<RelationshipProxy, IEnumerable> relationships)`
`39`	`40`	`{`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ 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 = _executorHelper.LoadDbValues((IEnumerable<TEntity>)node.UniqueEntities, ResourceHook.BeforeUpdate, node.RelationshipsToNextLayer);`
	`50`	`+ var dbValues = LoadDbValues(typeof(TEntity), (IEnumerable<TEntity>)node.UniqueEntities, ResourceHook.BeforeUpdate, node.RelationshipsToNextLayer);`
`51`	`51`	`var diff = new EntityDiff<TEntity>(node.UniqueEntities, dbValues, node.PrincipalsToNextLayer());`
`52`	`52`	`IEnumerable<TEntity> updated = container.BeforeUpdate(diff, pipeline);`
`53`	`53`	`node.UpdateUnique(updated);`
`@@ -58,6 +58,7 @@ public virtual IEnumerable<TEntity> BeforeUpdate<TEntity>(IEnumerable<TEntity> e`
`58`	`58`	`return entities;`
`59`	`59`	`}`
`60`	`60`
	`61`	`+`
`61`	`62`	`/// <inheritdoc/>`
`62`	`63`	`public virtual IEnumerable<TEntity> BeforeCreate<TEntity>(IEnumerable<TEntity> entities, ResourcePipeline pipeline) where TEntity : class, IIdentifiable`
`63`	`64`	`{`
`@@ -77,7 +78,8 @@ public virtual IEnumerable<TEntity> BeforeDelete<TEntity>(IEnumerable<TEntity> e`
`77`	`78`	`{`
`78`	`79`	`if (GetHook(ResourceHook.BeforeDelete, entities, out var container, out var node))`
`79`	`80`	`{`
`80`		`- IEnumerable<TEntity> updated = container.BeforeDelete((HashSet<TEntity>)node.UniqueEntities, pipeline);`
	`81`	`+ var targetEntities = (LoadDbValues(typeof(TEntity), (IEnumerable<TEntity>)node.UniqueEntities, ResourceHook.BeforeDelete, node.RelationshipsToNextLayer) ?? node.UniqueEntities);`
	`82`	`+ IEnumerable<TEntity> updated = container.BeforeDelete((HashSet<TEntity>)targetEntities, pipeline);`
`81`	`83`	`node.UpdateUnique(updated);`
`82`	`84`	`node.Reassign(entities);`
`83`	`85`	`}`
`@@ -246,7 +248,7 @@ void FireNestedBeforeUpdateHooks(ResourcePipeline pipeline, EntityChildLayer lay`
`246`	`248`	`{`
`247`	`249`	`if (uniqueEntities.Cast<IIdentifiable>().Any())`
`248`	`250`	`{`
`249`		`- var dbValues = _executorHelper.LoadDbValues(entityType, entityType, uniqueEntities, ResourceHook.BeforeUpdateRelationship, node.RelationshipsToNextLayer);`
	`251`	`+ var dbValues = LoadDbValues(entityType, uniqueEntities, ResourceHook.BeforeUpdateRelationship, node.RelationshipsToNextLayer);`
`250`	`252`	`var resourcesByRelationship = CreateRelationshipHelper(entityType, node.RelationshipsFromPreviousLayer.GetDependentEntities(), dbValues);`
`251`	`253`	`var allowedIds = CallHook(nestedHookcontainer, ResourceHook.BeforeUpdateRelationship, new object[] { GetIds(uniqueEntities), resourcesByRelationship, pipeline }).Cast<string>();`
`252`	`254`	`var updated = GetAllowedEntities(uniqueEntities, allowedIds);`
`@@ -381,6 +383,12 @@ RelationshipProxy GetInverseRelationship(RelationshipProxy proxy)`
`381`	`383`	`return new RelationshipProxy(_graph.GetInverseRelationship(proxy.Attribute), proxy.PrincipalType, false);`
`382`	`384`	`}`
`383`	`385`
	`386`	`+ IEnumerable LoadDbValues(Type containerEntityType, IEnumerable uniqueEntities, ResourceHook targetHook, RelationshipProxy[] relationshipsToNextLayer)`
	`387`	`+ {`
	`388`	`+ if (!_executorHelper.ShouldLoadDbValues(containerEntityType, targetHook)) return null;`
	`389`	`+ return _executorHelper.LoadDbValues(containerEntityType, uniqueEntities, targetHook, relationshipsToNextLayer);`
	`390`	`+ }`
	`391`	`+`
`384`	`392`	`void FireAfterUpdateRelationship(IResourceHookContainer container, IEntityNode node, ResourcePipeline pipeline)`
`385`	`393`	`{`
`386`	`394`	`var resourcesByRelationship = CreateRelationshipHelper(node.EntityType, node.RelationshipsFromPreviousLayer.GetDependentEntities());`
Original file line number	Diff line number	Diff line change
`@@ -116,9 +116,10 @@ public virtual async Task<TResource> CreateAsync(TResource resource)`
`116`	`116`	`}`
`117`	`117`	`public virtual async Task<bool> DeleteAsync(TId id)`
`118`	`118`	`{`
`119`		`- var entity = await _entities.GetAsync(id);`
	`119`	`+ var entity = (TEntity)Activator.CreateInstance(typeof(TEntity));`
	`120`	`+ entity.Id = id;`
`120`	`121`	`if (!IsNull(_hookExecutor, entity)) _hookExecutor.BeforeDelete(AsList(entity), ResourcePipeline.Delete);`
`121`		`- var succeeded = await _entities.DeleteAsync(entity);`
	`122`	`+ var succeeded = await _entities.DeleteAsync(entity.Id);`
`122`	`123`	`if (!IsNull(_hookExecutor, entity)) _hookExecutor.AfterDelete(AsList(entity), ResourcePipeline.Delete, succeeded);`
`123`	`124`	`return succeeded;`
`124`	`125`	`}`