fix test

Author: jaredcnance

src/JsonApiDotNetCore/Builders/ContextGraphBuilder.cs

@@ -188,13 +188,23 @@ protected virtual List<RelationshipAttribute> GetRelationships(Type entityType)
 
                     var throughProperties = hasManyThroughAttribute.ThroughType.GetProperties();
 
-                    // Article → ArticleTag.Article
+                    // ArticleTag.Article
                     hasManyThroughAttribute.LeftProperty = throughProperties.SingleOrDefault(x => x.PropertyType == entityType)
                         ?? throw new JsonApiSetupException($"{hasManyThroughAttribute.ThroughType} does not contain a navigation property to type {entityType}");
 
+                    // ArticleTag.ArticleId
+                    var leftIdPropertyName = JsonApiOptions.RelatedIdMapper.GetRelatedIdPropertyName(hasManyThroughAttribute.LeftProperty.Name);
+                    hasManyThroughAttribute.LeftIdProperty = throughProperties.SingleOrDefault(x => x.Name == leftIdPropertyName)
+                        ?? throw new JsonApiSetupException($"{hasManyThroughAttribute.ThroughType} does not contain a relationship id property to type {entityType} with name {leftIdPropertyName}");
+
                     // Article → ArticleTag.Tag
                     hasManyThroughAttribute.RightProperty = throughProperties.SingleOrDefault(x => x.PropertyType == hasManyThroughAttribute.Type)
                         ?? throw new JsonApiSetupException($"{hasManyThroughAttribute.ThroughType} does not contain a navigation property to type {hasManyThroughAttribute.Type}");
+                    
+                    // ArticleTag.TagId
+                    var rightIdPropertyName = JsonApiOptions.RelatedIdMapper.GetRelatedIdPropertyName(hasManyThroughAttribute.RightProperty.Name);
+                    hasManyThroughAttribute.RightIdProperty = throughProperties.SingleOrDefault(x => x.Name == rightIdPropertyName)
+                        ?? throw new JsonApiSetupException($"{hasManyThroughAttribute.ThroughType} does not contain a relationship id property to type {hasManyThroughAttribute.Type} with name {rightIdPropertyName}");
                 }
             }
 

src/JsonApiDotNetCore/Configuration/JsonApiOptions.cs

@@ -22,6 +22,11 @@ public class JsonApiOptions
         /// </summary>
         public static IResourceNameFormatter ResourceNameFormatter { get; set; } = new DefaultResourceNameFormatter();
 
+        /// <summary>
+        /// Provides an interface for formatting relationship id properties given the navigation property name
+        /// </summary>
+        public static IRelatedIdMapper RelatedIdMapper { get; set; } = new DefaultRelatedIdMapper();
+
         /// <summary>
         /// Whether or not stack traces should be serialized in Error objects
         /// </summary>

src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs

@@ -259,7 +259,15 @@ public virtual async Task<TEntity> UpdateAsync(TId id, TEntity entity)
         /// <inheritdoc />
         public async Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds)
         {
-            var genericProcessor = _genericProcessorFactory.GetProcessor<IGenericProcessor>(typeof(GenericProcessor<>), relationship.Type);
+            // TODO: it would be better to let this be determined within the relationship attribute...
+            // need to think about the right way to do that since HasMany doesn't need to think about this
+            // and setting the HasManyThrough.Type to the join type (ArticleTag instead of Tag) for this changes the semantics
+            // of the property...
+            var typeToUpdate = (relationship is HasManyThroughAttribute hasManyThrough)
+                ? hasManyThrough.ThroughType
+                : relationship.Type;
+
+            var genericProcessor = _genericProcessorFactory.GetProcessor<IGenericProcessor>(typeof(GenericProcessor<>), typeToUpdate);
             await genericProcessor.UpdateRelationshipsAsync(parent, relationship, relationshipIds);
         }
 

src/JsonApiDotNetCore/Extensions/TypeExtensions.cs

@@ -79,5 +79,17 @@ public static bool Implements<T>(this Type concreteType)
         /// </summary>
         public static bool Implements(this Type concreteType, Type interfaceType) 
             => interfaceType?.IsAssignableFrom(concreteType) == true;
+
+        /// <summary>
+        /// Whether or not a type inherits a base type.
+        /// </summary>
+        public static bool Inherits<T>(this Type concreteType) 
+            => Inherits(concreteType, typeof(T));
+
+        /// <summary>
+        /// Whether or not a type inherits a base type.
+        /// </summary>
+        public static bool Inherits(this Type concreteType, Type interfaceType) 
+            => interfaceType?.IsAssignableFrom(concreteType) == true;
     }
 }

src/JsonApiDotNetCore/Graph/ResourceIdMapper.cs

