first pass at pointer replacement and service location

Author: jaredcnance

src/JsonApiDotNetCore/Builders/ContextGraphBuilder.cs

@@ -28,7 +28,10 @@ public IContextGraph Build()
             return graph;
         }
 
-        public void AddResource<TResource>(string pluralizedTypeName) where TResource : class
+        public void AddResource<TResource>(string pluralizedTypeName) where TResource : class, IIdentifiable<int>
+            => AddResource<TResource, int>(pluralizedTypeName);
+
+        public void AddResource<TResource, TId>(string pluralizedTypeName) where TResource : class, IIdentifiable<TId>
         {
             var entityType = typeof(TResource);
 
@@ -38,6 +41,7 @@ public void AddResource<TResource>(string pluralizedTypeName) where TResource :
             {
                 EntityName = pluralizedTypeName,
                 EntityType = entityType,
+                IdentityType = typeof(TId),
                 Attributes = GetAttributes(entityType),
                 Relationships = GetRelationships(entityType)
             });

src/JsonApiDotNetCore/Builders/IContextGraphBuilder.cs

@@ -8,7 +8,8 @@ public interface IContextGraphBuilder
     {
         Link DocumentLinks  { get; set; }
         IContextGraph Build();
-        void AddResource<TResource>(string pluralizedTypeName) where TResource : class;
+        void AddResource<TResource>(string pluralizedTypeName) where TResource : class, IIdentifiable<int>;
+        void AddResource<TResource, TId>(string pluralizedTypeName) where TResource : class, IIdentifiable<TId>;
         void AddDbContext<T>() where T : DbContext;
     }
 }

src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs

@@ -137,7 +137,7 @@ public virtual async Task<TEntity> UpdateAsync(TId id, TEntity entity)
 
         public async Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds)
         {
-            var genericProcessor = _genericProcessorFactory.GetProcessor(relationship.Type);
+            var genericProcessor = _genericProcessorFactory.GetProcessor<IGenericProcessor>(relationship.Type);
             await genericProcessor.UpdateRelationshipsAsync(parent, relationship, relationshipIds);
         }
 

src/JsonApiDotNetCore/Internal/ContextEntity.cs

@@ -8,6 +8,7 @@ public class ContextEntity
     {
         public string EntityName { get; set; }
         public Type EntityType { get; set; }
+        public Type IdentityType { get; set; }
         public List<AttrAttribute> Attributes { get; set; }
         public List<RelationshipAttribute> Relationships { get; set; }
         public Link Links { get; set; } = Link.All;

src/JsonApiDotNetCore/Internal/Generics/GenericProcessorFactory.cs

@@ -1,24 +1,20 @@
 using System;
-using Microsoft.EntityFrameworkCore;
 
 namespace JsonApiDotNetCore.Internal.Generics
 {
     public class GenericProcessorFactory : IGenericProcessorFactory
     {
-        private readonly DbContext _dbContext;
         private readonly IServiceProvider _serviceProvider;
 
-        public GenericProcessorFactory(DbContext dbContext, 
-            IServiceProvider serviceProvider)
+        public GenericProcessorFactory(IServiceProvider serviceProvider)
         {
-            _dbContext = dbContext;
             _serviceProvider = serviceProvider;
         }
 
-        public IGenericProcessor GetProcessor(Type type)
+        public TInterface GetProcessor<TInterface>(Type[] types)
         {
-            var processorType = typeof(GenericProcessor<>).MakeGenericType(type);
-            return (IGenericProcessor)_serviceProvider.GetService(processorType);
+            var processorType = typeof(GenericProcessor<>).MakeGenericType(types);
+            return (TInterface)_serviceProvider.GetService(processorType);
         }
     }
 }

src/JsonApiDotNetCore/Internal/Generics/IGenericProcessorFactory.cs

@@ -5,10 +5,12 @@ namespace JsonApiDotNetCore.Internal.Generics
     /// <summary>
     /// Used to generate a generic operations processor when the types
     /// are not know until runtime. The typical use case would be for
+    /// accessing relationship data.be for
     /// accessing relationship data.
     /// </summary>
     public interface IGenericProcessorFactory
     {
-        IGenericProcessor GetProcessor(Type type);
+
+        TInterface GetProcessor<TInterface>(params Type[] types);
     }
 }

