feat(*): add Error and exception handling

Author: jaredcnance

src/JsonApiDotNetCore/Builders/DocumentBuilder.cs

@@ -34,9 +34,9 @@ public Document Build(IIdentifiable entity)
         public Documents Build(IEnumerable<IIdentifiable> entities)
         {
             var entityType = entities
-                .GetType()
-                .GenericTypeArguments[0];
-
+            .GetType()
+            .GenericTypeArguments[0];
+        
             var contextEntity = _contextGraph.GetContextEntity(entityType);
 
             var documents = new Documents
@@ -47,7 +47,7 @@ public Documents Build(IEnumerable<IIdentifiable> entities)
             foreach (var entity in entities)
                 documents.Data.Add(_getData(contextEntity, entity));
 
-            return documents;
+            return documents;      
         }
 
         private DocumentData _getData(ContextEntity contextEntity, IIdentifiable entity)
@@ -89,7 +89,7 @@ private void _addRelationships(DocumentData data, ContextEntity contextEntity, I
                     }
                 };
 
-                if (_jsonApiContext.IncludedRelationships.Contains(r.RelationshipName.ToProperCase()))
+                if (_hasRelationship(r.RelationshipName))
                 {
                     var navigationEntity = _jsonApiContext.ContextGraph
                         .GetRelationship(entity, r.RelationshipName);
@@ -105,6 +105,13 @@ private void _addRelationships(DocumentData data, ContextEntity contextEntity, I
                 data.Relationships.Add(r.RelationshipName.Dasherize(), relationshipData);
             });
         }
+
+        private bool _hasRelationship(string relationshipName)
+        {
+            return _jsonApiContext.IncludedRelationships != null && 
+                _jsonApiContext.IncludedRelationships.Contains(relationshipName.ToProperCase());
+        }
+
         private List<Dictionary<string, string>> GetRelationships(IEnumerable<object> entities, string relationshipName)
         {
             var objType = entities.GetType().GenericTypeArguments[0];

src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 using JsonApiDotNetCore.Extensions;
+using JsonApiDotNetCore.Internal;
 using JsonApiDotNetCore.Internal.Query;
 using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Services;
@@ -124,7 +125,12 @@ public virtual async Task<bool> DeleteAsync(TId id)
 
         public IQueryable<TEntity> Include(IQueryable<TEntity> entities, string relationshipName)
         {
-            return entities.Include(relationshipName);
+            var entity = _jsonApiContext.RequestEntity;
+            if(entity.Relationships.Any(r => r.RelationshipName == relationshipName))
+                return entities.Include(relationshipName);
+
+            throw new JsonApiException("400", "Invalid relationship",
+                $"{entity.EntityName} does not have a relationship named {relationshipName}");
         }
     }
 }

src/JsonApiDotNetCore/Extensions/IApplicationBuilderExtensions.cs

@@ -7,6 +7,7 @@ public static class IApplicationBuilderExtensions
         public static IApplicationBuilder UseJsonApi(this IApplicationBuilder app)
         {
             app.UseMvc();
+            
             return app;
         }
     }

src/JsonApiDotNetCore/Extensions/ServiceProviderExtensions.cs

