Merged ErrorDocument and AtomicOperationsDocument into Document

Bugfix: jsonapi/version was missing in error responses

Author: Bart Koelman

src/JsonApiDotNetCore/Controllers/CoreJsonApiController.cs

@@ -21,7 +21,7 @@ protected IActionResult Error(IEnumerable<ErrorObject> errors)
         {
             ArgumentGuard.NotNull(errors, nameof(errors));
 
-            var document = new ErrorDocument
+            var document = new Document
             {
                 Errors = errors.ToList()
             };

src/JsonApiDotNetCore/Middleware/AsyncJsonApiExceptionFilter.cs

@@ -26,11 +26,11 @@ public Task OnExceptionAsync(ExceptionContext context)
 
             if (context.HttpContext.IsJsonApiRequest())
             {
-                ErrorDocument errorDocument = _exceptionHandler.HandleException(context.Exception);
+                Document document = _exceptionHandler.HandleException(context.Exception);
 
-                context.Result = new ObjectResult(errorDocument)
+                context.Result = new ObjectResult(document)
                 {
-                    StatusCode = (int)errorDocument.GetErrorStatusCode()
+                    StatusCode = (int)document.GetErrorStatusCode()
                 };
             }
 

src/JsonApiDotNetCore/Middleware/ExceptionHandler.cs

@@ -28,7 +28,7 @@ public ExceptionHandler(ILoggerFactory loggerFactory, IJsonApiOptions options)
             _logger = loggerFactory.CreateLogger<ExceptionHandler>();
         }
 
-        public ErrorDocument HandleException(Exception exception)
+        public Document HandleException(Exception exception)
         {
             ArgumentGuard.NotNull(exception, nameof(exception));
 
@@ -71,7 +71,7 @@ protected virtual string GetLogMessage(Exception exception)
             return exception.Message;
         }
 
-        protected virtual ErrorDocument CreateErrorDocument(Exception exception)
+        protected virtual Document CreateErrorDocument(Exception exception)
         {
             ArgumentGuard.NotNull(exception, nameof(exception));
 
@@ -90,7 +90,7 @@ protected virtual ErrorDocument CreateErrorDocument(Exception exception)
                 ApplyOptions(error, exception);
             }
 
-            return new ErrorDocument
+            return new Document
             {
                 Errors = errors.ToList()
             };

src/JsonApiDotNetCore/Middleware/IExceptionHandler.cs

@@ -8,6 +8,6 @@ namespace JsonApiDotNetCore.Middleware
     /// </summary>
     public interface IExceptionHandler
     {
-        ErrorDocument HandleException(Exception exception);
+        Document HandleException(Exception exception);
     }
 }

src/JsonApiDotNetCore/Middleware/JsonApiMiddleware.cs

@@ -209,7 +209,7 @@ private static async Task FlushResponseAsync(HttpResponse httpResponse, JsonSeri
             httpResponse.ContentType = HeaderConstants.MediaType;
             httpResponse.StatusCode = (int)error.StatusCode;
 
-            var errorDocument = new ErrorDocument
+            var errorDocument = new Document
             {
                 Errors = error.AsList()
             };

src/JsonApiDotNetCore/Serialization/AtomicOperationsResponseSerializer.cs

@@ -59,7 +59,7 @@ public string Serialize(object content)
                 return SerializeOperationsDocument(operations);
             }
 
-            if (content is ErrorDocument errorDocument)
+            if (content is Document errorDocument)
             {
                 return SerializeErrorDocument(errorDocument);
             }
@@ -69,12 +69,19 @@ public string Serialize(object content)
 
         private string SerializeOperationsDocument(IEnumerable<OperationContainer> operations)
         {
-            var document = new AtomicOperationsDocument
+            var document = new Document
             {
                 Results = operations.Select(SerializeOperation).ToList(),
                 Meta = _metaBuilder.Build()
             };
 
+            SetApiVersion(document);
+
+            return SerializeObject(document, _options.SerializerSettings);
+        }
+
+        private void SetApiVersion(Document document)
+        {
             if (_options.IncludeJsonApiVersion)
             {
                 document.JsonApi = new JsonApiObject
@@ -86,8 +93,6 @@ private string SerializeOperationsDocument(IEnumerable<OperationContainer> opera
                     }
                 };
             }
