feat(context-graph): first pass at refactoring the graph API

also affects the service collection extensions

Author: jaredcnance

src/JsonApiDotNetCore/Builders/ContextGraphBuilder.cs

@@ -0,0 +1,111 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Microsoft.EntityFrameworkCore;
+using JsonApiDotNetCore.Internal;
+using JsonApiDotNetCore.Models;
+
+namespace JsonApiDotNetCore.Builders
+{
+    public class ContextGraphBuilder : IContextGraphBuilder
+    {
+        private List<ContextEntity> Entities;
+
+        public ContextGraphBuilder()
+        {
+            Entities = new List<ContextEntity>();
+        }
+
+        public IContextGraph Build()
+        {
+            var graph = new ContextGraph()
+            {
+                Entities = Entities
+            };
+
+            return graph;
+        }
+
+        public void AddResource<TResource>(string pluralizedTypeName) where TResource : class
+        {
+            var entityType = typeof(TResource);
+            Entities.Add(new ContextEntity
+            {
+                EntityName = pluralizedTypeName,
+                EntityType = entityType,
+                Attributes = GetAttributes(entityType),
+                Relationships = GetRelationships(entityType)
+            });
+        }
+
+        protected virtual List<AttrAttribute> GetAttributes(Type entityType)
+        {
+            var attributes = new List<AttrAttribute>();
+
+            var properties = entityType.GetProperties();
+
+            foreach (var prop in properties)
+            {
+                var attribute = (AttrAttribute)prop.GetCustomAttribute(typeof(AttrAttribute));
+                if (attribute == null) continue;
+                attribute.InternalAttributeName = prop.Name;
+                attributes.Add(attribute);
+            }
+            return attributes;
+        }
+
+        protected virtual List<RelationshipAttribute> GetRelationships(Type entityType)
+        {
+            var attributes = new List<RelationshipAttribute>();
+
+            var properties = entityType.GetProperties();
+
+            foreach (var prop in properties)
+            {
+                var attribute = (RelationshipAttribute)prop.GetCustomAttribute(typeof(RelationshipAttribute));
+                if (attribute == null) continue;
+                attribute.InternalRelationshipName = prop.Name;
+                attribute.Type = GetRelationshipType(attribute, prop);
+                attributes.Add(attribute);
+            }
+            return attributes;
+        }
+
+        protected virtual Type GetRelationshipType(RelationshipAttribute relation, PropertyInfo prop)
+        {
+            if (relation.IsHasMany)
+                return prop.PropertyType.GetGenericArguments()[0];
+            else
+                return prop.PropertyType;
+        }
+
+        public void AddDbContext<T>() where T : DbContext
+        {
+            var contextType = typeof(T);
+
+            var entities = new List<ContextEntity>();
+
+            var contextProperties = contextType.GetProperties();
+
+            foreach (var property in contextProperties)
+            {
+                var dbSetType = property.PropertyType;
+
+                if (dbSetType.GetTypeInfo().IsGenericType
+                    && dbSetType.GetGenericTypeDefinition() == typeof(DbSet<>))
+                {
+                    var entityType = dbSetType.GetGenericArguments()[0];
+                    entities.Add(new ContextEntity
+                    {
+                        EntityName = property.Name,
+                        EntityType = entityType,
+                        Attributes = GetAttributes(entityType),
+                        Relationships = GetRelationships(entityType)
+                    });
+                }
+            }
+
+            Entities = entities;
+        }
+    }
+}

src/JsonApiDotNetCore/Builders/IContextGraphBuilder.cs

@@ -0,0 +1,11 @@
+using JsonApiDotNetCore.Internal;
+using Microsoft.EntityFrameworkCore;
+
+namespace JsonApiDotNetCore.Builders
+{
+    public interface IContextGraphBuilder
+    {
+        IContextGraph Build();
+        void AddResource<TResource>(string pluralizedTypeName) where TResource : class;
+    }
+}

src/JsonApiDotNetCore/Configuration/JsonApiOptions.cs

@@ -1,3 +1,8 @@
+using System;
+using JsonApiDotNetCore.Builders;
+using JsonApiDotNetCore.Internal;
+using Microsoft.EntityFrameworkCore;
+
 namespace JsonApiDotNetCore.Configuration
 {
     public class JsonApiOptions
@@ -6,5 +11,31 @@ public class JsonApiOptions
         public int DefaultPageSize { get; set; }
         public bool IncludeTotalRecordCount { get; set; }
         public bool AllowClientGeneratedIds { get; set; }
+        public IContextGraph ContextGraph  { get; set; }
+
+        public void BuildContextGraph<TContext>(Action<IContextGraphBuilder> builder)
+        where TContext : DbContext
+        {
+            var contextGraphBuilder = new ContextGraphBuilder();
+            
+            contextGraphBuilder.AddDbContext<TContext>();
+
+            if(builder != null)
+                builder(contextGraphBuilder);
+
+            ContextGraph = contextGraphBuilder.Build();
+        }
+
+        public void BuildContextGraph(Action<IContextGraphBuilder> builder)
+        {
+            if(builder == null)
+                throw new ArgumentException("Cannot build non-EF context graph without a IContextGraphBuilder action", nameof(builder));
+
+            var contextGraphBuilder = new ContextGraphBuilder();
+
+            builder(contextGraphBuilder);
+
+            ContextGraph = contextGraphBuilder.Build();
+        }
     }
 }

