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();