src/JsonApiDotNetCore/Models/DocumentData.cs

@@ -1,20 +1,63 @@
 using System.Collections.Generic;
+using JsonApiDotNetCore.Models.Pointers;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Schema;
 
 namespace JsonApiDotNetCore.Models
 {
     public class DocumentData
     {
         [JsonProperty("type")]
-        public string Type { get; set; }
+        public object Type { get; set; }
 
         [JsonProperty("id")]
-        public string Id { get; set; }
+        public object Id { get; set; }
 
         [JsonProperty("attributes")]
         public Dictionary<string, object> Attributes { get; set; }
 
         [JsonProperty("relationships")]
         public Dictionary<string, RelationshipData> Relationships { get; set; }
     }
+
+    public class DocumentDataPointerReplacement<TPointer, TPointerBase>
+        where TPointer : Pointer<TPointerBase>, new()
+    {
+        private readonly DocumentData _data;
+
+        public DocumentDataPointerReplacement(DocumentData data)
+        {
+            _data = data;
+        }
+
+        public void ReplacePointers(List<TPointerBase> parentDoc)
+        {
+            ReplacePointer(_data.Id, parentDoc);
+            ReplacePointer(_data.Type, parentDoc);
+        }
+
+        private void ReplacePointer(object reference, List<TPointerBase> parentDoc)
+        {
+            if (reference is JObject jObj)
+                if (jObj.TryParse<TPointer, TPointerBase>(Pointer<TPointerBase>.JsonSchema, out Pointer<TPointerBase> pointer))
+                    reference = pointer.GetValue(parentDoc);
+        }
+    }
 }
+
+public static class JObjectExtensions
+{
+    public static bool TryParse<TPointer, TPointerBase>(this JObject obj, JSchema schema, out Pointer<TPointerBase> pointer)
+      where TPointer : Pointer<TPointerBase>, new()
+    {
+        if (obj.IsValid(schema))
+        {
+            pointer = obj.ToObject<TPointer>();
+            return true;
+        }
+
+        pointer = null;
+        return false;
+    }
+}

src/JsonApiDotNetCore/Models/Operations/Operation.cs

@@ -47,5 +47,16 @@ private void SetData(object data)
         public bool DataIsList { get; private set; }
         public List<DocumentData> DataList { get; private set; }
         public DocumentData DataObject { get; private set; }
+
+        public string GetResourceTypeName()
+        {
+            if(Ref != null)
+                return Ref.Type?.ToString();
+
+            if(DataIsList)
+                return DataList[0].Type?.ToString();
+
+            return DataObject.Type?.ToString();
+        }
     }
 }

src/JsonApiDotNetCore/Models/Pointers/OperationsPointer.cs

@@ -5,7 +5,7 @@
 
 namespace JsonApiDotNetCore.Models.Pointers
 {
-    public class OperationsPointer : Pointer
+    public class OperationsPointer : Pointer<Operation>
     {
         /// <exception cref="System.ArgumentNullException"></exception>
         /// <exception cref="System.ArgumentException"></exception>

src/JsonApiDotNetCore/Models/Pointers/Pointer.cs

@@ -3,9 +3,9 @@
 
 namespace JsonApiDotNetCore.Models.Pointers
 {
-    public abstract class Pointer
+    public abstract class Pointer<TPointerBase>
     {
-        private static JSchema JsonSchema { get; } = JSchema.Parse("{ 'pointer': {'type': 'string'} }");
+        public static JSchema JsonSchema { get; } = JSchema.Parse("{ 'pointer': {'type': 'string'} }");
 
         /// <summary>
         /// Location represented by the pointer