src/JsonApiDotNetCore/Extensions/IServiceCollectionExtensions.cs

@@ -19,18 +19,14 @@ public static void AddJsonApi<TContext>(this IServiceCollection services)
             where TContext : DbContext
         {
             var mvcBuilder = services.AddMvc();
-            AddInternals<TContext>(services, new JsonApiOptions(), mvcBuilder);
+            AddJsonApi<TContext>(services, (opt) => {}, mvcBuilder);
         }
 
         public static void AddJsonApi<TContext>(this IServiceCollection services, Action<JsonApiOptions> options) 
             where TContext : DbContext
         {
-            var config = new JsonApiOptions();
-            
-            options(config);
-
             var mvcBuilder = services.AddMvc();
-            AddInternals<TContext>(services, config, mvcBuilder);
+            AddJsonApi<TContext>(services, options, mvcBuilder);
         }
 
          public static void AddJsonApi<TContext>(this IServiceCollection services, 
@@ -41,40 +37,44 @@ public static void AddJsonApi<TContext>(this IServiceCollection services,
 
             options(config);
 
-            AddInternals<TContext>(services, config, mvcBuilder);
-        }
+            if(config.ContextGraph == null)
+                config.BuildContextGraph<TContext>(null);
+
+            services.AddScoped(typeof(DbContext), typeof(TContext));
 
-        private static void AddInternals<TContext>(IServiceCollection services, 
-            JsonApiOptions jsonApiOptions,
-            IMvcBuilder mvcBuilder) where TContext : DbContext
-        {
-            services.AddJsonApiInternals<TContext>(jsonApiOptions);
             mvcBuilder
                 .AddMvcOptions(opt => {
                     opt.Filters.Add(typeof(JsonApiExceptionFilter));
-                    opt.SerializeAsJsonApi(jsonApiOptions);
+                    opt.SerializeAsJsonApi(config);
                 });
+
+            AddJsonApiInternals(services, config);
         }
 
-        public static void AddJsonApiInternals<TContext>(this IServiceCollection services, JsonApiOptions jsonApiOptions) 
-            where TContext : DbContext
+        public static void AddJsonApi(this IServiceCollection services, 
+            Action<JsonApiOptions> options,
+            IMvcBuilder mvcBuilder)
         {
-            var contextGraphBuilder = new ContextGraphBuilder<TContext>();
-            var contextGraph = contextGraphBuilder.Build();
+            var config = new JsonApiOptions();
+            
+            options(config);
 
-            services.AddScoped(typeof(DbContext), typeof(TContext));
-            services.AddScoped(typeof(IResourceService<>), typeof(EntityResourceService<>));
-            services.AddScoped(typeof(IResourceService<,>), typeof(EntityResourceService<,>));
+            AddJsonApiInternals(services, config);
+        }
+
+        public static void AddJsonApiInternals(
+            this IServiceCollection services, 
+            JsonApiOptions jsonApiOptions)
+        {
             services.AddScoped(typeof(IEntityRepository<>), typeof(DefaultEntityRepository<>));
             services.AddScoped(typeof(IEntityRepository<,>), typeof(DefaultEntityRepository<,>));
-
+            services.AddScoped(typeof(IResourceService<>), typeof(EntityResourceService<>));
+            services.AddScoped(typeof(IResourceService<,>), typeof(EntityResourceService<,>));
             services.AddSingleton<JsonApiOptions>(jsonApiOptions);
-            services.AddSingleton<IContextGraph>(contextGraph);
+            services.AddSingleton<IContextGraph>(jsonApiOptions.ContextGraph);
             services.AddScoped<IJsonApiContext,JsonApiContext>();
             services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
-
             services.AddScoped<JsonApiRouteHandler>();
-
             services.AddScoped<IMetaBuilder, MetaBuilder>();
             services.AddScoped<IDocumentBuilder, DocumentBuilder>();
             services.AddScoped<IJsonApiSerializer, JsonApiSerializer>();

src/JsonApiDotNetCore/Internal/ContextGraph.cs

@@ -1,12 +1,11 @@
 using System.Reflection;
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.EntityFrameworkCore;
 using System;
 
 namespace JsonApiDotNetCore.Internal
 {
-    public class ContextGraph<T> : IContextGraph where T : DbContext
+    public class ContextGraph : IContextGraph
     {
         public List<ContextEntity> Entities { get; set; }