add include extension

Author: jaredcnance

JsonApiDotNetCore/Data/ResourceRepository.cs

@@ -4,6 +4,7 @@
 using System.Linq.Expressions;
 using JsonApiDotNetCore.Abstractions;
 using System.Reflection;
+using JsonApiDotNetCore.Extensions;
 using JsonApiDotNetCore.Routing;
 using Microsoft.EntityFrameworkCore;
 
@@ -28,32 +29,53 @@ public object Get(string id)
       var relationalRoute = _context.Route as RelationalRoute;
       if (relationalRoute == null)
       {
-        return GetEntityById(id);
+        return GetEntityById(_context.Route.BaseModelType, id, null);
       }
-      return GetRelated(id, relationalRoute.RelationshipName);
+      return GetRelated(id, relationalRoute);
     }
 
-    private object GetRelated(string id, string relationshipName)
+    private object GetRelated(string id, RelationalRoute relationalRoute)
     {
       // HACK: this would rely on lazy loading to work...will probably fail
-      var entity = GetEntityById(id);
-      var entityType = entity.GetType();
-      return entityType.GetProperties().FirstOrDefault(pi => pi.Name == relationshipName).GetValue(entity);
+      var entity = GetEntityById(relationalRoute.RelationalType, id, relationalRoute.RelationshipName);
+      return relationalRoute.RelationalType.GetProperties().FirstOrDefault(pi => pi.Name.ToCamelCase() == relationalRoute.RelationshipName.ToCamelCase()).GetValue(entity);
     }
 
-    private object GetDbSetFromContext(string propName)
+
+    private IQueryable GetDbSetFromContext(string propName)
     {
       var dbContext = _context.DbContext;
-      return dbContext.GetType().GetProperties().FirstOrDefault(pI => pI.Name == propName)?.GetValue(dbContext, null);
+      return (IQueryable)dbContext.GetType().GetProperties().FirstOrDefault(pI => pI.Name.ToCamelCase() == propName)?.GetValue(dbContext, null);
     }
 
-    private object GetEntityById(string id)
+    private object GetEntityById(Type modelType, string id, string includedRelationship)
     {
       // HACK: I _believe_ by casting to IEnumerable, we are loading all records into memory, if so... find a better way...
       //        Also, we are making a BIG assumption that the resource has an attribute Id and not ResourceId which is allowed by EF
-      return
-        (GetDbSetFromContext(_context.Route.BaseRouteDefinition.ContextPropertyName) as IEnumerable<dynamic>)?
-          .FirstOrDefault(x => x.Id.ToString() == id);
+      var methodToCall = typeof(ResourceRepository).GetMethods().Single(method => method.Name.Equals("GetDbSet"));
+      var genericMethod = methodToCall.MakeGenericMethod(modelType);
+      genericMethod.Invoke(genericMethod, null);
+      var dbSet = genericMethod.Invoke(this, null);
+
+      if (!string.IsNullOrEmpty(includedRelationship))
+      {
+        var includeMethod = typeof(ResourceRepository).GetMethods().Single(method => method.Name.Equals("IncludeEntity"));
+        var genericIncludeMethod = includeMethod.MakeGenericMethod(modelType);
+        genericIncludeMethod.Invoke(genericMethod, null);
+        dbSet = genericIncludeMethod.Invoke(this, new []{ dbSet, includedRelationship });
+      }
+
+      return (dbSet as IEnumerable<dynamic>).SingleOrDefault(x => x.Id.ToString() == id);
+    }
+
+    private DbSet<T> GetDbSet<T>() where T : class
+    {
+      return ((DbContext) _context.DbContext).Set<T>();
+    }
+
+    private IQueryable<T> IncludeEntity<T>(IQueryable<T> queryable, string includedEntityName) where T : class
+    {
+      return queryable.Include(includedEntityName);
     }
   }
 }

JsonApiDotNetCore/Extensions/EfIncludeExtension.cs

