More fixes for resources with parameterized constructors

Bart Koelman · Bart Koelman · commit 606f627246c6 · 2020-05-07T16:40:45.000+02:00
diff --git a/src/Examples/JsonApiDotNetCoreExample/Models/ArticleTag.cs b/src/Examples/JsonApiDotNetCoreExample/Models/ArticleTag.cs
@@ -1,4 +1,6 @@
+using System;
 using JsonApiDotNetCore.Models;
+using JsonApiDotNetCoreExample.Data;
 
 namespace JsonApiDotNetCoreExample.Models
 {
@@ -9,8 +11,12 @@ public sealed class ArticleTag
 
         public int TagId { get; set; }
         public Tag Tag { get; set; }
-    }
 
+        public ArticleTag(AppDbContext appDbContext)
+        {
+            if (appDbContext == null) throw new ArgumentNullException(nameof(appDbContext));
+        }
+    }
 
     public class IdentifiableArticleTag : Identifiable
     {
diff --git a/src/JsonApiDotNetCore/Data/DefaultResourceRepository.cs b/src/JsonApiDotNetCore/Data/DefaultResourceRepository.cs
@@ -109,7 +109,7 @@ public virtual async Task CreateAsync(TResource entity)
                     // was already tracked) than the one assigned to the to-be-created entity.
                     // Alternatively, even if we don't have to reassign anything because of already tracked 
                     // entities, we still need to assign the "through" entities in the case of many-to-many.
-                    relationshipAttr.SetValue(entity, trackedRelationshipValue);
+                    relationshipAttr.SetValue(entity, trackedRelationshipValue, _resourceFactory);
             }
             _dbSet.Add(entity);
             await _context.SaveChangesAsync();
@@ -182,7 +182,7 @@ private void DetachRelationships(TResource entity)
                     // trigger a full reload of relationships: the navigation 
                     // property actually needs to be nulled out, otherwise
                     // EF will still add duplicate instances to the collection
-                    relationship.SetValue(entity, null);
+                    relationship.SetValue(entity, null, _resourceFactory);
                 }
                 else
                 {
@@ -216,7 +216,7 @@ public virtual async Task UpdateAsync(TResource requestEntity, TResource databas
                 LoadInverseRelationships(trackedRelationshipValue, relationshipAttr);
                 // assigns the updated relationship to the database entity
                 //AssignRelationshipValue(databaseEntity, trackedRelationshipValue, relationshipAttr);
-                relationshipAttr.SetValue(databaseEntity, trackedRelationshipValue);
+                relationshipAttr.SetValue(databaseEntity, trackedRelationshipValue, _resourceFactory);
             }
 
             await _context.SaveChangesAsync();
diff --git a/src/JsonApiDotNetCore/Hooks/ResourceHookExecutor.cs b/src/JsonApiDotNetCore/Hooks/ResourceHookExecutor.cs
@@ -22,19 +22,22 @@ internal sealed class ResourceHookExecutor : IResourceHookExecutor
         private readonly IIncludeService _includeService;
         private readonly ITargetedFields _targetedFields;
         private readonly IResourceGraph _resourceGraph;
+        private readonly IResourceFactory _resourceFactory;
 
         public ResourceHookExecutor(
             IHookExecutorHelper executorHelper,
             ITraversalHelper traversalHelper,
             ITargetedFields targetedFields,
             IIncludeService includedRelationships,
-            IResourceGraph resourceGraph)
+            IResourceGraph resourceGraph,
+            IResourceFactory resourceFactory)
         {
             _executorHelper = executorHelper;
             _traversalHelper = traversalHelper;
             _targetedFields = targetedFields;
             _includeService = includedRelationships;
             _resourceGraph = resourceGraph;
+            _resourceFactory = resourceFactory;
         }
 
         /// <inheritdoc/>
@@ -57,7 +60,7 @@ public IEnumerable<TResource> BeforeUpdate<TResource>(IEnumerable<TResource> ent
                 var diff = new DiffableEntityHashSet<TResource>(node.UniqueEntities, dbValues, node.LeftsToNextLayer(), _targetedFields);
                 IEnumerable<TResource> updated = container.BeforeUpdate(diff, pipeline);
                 node.UpdateUnique(updated);
-                node.Reassign(entities);
+                node.Reassign(_resourceFactory, entities);
             }
 
             FireNestedBeforeUpdateHooks(pipeline, _traversalHelper.CreateNextLayer(node));
