implement creation of HasManyThrough relationships

Author: jaredcnance

src/JsonApiDotNetCore/Builders/ContextGraphBuilder.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -172,10 +173,17 @@ protected virtual List<RelationshipAttribute> GetRelationships(Type entityType)
                     if(throughProperty == null)
                         throw new JsonApiSetupException($"Invalid '{nameof(HasManyThroughAttribute)}' on type '{entityType}'. Type does not contain a property named '{hasManyThroughAttribute.InternalThroughName}'.");
 
+                    if(throughProperty.PropertyType.Implements<IList>() == false)
+                        throw new JsonApiSetupException($"Invalid '{nameof(HasManyThroughAttribute)}' on type '{entityType}.{throughProperty.Name}'. Property type does not implement IList.");
+                    
                     // assumption: the property should be a generic collection, e.g. List<ArticleTag>
                     if(throughProperty.PropertyType.IsGenericType == false)
                         throw new JsonApiSetupException($"Invalid '{nameof(HasManyThroughAttribute)}' on type '{entityType}'. Expected through entity to be a generic type, such as List<{prop.PropertyType}>.");
 
+                    // Article → List<ArticleTag>
+                    hasManyThroughAttribute.ThroughProperty = throughProperty;
+
+                    // ArticleTag
                     hasManyThroughAttribute.ThroughType = throughProperty.PropertyType.GetGenericArguments()[0];
 
                     var throughProperties = hasManyThroughAttribute.ThroughType.GetProperties();

src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
@@ -143,17 +144,17 @@ public virtual async Task<TEntity> GetAndIncludeAsync(TId id, string relationshi
         /// <inheritdoc />
         public virtual async Task<TEntity> CreateAsync(TEntity entity)
         {
-            AttachRelationships();
+            AttachRelationships(entity);
             _dbSet.Add(entity);
 
             await _context.SaveChangesAsync();
 
             return entity;
         }
 
-        protected virtual void AttachRelationships()
+        protected virtual void AttachRelationships(TEntity entity = null)
         {
-            AttachHasManyPointers();
+            AttachHasManyPointers(entity);
             AttachHasOnePointers();
         }
 
@@ -183,15 +184,42 @@ public void DetachRelationshipPointers(TEntity entity)
         /// This is used to allow creation of HasMany relationships when the
         /// dependent side of the relationship already exists.
         /// </summary>
-        private void AttachHasManyPointers()
+        private void AttachHasManyPointers(TEntity entity)
         {
             var relationships = _jsonApiContext.HasManyRelationshipPointers.Get();
             foreach (var relationship in relationships)
             {
-                foreach (var pointer in relationship.Value)
-                {
-                    _context.Entry(pointer).State = EntityState.Unchanged;
-                }
+                if(relationship.Key is HasManyThroughAttribute hasManyThrough)
+                    AttachHasManyThrough(entity, hasManyThrough, relationship.Value);
+                else
+                    AttachHasMany(relationship.Key as HasManyAttribute, relationship.Value);                
+            }
+        }
+
+        private void AttachHasMany(HasManyAttribute relationship, IList pointers)
+        {
+            foreach (var pointer in pointers)
+            {
+                _context.Entry(pointer).State = EntityState.Unchanged;
+            }
+        }
+
+        private void AttachHasManyThrough(TEntity entity, HasManyThroughAttribute hasManyThrough, IList pointers)
+        {
+            // create the collection (e.g. List<ArticleTag>)
+            // this type MUST implement IList so we can build the collection
+            // if this is problematic, we _could_ reflect on the type and find an Add method
+            // or we might be able to create a proxy type and implement the enumerator
+            var throughRelationshipCollection = Activator.CreateInstance(hasManyThrough.ThroughProperty.PropertyType) as IList;
+            hasManyThrough.ThroughProperty.SetValue(entity, throughRelationshipCollection);
+            foreach (var pointer in pointers)
+            {
+                _context.Entry(pointer).State = EntityState.Unchanged;
+
+                var throughInstance = Activator.CreateInstance(hasManyThrough.ThroughType);
+                hasManyThrough.LeftProperty.SetValue(throughInstance, entity);
+                hasManyThrough.RightProperty.SetValue(throughInstance, pointer);
+                throughRelationshipCollection.Add(throughInstance);
             }
         }
 

src/JsonApiDotNetCore/Extensions/TypeExtensions.cs

@@ -67,5 +67,17 @@ private static object CreateNewInstance(Type type)
                 throw new JsonApiException(500, $"Type '{type}' cannot be instantiated using the default constructor.", e);
             }
         }
+
+        /// <summary>
+        /// Whether or not a type implements an interface.
+        /// </summary>
+        public static bool Implements<T>(this Type concreteType) 
+            => Implements(concreteType, typeof(T));
+
+        /// <summary>
+        /// Whether or not a type implements an interface.
+        /// </summary>
+        public static bool Implements(this Type concreteType, Type interfaceType) 
+            => interfaceType?.IsAssignableFrom(concreteType) == true;
     }
 }

src/JsonApiDotNetCore/Models/HasManyThroughAttribute.cs

@@ -5,6 +5,7 @@ namespace JsonApiDotNetCore.Models
 {
     /// <summary>
     /// Create a HasMany relationship through a many-to-many join relationship.
+    /// This type can only be applied on types that implement IList.
     /// </summary>
     /// 
     /// <example>
@@ -109,6 +110,21 @@ public HasManyThroughAttribute(string publicName, string internalThroughName, Li
         /// </example>
         public PropertyInfo RightProperty { get; internal set; }
 
+        /// <summary>
+        /// The join entity property on the parent resource.
+        /// </summary>
+        /// 
+        /// <example>
+        /// In the `[HasManyThrough("tags", nameof(ArticleTags))]` example
+        /// this would point to the `Article.ArticleTags` property
+        ///
+        /// <code>
+        /// public List&lt;ArticleTags&gt; ArticleTags { get; set; }
+        /// </code>
+        ///
+        /// </example>
+        public PropertyInfo ThroughProperty { get; internal set; }
+
         /// <inheritdoc />
         /// <example>
         /// "ArticleTags.Tag"

src/JsonApiDotNetCore/Models/RelationshipAttribute.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Reflection;
 
 namespace JsonApiDotNetCore.Models
 {

test/UnitTests/Extensions/TypeExtensions_Tests.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using JsonApiDotNetCore.Extensions;
 using JsonApiDotNetCore.Models;
@@ -36,6 +37,32 @@ public void New_Creates_An_Instance_If_T_Implements_Interface()
             Assert.IsType<Model>(instance);
         }
 
+        [Fact]
+        public void Implements_Returns_True_If_Type_Implements_Interface()
+        {
+            // arrange
+            var type = typeof(Model);
+
+            // act
+            var result = type.Implements<IIdentifiable>();
+
+            // assert
+            Assert.True(result);
+        }
+
+        [Fact]
+        public void Implements_Returns_False_If_Type_DoesNot_Implement_Interface()
+        {
+            // arrange
+            var type = typeof(String);
+
+            // act
+            var result = type.Implements<IIdentifiable>();
+
+            // assert
+            Assert.False(result);
+        }
+
         private class Model : IIdentifiable
         {
             public string StringId { get; set; }