@@ -0,0 +1,82 @@
+// SOURCE: https://github.com/aspnet/EntityFramework/issues/3921
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using Microsoft.EntityFrameworkCore;
+
+namespace JsonApiDotNetCore.Extensions
+{
+  public static class EfIncludeExtension
+  {
+    private static MethodInfo _include = typeof(EntityFrameworkQueryableExtensions)
+                        .GetMethod("Include");
+
+    private static MethodInfo _thenIncludeReference = typeof(EntityFrameworkQueryableExtensions)
+        .GetMethods()
+        .Where(m => m.Name == "ThenInclude")
+        .Single(m => m.Name == "ThenInclude" &&
+                     m.GetParameters()
+                      .Single(p => p.Name == "source")
+                      .ParameterType
+                      .GetGenericArguments()[1].Name != typeof(ICollection<>).Name);
+
+    private static MethodInfo _thenIncludeCollection = typeof(EntityFrameworkQueryableExtensions)
+        .GetMethods()
+        .Where(m => m.Name == "ThenInclude")
+        .Single(m => m.Name == "ThenInclude" &&
+                     m.GetParameters()
+                      .Single(p => p.Name == "source")
+                      .ParameterType
+                      .GetGenericArguments()[1].Name == typeof(ICollection<>).Name);
+
+    public static IQueryable<T> Include<T>(this IQueryable<T> query, string include)
+    {
+      return query.Include(include.Split('.'));
+    }
+
+    public static IQueryable<T> Include<T>(this IQueryable<T> query, params string[] include)
+    {
+      var currentType = query.ElementType;
+      var previousNavWasCollection = false;
+
+      for (int i = 0; i < include.Length; i++)
+      {
+        var navigationName = include[i];
+        var navigationProperty = currentType.GetProperty(navigationName);
+        if (navigationProperty == null)
+        {
+          throw new ArgumentException($"'{navigationName}' is not a valid property of '{currentType}'");
+        }
+
+        var includeMethod = i == 0
+            ? _include.MakeGenericMethod(query.ElementType, navigationProperty.PropertyType)
+            : previousNavWasCollection
+                ? _thenIncludeCollection.MakeGenericMethod(query.ElementType, currentType, navigationProperty.PropertyType)
+                : _thenIncludeReference.MakeGenericMethod(query.ElementType, currentType, navigationProperty.PropertyType);
+
+        var expressionParameter = Expression.Parameter(currentType);
+        var expression = Expression.Lambda(
+            Expression.Property(expressionParameter, navigationName),
+            expressionParameter);
+
+        query = (IQueryable<T>)includeMethod.Invoke(null, new object[] { query, expression });
+
+        if (navigationProperty.PropertyType.GetInterfaces().Any(x => x.Name == typeof(ICollection<>).Name))
+        {
+          previousNavWasCollection = true;
+          currentType = navigationProperty.PropertyType.GetGenericArguments().Single();
+        }
+        else
+        {
+          previousNavWasCollection = false;
+          currentType = navigationProperty.PropertyType;
+        }
+      }
+
+      return query;
+    }
+  }
+}

JsonApiDotNetCore/Extensions/PathStringExtensions.cs

@@ -12,7 +12,7 @@ public static string ExtractFirstSegment(this PathString path, out PathString re
       if (!path.HasValue) return string.Empty;
 
       var splitPath = SplitPath(path);
-      remainingSegments = new PathString(RemoveFirstSegmentFromPath(splitPath));
+      remainingSegments = new PathString($"/{RemoveFirstSegmentFromPath(splitPath)}");
       return splitPath[0];
     }
 

JsonApiDotNetCore/Routing/RouteBuilder.cs

@@ -54,8 +54,8 @@ private PathString SetBaseRouteDefinition()
         if (_request.Path.StartsWithSegments(new PathString(rte.PathString), StringComparison.OrdinalIgnoreCase, out remainingPathString))
         {
           _baseRouteDefinition = rte;
+          return remainingPathString;
         }
-        return remainingPathString;
       }
       throw new Exception("Route is not defined.");
     }

JsonApiDotNetCore/Routing/Router.cs

@@ -76,7 +76,7 @@ private void SendResponse(ObjectResult result)
       var context = _jsonApiContext.HttpContext;
       context.Response.StatusCode = result.StatusCode ?? 500;
       context.Response.ContentType = "application/vnd.api+json";
-      context.Response.WriteAsync(result.Value.ToString());
+      context.Response.WriteAsync(result.Value == null ? "" : result.Value.ToString());
       context.Response.Body.Flush();
     }
   }