@@ -72,7 +75,7 @@ public IEnumerable<TResource> BeforeCreate<TResource>(IEnumerable<TResource> ent
                 var affected = new EntityHashSet<TResource>((HashSet<TResource>)node.UniqueEntities, node.LeftsToNextLayer());
                 IEnumerable<TResource> updated = container.BeforeCreate(affected, pipeline);
                 node.UpdateUnique(updated);
-                node.Reassign(entities);
+                node.Reassign(_resourceFactory, entities);
             }
             FireNestedBeforeUpdateHooks(pipeline, _traversalHelper.CreateNextLayer(node));
             return entities;
@@ -89,7 +92,7 @@ public IEnumerable<TResource> BeforeDelete<TResource>(IEnumerable<TResource> ent
 
                 IEnumerable<TResource> updated = container.BeforeDelete(affected, pipeline);
                 node.UpdateUnique(updated);
-                node.Reassign(entities);
+                node.Reassign(_resourceFactory, entities);
             }
 
             // If we're deleting an article, we're implicitly affected any owners related to it.
@@ -113,14 +116,14 @@ public IEnumerable<TResource> OnReturn<TResource>(IEnumerable<TResource> entitie
                 IEnumerable<TResource> updated = container.OnReturn((HashSet<TResource>)node.UniqueEntities, pipeline);
                 ValidateHookResponse(updated);
                 node.UpdateUnique(updated);
-                node.Reassign(entities);
+                node.Reassign(_resourceFactory, entities);
             }
 
             Traverse(_traversalHelper.CreateNextLayer(node), ResourceHook.OnReturn, (nextContainer, nextNode) =>
             {
                 var filteredUniqueSet = CallHook(nextContainer, ResourceHook.OnReturn, new object[] { nextNode.UniqueEntities, pipeline });
                 nextNode.UpdateUnique(filteredUniqueSet);
-                nextNode.Reassign();
+                nextNode.Reassign(_resourceFactory);
             });
             return entities;
         }
@@ -270,7 +273,7 @@ private void FireNestedBeforeUpdateHooks(ResourcePipeline pipeline, NodeLayer la
                         var allowedIds = CallHook(nestedHookContainer, ResourceHook.BeforeUpdateRelationship, new object[] { GetIds(uniqueEntities), resourcesByRelationship, pipeline }).Cast<string>();
                         var updated = GetAllowedEntities(uniqueEntities, allowedIds);
                         node.UpdateUnique(updated);
-                        node.Reassign();
+                        node.Reassign(_resourceFactory);
                     }
                 }
 
diff --git a/src/JsonApiDotNetCore/Hooks/Traversal/ChildNode.cs b/src/JsonApiDotNetCore/Hooks/Traversal/ChildNode.cs
@@ -53,8 +53,7 @@ public void UpdateUnique(IEnumerable updated)
         /// <summary>
         /// Reassignment is done according to provided relationships
         /// </summary>
-        /// <param name="updated"></param>
-        public void Reassign(IEnumerable updated = null)
+        public void Reassign(IResourceFactory resourceFactory, IEnumerable updated = null)
         {
             var unique = (HashSet<TResource>)UniqueEntities;
             foreach (var group in _relationshipsFromPreviousLayer)
@@ -70,13 +69,13 @@ public void Reassign(IEnumerable updated = null)
                     {
                         var intersection = relationshipCollection.Intersect(unique, _comparer);
                         IEnumerable typedCollection = intersection.CopyToTypedCollection(relationshipCollection.GetType());
-                        proxy.SetValue(left, typedCollection);
+                        proxy.SetValue(left, typedCollection, resourceFactory);
                     }
                     else if (currentValue is IIdentifiable relationshipSingle)
                     {
                         if (!unique.Intersect(new HashSet<IIdentifiable> { relationshipSingle }, _comparer).Any())
                         {
-                            proxy.SetValue(left, null);
+                            proxy.SetValue(left, null, resourceFactory);
                         }
                     }
                 }
