style: IGenericProcessor --> IHasManyThroughUpdateHelper

Author: maurei

src/JsonApiDotNetCore/Builders/JsonApiApplicationBuilder.cs

@@ -155,7 +155,7 @@ public void ConfigureServices()
             _services.AddScoped<IJsonApiWriter, JsonApiWriter>();
             _services.AddScoped<IJsonApiReader, JsonApiReader>();
             _services.AddScoped<IGenericProcessorFactory, GenericProcessorFactory>();
-            _services.AddScoped(typeof(GenericProcessor<>));
+            _services.AddScoped(typeof(HasManyThroughUpdateHelper<>));
             _services.AddScoped<IQueryParameterDiscovery, QueryParameterDiscovery>();
             _services.AddScoped<ITargetedFields, TargetedFields>();
             _services.AddScoped<IResourceDefinitionProvider, ResourceDefinitionProvider>();

src/JsonApiDotNetCore/Data/DefaultResourceRepository.cs

@@ -55,9 +55,9 @@ public DefaultResourceRepository(
         public virtual IQueryable<TResource> Get(TId id) => _dbSet.Where(e => e.Id.Equals(id));
 
         /// <inheritdoc />
-        public virtual IQueryable<TResource> Select(IQueryable<TResource> entities, List<AttrAttribute> fields)
+        public virtual IQueryable<TResource> Select(IQueryable<TResource> entities, params AttrAttribute[] fields)
         {
-            if (fields?.Count > 0)
+            if (fields.Any())
                 return entities.Select(fields);
 
             return entities;
@@ -256,16 +256,20 @@ private IIdentifiable GetTrackedHasOneRelationshipValue(IIdentifiable relationsh
         /// <inheritdoc />
         public async Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds)
         {
-            // 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.RightType;
-
-            var genericProcessor = _genericProcessorFactory.GetProcessor<IGenericProcessor>(typeof(GenericProcessor<>), typeToUpdate);
-            await genericProcessor.UpdateRelationshipsAsync(parent, relationship, relationshipIds);
+            if (relationship is HasManyThroughAttribute hasManyThrough)
+            {
+                var helper = _genericProcessorFactory.GetProcessor<IHasManyThroughUpdateHelper>(typeof(HasManyThroughUpdateHelper<>), hasManyThrough.ThroughType);
+                await helper.UpdateAsync((IIdentifiable)parent, hasManyThrough, relationshipIds);
+                return;
+            }
+
+            var context = _context.Set(relationship.RightType);
+            var updatedValue = relationship is HasManyAttribute
+                ? context.Where(e => relationshipIds.Contains(((IIdentifiable)e).StringId)).Cast(relationship.RightType)
+                : context.FirstOrDefault(e => relationshipIds.First() == ((IIdentifiable)e).StringId);
+
+            relationship.SetValue(parent, updatedValue);
+            await _context.SaveChangesAsync();
         }
 
         /// <inheritdoc />

src/JsonApiDotNetCore/Data/IResourceReadRepository.cs

@@ -26,7 +26,7 @@ public interface IResourceReadRepository<TResource, in TId>
         /// <summary>
         /// Apply fields to the provided queryable
         /// </summary>
-        IQueryable<TResource> Select(IQueryable<TResource> entities, List<AttrAttribute> fields);
+        IQueryable<TResource> Select(IQueryable<TResource> entities, params AttrAttribute[] fields);
         /// <summary>
         /// Include a relationship in the query
         /// </summary>

src/JsonApiDotNetCore/Extensions/DbContextExtensions.cs

@@ -10,10 +10,6 @@ namespace JsonApiDotNetCore.Extensions
 {
     public static class DbContextExtensions
     {
-        [Obsolete("This is no longer required since the introduction of context.Set<T>", error: false)]
-        public static DbSet<T> GetDbSet<T>(this DbContext context) where T : class 
-            => context.Set<T>();
-
         /// <summary>
         /// Get the DbSet when the model type is unknown until runtime
         /// </summary>

src/JsonApiDotNetCore/Extensions/IQueryableExtensions.cs

@@ -64,7 +64,7 @@ public static IQueryable<TSource> Filter<TSource>(this IQueryable<TSource> sourc
             return CallGenericWhereMethod(source, filterQuery);
         }
 
-        public static IQueryable<TSource> Select<TSource>(this IQueryable<TSource> source, List<AttrAttribute> columns)
+        public static IQueryable<TSource> Select<TSource>(this IQueryable<TSource> source, AttrAttribute[] columns)
             => CallGenericSelectMethod(source, columns.Select(attr => attr.InternalAttributeName).ToList());
 
         public static IOrderedQueryable<TSource> Sort<TSource>(this IQueryable<TSource> source, SortQueryContext sortQuery)

src/JsonApiDotNetCore/Internal/Generics/GenericProcessor.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+using JsonApiDotNetCore.Data;
+using JsonApiDotNetCore.Extensions;
+using JsonApiDotNetCore.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace JsonApiDotNetCore.Internal.Generics
+{
+    /// <summary>
+    /// A special helper service that gets instantiated for the right-type of a many-to-many relationship and is responsible for
+    /// processing updates for that relationships
+    /// </summary>
+    public interface IHasManyThroughUpdateHelper
+    {
+        Task UpdateAsync(IIdentifiable parent, HasManyThroughAttribute relationship, IEnumerable<string> relationshipIds);
+    }
+
+    /// <summary>
+    /// A special processor that gets instantiated for a generic type (&lt;T&gt;)
+    /// when the actual type is not known until runtime. Specifically, this is used for updating
+    /// relationships.
+    /// </summary>
+    public class HasManyThroughUpdateHelper<T> : IHasManyThroughUpdateHelper where T : class
+    {
+        private readonly DbContext _context;
+        public HasManyThroughUpdateHelper(IDbContextResolver contextResolver)
+        {
+            _context = contextResolver.GetContext();
+        }
+
+        public virtual async Task UpdateAsync(IIdentifiable parent, HasManyThroughAttribute relationship, IEnumerable<string> relationshipIds)
+        {
+            // we need to create a transaction for the HasManyThrough case so we can get and remove any existing
+            // join entities and only commit if all operations are successful
+            using (var transaction = await _context.GetCurrentOrCreateTransactionAsync())
+            {
+                // ArticleTag
+                ParameterExpression parameter = Expression.Parameter(relationship.ThroughType);
+
+                // ArticleTag.ArticleId
+                Expression property = Expression.Property(parameter, relationship.LeftIdProperty);
+
+                // article.Id
+                var parentId = TypeHelper.ConvertType(parent.StringId, relationship.LeftIdProperty.PropertyType);
+                Expression target = Expression.Constant(parentId);
+
+                // ArticleTag.ArticleId.Equals(article.Id)
+                Expression equals = Expression.Call(property, "Equals", null, target);
+
+                var lambda = Expression.Lambda<Func<T, bool>>(equals, parameter);
+
+                // TODO: we shouldn't need to do this instead we should try updating the existing?
+                // the challenge here is if a composite key is used, then we will fail to 
+                // create due to a unique key violation
+                var oldLinks = _context
+                    .Set<T>()
+                    .Where(lambda.Compile())
+                    .ToList();
+
+                _context.RemoveRange(oldLinks);
+
+                var newLinks = relationshipIds.Select(x => {
+                    var link = Activator.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;
+                });
+
+                _context.AddRange(newLinks);
+                await _context.SaveChangesAsync();
+
+                transaction.Commit();
+            }
+        }
+    }
+}

src/JsonApiDotNetCore/Internal/Generics/HasManyThroughUpdateHelper.cs

@@ -1,7 +1,6 @@
 using JsonApiDotNetCore.Internal.Contracts;
 using System;
 using System.Collections.Generic;
-using JsonApiDotNetCore.Services;
 using JsonApiDotNetCore.Query;
 using System.Linq;
 using JsonApiDotNetCore.Models;

src/JsonApiDotNetCore/Serialization/Server/FieldsToSerialize.cs

@@ -263,7 +263,7 @@ protected virtual IQueryable<TResource> ApplySelect(IQueryable<TResource> entiti
         {
             var fields = _sparseFieldsService.Get();
             if (fields != null && fields.Any())
-                entities = _repository.Select(entities, fields);
+                entities = _repository.Select(entities, fields.ToArray());
 
             return entities;
         }
@@ -276,7 +276,7 @@ protected virtual IQueryable<TResource> ApplySelect(IQueryable<TResource> entiti
         private async Task<TResource> GetWithRelationshipsAsync(TId id)
         {
             var sparseFieldset = _sparseFieldsService.Get();
-            var query = _repository.Select(_repository.Get(id), sparseFieldset);
+            var query = _repository.Select(_repository.Get(id), sparseFieldset.ToArray());
 
             foreach (var chain in _includeService.Get())
                 query = _repository.Include(query, chain.ToArray());

src/JsonApiDotNetCore/Services/DefaultResourceService.cs

@@ -73,7 +73,7 @@ public async Task Can_Select_Sparse_Fieldsets()
             var query = _dbContext
                 .TodoItems
                 .Where(t => t.Id == todoItem.Id)
-                .Select(_resourceGraph.GetAttributes<TodoItem>(e => new { e.Id, e.Description, e.CreatedDate, e.AchievedDate } ).ToList());
+                .Select(_resourceGraph.GetAttributes<TodoItem>(e => new { e.Id, e.Description, e.CreatedDate, e.AchievedDate } ).ToArray());
 
             var resultSql = StringExtensions.Normalize(query.ToSql());
             var result = await query.FirstAsync();