@@ -32,7 +32,10 @@ private static void _addInternals<TContext>(IServiceCollection services, JsonApi
         {
             services.AddJsonApiInternals<TContext>();
             services.AddMvc()
-                .AddMvcOptions(opt => opt.SerializeAsJsonApi(jsonApiOptions));
+                .AddMvcOptions(opt => {
+                    opt.Filters.Add(typeof(JsonApiExceptionFilter));
+                    opt.SerializeAsJsonApi(jsonApiOptions);
+                });
         }
 
         public static void AddJsonApiInternals<TContext>(this IServiceCollection services) 

src/JsonApiDotNetCore/Formatters/JsonApiOutputFormatter.cs

@@ -1,10 +1,13 @@
 using System;
+using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using JsonApiDotNetCore.Internal;
 using JsonApiDotNetCore.Serialization;
 using JsonApiDotNetCore.Services;
 using Microsoft.AspNetCore.Mvc.Formatters;
 using Microsoft.Extensions.DependencyInjection;
+using Newtonsoft.Json;
 
 namespace JsonApiDotNetCore.Formatters
 {
@@ -31,11 +34,22 @@ public async Task WriteAsync(OutputFormatterWriteContext context)
             {
                 var jsonApiContext = context.HttpContext.RequestServices.GetService<IJsonApiContext>();
 
-                var responseContent = JsonApiSerializer.Serialize(context.Object, jsonApiContext);
+                string responseContent;
+                try
+                {
+                    if(context.Object.GetType() == typeof(Error))
+                        responseContent = JsonConvert.SerializeObject(context.Object);
+                    else
+                        responseContent = JsonApiSerializer.Serialize(context.Object, jsonApiContext);
+                }
+                catch(Exception e)
+                {
+                    responseContent = new Error("400", e.Message).GetJson();
+                    response.StatusCode = 400;
+                }
 
                 await writer.WriteAsync(responseContent);
-
-                await writer.FlushAsync();
+                await writer.FlushAsync();       
             }
         }
     }

src/JsonApiDotNetCore/Internal/Error.cs

@@ -0,0 +1,36 @@
+using Newtonsoft.Json;
+
+namespace JsonApiDotNetCore.Internal
+{
+    public class Error
+    {
+        public Error(string status, string title)
+        {
+            Status = status;
+            Title = title;
+        }
+
+        public Error(string status, string title, string detail)
+        {
+            Status = status;
+            Title = title;
+            Detail = detail;
+        }
+        
+        [JsonProperty("title")]
+        public string Title { get; set; }
+
+        [JsonProperty("detail")]
+        public string Detail { get; set; }
+        
+        [JsonProperty("status")]
+        public string Status { get; set; }
+
+        public string GetJson()
+        {
+            return JsonConvert.SerializeObject(this, new JsonSerializerSettings {
+                NullValueHandling = NullValueHandling.Ignore
+            });
+        }
+    }
+}

src/JsonApiDotNetCore/Internal/JsonApiException.cs

@@ -0,0 +1,31 @@
+using System;
+
+namespace JsonApiDotNetCore.Internal
+{
+    public class JsonApiException : Exception
+    {
+        private string _statusCode;
+        private string _detail;
+        private string _message;
+
+        public JsonApiException(string statusCode, string message)
+        : base(message)
+        { 
+            _statusCode = statusCode;
+            _message = message;
+        }
+
+        public JsonApiException(string statusCode, string message, string detail)
+        : base(message)
+        { 
+            _statusCode = statusCode;
+            _message = message;
+            _detail = detail;            
+        }
+
+        public Error GetError()
+        {
+            return new Error(_statusCode, _message, _detail);
+        }
+    }
+}

src/JsonApiDotNetCore/Middleware/JsonApiExceptionFilter.cs

@@ -0,0 +1,32 @@
+using System;
+using JsonApiDotNetCore.Internal;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.Extensions.Logging;
+
+namespace JsonApiDotNetCore.Formatters
+{
+    public class JsonApiExceptionFilter : ActionFilterAttribute, IExceptionFilter
+    {
+        private readonly ILogger _logger;
+        
+        public JsonApiExceptionFilter(ILoggerFactory loggerFactory)
+        {
+            _logger = loggerFactory.CreateLogger<JsonApiExceptionFilter>();
+        }
+
+        public void OnException(ExceptionContext context)
+        {
+            _logger.LogError(context.Exception.Message);
+
+            var jsonApiException = (JsonApiException)context.Exception;
+            if(jsonApiException != null)
+            {
+                var error = jsonApiException.GetError();
+                var result = new ObjectResult(error);
+                result.StatusCode = Convert.ToInt16(error.Status);
+                context.Result = result; 
+            }
+        }
+    }
+}