diff --git a/src/JsonApiDotNetCore/Hooks/Traversal/IEntityNode.cs b/src/JsonApiDotNetCore/Hooks/Traversal/IEntityNode.cs
@@ -1,4 +1,5 @@
 using System.Collections;
+using JsonApiDotNetCore.Internal;
 using RightType = System.Type;
 
 namespace JsonApiDotNetCore.Hooks
@@ -30,7 +31,7 @@ internal interface INode
         /// A helper method to assign relationships to the previous layer after firing hooks.
         /// Or, in case of the root node, to update the original source enumerable.
         /// </summary>
-        void Reassign(IEnumerable source = null);
+        void Reassign(IResourceFactory resourceFactory, IEnumerable source = null);
         /// <summary>
         /// A helper method to internally update the unique set of entities as a result of 
         /// a filter action in a hook.
diff --git a/src/JsonApiDotNetCore/Hooks/Traversal/RelationshipProxy.cs b/src/JsonApiDotNetCore/Hooks/Traversal/RelationshipProxy.cs
@@ -2,6 +2,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using JsonApiDotNetCore.Extensions;
+using JsonApiDotNetCore.Internal;
 using JsonApiDotNetCore.Models;
 
 namespace JsonApiDotNetCore.Hooks
@@ -81,7 +82,8 @@ public object GetValue(IIdentifiable entity)
         /// </summary>
         /// <param name="entity">Parent entity.</param>
         /// <param name="value">The relationship value.</param>
-        public void SetValue(IIdentifiable entity, object value)
+        /// <param name="resourceFactory"></param>
+        public void SetValue(IIdentifiable entity, object value, IResourceFactory resourceFactory)
         {
             if (Attribute is HasManyThroughAttribute hasManyThrough)
             {
@@ -108,7 +110,7 @@ public void SetValue(IIdentifiable entity, object value)
                 return;
             }
 
-            Attribute.SetValue(entity, value);
+            Attribute.SetValue(entity, value, resourceFactory);
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Hooks/Traversal/RootNode.cs b/src/JsonApiDotNetCore/Hooks/Traversal/RootNode.cs
@@ -59,7 +59,7 @@ public void UpdateUnique(IEnumerable updated)
             _uniqueEntities = new HashSet<TResource>(intersected);
         }
 
-        public void Reassign(IEnumerable source = null)
+        public void Reassign(IResourceFactory resourceFactory, IEnumerable source = null)
         {
             var ids = _uniqueEntities.Select(ue => ue.StringId);
 
diff --git a/src/JsonApiDotNetCore/Internal/Generics/RepositoryRelationshipUpdateHelper.cs b/src/JsonApiDotNetCore/Internal/Generics/RepositoryRelationshipUpdateHelper.cs
@@ -33,9 +33,12 @@ public interface IRepositoryRelationshipUpdateHelper
     /// <inheritdoc/>
     public class RepositoryRelationshipUpdateHelper<TRelatedResource> : IRepositoryRelationshipUpdateHelper where TRelatedResource : class
     {
+        private readonly IResourceFactory _resourceFactory;
         private readonly DbContext _context;
-        public RepositoryRelationshipUpdateHelper(IDbContextResolver contextResolver)
+
+        public RepositoryRelationshipUpdateHelper(IDbContextResolver contextResolver, IResourceFactory resourceFactory)
         {
+            _resourceFactory = resourceFactory;
             _context = contextResolver.GetContext();
         }
 
@@ -65,7 +68,7 @@ private async Task UpdateOneToOneAsync(IIdentifiable parent, RelationshipAttribu
                 var equalsLambda = Expression.Lambda<Func<TRelatedResource, bool>>(callEquals, parameter);
                 value = await _context.Set<TRelatedResource>().FirstOrDefaultAsync(equalsLambda);
             }
-            relationship.SetValue(parent, value);
+            relationship.SetValue(parent, value, _resourceFactory);
         }
 
         private async Task UpdateOneToManyAsync(IIdentifiable parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds)
@@ -95,7 +98,7 @@ private async Task UpdateOneToManyAsync(IIdentifiable parent, RelationshipAttrib
                 value = resultSet.CopyToTypedCollection(relationship.PropertyInfo.PropertyType);
             }
 
-            relationship.SetValue(parent, value);
+            relationship.SetValue(parent, value, _resourceFactory);
         }
 
         private async Task UpdateManyToManyAsync(IIdentifiable parent, HasManyThroughAttribute relationship, IEnumerable<string> relationshipIds)