-
-            return SerializeObject(document, _options.SerializerSettings);
         }
 
         private AtomicResultObject SerializeOperation(OperationContainer operation)
@@ -120,9 +125,11 @@ private AtomicResultObject SerializeOperation(OperationContainer operation)
             };
         }
 
-        private string SerializeErrorDocument(ErrorDocument errorDocument)
+        private string SerializeErrorDocument(Document document)
         {
-            return SerializeObject(errorDocument, _options.SerializerSettings, serializer =>
+            SetApiVersion(document);
+
+            return SerializeObject(document, _options.SerializerSettings, serializer =>
             {
                 serializer.ApplyErrorSettings();
             });

src/JsonApiDotNetCore/Serialization/BaseSerializer.cs

@@ -48,7 +48,10 @@ protected Document Build(IIdentifiable resource, IReadOnlyCollection<AttrAttribu
 
             if (resource == null)
             {
-                return new Document();
+                return new Document
+                {
+                    IsPopulated = true
+                };
             }
 
             return new Document

src/JsonApiDotNetCore/Serialization/IJsonApiDeserializer.cs

@@ -8,8 +8,7 @@ namespace JsonApiDotNetCore.Serialization
     public interface IJsonApiDeserializer
     {
         /// <summary>
-        /// Deserializes JSON into a <see cref="Document" /> or <see cref="AtomicOperationsDocument" /> and constructs resources from
-        /// <see cref="ExposableData{T}.Data" />.
+        /// Deserializes JSON into a <see cref="Document" /> and constructs resources from <see cref="ExposableData{TResource}.Data" />.
         /// </summary>
         /// <param name="body">
         /// The JSON to be deserialized.

src/JsonApiDotNetCore/Serialization/JsonApiWriter.cs

@@ -65,10 +65,10 @@ public async Task WriteAsync(OutputFormatterWriteContext context)
             catch (Exception exception)
 #pragma warning restore AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException
             {
-                ErrorDocument errorDocument = _exceptionHandler.HandleException(exception);
-                responseContent = _serializer.Serialize(errorDocument);
+                Document document = _exceptionHandler.HandleException(exception);
+                responseContent = _serializer.Serialize(document);
 
-                response.StatusCode = (int)errorDocument.GetErrorStatusCode();
+                response.StatusCode = (int)document.GetErrorStatusCode();
             }
 
             bool hasMatchingETag = SetETagResponseHeader(request, response, responseContent);
@@ -132,15 +132,15 @@ private static object WrapErrors(object contextObject)
         {
             if (contextObject is IEnumerable<ErrorObject> errors)
             {
-                return new ErrorDocument
+                return new Document
                 {
                     Errors = errors.ToList()
                 };
             }
 
             if (contextObject is ErrorObject error)
             {
-                return new ErrorDocument
+                return new Document
                 {
                     Errors = error.AsList()
                 };

src/JsonApiDotNetCore/Serialization/Objects/AtomicOperationsDocument.cs

@@ -1,23 +1,53 @@
+using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Net;
 using Newtonsoft.Json;
 
 namespace JsonApiDotNetCore.Serialization.Objects
 {
     /// <summary>
-    /// See https://jsonapi.org/format/1.1/#document-top-level.
+    /// See https://jsonapi.org/format/1.1/#document-top-level and https://jsonapi.org/ext/atomic/#document-structure.
     /// </summary>
     public sealed class Document : ExposableData<ResourceObject>
     {
-        [JsonProperty("meta", NullValueHandling = NullValueHandling.Ignore)]
-        public IDictionary<string, object> Meta { get; set; }
-
         [JsonProperty("jsonapi", NullValueHandling = NullValueHandling.Ignore)]
         public JsonApiObject JsonApi { get; set; }
 
+        [JsonProperty("atomic:operations", NullValueHandling = NullValueHandling.Ignore)]
+        public IList<AtomicOperationObject> Operations { get; set; }
+
+        [JsonProperty("atomic:results", NullValueHandling = NullValueHandling.Ignore)]
+        public IList<AtomicResultObject> Results { get; set; }
+
+        [JsonProperty("errors", NullValueHandling = NullValueHandling.Ignore)]
+        public IList<ErrorObject> Errors { get; set; }
+
+        [JsonProperty("meta", NullValueHandling = NullValueHandling.Ignore)]
+        public IDictionary<string, object> Meta { get; set; }
+
         [JsonProperty("links", NullValueHandling = NullValueHandling.Ignore)]
         public TopLevelLinks Links { get; set; }
 
         [JsonProperty("included", NullValueHandling = NullValueHandling.Ignore, Order = 1)]
         public IList<ResourceObject> Included { get; set; }
+
+        internal HttpStatusCode GetErrorStatusCode()
+        {
+            if (Errors.IsNullOrEmpty())
+            {
+                throw new InvalidOperationException("No errors found.");
+            }
+
+            int[] statusCodes = Errors.Select(error => (int)error.StatusCode).Distinct().ToArray();
+
+            if (statusCodes.Length == 1)
+            {
+                return (HttpStatusCode)statusCodes[0];
+            }
+
+            int statusCode = int.Parse($"{statusCodes.Max().ToString()[0]}00");
+            return (HttpStatusCode)statusCode;
+        }
     }
 }

src/JsonApiDotNetCore/Serialization/Objects/Document.cs

@@ -18,7 +18,7 @@ public abstract class ExposableData<TResource>
         /// Internally used to indicate if the document's primary data should still be serialized when it's value is null. This is used when a single resource is
         /// requested but not present (eg /articles/1/author).
         /// </summary>
-        internal bool IsPopulated { get; private set; }
+        internal bool IsPopulated { get; set; }
 
         internal bool HasResource => IsPopulated && !IsEmpty;
 
@@ -59,12 +59,7 @@ public object Data
         /// </remarks>
         public bool ShouldSerializeData()
         {
-            if (GetType() == typeof(RelationshipObject))
-            {
-                return IsPopulated;
-            }
-
-            return true;
+            return IsPopulated;
         }
 
         /// <summary>

src/JsonApiDotNetCore/Serialization/Objects/ErrorDocument.cs

@@ -75,12 +75,12 @@ public object Deserialize(string body)
 
         private object DeserializeOperationsDocument(string body)
         {
-            AtomicOperationsDocument document;
+            Document document;
 
             using (CodeTimingSessionManager.Current.Measure("Newtonsoft.Deserialize", MeasurementSettings.ExcludeJsonSerializationInPercentages))
             {
                 JToken bodyToken = LoadJToken(body);
-                document = bodyToken.ToObject<AtomicOperationsDocument>();
+                document = bodyToken.ToObject<Document>();
             }
 
             if ((document?.Operations).IsNullOrEmpty())

src/JsonApiDotNetCore/Serialization/Objects/ExposableData.cs

@@ -72,17 +72,19 @@ public string Serialize(object content)
                 return SerializeMany(collectionOfIdentifiable.ToArray());
             }
 
-            if (content is ErrorDocument errorDocument)
+            if (content is Document errorDocument)
             {
                 return SerializeErrorDocument(errorDocument);
             }
 
             throw new InvalidOperationException("Data being returned must be errors or resources.");
         }
 
-        private string SerializeErrorDocument(ErrorDocument errorDocument)
+        private string SerializeErrorDocument(Document document)
         {
-            return SerializeObject(errorDocument, _options.SerializerSettings, serializer =>
+            SetApiVersion(document);
+
+            return SerializeObject(document, _options.SerializerSettings, serializer =>
             {
                 serializer.ApplyErrorSettings();
             });
@@ -165,6 +167,15 @@ internal string SerializeMany(IReadOnlyCollection<IIdentifiable> resources)
         /// Adds top-level objects that are only added to a document in the case of server-side serialization.
         /// </summary>
         private void AddTopLevelObjects(Document document)
+        {
+            SetApiVersion(document);
+
+            document.Links = _linkBuilder.GetTopLevelLinks();
+            document.Meta = _metaBuilder.Build();
+            document.Included = _includedBuilder.Build();
+        }
+
+        private void SetApiVersion(Document document)
         {
             if (_options.IncludeJsonApiVersion)
             {
@@ -173,10 +184,6 @@ private void AddTopLevelObjects(Document document)
                     Version = "1.1"
                 };
             }
-
-            document.Links = _linkBuilder.GetTopLevelLinks();
-            document.Meta = _metaBuilder.Build();
-            document.Included = _includedBuilder.Build();
         }
     }
 }