@@ -0,0 +1,27 @@
+namespace JsonApiDotNetCore.Graph
+{
+    /// <summary>
+    /// Provides an interface for formatting relationship identifiers from the navigation property name
+    /// </summary>
+    public interface IRelatedIdMapper
+    {
+        /// <summary>
+        /// Get the internal property name for the database mapped identifier property
+        /// </summary>
+        ///
+        /// <example>
+        /// <code>
+        /// DefaultResourceNameFormatter.FormatId("Article");
+        /// // "ArticleId"
+        /// </code>
+        /// </example>
+        string GetRelatedIdPropertyName(string propertyName);
+    }
+
+    /// <inheritdoc />
+    public class DefaultRelatedIdMapper : IRelatedIdMapper
+    {
+        /// <inheritdoc />
+        public string GetRelatedIdPropertyName(string propertyName) => propertyName + "Id";
+    }
+}

src/JsonApiDotNetCore/Internal/Generics/GenericProcessor.cs

@@ -16,7 +16,7 @@ public interface IGenericProcessor
         void SetRelationships(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds);
     }
 
-    public class GenericProcessor<T> : IGenericProcessor where T : class, IIdentifiable
+    public class GenericProcessor<T> : IGenericProcessor where T : class
     {
         private readonly DbContext _context;
         public GenericProcessor(IDbContextResolver contextResolver)
@@ -33,39 +33,51 @@ public virtual async Task UpdateRelationshipsAsync(object parent, RelationshipAt
 
         public virtual void SetRelationships(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds)
         {
-            if (relationship is HasManyThroughAttribute hasManyThrough)
+            if (relationship is HasManyThroughAttribute hasManyThrough && parent is IIdentifiable identifiableParent)
             {
-                var parentId = ((IIdentifiable)parent).StringId;
-                ParameterExpression parameter = Expression.Parameter(hasManyThrough.Type);
-                Expression property = Expression.Property(parameter, hasManyThrough.LeftProperty);
+                // ArticleTag
+                ParameterExpression parameter = Expression.Parameter(hasManyThrough.ThroughType);
+
+                // ArticleTag.ArticleId
+                Expression property = Expression.Property(parameter, hasManyThrough.LeftIdProperty);
+
+                // article.Id
+                var parentId = TypeHelper.ConvertType(identifiableParent.StringId, hasManyThrough.LeftIdProperty.PropertyType);
                 Expression target = Expression.Constant(parentId);
-                Expression toString = Expression.Call(property, "ToString", null, null);
-                Expression equals = Expression.Call(toString, "Equals", null, target);
-                Expression<Func<object, bool>> lambda = Expression.Lambda<Func<object, bool>>(equals, parameter);
+
+                // ArticleTag.ArticleId.Equals(article.Id)
+                Expression equals = Expression.Call(property, "Equals", null, target);
+
+                var lambda = Expression.Lambda<Func<T, bool>>(equals, parameter);
 
                 var oldLinks = _context
-                    .Set(hasManyThrough.ThroughType)
+                    .Set<T>()
                     .Where(lambda.Compile())
                     .ToList();
 
-                _context.Remove(oldLinks);
+                // TODO: we shouldn't need to do this and it especially shouldn't happen outside a transaction
+                //       instead we should try updating the existing?
+                _context.RemoveRange(oldLinks);
 
                 var newLinks = relationshipIds.Select(x => {
                     var link = Activator.CreateInstance(hasManyThrough.ThroughType);
-                    hasManyThrough.LeftProperty.SetValue(link, TypeHelper.ConvertType(parent, hasManyThrough.LeftProperty.PropertyType));
-                    hasManyThrough.RightProperty.SetValue(link, TypeHelper.ConvertType(x, hasManyThrough.RightProperty.PropertyType));
+                    hasManyThrough.LeftIdProperty.SetValue(link, TypeHelper.ConvertType(parentId, hasManyThrough.LeftIdProperty.PropertyType));
+                    hasManyThrough.RightIdProperty.SetValue(link, TypeHelper.ConvertType(x, hasManyThrough.RightIdProperty.PropertyType));
                     return link;
                 });
+
                 _context.AddRange(newLinks);
             }
             else if (relationship.IsHasMany)
             {
-                var entities = _context.Set<T>().Where(x => relationshipIds.Contains(x.StringId)).ToList();
+                // TODO: need to handle the failure mode when the relationship does not implement IIdentifiable
+                var entities = _context.Set<T>().Where(x => relationshipIds.Contains(((IIdentifiable)x).StringId)).ToList();
                 relationship.SetValue(parent, entities);
             }
             else
             {
-                var entity = _context.Set<T>().SingleOrDefault(x => relationshipIds.First() == x.StringId);
+                // TODO: need to handle the failure mode when the relationship does not implement IIdentifiable
+                var entity = _context.Set<T>().SingleOrDefault(x => relationshipIds.First() == ((IIdentifiable)x).StringId);
                 relationship.SetValue(parent, entity);
             }
         }

src/JsonApiDotNetCore/Models/HasManyThroughAttribute.cs

@@ -95,6 +95,21 @@ public HasManyThroughAttribute(string publicName, string internalThroughName, Li
         /// </example>
         public PropertyInfo LeftProperty { get; internal set; }
 
+        /// <summary>
+        /// The id property back to the parent resource from the join type.
+        /// </summary>
+        /// 
+        /// <example>
+        /// In the `[HasManyThrough("tags", nameof(ArticleTags))]` example
+        /// this would point to the `Article.ArticleTags.ArticleId` property
+        ///
+        /// <code>
+        /// public int ArticleId { get; set; }
+        /// </code>
+        ///
+        /// </example>
+        public PropertyInfo LeftIdProperty { get; internal set; }
+
         /// <summary>
         /// The navigation property to the related resource from the join type.
         /// </summary>
@@ -110,6 +125,21 @@ public HasManyThroughAttribute(string publicName, string internalThroughName, Li
         /// </example>
         public PropertyInfo RightProperty { get; internal set; }
 
+        /// <summary>
+        /// The id property to the related resource from the join type.
+        /// </summary>
+        /// 
+        /// <example>
+        /// In the `[HasManyThrough("tags", nameof(ArticleTags))]` example
+        /// this would point to the `Article.ArticleTags.TagId` property
+        ///
+        /// <code>
+        /// public int TagId { get; set; }
+        /// </code>
+        ///
+        /// </example>
+        public PropertyInfo RightIdProperty { get; internal set; }
+
         /// <summary>
         /// The join entity property on the parent resource.
         /// </summary>

src/JsonApiDotNetCore/Models/HasOneAttribute.cs

@@ -1,4 +1,5 @@
 using System;
+using JsonApiDotNetCore.Configuration;
 
 namespace JsonApiDotNetCore.Models
 {
@@ -38,7 +39,7 @@ public HasOneAttribute(string publicName = null, Link documentLinks = Link.All,
         /// The independent resource identifier.
         /// </summary>
         public string IdentifiablePropertyName => string.IsNullOrWhiteSpace(_explicitIdentifiablePropertyName)
-            ? $"{InternalRelationshipName}Id"
+            ? JsonApiOptions.RelatedIdMapper.GetRelatedIdPropertyName(InternalRelationshipName)
             : _explicitIdentifiablePropertyName;
 
         /// <summary>

src/JsonApiDotNetCore/Models/RelationshipAttribute.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Reflection;
+using JsonApiDotNetCore.Extensions;
 
 namespace JsonApiDotNetCore.Models
 {
@@ -22,11 +23,11 @@ protected RelationshipAttribute(string publicName, Link documentLinks, bool canI
         /// 
         /// <example>
         /// <code>
-        /// public List&lt;Articles&gt; Articles { get; set; } // Type => Article
+        /// public List&lt;Tag&gt; Tags { get; set; } // Type => Tag
         /// </code>
         /// </example>
         public Type Type { get; internal set; }
-        public bool IsHasMany => GetType() == typeof(HasManyAttribute) || typeof(HasManyAttribute).IsAssignableFrom(GetType());
+        public bool IsHasMany => GetType() == typeof(HasManyAttribute) || GetType().Inherits(typeof(HasManyAttribute));
         public bool IsHasOne => GetType() == typeof(HasOneAttribute);
         public Link DocumentLinks { get; } = Link.All;
         public bool CanInclude { get; }

test/JsonApiDotNetCoreExampleTests/Acceptance/ManyToManyTests.cs

@@ -210,13 +210,10 @@ public async Task Can_Update_Many_To_Many_Through_Relationship_Link()
             var body = await response.Content.ReadAsStringAsync();
             Assert.True(HttpStatusCode.OK == response.StatusCode, $"{route} returned {response.StatusCode} status code with payload: {body}");
 
-            var articleResponse = _fixture.GetService<IJsonApiDeSerializer>().Deserialize<Article>(body);
-            Assert.NotNull(articleResponse);
-            
             _fixture.ReloadDbContext();
             var persistedArticle = await _fixture.Context.Articles
                 .Include(a => a.ArticleTags)
-                .SingleAsync(a => a.Id == articleResponse.Id);
+                .SingleAsync(a => a.Id == article.Id);
 
             var persistedArticleTag = Assert.Single(persistedArticle.ArticleTags);
             Assert.Equal(tag.Id, persistedArticleTag.TagId);