@@ -125,7 +128,7 @@ private async Task UpdateManyToManyAsync(IIdentifiable parent, HasManyThroughAtt
 
             var newLinks = relationshipIds.Select(x =>
             {
-                var link = TypeHelper.CreateInstance(relationship.ThroughType);
+                var link = _resourceFactory.CreateInstance(relationship.ThroughType);
                 relationship.LeftIdProperty.SetValue(link, TypeHelper.ConvertType(parentId, relationship.LeftIdProperty.PropertyType));
                 relationship.RightIdProperty.SetValue(link, TypeHelper.ConvertType(x, relationship.RightIdProperty.PropertyType));
                 return link;
diff --git a/src/JsonApiDotNetCore/Internal/IResourceFactory.cs b/src/JsonApiDotNetCore/Internal/IResourceFactory.cs
@@ -10,8 +10,8 @@ namespace JsonApiDotNetCore.Internal
 {
     public interface IResourceFactory
     {
-        public IIdentifiable CreateInstance(Type resourceType);
-        public TResource CreateInstance<TResource>() where TResource : IIdentifiable;
+        public object CreateInstance(Type resourceType);
+        public TResource CreateInstance<TResource>();
         public NewExpression CreateNewExpression(Type resourceType);
     }
 
@@ -24,17 +24,17 @@ public DefaultResourceFactory(IServiceProvider serviceProvider)
             _serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
         }
 
-        public IIdentifiable CreateInstance(Type resourceType)
+        public object CreateInstance(Type resourceType)
         {
             if (resourceType == null)
             {
                 throw new ArgumentNullException(nameof(resourceType));
             }
 
-            return (IIdentifiable) InnerCreateInstance(resourceType, _serviceProvider);
+            return InnerCreateInstance(resourceType, _serviceProvider);
         }
 
-        public TResource CreateInstance<TResource>() where TResource : IIdentifiable
+        public TResource CreateInstance<TResource>()
         {
             return (TResource) InnerCreateInstance(typeof(TResource), _serviceProvider);
         }
diff --git a/src/JsonApiDotNetCore/Internal/TypeHelper.cs b/src/JsonApiDotNetCore/Internal/TypeHelper.cs
@@ -240,7 +240,7 @@ public static object CreateInstance(Type type)
 
         public static object ConvertStringIdToTypedId(Type resourceType, string stringId, IResourceFactory resourceFactory)
         {
-            var tempResource = resourceFactory.CreateInstance(resourceType);
+            var tempResource = (IIdentifiable)resourceFactory.CreateInstance(resourceType);
             tempResource.StringId = stringId;
             return GetResourceTypedId(tempResource);
         }
diff --git a/src/JsonApiDotNetCore/Models/Annotation/HasManyThroughAttribute.cs b/src/JsonApiDotNetCore/Models/Annotation/HasManyThroughAttribute.cs
@@ -86,9 +86,9 @@ public override object GetValue(object entity)
         }
 
         /// <inheritdoc />
-        public override void SetValue(object entity, object newValue)
+        public override void SetValue(object entity, object newValue, IResourceFactory resourceFactory)
         {
-            base.SetValue(entity, newValue);
+            base.SetValue(entity, newValue, resourceFactory);
 
             if (newValue == null)
             {
@@ -99,7 +99,7 @@ public override void SetValue(object entity, object newValue)
                 List<object> joinEntities = new List<object>();
                 foreach (IIdentifiable resource in (IEnumerable)newValue)
                 {
-                    object joinEntity = TypeHelper.CreateInstance(ThroughType);
+                    object joinEntity = resourceFactory.CreateInstance(ThroughType);
                     LeftProperty.SetValue(joinEntity, entity);
                     RightProperty.SetValue(joinEntity, resource);
                     joinEntities.Add(joinEntity);
diff --git a/src/JsonApiDotNetCore/Models/Annotation/HasOneAttribute.cs b/src/JsonApiDotNetCore/Models/Annotation/HasOneAttribute.cs
@@ -47,7 +47,7 @@ public HasOneAttribute(string publicName = null, Link links = Link.NotConfigured
             : _explicitIdentifiablePropertyName;
 
         /// <inheritdoc />
-        public override void SetValue(object entity, object newValue)
+        public override void SetValue(object entity, object newValue, IResourceFactory resourceFactory)
         {
             string propertyName = PropertyInfo.Name;
             // if we're deleting the relationship (setting it to null),
diff --git a/src/JsonApiDotNetCore/Models/Annotation/RelationshipAttribute.cs b/src/JsonApiDotNetCore/Models/Annotation/RelationshipAttribute.cs
@@ -62,7 +62,7 @@ public virtual object GetValue(object entity)
         /// <summary>
         /// Sets the value of the resource property this attributes was declared on.
         /// </summary>
-        public virtual void SetValue(object entity, object newValue)
+        public virtual void SetValue(object entity, object newValue, IResourceFactory resourceFactory)
         {
             PropertyInfo.SetValue(entity, newValue);
         }
diff --git a/src/JsonApiDotNetCore/Serialization/Client/ResponseDeserializer.cs b/src/JsonApiDotNetCore/Serialization/Client/ResponseDeserializer.cs
@@ -65,13 +65,13 @@ protected override void AfterProcessField(IIdentifiable entity, IResourceField f
             {
                 // add attributes and relationships of a parsed HasOne relationship
                 var rio = data.SingleData;
-                hasOneAttr.SetValue(entity, rio == null ? null : ParseIncludedRelationship(hasOneAttr, rio));
+                hasOneAttr.SetValue(entity, rio == null ? null : ParseIncludedRelationship(hasOneAttr, rio), _resourceFactory);
             }
             else if (field is HasManyAttribute hasManyAttr)
             {  // add attributes and relationships of a parsed HasMany relationship
                 var items = data.ManyData.Select(rio => ParseIncludedRelationship(hasManyAttr, rio));
                 var values = items.CopyToTypedCollection(hasManyAttr.PropertyInfo.PropertyType);
-                hasManyAttr.SetValue(entity, values);
+                hasManyAttr.SetValue(entity, values, _resourceFactory);
             }
         }
 
diff --git a/src/JsonApiDotNetCore/Serialization/Common/BaseDocumentParser.cs b/src/JsonApiDotNetCore/Serialization/Common/BaseDocumentParser.cs
@@ -22,7 +22,7 @@ namespace JsonApiDotNetCore.Serialization
     public abstract class BaseDocumentParser
     {
         protected readonly IResourceContextProvider _contextProvider;
-        private readonly IResourceFactory _resourceFactory;
+        protected readonly IResourceFactory _resourceFactory;
         protected Document _document;
 
         protected BaseDocumentParser(IResourceContextProvider contextProvider, IResourceFactory resourceFactory)
@@ -142,7 +142,7 @@ private IIdentifiable ParseResourceObject(ResourceObject data)
                     "If you have manually registered the resource, check that the call to AddResource correctly sets the public name.", null);
             }
 
-            var entity = _resourceFactory.CreateInstance(resourceContext.ResourceType);
+            var entity = (IIdentifiable)_resourceFactory.CreateInstance(resourceContext.ResourceType);
 
             entity = SetAttributes(entity, data.Attributes, resourceContext.Attributes);
             entity = SetRelationships(entity, data.Relationships, resourceContext.Relationships);
@@ -211,13 +211,13 @@ private void SetNavigation(IIdentifiable entity, HasOneAttribute attr, string re
         {
             if (relatedId == null)
             {
-                attr.SetValue(entity, null);
+                attr.SetValue(entity, null, _resourceFactory);
             }
             else
             {
-                var relatedInstance = _resourceFactory.CreateInstance(attr.RightType);
+                var relatedInstance = (IIdentifiable)_resourceFactory.CreateInstance(attr.RightType);
                 relatedInstance.StringId = relatedId;
-                attr.SetValue(entity, relatedInstance);
+                attr.SetValue(entity, relatedInstance, _resourceFactory);
             }
         }
 
@@ -239,7 +239,7 @@ private void SetHasManyRelationship(
                 });
 
                 var convertedCollection = relatedResources.CopyToTypedCollection(attr.PropertyInfo.PropertyType);
-                attr.SetValue(entity, convertedCollection);
+                attr.SetValue(entity, convertedCollection, _resourceFactory);
             }
 
             AfterProcessField(entity, attr, relationshipData);
diff --git a/test/JsonApiDotNetCoreExampleTests/Acceptance/ManyToManyTests.cs b/test/JsonApiDotNetCoreExampleTests/Acceptance/ManyToManyTests.cs
diff --git a/test/JsonApiDotNetCoreExampleTests/Acceptance/ResourceDefinitions/ResourceDefinitionTests.cs b/test/JsonApiDotNetCoreExampleTests/Acceptance/ResourceDefinitions/ResourceDefinitionTests.cs
diff --git a/test/UnitTests/ResourceHooks/ResourceHooksTestsSetup.cs b/test/UnitTests/ResourceHooks/ResourceHooksTestsSetup.cs

Original file line number	Diff line number	Diff line change
`@@ -109,7 +109,7 @@ public virtual async Task CreateAsync(TResource entity)`
`109`	`109`	`// was already tracked) than the one assigned to the to-be-created entity.`
`110`	`110`	`// Alternatively, even if we don't have to reassign anything because of already tracked`
`111`	`111`	`// entities, we still need to assign the "through" entities in the case of many-to-many.`
`112`		`- relationshipAttr.SetValue(entity, trackedRelationshipValue);`
	`112`	`+ relationshipAttr.SetValue(entity, trackedRelationshipValue, _resourceFactory);`
`113`	`113`	`}`
`114`	`114`	`_dbSet.Add(entity);`
`115`	`115`	`await _context.SaveChangesAsync();`
`@@ -182,7 +182,7 @@ private void DetachRelationships(TResource entity)`
`182`	`182`	`// trigger a full reload of relationships: the navigation`
`183`	`183`	`// property actually needs to be nulled out, otherwise`
`184`	`184`	`// EF will still add duplicate instances to the collection`
`185`		`- relationship.SetValue(entity, null);`
	`185`	`+ relationship.SetValue(entity, null, _resourceFactory);`
`186`	`186`	`}`
`187`	`187`	`else`
`188`	`188`	`{`
`@@ -216,7 +216,7 @@ public virtual async Task UpdateAsync(TResource requestEntity, TResource databas`
`216`	`216`	`LoadInverseRelationships(trackedRelationshipValue, relationshipAttr);`
`217`	`217`	`// assigns the updated relationship to the database entity`
`218`	`218`	`//AssignRelationshipValue(databaseEntity, trackedRelationshipValue, relationshipAttr);`
`219`		`- relationshipAttr.SetValue(databaseEntity, trackedRelationshipValue);`
	`219`	`+ relationshipAttr.SetValue(databaseEntity, trackedRelationshipValue, _resourceFactory);`
`220`	`220`	`}`
`221`	`221`
`222`	`222`	`await _context.SaveChangesAsync();`
Original file line number	Diff line number	Diff line change
`@@ -53,8 +53,7 @@ public void UpdateUnique(IEnumerable updated)`
`53`	`53`	`/// <summary>`
`54`	`54`	`/// Reassignment is done according to provided relationships`
`55`	`55`	`/// </summary>`
`56`		`- /// <param name="updated"></param>`
`57`		`- public void Reassign(IEnumerable updated = null)`
	`56`	`+ public void Reassign(IResourceFactory resourceFactory, IEnumerable updated = null)`
`58`	`57`	`{`
`59`	`58`	`var unique = (HashSet<TResource>)UniqueEntities;`
`60`	`59`	`foreach (var group in _relationshipsFromPreviousLayer)`
`@@ -70,13 +69,13 @@ public void Reassign(IEnumerable updated = null)`
`70`	`69`	`{`
`71`	`70`	`var intersection = relationshipCollection.Intersect(unique, _comparer);`
`72`	`71`	`IEnumerable typedCollection = intersection.CopyToTypedCollection(relationshipCollection.GetType());`
`73`		`- proxy.SetValue(left, typedCollection);`
	`72`	`+ proxy.SetValue(left, typedCollection, resourceFactory);`
`74`	`73`	`}`
`75`	`74`	`else if (currentValue is IIdentifiable relationshipSingle)`
`76`	`75`	`{`
`77`	`76`	`if (!unique.Intersect(new HashSet<IIdentifiable> { relationshipSingle }, _comparer).Any())`
`78`	`77`	`{`
`79`		`- proxy.SetValue(left, null);`
	`78`	`+ proxy.SetValue(left, null, resourceFactory);`
`80`	`79`	`}`
`81`	`80`	`}`
`82`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`using System.Collections;`
`3`	`3`	`using System.Collections.Generic;`
`4`	`4`	`using JsonApiDotNetCore.Extensions;`
	`5`	`+using JsonApiDotNetCore.Internal;`
`5`	`6`	`using JsonApiDotNetCore.Models;`
`6`	`7`
`7`	`8`	`namespace JsonApiDotNetCore.Hooks`
`@@ -81,7 +82,8 @@ public object GetValue(IIdentifiable entity)`
`81`	`82`	`/// </summary>`
`82`	`83`	`/// <param name="entity">Parent entity.</param>`
`83`	`84`	`/// <param name="value">The relationship value.</param>`
`84`		`- public void SetValue(IIdentifiable entity, object value)`
	`85`	`+ /// <param name="resourceFactory"></param>`
	`86`	`+ public void SetValue(IIdentifiable entity, object value, IResourceFactory resourceFactory)`
`85`	`87`	`{`
`86`	`88`	`if (Attribute is HasManyThroughAttribute hasManyThrough)`
`87`	`89`	`{`
`@@ -108,7 +110,7 @@ public void SetValue(IIdentifiable entity, object value)`
`108`	`110`	`return;`
`109`	`111`	`}`
`110`	`112`
`111`		`- Attribute.SetValue(entity, value);`
	`113`	`+ Attribute.SetValue(entity, value, resourceFactory);`
`112`	`114`	`}`
`113`	`115`	`}`
`114`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ public void UpdateUnique(IEnumerable updated)`
`59`	`59`	`_uniqueEntities = new HashSet<TResource>(intersected);`
`60`	`60`	`}`
`61`	`61`
`62`		`- public void Reassign(IEnumerable source = null)`
	`62`	`+ public void Reassign(IResourceFactory resourceFactory, IEnumerable source = null)`
`63`	`63`	`{`
`64`	`64`	`var ids = _uniqueEntities.Select(ue => ue.StringId);`
`65`	`65`
Original file line number	Diff line number	Diff line change
`@@ -33,9 +33,12 @@ public interface IRepositoryRelationshipUpdateHelper`
`33`	`33`	`/// <inheritdoc/>`
`34`	`34`	`public class RepositoryRelationshipUpdateHelper<TRelatedResource> : IRepositoryRelationshipUpdateHelper where TRelatedResource : class`
`35`	`35`	`{`
	`36`	`+ private readonly IResourceFactory _resourceFactory;`
`36`	`37`	`private readonly DbContext _context;`
`37`		`- public RepositoryRelationshipUpdateHelper(IDbContextResolver contextResolver)`
	`38`	`+`
	`39`	`+ public RepositoryRelationshipUpdateHelper(IDbContextResolver contextResolver, IResourceFactory resourceFactory)`
`38`	`40`	`{`
	`41`	`+ _resourceFactory = resourceFactory;`
`39`	`42`	`_context = contextResolver.GetContext();`
`40`	`43`	`}`
`41`	`44`
`@@ -65,7 +68,7 @@ private async Task UpdateOneToOneAsync(IIdentifiable parent, RelationshipAttribu`
`65`	`68`	`var equalsLambda = Expression.Lambda<Func<TRelatedResource, bool>>(callEquals, parameter);`
`66`	`69`	`value = await _context.Set<TRelatedResource>().FirstOrDefaultAsync(equalsLambda);`
`67`	`70`	`}`
`68`		`- relationship.SetValue(parent, value);`
	`71`	`+ relationship.SetValue(parent, value, _resourceFactory);`
`69`	`72`	`}`
`70`	`73`
`71`	`74`	`private async Task UpdateOneToManyAsync(IIdentifiable parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds)`
`@@ -95,7 +98,7 @@ private async Task UpdateOneToManyAsync(IIdentifiable parent, RelationshipAttrib`
`95`	`98`	`value = resultSet.CopyToTypedCollection(relationship.PropertyInfo.PropertyType);`
`96`	`99`	`}`
`97`	`100`
`98`		`- relationship.SetValue(parent, value);`
	`101`	`+ relationship.SetValue(parent, value, _resourceFactory);`
`99`	`102`	`}`
`100`	`103`
`101`	`104`	`private async Task UpdateManyToManyAsync(IIdentifiable parent, HasManyThroughAttribute relationship, IEnumerable<string> relationshipIds)`
`@@ -125,7 +128,7 @@ private async Task UpdateManyToManyAsync(IIdentifiable parent, HasManyThroughAtt`
`125`	`128`
`126`	`129`	`var newLinks = relationshipIds.Select(x =>`
`127`	`130`	`{`
`128`		`- var link = TypeHelper.CreateInstance(relationship.ThroughType);`
	`131`	`+ var link = _resourceFactory.CreateInstance(relationship.ThroughType);`
`129`	`132`	`relationship.LeftIdProperty.SetValue(link, TypeHelper.ConvertType(parentId, relationship.LeftIdProperty.PropertyType));`
`130`	`133`	`relationship.RightIdProperty.SetValue(link, TypeHelper.ConvertType(x, relationship.RightIdProperty.PropertyType));`
`131`	`134`	`return link;`
Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,8 @@ namespace JsonApiDotNetCore.Internal`
`10`	`10`	`{`
`11`	`11`	`public interface IResourceFactory`
`12`	`12`	`{`
`13`		`- public IIdentifiable CreateInstance(Type resourceType);`
`14`		`- public TResource CreateInstance<TResource>() where TResource : IIdentifiable;`
	`13`	`+ public object CreateInstance(Type resourceType);`
	`14`	`+ public TResource CreateInstance<TResource>();`
`15`	`15`	`public NewExpression CreateNewExpression(Type resourceType);`
`16`	`16`	`}`
`17`	`17`
`@@ -24,17 +24,17 @@ public DefaultResourceFactory(IServiceProvider serviceProvider)`
`24`	`24`	`_serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));`
`25`	`25`	`}`
`26`	`26`
`27`		`- public IIdentifiable CreateInstance(Type resourceType)`
	`27`	`+ public object CreateInstance(Type resourceType)`
`28`	`28`	`{`
`29`	`29`	`if (resourceType == null)`
`30`	`30`	`{`
`31`	`31`	`throw new ArgumentNullException(nameof(resourceType));`
`32`	`32`	`}`
`33`	`33`
`34`		`- return (IIdentifiable) InnerCreateInstance(resourceType, _serviceProvider);`
	`34`	`+ return InnerCreateInstance(resourceType, _serviceProvider);`
`35`	`35`	`}`
`36`	`36`
`37`		`- public TResource CreateInstance<TResource>() where TResource : IIdentifiable`
	`37`	`+ public TResource CreateInstance<TResource>()`
`38`	`38`	`{`
`39`	`39`	`return (TResource) InnerCreateInstance(typeof(TResource), _serviceProvider);`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -240,7 +240,7 @@ public static object CreateInstance(Type type)`
`240`	`240`
`241`	`241`	`public static object ConvertStringIdToTypedId(Type resourceType, string stringId, IResourceFactory resourceFactory)`
`242`	`242`	`{`
`243`		`- var tempResource = resourceFactory.CreateInstance(resourceType);`
	`243`	`+ var tempResource = (IIdentifiable)resourceFactory.CreateInstance(resourceType);`
`244`	`244`	`tempResource.StringId = stringId;`
`245`	`245`	`return GetResourceTypedId(tempResource);`
`246`	`246`	`}`