diff --git a/ROADMAP.md b/ROADMAP.md
index 1c15a33b2b..b3eb75daa6 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -20,7 +20,7 @@ The need for breaking changes has blocked several efforts in the v4.x release, s
 - [x] Instrumentation [#1032](https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/1032)
 - [x] Optimized delete to-many [#1030](https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/1030)
 - [x] Support System.Text.Json [#664](https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/664) [#999](https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/999) [1077](https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/1077) [1078](https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/1078)
-- [ ] Optimize IIdentifiable to ResourceObject conversion [#1028](https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/1028) [#1024](https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/1024) [#233](https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/233)
+- [x] Optimize IIdentifiable to ResourceObject conversion [#1028](https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/1028) [#1024](https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/1024) [#233](https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/233)
 - [ ] Nullable reference types [#1029](https://github.com/json-api-dotnet/JsonApiDotNetCore/issues/1029)
 
 Aside from the list above, we have interest in the following topics. It's too soon yet to decide whether they'll make it into v5.x or in a later major version.
diff --git a/benchmarks/Deserialization/DeserializationBenchmarkBase.cs b/benchmarks/Deserialization/DeserializationBenchmarkBase.cs
new file mode 100644
index 0000000000..a99861b562
--- /dev/null
+++ b/benchmarks/Deserialization/DeserializationBenchmarkBase.cs
@@ -0,0 +1,122 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Design;
+using System.Text.Json;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Serialization.JsonConverters;
+using JsonApiDotNetCore.Serialization.Request.Adapters;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace Benchmarks.Deserialization
+{
+    public abstract class DeserializationBenchmarkBase
+    {
+        protected readonly JsonSerializerOptions SerializerReadOptions;
+        protected readonly DocumentAdapter DocumentAdapter;
+
+        protected DeserializationBenchmarkBase()
+        {
+            var options = new JsonApiOptions();
+            IResourceGraph resourceGraph = new ResourceGraphBuilder(options, NullLoggerFactory.Instance).Add<ResourceA>().Build();
+            options.SerializerOptions.Converters.Add(new ResourceObjectConverter(resourceGraph));
+            SerializerReadOptions = ((IJsonApiOptions)options).SerializerReadOptions;
+
+            var serviceContainer = new ServiceContainer();
+            var resourceFactory = new ResourceFactory(serviceContainer);
+            var resourceDefinitionAccessor = new ResourceDefinitionAccessor(resourceGraph, serviceContainer);
+
+            serviceContainer.AddService(typeof(IResourceDefinitionAccessor), resourceDefinitionAccessor);
+            serviceContainer.AddService(typeof(IResourceDefinition<ResourceA>), new JsonApiResourceDefinition<ResourceA>(resourceGraph));
+
+            // ReSharper disable once VirtualMemberCallInConstructor
+            JsonApiRequest request = CreateJsonApiRequest(resourceGraph);
+            var targetedFields = new TargetedFields();
+
+            var resourceIdentifierObjectAdapter = new ResourceIdentifierObjectAdapter(resourceGraph, resourceFactory);
+            var relationshipDataAdapter = new RelationshipDataAdapter(resourceIdentifierObjectAdapter);
+            var resourceObjectAdapter = new ResourceObjectAdapter(resourceGraph, resourceFactory, options, relationshipDataAdapter);
+            var resourceDataAdapter = new ResourceDataAdapter(resourceDefinitionAccessor, resourceObjectAdapter);
+
+            var atomicReferenceAdapter = new AtomicReferenceAdapter(resourceGraph, resourceFactory);
+            var atomicOperationResourceDataAdapter = new ResourceDataInOperationsRequestAdapter(resourceDefinitionAccessor, resourceObjectAdapter);
+
+            var atomicOperationObjectAdapter = new AtomicOperationObjectAdapter(options, atomicReferenceAdapter,
+                atomicOperationResourceDataAdapter, relationshipDataAdapter);
+
+            var resourceDocumentAdapter = new DocumentInResourceOrRelationshipRequestAdapter(options, resourceDataAdapter, relationshipDataAdapter);
+            var operationsDocumentAdapter = new DocumentInOperationsRequestAdapter(options, atomicOperationObjectAdapter);
+
+            DocumentAdapter = new DocumentAdapter(request, targetedFields, resourceDocumentAdapter, operationsDocumentAdapter);
+        }
+
+        protected abstract JsonApiRequest CreateJsonApiRequest(IResourceGraph resourceGraph);
+
+        [UsedImplicitly(ImplicitUseTargetFlags.Members)]
+        public sealed class ResourceA : Identifiable
+        {
+            [Attr]
+            public bool Attribute01 { get; set; }
+
+            [Attr]
+            public char Attribute02 { get; set; }
+
+            [Attr]
+            public ulong? Attribute03 { get; set; }
+
+            [Attr]
+            public decimal Attribute04 { get; set; }
+
+            [Attr]
+            public float? Attribute05 { get; set; }
+
+            [Attr]
+            public string Attribute06 { get; set; }
+
+            [Attr]
+            public DateTime? Attribute07 { get; set; }
+
+            [Attr]
+            public DateTimeOffset? Attribute08 { get; set; }
+
+            [Attr]
+            public TimeSpan? Attribute09 { get; set; }
+
+            [Attr]
+            public DayOfWeek Attribute10 { get; set; }
+
+            [HasOne]
+            public ResourceA Single1 { get; set; }
+
+            [HasOne]
+            public ResourceA Single2 { get; set; }
+
+            [HasOne]
+            public ResourceA Single3 { get; set; }
+
+            [HasOne]
+            public ResourceA Single4 { get; set; }
+
+            [HasOne]
+            public ResourceA Single5 { get; set; }
+
+            [HasMany]
+            public ISet<ResourceA> Multi1 { get; set; }
+
+            [HasMany]
+            public ISet<ResourceA> Multi2 { get; set; }
+
+            [HasMany]
+            public ISet<ResourceA> Multi3 { get; set; }
+
+            [HasMany]
+            public ISet<ResourceA> Multi4 { get; set; }
+
+            [HasMany]
+            public ISet<ResourceA> Multi5 { get; set; }
+        }
+    }
+}
diff --git a/benchmarks/Deserialization/OperationsDeserializationBenchmarks.cs b/benchmarks/Deserialization/OperationsDeserializationBenchmarks.cs
new file mode 100644
index 0000000000..c09b7c77c7
--- /dev/null
+++ b/benchmarks/Deserialization/OperationsDeserializationBenchmarks.cs
@@ -0,0 +1,285 @@
+using System;
+using System.Text.Json;
+using BenchmarkDotNet.Attributes;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace Benchmarks.Deserialization
+{
+    [MarkdownExporter]
+    // ReSharper disable once ClassCanBeSealed.Global
+    public class OperationsDeserializationBenchmarks : DeserializationBenchmarkBase
+    {
+        private static readonly string RequestBody = JsonSerializer.Serialize(new
+        {
+            atomic__operations = new object[]
+            {
+                new
+                {
+                    op = "add",
+                    data = new
+                    {
+                        type = "resourceAs",
+                        lid = "a-1",
+                        attributes = new
+                        {
+                            attribute01 = true,
+                            attribute02 = 'A',
+                            attribute03 = 100UL,
+                            attribute04 = 100.001m,
+                            attribute05 = 200.002f,
+                            attribute06 = "text",
+                            attribute07 = DateTime.MaxValue,
+                            attribute08 = DateTimeOffset.MaxValue,
+                            attribute09 = TimeSpan.MaxValue,
+                            attribute10 = DayOfWeek.Friday
+                        },
+                        relationships = new
+                        {
+                            single1 = new
+                            {
+                                data = new
+                                {
+                                    type = "resourceAs",
+                                    id = "101"
+                                }
+                            },
+                            single2 = new
+                            {
+                                data = new
+                                {
+                                    type = "resourceAs",
+                                    id = "102"
+                                }
+                            },
+                            single3 = new
+                            {
+                                data = new
+                                {
+                                    type = "resourceAs",
+                                    id = "103"
+                                }
+                            },
+                            single4 = new
+                            {
+                                data = new
+                                {
+                                    type = "resourceAs",
+                                    id = "104"
+                                }
+                            },
+                            single5 = new
+                            {
+                                data = new
+                                {
+                                    type = "resourceAs",
+                                    id = "105"
+                                }
+                            },
+                            multi1 = new
+                            {
+                                data = new[]
+                                {
+                                    new
+                                    {
+                                        type = "resourceAs",
+                                        id = "201"
+                                    }
+                                }
+                            },
+                            multi2 = new
+                            {
+                                data = new[]
+                                {
+                                    new
+                                    {
+                                        type = "resourceAs",
+                                        id = "202"
+                                    }
+                                }
+                            },
+                            multi3 = new
+                            {
+                                data = new[]
+                                {
+                                    new
+                                    {
+                                        type = "resourceAs",
+                                        id = "203"
+                                    }
+                                }
+                            },
+                            multi4 = new
+                            {
+                                data = new[]
+                                {
+                                    new
+                                    {
+                                        type = "resourceAs",
+                                        id = "204"
+                                    }
+                                }
+                            },
+                            multi5 = new
+                            {
+                                data = new[]
+                                {
+                                    new
+                                    {
+                                        type = "resourceAs",
+                                        id = "205"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                new
+                {
+                    op = "update",
+                    data = new
+                    {
+                        type = "resourceAs",
+                        id = "1",
+                        attributes = new
+                        {
+                            attribute01 = true,
+                            attribute02 = 'A',
+                            attribute03 = 100UL,
+                            attribute04 = 100.001m,
+                            attribute05 = 200.002f,
+                            attribute06 = "text",
+                            attribute07 = DateTime.MaxValue,
+                            attribute08 = DateTimeOffset.MaxValue,
+                            attribute09 = TimeSpan.MaxValue,
+                            attribute10 = DayOfWeek.Friday
+                        },
+                        relationships = new
+                        {
+                            single1 = new
+                            {
+                                data = new
+                                {
+                                    type = "resourceAs",
+                                    id = "101"
+                                }
+                            },
+                            single2 = new
+                            {
+                                data = new
+                                {
+                                    type = "resourceAs",
+                                    id = "102"
+                                }
+                            },
+                            single3 = new
+                            {
+                                data = new
+                                {
+                                    type = "resourceAs",
+                                    id = "103"
+                                }
+                            },
+                            single4 = new
+                            {
+                                data = new
+                                {
+                                    type = "resourceAs",
+                                    id = "104"
+                                }
+                            },
+                            single5 = new
+                            {
+                                data = new
+                                {
+                                    type = "resourceAs",
+                                    id = "105"
+                                }
+                            },
+                            multi1 = new
+                            {
+                                data = new[]
+                                {
+                                    new
+                                    {
+                                        type = "resourceAs",
+                                        id = "201"
+                                    }
+                                }
+                            },
+                            multi2 = new
+                            {
+                                data = new[]
+                                {
+                                    new
+                                    {
+                                        type = "resourceAs",
+                                        id = "202"
+                                    }
+                                }
+                            },
+                            multi3 = new
+                            {
+                                data = new[]
+                                {
+                                    new
+                                    {
+                                        type = "resourceAs",
+                                        id = "203"
+                                    }
+                                }
+                            },
+                            multi4 = new
+                            {
+                                data = new[]
+                                {
+                                    new
+                                    {
+                                        type = "resourceAs",
+                                        id = "204"
+                                    }
+                                }
+                            },
+                            multi5 = new
+                            {
+                                data = new[]
+                                {
+                                    new
+                                    {
+                                        type = "resourceAs",
+                                        id = "205"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                new
+                {
+                    op = "remove",
+                    @ref = new
+                    {
+                        type = "resourceAs",
+                        lid = "a-1"
+                    }
+                }
+            }
+        }).Replace("atomic__operations", "atomic:operations");
+
+        [Benchmark]
+        public object DeserializeOperationsRequest()
+        {
+            var document = JsonSerializer.Deserialize<Document>(RequestBody, SerializerReadOptions);
+            return DocumentAdapter.Convert(document);
+        }
+
+        protected override JsonApiRequest CreateJsonApiRequest(IResourceGraph resourceGraph)
+        {
+            return new()
+            {
+                Kind = EndpointKind.AtomicOperations
+            };
+        }
+    }
+}
diff --git a/benchmarks/Deserialization/ResourceDeserializationBenchmarks.cs b/benchmarks/Deserialization/ResourceDeserializationBenchmarks.cs
new file mode 100644
index 0000000000..d3fe50ffa6
--- /dev/null
+++ b/benchmarks/Deserialization/ResourceDeserializationBenchmarks.cs
@@ -0,0 +1,151 @@
+using System;
+using System.Text.Json;
+using BenchmarkDotNet.Attributes;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace Benchmarks.Deserialization
+{
+    [MarkdownExporter]
+    // ReSharper disable once ClassCanBeSealed.Global
+    public class ResourceDeserializationBenchmarks : DeserializationBenchmarkBase
+    {
+        private static readonly string RequestBody = JsonSerializer.Serialize(new
+        {
+            data = new
+            {
+                type = "resourceAs",
+                attributes = new
+                {
+                    attribute01 = true,
+                    attribute02 = 'A',
+                    attribute03 = 100UL,
+                    attribute04 = 100.001m,
+                    attribute05 = 200.002f,
+                    attribute06 = "text",
+                    attribute07 = DateTime.MaxValue,
+                    attribute08 = DateTimeOffset.MaxValue,
+                    attribute09 = TimeSpan.MaxValue,
+                    attribute10 = DayOfWeek.Friday
+                },
+                relationships = new
+                {
+                    single1 = new
+                    {
+                        data = new
+                        {
+                            type = "resourceAs",
+                            id = "101"
+                        }
+                    },
+                    single2 = new
+                    {
+                        data = new
+                        {
+                            type = "resourceAs",
+                            id = "102"
+                        }
+                    },
+                    single3 = new
+                    {
+                        data = new
+                        {
+                            type = "resourceAs",
+                            id = "103"
+                        }
+                    },
+                    single4 = new
+                    {
+                        data = new
+                        {
+                            type = "resourceAs",
+                            id = "104"
+                        }
+                    },
+                    single5 = new
+                    {
+                        data = new
+                        {
+                            type = "resourceAs",
+                            id = "105"
+                        }
+                    },
+                    multi1 = new
+                    {
+                        data = new[]
+                        {
+                            new
+                            {
+                                type = "resourceAs",
+                                id = "201"
+                            }
+                        }
+                    },
+                    multi2 = new
+                    {
+                        data = new[]
+                        {
+                            new
+                            {
+                                type = "resourceAs",
+                                id = "202"
+                            }
+                        }
+                    },
+                    multi3 = new
+                    {
+                        data = new[]
+                        {
+                            new
+                            {
+                                type = "resourceAs",
+                                id = "203"
+                            }
+                        }
+                    },
+                    multi4 = new
+                    {
+                        data = new[]
+                        {
+                            new
+                            {
+                                type = "resourceAs",
+                                id = "204"
+                            }
+                        }
+                    },
+                    multi5 = new
+                    {
+                        data = new[]
+                        {
+                            new
+                            {
+                                type = "resourceAs",
+                                id = "205"
+                            }
+                        }
+                    }
+                }
+            }
+        });
+
+        [Benchmark]
+        public object DeserializeResourceRequest()
+        {
+            var document = JsonSerializer.Deserialize<Document>(RequestBody, SerializerReadOptions);
+
+            return DocumentAdapter.Convert(document);
+        }
+
+        protected override JsonApiRequest CreateJsonApiRequest(IResourceGraph resourceGraph)
+        {
+            return new()
+            {
+                Kind = EndpointKind.Primary,
+                PrimaryResourceType = resourceGraph.GetResourceType<ResourceA>(),
+                WriteOperation = WriteOperationKind.CreateResource
+            };
+        }
+    }
+}
diff --git a/benchmarks/LinkBuilder/LinkBuilderGetNamespaceFromPathBenchmarks.cs b/benchmarks/LinkBuilding/LinkBuilderGetNamespaceFromPathBenchmarks.cs
similarity index 98%
rename from benchmarks/LinkBuilder/LinkBuilderGetNamespaceFromPathBenchmarks.cs
rename to benchmarks/LinkBuilding/LinkBuilderGetNamespaceFromPathBenchmarks.cs
index c7110bf73e..400fc0dbcf 100644
--- a/benchmarks/LinkBuilder/LinkBuilderGetNamespaceFromPathBenchmarks.cs
+++ b/benchmarks/LinkBuilding/LinkBuilderGetNamespaceFromPathBenchmarks.cs
@@ -2,7 +2,7 @@
 using System.Text;
 using BenchmarkDotNet.Attributes;
 
-namespace Benchmarks.LinkBuilder
+namespace Benchmarks.LinkBuilding
 {
     // ReSharper disable once ClassCanBeSealed.Global
     [MarkdownExporter]
diff --git a/benchmarks/Program.cs b/benchmarks/Program.cs
index 0d745a795d..995538eb76 100644
--- a/benchmarks/Program.cs
+++ b/benchmarks/Program.cs
@@ -1,5 +1,6 @@
 using BenchmarkDotNet.Running;
-using Benchmarks.LinkBuilder;
+using Benchmarks.Deserialization;
+using Benchmarks.LinkBuilding;
 using Benchmarks.Query;
 using Benchmarks.Serialization;
 
@@ -11,8 +12,10 @@ private static void Main(string[] args)
         {
             var switcher = new BenchmarkSwitcher(new[]
             {
-                typeof(JsonApiDeserializerBenchmarks),
-                typeof(JsonApiSerializerBenchmarks),
+                typeof(ResourceDeserializationBenchmarks),
+                typeof(OperationsDeserializationBenchmarks),
+                typeof(ResourceSerializationBenchmarks),
+                typeof(OperationsSerializationBenchmarks),
                 typeof(QueryParserBenchmarks),
                 typeof(LinkBuilderGetNamespaceFromPathBenchmarks)
             });
diff --git a/benchmarks/Query/QueryParserBenchmarks.cs b/benchmarks/Query/QueryParserBenchmarks.cs
index 8f1ec950da..bb6cec20e8 100644
--- a/benchmarks/Query/QueryParserBenchmarks.cs
+++ b/benchmarks/Query/QueryParserBenchmarks.cs
@@ -36,7 +36,7 @@ public QueryParserBenchmarks()
 
             var request = new JsonApiRequest
             {
-                PrimaryResource = resourceGraph.GetResourceContext(typeof(BenchmarkResource)),
+                PrimaryResourceType = resourceGraph.GetResourceType(typeof(BenchmarkResource)),
                 IsCollection = true
             };
 
diff --git a/benchmarks/Serialization/JsonApiDeserializerBenchmarks.cs b/benchmarks/Serialization/JsonApiDeserializerBenchmarks.cs
deleted file mode 100644
index 2c2cb62223..0000000000
--- a/benchmarks/Serialization/JsonApiDeserializerBenchmarks.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-using System.ComponentModel.Design;
-using System.Text.Json;
-using BenchmarkDotNet.Attributes;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Middleware;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Serialization;
-using Microsoft.AspNetCore.Http;
-
-namespace Benchmarks.Serialization
-{
-    // ReSharper disable once ClassCanBeSealed.Global
-    [MarkdownExporter]
-    public class JsonApiDeserializerBenchmarks
-    {
-        private static readonly string RequestBody = JsonSerializer.Serialize(new
-        {
-            data = new
-            {
-                type = BenchmarkResourcePublicNames.Type,
-                id = "1",
-                attributes = new
-                {
-                }
-            }
-        });
-
-        private readonly DependencyFactory _dependencyFactory = new();
-        private readonly IJsonApiDeserializer _jsonApiDeserializer;
-
-        public JsonApiDeserializerBenchmarks()
-        {
-            var options = new JsonApiOptions();
-            IResourceGraph resourceGraph = _dependencyFactory.CreateResourceGraph(options);
-
-            var serviceContainer = new ServiceContainer();
-            var resourceDefinitionAccessor = new ResourceDefinitionAccessor(resourceGraph, serviceContainer);
-
-            serviceContainer.AddService(typeof(IResourceDefinitionAccessor), resourceDefinitionAccessor);
-            serviceContainer.AddService(typeof(IResourceDefinition<BenchmarkResource>), new JsonApiResourceDefinition<BenchmarkResource>(resourceGraph));
-
-            var targetedFields = new TargetedFields();
-            var request = new JsonApiRequest();
-            var resourceFactory = new ResourceFactory(serviceContainer);
-            var httpContextAccessor = new HttpContextAccessor();
-
-            _jsonApiDeserializer = new RequestDeserializer(resourceGraph, resourceFactory, targetedFields, httpContextAccessor, request, options,
-                resourceDefinitionAccessor);
-        }
-
-        [Benchmark]
-        public object DeserializeSimpleObject()
-        {
-            return _jsonApiDeserializer.Deserialize(RequestBody);
-        }
-    }
-}
diff --git a/benchmarks/Serialization/JsonApiSerializerBenchmarks.cs b/benchmarks/Serialization/JsonApiSerializerBenchmarks.cs
deleted file mode 100644
index 0fa58c272e..0000000000
--- a/benchmarks/Serialization/JsonApiSerializerBenchmarks.cs
+++ /dev/null
@@ -1,65 +0,0 @@
-using System;
-using BenchmarkDotNet.Attributes;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Middleware;
-using JsonApiDotNetCore.Queries;
-using JsonApiDotNetCore.QueryStrings.Internal;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Serialization;
-using JsonApiDotNetCore.Serialization.Building;
-using Moq;
-
-namespace Benchmarks.Serialization
-{
-    // ReSharper disable once ClassCanBeSealed.Global
-    [MarkdownExporter]
-    public class JsonApiSerializerBenchmarks
-    {
-        private static readonly BenchmarkResource Content = new()
-        {
-            Id = 123,
-            Name = Guid.NewGuid().ToString()
-        };
-
-        private readonly DependencyFactory _dependencyFactory = new();
-        private readonly IJsonApiSerializer _jsonApiSerializer;
-
-        public JsonApiSerializerBenchmarks()
-        {
-            var options = new JsonApiOptions();
-            IResourceGraph resourceGraph = _dependencyFactory.CreateResourceGraph(options);
-            IFieldsToSerialize fieldsToSerialize = CreateFieldsToSerialize(resourceGraph);
-
-            IMetaBuilder metaBuilder = new Mock<IMetaBuilder>().Object;
-            ILinkBuilder linkBuilder = new Mock<ILinkBuilder>().Object;
-            IIncludedResourceObjectBuilder includeBuilder = new Mock<IIncludedResourceObjectBuilder>().Object;
-
-            var resourceObjectBuilder = new ResourceObjectBuilder(resourceGraph, options);
-
-            IResourceDefinitionAccessor resourceDefinitionAccessor = new Mock<IResourceDefinitionAccessor>().Object;
-
-            _jsonApiSerializer = new ResponseSerializer<BenchmarkResource>(metaBuilder, linkBuilder, includeBuilder, fieldsToSerialize, resourceObjectBuilder,
-                resourceDefinitionAccessor, options);
-        }
-
-        private static FieldsToSerialize CreateFieldsToSerialize(IResourceGraph resourceGraph)
-        {
-            var request = new JsonApiRequest();
-
-            var constraintProviders = new IQueryConstraintProvider[]
-            {
-                new SparseFieldSetQueryStringParameterReader(request, resourceGraph)
-            };
-
-            IResourceDefinitionAccessor accessor = new Mock<IResourceDefinitionAccessor>().Object;
-
-            return new FieldsToSerialize(resourceGraph, constraintProviders, accessor, request);
-        }
-
-        [Benchmark]
-        public object SerializeSimpleObject()
-        {
-            return _jsonApiSerializer.Serialize(Content);
-        }
-    }
-}
diff --git a/benchmarks/Serialization/OperationsSerializationBenchmarks.cs b/benchmarks/Serialization/OperationsSerializationBenchmarks.cs
new file mode 100644
index 0000000000..fbcdf0b0a9
--- /dev/null
+++ b/benchmarks/Serialization/OperationsSerializationBenchmarks.cs
@@ -0,0 +1,137 @@
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using BenchmarkDotNet.Attributes;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Queries.Internal;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace Benchmarks.Serialization
+{
+    [MarkdownExporter]
+    // ReSharper disable once ClassCanBeSealed.Global
+    public class OperationsSerializationBenchmarks : SerializationBenchmarkBase
+    {
+        private readonly IEnumerable<OperationContainer> _responseOperations;
+
+        public OperationsSerializationBenchmarks()
+        {
+            // ReSharper disable once VirtualMemberCallInConstructor
+            JsonApiRequest request = CreateJsonApiRequest(ResourceGraph);
+
+            _responseOperations = CreateResponseOperations(request);
+        }
+
+        private static IEnumerable<OperationContainer> CreateResponseOperations(IJsonApiRequest request)
+        {
+            var resource1 = new ResourceA
+            {
+                Id = 1,
+                Attribute01 = true,
+                Attribute02 = 'A',
+                Attribute03 = 100UL,
+                Attribute04 = 100.001m,
+                Attribute05 = 100.002f,
+                Attribute06 = "text1",
+                Attribute07 = new DateTime(2001, 1, 1),
+                Attribute08 = new DateTimeOffset(2001, 1, 1, 0, 0, 0, TimeSpan.FromHours(1)),
+                Attribute09 = new TimeSpan(1, 0, 0),
+                Attribute10 = DayOfWeek.Sunday
+            };
+
+            var resource2 = new ResourceA
+            {
+                Id = 2,
+                Attribute01 = false,
+                Attribute02 = 'B',
+                Attribute03 = 200UL,
+                Attribute04 = 200.001m,
+                Attribute05 = 200.002f,
+                Attribute06 = "text2",
+                Attribute07 = new DateTime(2002, 2, 2),
+                Attribute08 = new DateTimeOffset(2002, 2, 2, 0, 0, 0, TimeSpan.FromHours(2)),
+                Attribute09 = new TimeSpan(2, 0, 0),
+                Attribute10 = DayOfWeek.Monday
+            };
+
+            var resource3 = new ResourceA
+            {
+                Id = 3,
+                Attribute01 = true,
+                Attribute02 = 'C',
+                Attribute03 = 300UL,
+                Attribute04 = 300.001m,
+                Attribute05 = 300.002f,
+                Attribute06 = "text3",
+                Attribute07 = new DateTime(2003, 3, 3),
+                Attribute08 = new DateTimeOffset(2003, 3, 3, 0, 0, 0, TimeSpan.FromHours(3)),
+                Attribute09 = new TimeSpan(3, 0, 0),
+                Attribute10 = DayOfWeek.Tuesday
+            };
+
+            var resource4 = new ResourceA
+            {
+                Id = 4,
+                Attribute01 = false,
+                Attribute02 = 'D',
+                Attribute03 = 400UL,
+                Attribute04 = 400.001m,
+                Attribute05 = 400.002f,
+                Attribute06 = "text4",
+                Attribute07 = new DateTime(2004, 4, 4),
+                Attribute08 = new DateTimeOffset(2004, 4, 4, 0, 0, 0, TimeSpan.FromHours(4)),
+                Attribute09 = new TimeSpan(4, 0, 0),
+                Attribute10 = DayOfWeek.Wednesday
+            };
+
+            var resource5 = new ResourceA
+            {
+                Id = 5,
+                Attribute01 = true,
+                Attribute02 = 'E',
+                Attribute03 = 500UL,
+                Attribute04 = 500.001m,
+                Attribute05 = 500.002f,
+                Attribute06 = "text5",
+                Attribute07 = new DateTime(2005, 5, 5),
+                Attribute08 = new DateTimeOffset(2005, 5, 5, 0, 0, 0, TimeSpan.FromHours(5)),
+                Attribute09 = new TimeSpan(5, 0, 0),
+                Attribute10 = DayOfWeek.Thursday
+            };
+
+            var targetedFields = new TargetedFields();
+
+            return new List<OperationContainer>
+            {
+                new(resource1, targetedFields, request),
+                new(resource2, targetedFields, request),
+                new(resource3, targetedFields, request),
+                new(resource4, targetedFields, request),
+                new(resource5, targetedFields, request)
+            };
+        }
+
+        [Benchmark]
+        public string SerializeOperationsResponse()
+        {
+            Document responseDocument = ResponseModelAdapter.Convert(_responseOperations);
+            return JsonSerializer.Serialize(responseDocument, SerializerWriteOptions);
+        }
+
+        protected override JsonApiRequest CreateJsonApiRequest(IResourceGraph resourceGraph)
+        {
+            return new()
+            {
+                Kind = EndpointKind.AtomicOperations,
+                PrimaryResourceType = resourceGraph.GetResourceType<ResourceA>()
+            };
+        }
+
+        protected override IEvaluatedIncludeCache CreateEvaluatedIncludeCache(IResourceGraph resourceGraph)
+        {
+            return new EvaluatedIncludeCache();
+        }
+    }
+}
diff --git a/benchmarks/Serialization/ResourceSerializationBenchmarks.cs b/benchmarks/Serialization/ResourceSerializationBenchmarks.cs
new file mode 100644
index 0000000000..8f538cc9a2
--- /dev/null
+++ b/benchmarks/Serialization/ResourceSerializationBenchmarks.cs
@@ -0,0 +1,143 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Text.Json;
+using BenchmarkDotNet.Attributes;
+using JsonApiDotNetCore;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Queries.Expressions;
+using JsonApiDotNetCore.Queries.Internal;
+using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace Benchmarks.Serialization
+{
+    [MarkdownExporter]
+    // ReSharper disable once ClassCanBeSealed.Global
+    public class ResourceSerializationBenchmarks : SerializationBenchmarkBase
+    {
+        private static readonly ResourceA ResponseResource = CreateResponseResource();
+
+        private static ResourceA CreateResponseResource()
+        {
+            var resource1 = new ResourceA
+            {
+                Id = 1,
+                Attribute01 = true,
+                Attribute02 = 'A',
+                Attribute03 = 100UL,
+                Attribute04 = 100.001m,
+                Attribute05 = 100.002f,
+                Attribute06 = "text1",
+                Attribute07 = new DateTime(2001, 1, 1),
+                Attribute08 = new DateTimeOffset(2001, 1, 1, 0, 0, 0, TimeSpan.FromHours(1)),
+                Attribute09 = new TimeSpan(1, 0, 0),
+                Attribute10 = DayOfWeek.Sunday
+            };
+
+            var resource2 = new ResourceA
+            {
+                Id = 2,
+                Attribute01 = false,
+                Attribute02 = 'B',
+                Attribute03 = 200UL,
+                Attribute04 = 200.001m,
+                Attribute05 = 200.002f,
+                Attribute06 = "text2",
+                Attribute07 = new DateTime(2002, 2, 2),
+                Attribute08 = new DateTimeOffset(2002, 2, 2, 0, 0, 0, TimeSpan.FromHours(2)),
+                Attribute09 = new TimeSpan(2, 0, 0),
+                Attribute10 = DayOfWeek.Monday
+            };
+
+            var resource3 = new ResourceA
+            {
+                Id = 3,
+                Attribute01 = true,
+                Attribute02 = 'C',
+                Attribute03 = 300UL,
+                Attribute04 = 300.001m,
+                Attribute05 = 300.002f,
+                Attribute06 = "text3",
+                Attribute07 = new DateTime(2003, 3, 3),
+                Attribute08 = new DateTimeOffset(2003, 3, 3, 0, 0, 0, TimeSpan.FromHours(3)),
+                Attribute09 = new TimeSpan(3, 0, 0),
+                Attribute10 = DayOfWeek.Tuesday
+            };
+
+            var resource4 = new ResourceA
+            {
+                Id = 4,
+                Attribute01 = false,
+                Attribute02 = 'D',
+                Attribute03 = 400UL,
+                Attribute04 = 400.001m,
+                Attribute05 = 400.002f,
+                Attribute06 = "text4",
+                Attribute07 = new DateTime(2004, 4, 4),
+                Attribute08 = new DateTimeOffset(2004, 4, 4, 0, 0, 0, TimeSpan.FromHours(4)),
+                Attribute09 = new TimeSpan(4, 0, 0),
+                Attribute10 = DayOfWeek.Wednesday
+            };
+
+            var resource5 = new ResourceA
+            {
+                Id = 5,
+                Attribute01 = true,
+                Attribute02 = 'E',
+                Attribute03 = 500UL,
+                Attribute04 = 500.001m,
+                Attribute05 = 500.002f,
+                Attribute06 = "text5",
+                Attribute07 = new DateTime(2005, 5, 5),
+                Attribute08 = new DateTimeOffset(2005, 5, 5, 0, 0, 0, TimeSpan.FromHours(5)),
+                Attribute09 = new TimeSpan(5, 0, 0),
+                Attribute10 = DayOfWeek.Thursday
+            };
+
+            resource1.Single2 = resource2;
+            resource2.Single3 = resource3;
+            resource3.Multi4 = resource4.AsHashSet();
+            resource4.Multi5 = resource5.AsHashSet();
+
+            return resource1;
+        }
+
+        [Benchmark]
+        public string SerializeResourceResponse()
+        {
+            Document responseDocument = ResponseModelAdapter.Convert(ResponseResource);
+            return JsonSerializer.Serialize(responseDocument, SerializerWriteOptions);
+        }
+
+        protected override JsonApiRequest CreateJsonApiRequest(IResourceGraph resourceGraph)
+        {
+            return new()
+            {
+                Kind = EndpointKind.Primary,
+                PrimaryResourceType = resourceGraph.GetResourceType<ResourceA>()
+            };
+        }
+
+        protected override IEvaluatedIncludeCache CreateEvaluatedIncludeCache(IResourceGraph resourceGraph)
+        {
+            ResourceType resourceAType = resourceGraph.GetResourceType<ResourceA>();
+
+            RelationshipAttribute single2 = resourceAType.GetRelationshipByPropertyName(nameof(ResourceA.Single2));
+            RelationshipAttribute single3 = resourceAType.GetRelationshipByPropertyName(nameof(ResourceA.Single3));
+            RelationshipAttribute multi4 = resourceAType.GetRelationshipByPropertyName(nameof(ResourceA.Multi4));
+            RelationshipAttribute multi5 = resourceAType.GetRelationshipByPropertyName(nameof(ResourceA.Multi5));
+
+            ImmutableArray<ResourceFieldAttribute> chain = ArrayFactory.Create<ResourceFieldAttribute>(single2, single3, multi4, multi5).ToImmutableArray();
+            IEnumerable<ResourceFieldChainExpression> chains = new ResourceFieldChainExpression(chain).AsEnumerable();
+
+            var converter = new IncludeChainConverter();
+            IncludeExpression include = converter.FromRelationshipChains(chains);
+
+            var cache = new EvaluatedIncludeCache();
+            cache.Set(include);
+            return cache;
+        }
+    }
+}
diff --git a/benchmarks/Serialization/SerializationBenchmarkBase.cs b/benchmarks/Serialization/SerializationBenchmarkBase.cs
new file mode 100644
index 0000000000..716169423b
--- /dev/null
+++ b/benchmarks/Serialization/SerializationBenchmarkBase.cs
@@ -0,0 +1,267 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Threading;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Queries;
+using JsonApiDotNetCore.Queries.Expressions;
+using JsonApiDotNetCore.Queries.Internal;
+using JsonApiDotNetCore.QueryStrings;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Serialization.Objects;
+using JsonApiDotNetCore.Serialization.Response;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace Benchmarks.Serialization
+{
+    public abstract class SerializationBenchmarkBase
+    {
+        protected readonly JsonSerializerOptions SerializerWriteOptions;
+        protected readonly IResponseModelAdapter ResponseModelAdapter;
+        protected readonly IResourceGraph ResourceGraph;
+
+        protected SerializationBenchmarkBase()
+        {
+            var options = new JsonApiOptions
+            {
+                SerializerOptions =
+                {
+                    Converters =
+                    {
+                        new JsonStringEnumConverter()
+                    }
+                }
+            };
+
+            ResourceGraph = new ResourceGraphBuilder(options, NullLoggerFactory.Instance).Add<ResourceA>().Build();
+            SerializerWriteOptions = ((IJsonApiOptions)options).SerializerWriteOptions;
+
+            // ReSharper disable VirtualMemberCallInConstructor
+            JsonApiRequest request = CreateJsonApiRequest(ResourceGraph);
+            IEvaluatedIncludeCache evaluatedIncludeCache = CreateEvaluatedIncludeCache(ResourceGraph);
+            // ReSharper restore VirtualMemberCallInConstructor
+
+            var linkBuilder = new FakeLinkBuilder();
+            var metaBuilder = new FakeMetaBuilder();
+            IQueryConstraintProvider[] constraintProviders = Array.Empty<IQueryConstraintProvider>();
+            var resourceDefinitionAccessor = new FakeResourceDefinitionAccessor();
+            var sparseFieldSetCache = new SparseFieldSetCache(constraintProviders, resourceDefinitionAccessor);
+            var requestQueryStringAccessor = new FakeRequestQueryStringAccessor();
+
+            ResponseModelAdapter = new ResponseModelAdapter(request, options, linkBuilder, metaBuilder, resourceDefinitionAccessor, evaluatedIncludeCache,
+                sparseFieldSetCache, requestQueryStringAccessor);
+        }
+
+        protected abstract JsonApiRequest CreateJsonApiRequest(IResourceGraph resourceGraph);
+
+        protected abstract IEvaluatedIncludeCache CreateEvaluatedIncludeCache(IResourceGraph resourceGraph);
+
+        [UsedImplicitly(ImplicitUseTargetFlags.Members)]
+        public sealed class ResourceA : Identifiable
+        {
+            [Attr]
+            public bool Attribute01 { get; set; }
+
+            [Attr]
+            public char Attribute02 { get; set; }
+
+            [Attr]
+            public ulong? Attribute03 { get; set; }
+
+            [Attr]
+            public decimal Attribute04 { get; set; }
+
+            [Attr]
+            public float? Attribute05 { get; set; }
+
+            [Attr]
+            public string Attribute06 { get; set; }
+
+            [Attr]
+            public DateTime? Attribute07 { get; set; }
+
+            [Attr]
+            public DateTimeOffset? Attribute08 { get; set; }
+
+            [Attr]
+            public TimeSpan? Attribute09 { get; set; }
+
+            [Attr]
+            public DayOfWeek Attribute10 { get; set; }
+
+            [HasOne]
+            public ResourceA Single1 { get; set; }
+
+            [HasOne]
+            public ResourceA Single2 { get; set; }
+
+            [HasOne]
+            public ResourceA Single3 { get; set; }
+
+            [HasOne]
+            public ResourceA Single4 { get; set; }
+
+            [HasOne]
+            public ResourceA Single5 { get; set; }
+
+            [HasMany]
+            public ISet<ResourceA> Multi1 { get; set; }
+
+            [HasMany]
+            public ISet<ResourceA> Multi2 { get; set; }
+
+            [HasMany]
+            public ISet<ResourceA> Multi3 { get; set; }
+
+            [HasMany]
+            public ISet<ResourceA> Multi4 { get; set; }
+
+            [HasMany]
+            public ISet<ResourceA> Multi5 { get; set; }
+        }
+
+        private sealed class FakeResourceDefinitionAccessor : IResourceDefinitionAccessor
+        {
+            public IImmutableSet<IncludeElementExpression> OnApplyIncludes(ResourceType resourceType, IImmutableSet<IncludeElementExpression> existingIncludes)
+            {
+                return existingIncludes;
+            }
+
+            public FilterExpression OnApplyFilter(ResourceType resourceType, FilterExpression existingFilter)
+            {
+                return existingFilter;
+            }
+
+            public SortExpression OnApplySort(ResourceType resourceType, SortExpression existingSort)
+            {
+                return existingSort;
+            }
+
+            public PaginationExpression OnApplyPagination(ResourceType resourceType, PaginationExpression existingPagination)
+            {
+                return existingPagination;
+            }
+
+            public SparseFieldSetExpression OnApplySparseFieldSet(ResourceType resourceType, SparseFieldSetExpression existingSparseFieldSet)
+            {
+                return existingSparseFieldSet;
+            }
+
+            public object GetQueryableHandlerForQueryStringParameter(Type resourceClrType, string parameterName)
+            {
+                return null;
+            }
+
+            public IDictionary<string, object> GetMeta(ResourceType resourceType, IIdentifiable resourceInstance)
+            {
+                return null;
+            }
+
+            public Task OnPrepareWriteAsync<TResource>(TResource resource, WriteOperationKind writeOperation, CancellationToken cancellationToken)
+                where TResource : class, IIdentifiable
+            {
+                return Task.CompletedTask;
+            }
+
+            public Task<IIdentifiable> OnSetToOneRelationshipAsync<TResource>(TResource leftResource, HasOneAttribute hasOneRelationship,
+                IIdentifiable rightResourceId, WriteOperationKind writeOperation, CancellationToken cancellationToken)
+                where TResource : class, IIdentifiable
+            {
+                return Task.FromResult(rightResourceId);
+            }
+
+            public Task OnSetToManyRelationshipAsync<TResource>(TResource leftResource, HasManyAttribute hasManyRelationship,
+                ISet<IIdentifiable> rightResourceIds, WriteOperationKind writeOperation, CancellationToken cancellationToken)
+                where TResource : class, IIdentifiable
+            {
+                return Task.CompletedTask;
+            }
+
+            public Task OnAddToRelationshipAsync<TResource, TId>(TId leftResourceId, HasManyAttribute hasManyRelationship, ISet<IIdentifiable> rightResourceIds,
+                CancellationToken cancellationToken)
+                where TResource : class, IIdentifiable<TId>
+            {
+                return Task.CompletedTask;
+            }
+
+            public Task OnRemoveFromRelationshipAsync<TResource>(TResource leftResource, HasManyAttribute hasManyRelationship,
+                ISet<IIdentifiable> rightResourceIds, CancellationToken cancellationToken)
+                where TResource : class, IIdentifiable
+            {
+                return Task.CompletedTask;
+            }
+
+            public Task OnWritingAsync<TResource>(TResource resource, WriteOperationKind writeOperation, CancellationToken cancellationToken)
+                where TResource : class, IIdentifiable
+            {
+                return Task.CompletedTask;
+            }
+
+            public Task OnWriteSucceededAsync<TResource>(TResource resource, WriteOperationKind writeOperation, CancellationToken cancellationToken)
+                where TResource : class, IIdentifiable
+            {
+                return Task.CompletedTask;
+            }
+
+            public void OnDeserialize(IIdentifiable resource)
+            {
+            }
+
+            public void OnSerialize(IIdentifiable resource)
+            {
+            }
+        }
+
+        private sealed class FakeLinkBuilder : ILinkBuilder
+        {
+            public TopLevelLinks GetTopLevelLinks()
+            {
+                return new()
+                {
+                    Self = "TopLevel:Self"
+                };
+            }
+
+            public ResourceLinks GetResourceLinks(ResourceType resourceType, string id)
+            {
+                return new()
+                {
+                    Self = "Resource:Self"
+                };
+            }
+
+            public RelationshipLinks GetRelationshipLinks(RelationshipAttribute relationship, IIdentifiable leftResource)
+            {
+                return new()
+                {
+                    Self = "Relationship:Self",
+                    Related = "Relationship:Related"
+                };
+            }
+        }
+
+        private sealed class FakeMetaBuilder : IMetaBuilder
+        {
+            public void Add(IReadOnlyDictionary<string, object> values)
+            {
+            }
+
+            public IDictionary<string, object> Build()
+            {
+                return null;
+            }
+        }
+
+        private sealed class FakeRequestQueryStringAccessor : IRequestQueryStringAccessor
+        {
+            public IQueryCollection Query { get; } = new QueryCollection(0);
+        }
+    }
+}
diff --git a/docs/getting-started/step-by-step.md b/docs/getting-started/step-by-step.md
index 9273de6eb1..1443409b7f 100644
--- a/docs/getting-started/step-by-step.md
+++ b/docs/getting-started/step-by-step.md
@@ -114,18 +114,18 @@ public void Configure(IApplicationBuilder app)
 One way to seed the database is in your Configure method:
 
 ```c#
-public void Configure(IApplicationBuilder app, AppDbContext context)
+public void Configure(IApplicationBuilder app, AppDbContext dbContext)
 {
-    context.Database.EnsureCreated();
+    dbContext.Database.EnsureCreated();
 
-    if (!context.People.Any())
+    if (!dbContext.People.Any())
     {
-        context.People.Add(new Person
+        dbContext.People.Add(new Person
         {
             Name = "John Doe"
         });
 
-        context.SaveChanges();
+        dbContext.SaveChanges();
     }
 
     app.UseRouting();
diff --git a/docs/usage/extensibility/repositories.md b/docs/usage/extensibility/repositories.md
index 623c959510..1ddd025ac5 100644
--- a/docs/usage/extensibility/repositories.md
+++ b/docs/usage/extensibility/repositories.md
@@ -39,12 +39,12 @@ public class ArticleRepository : EntityFrameworkCoreRepository<Article>
     private readonly IAuthenticationService _authenticationService;
 
     public ArticleRepository(IAuthenticationService authenticationService,
-        ITargetedFields targetedFields, IDbContextResolver contextResolver,
+        ITargetedFields targetedFields, IDbContextResolver dbContextResolver,
         IResourceGraph resourceGraph, IGenericServiceFactory genericServiceFactory,
         IResourceFactory resourceFactory,
         IEnumerable<IQueryConstraintProvider> constraintProviders,
         ILoggerFactory loggerFactory)
-        : base(targetedFields, contextResolver, resourceGraph, genericServiceFactory,
+        : base(targetedFields, dbContextResolver, resourceGraph, genericServiceFactory,
             resourceFactory, constraintProviders, loggerFactory) 
     {
         _authenticationService = authenticationService;
@@ -68,13 +68,13 @@ public class DbContextARepository<TResource> : EntityFrameworkCoreRepository<TRe
     where TResource : class, IIdentifiable<int>
 {
     public DbContextARepository(ITargetedFields targetedFields,
-        DbContextResolver<DbContextA> contextResolver,
+        DbContextResolver<DbContextA> dbContextResolver,
     //  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         IResourceGraph resourceGraph, IGenericServiceFactory genericServiceFactory,
         IResourceFactory resourceFactory,
         IEnumerable<IQueryConstraintProvider> constraintProviders,
         ILoggerFactory loggerFactory)
-        : base(targetedFields, contextResolver, resourceGraph, genericServiceFactory,
+        : base(targetedFields, dbContextResolver, resourceGraph, genericServiceFactory,
             resourceFactory, constraintProviders, loggerFactory)
     {
     }
diff --git a/docs/usage/extensibility/resource-definitions.md b/docs/usage/extensibility/resource-definitions.md
index 5f0ca406be..6ebace8d52 100644
--- a/docs/usage/extensibility/resource-definitions.md
+++ b/docs/usage/extensibility/resource-definitions.md
@@ -172,11 +172,8 @@ public class AccountDefinition : JsonApiResourceDefinition<Account>
 
     public override FilterExpression OnApplyFilter(FilterExpression existingFilter)
     {
-        var resourceContext = ResourceGraph.GetResourceContext<Account>();
-
-        var isSuspendedAttribute =
-            resourceContext.Attributes.Single(account =>
-                account.Property.Name == nameof(Account.IsSuspended));
+        var isSuspendedAttribute = ResourceType.Attributes.Single(account =>
+            account.Property.Name == nameof(Account.IsSuspended));
 
         var isNotSuspended = new ComparisonExpression(ComparisonOperator.Equals,
             new ResourceFieldChainExpression(isSuspendedAttribute),
diff --git a/src/Examples/GettingStarted/Startup.cs b/src/Examples/GettingStarted/Startup.cs
index 10d2f338f0..13beab63fe 100644
--- a/src/Examples/GettingStarted/Startup.cs
+++ b/src/Examples/GettingStarted/Startup.cs
@@ -26,22 +26,22 @@ public void ConfigureServices(IServiceCollection services)
 
         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
         [UsedImplicitly]
-        public void Configure(IApplicationBuilder app, SampleDbContext context)
+        public void Configure(IApplicationBuilder app, SampleDbContext dbContext)
         {
-            context.Database.EnsureDeleted();
-            context.Database.EnsureCreated();
-            CreateSampleData(context);
+            dbContext.Database.EnsureDeleted();
+            dbContext.Database.EnsureCreated();
+            CreateSampleData(dbContext);
 
             app.UseRouting();
             app.UseJsonApi();
             app.UseEndpoints(endpoints => endpoints.MapControllers());
         }
 
-        private static void CreateSampleData(SampleDbContext context)
+        private static void CreateSampleData(SampleDbContext dbContext)
         {
             // Note: The generate-examples.ps1 script (to create example requests in documentation) depends on these.
 
-            context.Books.AddRange(new Book
+            dbContext.Books.AddRange(new Book
             {
                 Title = "Frankenstein",
                 PublishYear = 1818,
@@ -67,7 +67,7 @@ private static void CreateSampleData(SampleDbContext context)
                 }
             });
 
-            context.SaveChanges();
+            dbContext.SaveChanges();
         }
     }
 }
diff --git a/src/Examples/JsonApiDotNetCoreExample/Startup.cs b/src/Examples/JsonApiDotNetCoreExample/Startup.cs
index fb75cfaef8..f14c1df8ce 100644
--- a/src/Examples/JsonApiDotNetCoreExample/Startup.cs
+++ b/src/Examples/JsonApiDotNetCoreExample/Startup.cs
@@ -55,6 +55,7 @@ public void ConfigureServices(IServiceCollection services)
                         options.SerializerOptions.Converters.Add(new JsonStringEnumConverter());
 #if DEBUG
                         options.IncludeExceptionStackTraceInErrors = true;
+                        options.IncludeRequestBodyInErrors = true;
 #endif
                     }, discovery => discovery.AddCurrentAssembly());
                 }
diff --git a/src/Examples/MultiDbContextExample/Repositories/DbContextARepository.cs b/src/Examples/MultiDbContextExample/Repositories/DbContextARepository.cs
index 5b07948005..fc5d58efd9 100644
--- a/src/Examples/MultiDbContextExample/Repositories/DbContextARepository.cs
+++ b/src/Examples/MultiDbContextExample/Repositories/DbContextARepository.cs
@@ -13,10 +13,10 @@ namespace MultiDbContextExample.Repositories
     public sealed class DbContextARepository<TResource> : EntityFrameworkCoreRepository<TResource>
         where TResource : class, IIdentifiable<int>
     {
-        public DbContextARepository(ITargetedFields targetedFields, DbContextResolver<DbContextA> contextResolver, IResourceGraph resourceGraph,
+        public DbContextARepository(ITargetedFields targetedFields, DbContextResolver<DbContextA> dbContextResolver, IResourceGraph resourceGraph,
             IResourceFactory resourceFactory, IEnumerable<IQueryConstraintProvider> constraintProviders, ILoggerFactory loggerFactory,
             IResourceDefinitionAccessor resourceDefinitionAccessor)
-            : base(targetedFields, contextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
+            : base(targetedFields, dbContextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
         {
         }
     }
diff --git a/src/Examples/MultiDbContextExample/Repositories/DbContextBRepository.cs b/src/Examples/MultiDbContextExample/Repositories/DbContextBRepository.cs
index afa7ed4bde..7c1ef16ec7 100644
--- a/src/Examples/MultiDbContextExample/Repositories/DbContextBRepository.cs
+++ b/src/Examples/MultiDbContextExample/Repositories/DbContextBRepository.cs
@@ -13,10 +13,10 @@ namespace MultiDbContextExample.Repositories
     public sealed class DbContextBRepository<TResource> : EntityFrameworkCoreRepository<TResource>
         where TResource : class, IIdentifiable<int>
     {
-        public DbContextBRepository(ITargetedFields targetedFields, DbContextResolver<DbContextB> contextResolver, IResourceGraph resourceGraph,
+        public DbContextBRepository(ITargetedFields targetedFields, DbContextResolver<DbContextB> dbContextResolver, IResourceGraph resourceGraph,
             IResourceFactory resourceFactory, IEnumerable<IQueryConstraintProvider> constraintProviders, ILoggerFactory loggerFactory,
             IResourceDefinitionAccessor resourceDefinitionAccessor)
-            : base(targetedFields, contextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
+            : base(targetedFields, dbContextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
         {
         }
     }
diff --git a/src/Examples/MultiDbContextExample/Startup.cs b/src/Examples/MultiDbContextExample/Startup.cs
index bc76c3cd9a..705bf8ef4c 100644
--- a/src/Examples/MultiDbContextExample/Startup.cs
+++ b/src/Examples/MultiDbContextExample/Startup.cs
@@ -25,6 +25,7 @@ public void ConfigureServices(IServiceCollection services)
             services.AddJsonApi(options =>
             {
                 options.IncludeExceptionStackTraceInErrors = true;
+                options.IncludeRequestBodyInErrors = true;
             }, dbContextTypes: new[]
             {
                 typeof(DbContextA),
diff --git a/src/Examples/NoEntityFrameworkExample/Startup.cs b/src/Examples/NoEntityFrameworkExample/Startup.cs
index c51985f5f2..758c31f731 100644
--- a/src/Examples/NoEntityFrameworkExample/Startup.cs
+++ b/src/Examples/NoEntityFrameworkExample/Startup.cs
@@ -34,9 +34,9 @@ public void ConfigureServices(IServiceCollection services)
 
         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
         [UsedImplicitly]
-        public void Configure(IApplicationBuilder app, AppDbContext context)
+        public void Configure(IApplicationBuilder app, AppDbContext dbContext)
         {
-            context.Database.EnsureCreated();
+            dbContext.Database.EnsureCreated();
 
             app.UseRouting();
             app.UseJsonApi();
diff --git a/src/JsonApiDotNetCore/AtomicOperations/LocalIdTracker.cs b/src/JsonApiDotNetCore/AtomicOperations/LocalIdTracker.cs
index 744a03a9e8..972440c4bc 100644
--- a/src/JsonApiDotNetCore/AtomicOperations/LocalIdTracker.cs
+++ b/src/JsonApiDotNetCore/AtomicOperations/LocalIdTracker.cs
@@ -1,8 +1,6 @@
 using System;
 using System.Collections.Generic;
-using System.Net;
 using JsonApiDotNetCore.Errors;
-using JsonApiDotNetCore.Serialization.Objects;
 
 namespace JsonApiDotNetCore.AtomicOperations
 {
@@ -32,11 +30,7 @@ private void AssertIsNotDeclared(string localId)
         {
             if (_idsTracked.ContainsKey(localId))
             {
-                throw new JsonApiException(new ErrorObject(HttpStatusCode.BadRequest)
-                {
-                    Title = "Another local ID with the same name is already defined at this point.",
-                    Detail = $"Another local ID with name '{localId}' is already defined at this point."
-                });
+                throw new DuplicateLocalIdValueException(localId);
             }
         }
 
@@ -75,11 +69,7 @@ public string GetValue(string localId, string resourceType)
 
             if (item.ServerId == null)
             {
-                throw new JsonApiException(new ErrorObject(HttpStatusCode.BadRequest)
-                {
-                    Title = "Local ID cannot be both defined and used within the same operation.",
-                    Detail = $"Local ID '{localId}' cannot be both defined and used within the same operation."
-                });
+                throw new LocalIdSingleOperationException(localId);
             }
 
             return item.ServerId;
@@ -89,11 +79,7 @@ private void AssertIsDeclared(string localId)
         {
             if (!_idsTracked.ContainsKey(localId))
             {
-                throw new JsonApiException(new ErrorObject(HttpStatusCode.BadRequest)
-                {
-                    Title = "Server-generated value for local ID is not available at this point.",
-                    Detail = $"Server-generated value for local ID '{localId}' is not available at this point."
-                });
+                throw new UnknownLocalIdValueException(localId);
             }
         }
 
@@ -101,11 +87,7 @@ private static void AssertSameResourceType(string currentType, string declaredTy
         {
             if (declaredType != currentType)
             {
-                throw new JsonApiException(new ErrorObject(HttpStatusCode.BadRequest)
-                {
-                    Title = "Type mismatch in local ID usage.",
-                    Detail = $"Local ID '{localId}' belongs to resource type '{declaredType}' instead of '{currentType}'."
-                });
+                throw new IncompatibleLocalIdTypeException(localId, declaredType, currentType);
             }
         }
 
diff --git a/src/JsonApiDotNetCore/AtomicOperations/LocalIdValidator.cs b/src/JsonApiDotNetCore/AtomicOperations/LocalIdValidator.cs
index d880ab7b42..5fd790a318 100644
--- a/src/JsonApiDotNetCore/AtomicOperations/LocalIdValidator.cs
+++ b/src/JsonApiDotNetCore/AtomicOperations/LocalIdValidator.cs
@@ -57,9 +57,9 @@ public void Validate(IEnumerable<OperationContainer> operations)
 
         private void ValidateOperation(OperationContainer operation)
         {
-            if (operation.Kind == WriteOperationKind.CreateResource)
+            if (operation.Request.WriteOperation == WriteOperationKind.CreateResource)
             {
-                DeclareLocalId(operation.Resource);
+                DeclareLocalId(operation.Resource, operation.Request.PrimaryResourceType);
             }
             else
             {
@@ -71,27 +71,25 @@ private void ValidateOperation(OperationContainer operation)
                 AssertLocalIdIsAssigned(secondaryResource);
             }
 
-            if (operation.Kind == WriteOperationKind.CreateResource)
+            if (operation.Request.WriteOperation == WriteOperationKind.CreateResource)
             {
-                AssignLocalId(operation);
+                AssignLocalId(operation, operation.Request.PrimaryResourceType);
             }
         }
 
-        private void DeclareLocalId(IIdentifiable resource)
+        private void DeclareLocalId(IIdentifiable resource, ResourceType resourceType)
         {
             if (resource.LocalId != null)
             {
-                ResourceContext resourceContext = _resourceGraph.GetResourceContext(resource.GetType());
-                _localIdTracker.Declare(resource.LocalId, resourceContext.PublicName);
+                _localIdTracker.Declare(resource.LocalId, resourceType.PublicName);
             }
         }
 
-        private void AssignLocalId(OperationContainer operation)
+        private void AssignLocalId(OperationContainer operation, ResourceType resourceType)
         {
             if (operation.Resource.LocalId != null)
             {
-                ResourceContext resourceContext = _resourceGraph.GetResourceContext(operation.Resource.GetType());
-                _localIdTracker.Assign(operation.Resource.LocalId, resourceContext.PublicName, "placeholder");
+                _localIdTracker.Assign(operation.Resource.LocalId, resourceType.PublicName, "placeholder");
             }
         }
 
@@ -99,8 +97,8 @@ private void AssertLocalIdIsAssigned(IIdentifiable resource)
         {
             if (resource.LocalId != null)
             {
-                ResourceContext resourceContext = _resourceGraph.GetResourceContext(resource.GetType());
-                _localIdTracker.GetValue(resource.LocalId, resourceContext.PublicName);
+                ResourceType resourceType = _resourceGraph.GetResourceType(resource.GetType());
+                _localIdTracker.GetValue(resource.LocalId, resourceType.PublicName);
             }
         }
     }
diff --git a/src/JsonApiDotNetCore/AtomicOperations/OperationProcessorAccessor.cs b/src/JsonApiDotNetCore/AtomicOperations/OperationProcessorAccessor.cs
index a71fa906cd..68cfb752b2 100644
--- a/src/JsonApiDotNetCore/AtomicOperations/OperationProcessorAccessor.cs
+++ b/src/JsonApiDotNetCore/AtomicOperations/OperationProcessorAccessor.cs
@@ -14,15 +14,12 @@ namespace JsonApiDotNetCore.AtomicOperations
     [PublicAPI]
     public class OperationProcessorAccessor : IOperationProcessorAccessor
     {
-        private readonly IResourceGraph _resourceGraph;
         private readonly IServiceProvider _serviceProvider;
 
-        public OperationProcessorAccessor(IResourceGraph resourceGraph, IServiceProvider serviceProvider)
+        public OperationProcessorAccessor(IServiceProvider serviceProvider)
         {
-            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
             ArgumentGuard.NotNull(serviceProvider, nameof(serviceProvider));
 
-            _resourceGraph = resourceGraph;
             _serviceProvider = serviceProvider;
         }
 
@@ -37,10 +34,10 @@ public Task<OperationContainer> ProcessAsync(OperationContainer operation, Cance
 
         protected virtual IOperationProcessor ResolveProcessor(OperationContainer operation)
         {
-            Type processorInterface = GetProcessorInterface(operation.Kind);
-            ResourceContext resourceContext = _resourceGraph.GetResourceContext(operation.Resource.GetType());
+            Type processorInterface = GetProcessorInterface(operation.Request.WriteOperation.GetValueOrDefault());
+            ResourceType resourceType = operation.Request.PrimaryResourceType;
 
-            Type processorType = processorInterface.MakeGenericType(resourceContext.ResourceType, resourceContext.IdentityType);
+            Type processorType = processorInterface.MakeGenericType(resourceType.ClrType, resourceType.IdentityClrType);
             return (IOperationProcessor)_serviceProvider.GetRequiredService(processorType);
         }
 
diff --git a/src/JsonApiDotNetCore/AtomicOperations/OperationsProcessor.cs b/src/JsonApiDotNetCore/AtomicOperations/OperationsProcessor.cs
index 8d531ea231..be266286db 100644
--- a/src/JsonApiDotNetCore/AtomicOperations/OperationsProcessor.cs
+++ b/src/JsonApiDotNetCore/AtomicOperations/OperationsProcessor.cs
@@ -1,12 +1,12 @@
 using System;
 using System.Collections.Generic;
-using System.Net;
 using System.Threading;
 using System.Threading.Tasks;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Errors;
 using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Queries.Internal;
 using JsonApiDotNetCore.Resources;
 using JsonApiDotNetCore.Serialization.Objects;
 
@@ -22,10 +22,12 @@ public class OperationsProcessor : IOperationsProcessor
         private readonly IResourceGraph _resourceGraph;
         private readonly IJsonApiRequest _request;
         private readonly ITargetedFields _targetedFields;
+        private readonly ISparseFieldSetCache _sparseFieldSetCache;
         private readonly LocalIdValidator _localIdValidator;
 
         public OperationsProcessor(IOperationProcessorAccessor operationProcessorAccessor, IOperationsTransactionFactory operationsTransactionFactory,
-            ILocalIdTracker localIdTracker, IResourceGraph resourceGraph, IJsonApiRequest request, ITargetedFields targetedFields)
+            ILocalIdTracker localIdTracker, IResourceGraph resourceGraph, IJsonApiRequest request, ITargetedFields targetedFields,
+            ISparseFieldSetCache sparseFieldSetCache)
         {
             ArgumentGuard.NotNull(operationProcessorAccessor, nameof(operationProcessorAccessor));
             ArgumentGuard.NotNull(operationsTransactionFactory, nameof(operationsTransactionFactory));
@@ -33,6 +35,7 @@ public OperationsProcessor(IOperationProcessorAccessor operationProcessorAccesso
             ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
             ArgumentGuard.NotNull(request, nameof(request));
             ArgumentGuard.NotNull(targetedFields, nameof(targetedFields));
+            ArgumentGuard.NotNull(sparseFieldSetCache, nameof(sparseFieldSetCache));
 
             _operationProcessorAccessor = operationProcessorAccessor;
             _operationsTransactionFactory = operationsTransactionFactory;
@@ -40,6 +43,7 @@ public OperationsProcessor(IOperationProcessorAccessor operationProcessorAccesso
             _resourceGraph = resourceGraph;
             _request = request;
             _targetedFields = targetedFields;
+            _sparseFieldSetCache = sparseFieldSetCache;
             _localIdValidator = new LocalIdValidator(_localIdTracker, _resourceGraph);
         }
 
@@ -57,6 +61,8 @@ public virtual async Task<IList<OperationContainer>> ProcessAsync(IList<Operatio
 
             try
             {
+                using IDisposable _ = new RevertRequestStateOnDispose(_request, _targetedFields);
+
                 foreach (OperationContainer operation in operations)
                 {
                     operation.SetTransactionId(transaction.TransactionId);
@@ -67,6 +73,8 @@ public virtual async Task<IList<OperationContainer>> ProcessAsync(IList<Operatio
                     results.Add(result);
 
                     await transaction.AfterProcessOperationAsync(cancellationToken);
+
+                    _sparseFieldSetCache.Reset();
                 }
 
                 await transaction.CommitAsync(cancellationToken);
@@ -89,15 +97,7 @@ public virtual async Task<IList<OperationContainer>> ProcessAsync(IList<Operatio
             catch (Exception exception)
 #pragma warning restore AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException
             {
-                throw new JsonApiException(new ErrorObject(HttpStatusCode.InternalServerError)
-                {
-                    Title = "An unhandled error occurred while processing an operation in this request.",
-                    Detail = exception.Message,
-                    Source = new ErrorSource
-                    {
-                        Pointer = $"/atomic:operations[{results.Count}]"
-                    }
-                }, exception);
+                throw new FailedOperationException(results.Count, exception);
             }
 
             return results;
@@ -109,9 +109,7 @@ protected virtual async Task<OperationContainer> ProcessOperationAsync(Operation
 
             TrackLocalIdsForOperation(operation);
 
-            _targetedFields.Attributes = operation.TargetedFields.Attributes;
-            _targetedFields.Relationships = operation.TargetedFields.Relationships;
-
+            _targetedFields.CopyFrom(operation.TargetedFields);
             _request.CopyFrom(operation.Request);
 
             return await _operationProcessorAccessor.ProcessAsync(operation, cancellationToken);
@@ -119,9 +117,9 @@ protected virtual async Task<OperationContainer> ProcessOperationAsync(Operation
 
         protected void TrackLocalIdsForOperation(OperationContainer operation)
         {
-            if (operation.Kind == WriteOperationKind.CreateResource)
+            if (operation.Request.WriteOperation == WriteOperationKind.CreateResource)
             {
-                DeclareLocalId(operation.Resource);
+                DeclareLocalId(operation.Resource, operation.Request.PrimaryResourceType);
             }
             else
             {
@@ -134,12 +132,11 @@ protected void TrackLocalIdsForOperation(OperationContainer operation)
             }
         }
 
-        private void DeclareLocalId(IIdentifiable resource)
+        private void DeclareLocalId(IIdentifiable resource, ResourceType resourceType)
         {
             if (resource.LocalId != null)
             {
-                ResourceContext resourceContext = _resourceGraph.GetResourceContext(resource.GetType());
-                _localIdTracker.Declare(resource.LocalId, resourceContext.PublicName);
+                _localIdTracker.Declare(resource.LocalId, resourceType.PublicName);
             }
         }
 
@@ -147,8 +144,8 @@ private void AssignStringId(IIdentifiable resource)
         {
             if (resource.LocalId != null)
             {
-                ResourceContext resourceContext = _resourceGraph.GetResourceContext(resource.GetType());
-                resource.StringId = _localIdTracker.GetValue(resource.LocalId, resourceContext.PublicName);
+                ResourceType resourceType = _resourceGraph.GetResourceType(resource.GetType());
+                resource.StringId = _localIdTracker.GetValue(resource.LocalId, resourceType.PublicName);
             }
         }
     }
diff --git a/src/JsonApiDotNetCore/AtomicOperations/Processors/CreateProcessor.cs b/src/JsonApiDotNetCore/AtomicOperations/Processors/CreateProcessor.cs
index 2e113561ab..4a408f368e 100644
--- a/src/JsonApiDotNetCore/AtomicOperations/Processors/CreateProcessor.cs
+++ b/src/JsonApiDotNetCore/AtomicOperations/Processors/CreateProcessor.cs
@@ -14,17 +14,14 @@ public class CreateProcessor<TResource, TId> : ICreateProcessor<TResource, TId>
     {
         private readonly ICreateService<TResource, TId> _service;
         private readonly ILocalIdTracker _localIdTracker;
-        private readonly IResourceGraph _resourceGraph;
 
-        public CreateProcessor(ICreateService<TResource, TId> service, ILocalIdTracker localIdTracker, IResourceGraph resourceGraph)
+        public CreateProcessor(ICreateService<TResource, TId> service, ILocalIdTracker localIdTracker)
         {
             ArgumentGuard.NotNull(service, nameof(service));
             ArgumentGuard.NotNull(localIdTracker, nameof(localIdTracker));
-            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
 
             _service = service;
             _localIdTracker = localIdTracker;
-            _resourceGraph = resourceGraph;
         }
 
         /// <inheritdoc />
@@ -37,9 +34,9 @@ public virtual async Task<OperationContainer> ProcessAsync(OperationContainer op
             if (operation.Resource.LocalId != null)
             {
                 string serverId = newResource != null ? newResource.StringId : operation.Resource.StringId;
-                ResourceContext resourceContext = _resourceGraph.GetResourceContext<TResource>();
+                ResourceType resourceType = operation.Request.PrimaryResourceType;
 
-                _localIdTracker.Assign(operation.Resource.LocalId, resourceContext.PublicName, serverId);
+                _localIdTracker.Assign(operation.Resource.LocalId, resourceType.PublicName, serverId);
             }
 
             return newResource == null ? null : operation.WithResource(newResource);
diff --git a/src/JsonApiDotNetCore/AtomicOperations/RevertRequestStateOnDispose.cs b/src/JsonApiDotNetCore/AtomicOperations/RevertRequestStateOnDispose.cs
new file mode 100644
index 0000000000..8c2e150a23
--- /dev/null
+++ b/src/JsonApiDotNetCore/AtomicOperations/RevertRequestStateOnDispose.cs
@@ -0,0 +1,38 @@
+using System;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Resources;
+
+namespace JsonApiDotNetCore.AtomicOperations
+{
+    /// <summary>
+    /// Copies the current request state into a backup, which is restored on dispose.
+    /// </summary>
+    internal sealed class RevertRequestStateOnDispose : IDisposable
+    {
+        private readonly IJsonApiRequest _sourceRequest;
+        private readonly ITargetedFields _sourceTargetedFields;
+
+        private readonly IJsonApiRequest _backupRequest = new JsonApiRequest();
+        private readonly ITargetedFields _backupTargetedFields = new TargetedFields();
+
+        public RevertRequestStateOnDispose(IJsonApiRequest request, ITargetedFields targetedFields)
+        {
+            ArgumentGuard.NotNull(request, nameof(request));
+
+            _sourceRequest = request;
+            _backupRequest.CopyFrom(request);
+
+            if (targetedFields != null)
+            {
+                _sourceTargetedFields = targetedFields;
+                _backupTargetedFields.CopyFrom(targetedFields);
+            }
+        }
+
+        public void Dispose()
+        {
+            _sourceRequest.CopyFrom(_backupRequest);
+            _sourceTargetedFields?.CopyFrom(_backupTargetedFields);
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/CollectionExtensions.cs b/src/JsonApiDotNetCore/CollectionExtensions.cs
index ca69755c1c..863b22d5fd 100644
--- a/src/JsonApiDotNetCore/CollectionExtensions.cs
+++ b/src/JsonApiDotNetCore/CollectionExtensions.cs
@@ -71,6 +71,11 @@ public static bool DictionaryEqual<TKey, TValue>(this IReadOnlyDictionary<TKey,
             return true;
         }
 
+        public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T> source)
+        {
+            return source ?? Enumerable.Empty<T>();
+        }
+
         public static void AddRange<T>(this ICollection<T> source, IEnumerable<T> itemsToAdd)
         {
             ArgumentGuard.NotNull(source, nameof(source));
diff --git a/src/JsonApiDotNetCore/Configuration/IJsonApiOptions.cs b/src/JsonApiDotNetCore/Configuration/IJsonApiOptions.cs
index 4b5d36c421..6e8e2d981e 100644
--- a/src/JsonApiDotNetCore/Configuration/IJsonApiOptions.cs
+++ b/src/JsonApiDotNetCore/Configuration/IJsonApiOptions.cs
@@ -30,10 +30,15 @@ public interface IJsonApiOptions
         bool IncludeJsonApiVersion { get; }
 
         /// <summary>
-        /// Whether or not <see cref="Exception" /> stack traces should be serialized in <see cref="ErrorObject.Meta" />. False by default.
+        /// Whether or not <see cref="Exception" /> stack traces should be included in <see cref="ErrorObject.Meta" />. False by default.
         /// </summary>
         bool IncludeExceptionStackTraceInErrors { get; }
 
+        /// <summary>
+        /// Whether or not the request body should be included in <see cref="Document.Meta" /> when it is invalid. False by default.
+        /// </summary>
+        bool IncludeRequestBodyInErrors { get; }
+
         /// <summary>
         /// Use relative links for all resources. False by default.
         /// </summary>
@@ -113,6 +118,11 @@ public interface IJsonApiOptions
         /// </summary>
         bool AllowUnknownQueryStringParameters { get; }
 
+        /// <summary>
+        /// Whether or not to produce an error on unknown attribute and relationship keys in request bodies. False by default.
+        /// </summary>
+        bool AllowUnknownFieldsInRequestBody { get; }
+
         /// <summary>
         /// Determines whether legacy filter notation in query strings, such as =eq:, =like:, and =in: is enabled. False by default.
         /// </summary>
diff --git a/src/JsonApiDotNetCore/Configuration/IRequestScopedServiceProvider.cs b/src/JsonApiDotNetCore/Configuration/IRequestScopedServiceProvider.cs
deleted file mode 100644
index 327eeca353..0000000000
--- a/src/JsonApiDotNetCore/Configuration/IRequestScopedServiceProvider.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using System;
-
-namespace JsonApiDotNetCore.Configuration
-{
-    /// <summary>
-    /// An interface used to separate the registration of the global <see cref="IServiceProvider" /> from a request-scoped service provider. This is useful
-    /// in cases when we need to manually resolve services from the request scope (e.g. operation processors).
-    /// </summary>
-    public interface IRequestScopedServiceProvider : IServiceProvider
-    {
-    }
-}
diff --git a/src/JsonApiDotNetCore/Configuration/IResourceGraph.cs b/src/JsonApiDotNetCore/Configuration/IResourceGraph.cs
index b7216f0f8c..1c2c058150 100644
--- a/src/JsonApiDotNetCore/Configuration/IResourceGraph.cs
+++ b/src/JsonApiDotNetCore/Configuration/IResourceGraph.cs
@@ -17,43 +17,44 @@ public interface IResourceGraph
         /// <summary>
         /// Gets the metadata for all registered resources.
         /// </summary>
-        IReadOnlySet<ResourceContext> GetResourceContexts();
+        IReadOnlySet<ResourceType> GetResourceTypes();
 
         /// <summary>
-        /// Gets the resource metadata for the resource that is publicly exposed by the specified name. Throws an <see cref="InvalidOperationException" /> when
-        /// not found.
+        /// Gets the metadata for the resource that is publicly exposed by the specified name. Throws an <see cref="InvalidOperationException" /> when not found.
         /// </summary>
-        ResourceContext GetResourceContext(string publicName);
+        ResourceType GetResourceType(string publicName);
 
         /// <summary>
-        /// Gets the resource metadata for the specified resource type. Throws an <see cref="InvalidOperationException" /> when not found.
+        /// Gets the metadata for the resource of the specified CLR type. Throws an <see cref="InvalidOperationException" /> when not found.
         /// </summary>
-        ResourceContext GetResourceContext(Type resourceType);
+        ResourceType GetResourceType(Type resourceClrType);
 
         /// <summary>
-        /// Gets the resource metadata for the specified resource type. Throws an <see cref="InvalidOperationException" /> when not found.
+        /// Gets the metadata for the resource of the specified CLR type. Throws an <see cref="InvalidOperationException" /> when not found.
         /// </summary>
-        ResourceContext GetResourceContext<TResource>()
+        ResourceType GetResourceType<TResource>()
             where TResource : class, IIdentifiable;
 
         /// <summary>
-        /// Attempts to get the resource metadata for the resource that is publicly exposed by the specified name. Returns <c>null</c> when not found.
+        /// Attempts to get the metadata for the resource that is publicly exposed by the specified name. Returns <c>null</c> when not found.
         /// </summary>
-        ResourceContext TryGetResourceContext(string publicName);
+        ResourceType TryGetResourceType(string publicName);
 
         /// <summary>
-        /// Attempts to get the resource metadata for the specified resource type. Returns <c>null</c> when not found.
+        /// Attempts to get metadata for the resource of the specified CLR type. Returns <c>null</c> when not found.
         /// </summary>
-        ResourceContext TryGetResourceContext(Type resourceType);
+        ResourceType TryGetResourceType(Type resourceClrType);
 
         /// <summary>
         /// Gets the fields (attributes and relationships) for <typeparamref name="TResource" /> that are targeted by the selector.
         /// </summary>
         /// <typeparam name="TResource">
-        /// The resource type for which to retrieve fields.
+        /// The resource CLR type for which to retrieve fields.
         /// </typeparam>
         /// <param name="selector">
-        /// Should be of the form: (TResource r) => new { r.Field1, r.Field2 }
+        /// Should be of the form: <![CDATA[
+        /// (TResource resource) => new { resource.Attribute1, resource.Relationship2 }
+        /// ]]>
         /// </param>
         IReadOnlyCollection<ResourceFieldAttribute> GetFields<TResource>(Expression<Func<TResource, dynamic>> selector)
             where TResource : class, IIdentifiable;
@@ -62,10 +63,12 @@ IReadOnlyCollection<ResourceFieldAttribute> GetFields<TResource>(Expression<Func
         /// Gets the attributes for <typeparamref name="TResource" /> that are targeted by the selector.
         /// </summary>
         /// <typeparam name="TResource">
-        /// The resource type for which to retrieve attributes.
+        /// The resource CLR type for which to retrieve attributes.
         /// </typeparam>
         /// <param name="selector">
-        /// Should be of the form: (TResource r) => new { r.Attribute1, r.Attribute2 }
+        /// Should be of the form: <![CDATA[
+        /// (TResource resource) => new { resource.attribute1, resource.Attribute2 }
+        /// ]]>
         /// </param>
         IReadOnlyCollection<AttrAttribute> GetAttributes<TResource>(Expression<Func<TResource, dynamic>> selector)
             where TResource : class, IIdentifiable;
@@ -74,10 +77,12 @@ IReadOnlyCollection<AttrAttribute> GetAttributes<TResource>(Expression<Func<TRes
         /// Gets the relationships for <typeparamref name="TResource" /> that are targeted by the selector.
         /// </summary>
         /// <typeparam name="TResource">
-        /// The resource type for which to retrieve relationships.
+        /// The resource CLR type for which to retrieve relationships.
         /// </typeparam>
         /// <param name="selector">
-        /// Should be of the form: (TResource r) => new { r.Relationship1, r.Relationship2 }
+        /// Should be of the form: <![CDATA[
+        /// (TResource resource) => new { resource.Relationship1, resource.Relationship2 }
+        /// ]]>
         /// </param>
         IReadOnlyCollection<RelationshipAttribute> GetRelationships<TResource>(Expression<Func<TResource, dynamic>> selector)
             where TResource : class, IIdentifiable;
diff --git a/src/JsonApiDotNetCore/Configuration/InverseNavigationResolver.cs b/src/JsonApiDotNetCore/Configuration/InverseNavigationResolver.cs
index abe95d00bf..a3461cfdcf 100644
--- a/src/JsonApiDotNetCore/Configuration/InverseNavigationResolver.cs
+++ b/src/JsonApiDotNetCore/Configuration/InverseNavigationResolver.cs
@@ -36,14 +36,14 @@ public void Resolve()
 
         private void Resolve(DbContext dbContext)
         {
-            foreach (ResourceContext resourceContext in _resourceGraph.GetResourceContexts().Where(context => context.Relationships.Any()))
+            foreach (ResourceType resourceType in _resourceGraph.GetResourceTypes().Where(resourceType => resourceType.Relationships.Any()))
             {
-                IEntityType entityType = dbContext.Model.FindEntityType(resourceContext.ResourceType);
+                IEntityType entityType = dbContext.Model.FindEntityType(resourceType.ClrType);
 
                 if (entityType != null)
                 {
                     IDictionary<string, INavigationBase> navigationMap = GetNavigations(entityType);
-                    ResolveRelationships(resourceContext.Relationships, navigationMap);
+                    ResolveRelationships(resourceType.Relationships, navigationMap);
                 }
             }
         }
diff --git a/src/JsonApiDotNetCore/Configuration/JsonApiApplicationBuilder.cs b/src/JsonApiDotNetCore/Configuration/JsonApiApplicationBuilder.cs
index 9200149b25..8db88c4ee2 100644
--- a/src/JsonApiDotNetCore/Configuration/JsonApiApplicationBuilder.cs
+++ b/src/JsonApiDotNetCore/Configuration/JsonApiApplicationBuilder.cs
@@ -10,16 +10,15 @@
 using JsonApiDotNetCore.QueryStrings.Internal;
 using JsonApiDotNetCore.Repositories;
 using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Serialization;
-using JsonApiDotNetCore.Serialization.Building;
 using JsonApiDotNetCore.Serialization.JsonConverters;
+using JsonApiDotNetCore.Serialization.Request;
+using JsonApiDotNetCore.Serialization.Request.Adapters;
+using JsonApiDotNetCore.Serialization.Response;
 using JsonApiDotNetCore.Services;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.ModelBinding;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Metadata;
-using Microsoft.EntityFrameworkCore.Metadata.Internal;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Logging;
@@ -82,7 +81,7 @@ public void AddResourceGraph(ICollection<Type> dbContextTypes, Action<ResourceGr
             foreach (Type dbContextType in dbContextTypes)
             {
                 var dbContext = (DbContext)_intermediateProvider.GetRequiredService(dbContextType);
-                AddResourcesFromDbContext(dbContext, _resourceGraphBuilder);
+                _resourceGraphBuilder.Add(dbContext);
             }
 
             configureResourceGraph?.Invoke(_resourceGraphBuilder);
@@ -134,8 +133,8 @@ public void ConfigureServiceContainer(ICollection<Type> dbContextTypes)
 
                 foreach (Type dbContextType in dbContextTypes)
                 {
-                    Type contextResolverType = typeof(DbContextResolver<>).MakeGenericType(dbContextType);
-                    _services.AddScoped(typeof(IDbContextResolver), contextResolverType);
+                    Type dbContextResolverType = typeof(DbContextResolver<>).MakeGenericType(dbContextType);
+                    _services.AddScoped(typeof(IDbContextResolver), dbContextResolverType);
                 }
 
                 _services.AddScoped<IOperationsTransactionFactory, EntityFrameworkCoreTransactionFactory>();
@@ -156,6 +155,7 @@ public void ConfigureServiceContainer(ICollection<Type> dbContextTypes)
             _services.AddScoped(typeof(IResourceChangeTracker<>), typeof(ResourceChangeTracker<>));
             _services.AddScoped<IPaginationContext, PaginationContext>();
             _services.AddScoped<IEvaluatedIncludeCache, EvaluatedIncludeCache>();
+            _services.AddScoped<ISparseFieldSetCache, SparseFieldSetCache>();
             _services.AddScoped<IQueryLayerComposer, QueryLayerComposer>();
             _services.AddScoped<IInverseNavigationResolver, InverseNavigationResolver>();
         }
@@ -173,12 +173,10 @@ private void AddMiddlewareLayer()
             _services.AddSingleton<IJsonApiRoutingConvention, JsonApiRoutingConvention>();
             _services.AddSingleton<IControllerResourceMapping>(sp => sp.GetRequiredService<IJsonApiRoutingConvention>());
             _services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
-            _services.AddSingleton<IRequestScopedServiceProvider, RequestScopedServiceProvider>();
             _services.AddScoped<IJsonApiRequest, JsonApiRequest>();
             _services.AddScoped<IJsonApiWriter, JsonApiWriter>();
             _services.AddScoped<IJsonApiReader, JsonApiReader>();
             _services.AddScoped<ITargetedFields, TargetedFields>();
-            _services.AddScoped<IFieldsToSerialize, FieldsToSerialize>();
         }
 
         private void AddResourceLayer()
@@ -250,18 +248,23 @@ private void RegisterDependentService<TCollectionElement, TElementToAdd>()
 
         private void AddSerializationLayer()
         {
-            _services.AddScoped<IIncludedResourceObjectBuilder, IncludedResourceObjectBuilder>();
-            _services.AddScoped<IJsonApiDeserializer, RequestDeserializer>();
-            _services.AddScoped<IJsonApiSerializerFactory, ResponseSerializerFactory>();
+            _services.AddScoped<IResourceIdentifierObjectAdapter, ResourceIdentifierObjectAdapter>();
+            _services.AddScoped<IRelationshipDataAdapter, RelationshipDataAdapter>();
+            _services.AddScoped<IResourceObjectAdapter, ResourceObjectAdapter>();
+            _services.AddScoped<IResourceDataAdapter, ResourceDataAdapter>();
+            _services.AddScoped<IAtomicReferenceAdapter, AtomicReferenceAdapter>();
+            _services.AddScoped<IResourceDataInOperationsRequestAdapter, ResourceDataInOperationsRequestAdapter>();
+            _services.AddScoped<IAtomicOperationObjectAdapter, AtomicOperationObjectAdapter>();
+            _services.AddScoped<IDocumentInResourceOrRelationshipRequestAdapter, DocumentInResourceOrRelationshipRequestAdapter>();
+            _services.AddScoped<IDocumentInOperationsRequestAdapter, DocumentInOperationsRequestAdapter>();
+            _services.AddScoped<IDocumentAdapter, DocumentAdapter>();
+
             _services.AddScoped<ILinkBuilder, LinkBuilder>();
             _services.AddScoped<IResponseMeta, EmptyResponseMeta>();
             _services.AddScoped<IMetaBuilder, MetaBuilder>();
-            _services.AddScoped(typeof(ResponseSerializer<>));
-            _services.AddScoped(typeof(AtomicOperationsResponseSerializer));
-            _services.AddScoped(sp => sp.GetRequiredService<IJsonApiSerializerFactory>().GetSerializer());
-            _services.AddScoped<IResourceObjectBuilder, ResponseResourceObjectBuilder>();
             _services.AddSingleton<IFingerprintGenerator, FingerprintGenerator>();
             _services.AddSingleton<IETagGenerator, ETagGenerator>();
+            _services.AddScoped<IResponseModelAdapter, ResponseModelAdapter>();
         }
 
         private void AddOperationsLayer()
@@ -278,24 +281,6 @@ private void AddOperationsLayer()
             _services.AddScoped<ILocalIdTracker, LocalIdTracker>();
         }
 
-        private void AddResourcesFromDbContext(DbContext dbContext, ResourceGraphBuilder builder)
-        {
-            foreach (IEntityType entityType in dbContext.Model.GetEntityTypes())
-            {
-                if (!IsImplicitManyToManyJoinEntity(entityType))
-                {
-                    builder.Add(entityType.ClrType);
-                }
-            }
-        }
-
-        private static bool IsImplicitManyToManyJoinEntity(IEntityType entityType)
-        {
-#pragma warning disable EF1001 // Internal EF Core API usage.
-            return entityType is EntityType { IsImplicitlyCreatedJoinEntityType: true };
-#pragma warning restore EF1001 // Internal EF Core API usage.
-        }
-
         public void Dispose()
         {
             _intermediateProvider.Dispose();
diff --git a/src/JsonApiDotNetCore/Configuration/JsonApiModelMetadataProvider.cs b/src/JsonApiDotNetCore/Configuration/JsonApiModelMetadataProvider.cs
index 19f9edc531..07f15db8a6 100644
--- a/src/JsonApiDotNetCore/Configuration/JsonApiModelMetadataProvider.cs
+++ b/src/JsonApiDotNetCore/Configuration/JsonApiModelMetadataProvider.cs
@@ -1,3 +1,4 @@
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.ModelBinding;
 using Microsoft.AspNetCore.Mvc.ModelBinding.Metadata;
@@ -13,18 +14,18 @@ internal sealed class JsonApiModelMetadataProvider : DefaultModelMetadataProvide
         private readonly JsonApiValidationFilter _jsonApiValidationFilter;
 
         /// <inheritdoc />
-        public JsonApiModelMetadataProvider(ICompositeMetadataDetailsProvider detailsProvider, IRequestScopedServiceProvider serviceProvider)
+        public JsonApiModelMetadataProvider(ICompositeMetadataDetailsProvider detailsProvider, IHttpContextAccessor httpContextAccessor)
             : base(detailsProvider)
         {
-            _jsonApiValidationFilter = new JsonApiValidationFilter(serviceProvider);
+            _jsonApiValidationFilter = new JsonApiValidationFilter(httpContextAccessor);
         }
 
         /// <inheritdoc />
         public JsonApiModelMetadataProvider(ICompositeMetadataDetailsProvider detailsProvider, IOptions<MvcOptions> optionsAccessor,
-            IRequestScopedServiceProvider serviceProvider)
+            IHttpContextAccessor httpContextAccessor)
             : base(detailsProvider, optionsAccessor)
         {
-            _jsonApiValidationFilter = new JsonApiValidationFilter(serviceProvider);
+            _jsonApiValidationFilter = new JsonApiValidationFilter(httpContextAccessor);
         }
 
         /// <inheritdoc />
diff --git a/src/JsonApiDotNetCore/Configuration/JsonApiOptions.cs b/src/JsonApiDotNetCore/Configuration/JsonApiOptions.cs
index 4806c36248..322e2cd725 100644
--- a/src/JsonApiDotNetCore/Configuration/JsonApiOptions.cs
+++ b/src/JsonApiDotNetCore/Configuration/JsonApiOptions.cs
@@ -38,6 +38,9 @@ public sealed class JsonApiOptions : IJsonApiOptions
         /// <inheritdoc />
         public bool IncludeExceptionStackTraceInErrors { get; set; }
 
+        /// <inheritdoc />
+        public bool IncludeRequestBodyInErrors { get; set; }
+
         /// <inheritdoc />
         public bool UseRelativeLinks { get; set; }
 
@@ -71,6 +74,9 @@ public sealed class JsonApiOptions : IJsonApiOptions
         /// <inheritdoc />
         public bool AllowUnknownQueryStringParameters { get; set; }
 
+        /// <inheritdoc />
+        public bool AllowUnknownFieldsInRequestBody { get; set; }
+
         /// <inheritdoc />
         public bool EnableLegacyFilterNotation { get; set; }
 
diff --git a/src/JsonApiDotNetCore/Configuration/JsonApiValidationFilter.cs b/src/JsonApiDotNetCore/Configuration/JsonApiValidationFilter.cs
index 1a661aaf1e..6829e35788 100644
--- a/src/JsonApiDotNetCore/Configuration/JsonApiValidationFilter.cs
+++ b/src/JsonApiDotNetCore/Configuration/JsonApiValidationFilter.cs
@@ -13,19 +13,21 @@ namespace JsonApiDotNetCore.Configuration
     /// </summary>
     internal sealed class JsonApiValidationFilter : IPropertyValidationFilter
     {
-        private readonly IRequestScopedServiceProvider _serviceProvider;
+        private readonly IHttpContextAccessor _httpContextAccessor;
 
-        public JsonApiValidationFilter(IRequestScopedServiceProvider serviceProvider)
+        public JsonApiValidationFilter(IHttpContextAccessor httpContextAccessor)
         {
-            ArgumentGuard.NotNull(serviceProvider, nameof(serviceProvider));
+            ArgumentGuard.NotNull(httpContextAccessor, nameof(httpContextAccessor));
 
-            _serviceProvider = serviceProvider;
+            _httpContextAccessor = httpContextAccessor;
         }
 
         /// <inheritdoc />
         public bool ShouldValidateEntry(ValidationEntry entry, ValidationEntry parentEntry)
         {
-            var request = _serviceProvider.GetRequiredService<IJsonApiRequest>();
+            IServiceProvider serviceProvider = GetScopedServiceProvider();
+
+            var request = serviceProvider.GetRequiredService<IJsonApiRequest>();
 
             if (IsId(entry.Key))
             {
@@ -39,17 +41,27 @@ public bool ShouldValidateEntry(ValidationEntry entry, ValidationEntry parentEnt
                 return false;
             }
 
-            var httpContextAccessor = _serviceProvider.GetRequiredService<IHttpContextAccessor>();
-
-            if (httpContextAccessor.HttpContext!.Request.Method == HttpMethods.Patch || request.WriteOperation == WriteOperationKind.UpdateResource)
+            if (_httpContextAccessor.HttpContext!.Request.Method == HttpMethods.Patch || request.WriteOperation == WriteOperationKind.UpdateResource)
             {
-                var targetedFields = _serviceProvider.GetRequiredService<ITargetedFields>();
+                var targetedFields = serviceProvider.GetRequiredService<ITargetedFields>();
                 return IsFieldTargeted(entry, targetedFields);
             }
 
             return true;
         }
 
+        private IServiceProvider GetScopedServiceProvider()
+        {
+            HttpContext httpContext = _httpContextAccessor.HttpContext;
+
+            if (httpContext == null)
+            {
+                throw new InvalidOperationException("Cannot resolve scoped services outside the context of an HTTP request.");
+            }
+
+            return httpContext.RequestServices;
+        }
+
         private static bool IsId(string key)
         {
             return key == nameof(Identifiable.Id) || key.EndsWith($".{nameof(Identifiable.Id)}", StringComparison.Ordinal);
@@ -57,7 +69,7 @@ private static bool IsId(string key)
 
         private static bool IsAtPrimaryEndpoint(IJsonApiRequest request)
         {
-            return request.Kind == EndpointKind.Primary || request.Kind == EndpointKind.AtomicOperations;
+            return request.Kind is EndpointKind.Primary or EndpointKind.AtomicOperations;
         }
 
         private static bool IsFieldTargeted(ValidationEntry entry, ITargetedFields targetedFields)
diff --git a/src/JsonApiDotNetCore/Configuration/RequestScopedServiceProvider.cs b/src/JsonApiDotNetCore/Configuration/RequestScopedServiceProvider.cs
deleted file mode 100644
index 649a219c0b..0000000000
--- a/src/JsonApiDotNetCore/Configuration/RequestScopedServiceProvider.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-using System;
-using Microsoft.AspNetCore.Http;
-
-namespace JsonApiDotNetCore.Configuration
-{
-    /// <inheritdoc />
-    public sealed class RequestScopedServiceProvider : IRequestScopedServiceProvider
-    {
-        private readonly IHttpContextAccessor _httpContextAccessor;
-
-        public RequestScopedServiceProvider(IHttpContextAccessor httpContextAccessor)
-        {
-            ArgumentGuard.NotNull(httpContextAccessor, nameof(httpContextAccessor));
-
-            _httpContextAccessor = httpContextAccessor;
-        }
-
-        /// <inheritdoc />
-        public object GetService(Type serviceType)
-        {
-            ArgumentGuard.NotNull(serviceType, nameof(serviceType));
-
-            if (_httpContextAccessor.HttpContext == null)
-            {
-                throw new InvalidOperationException($"Cannot resolve scoped service '{serviceType.FullName}' outside the context of an HTTP request. " +
-                    "If you are hitting this error in automated tests, you should instead inject your own " +
-                    "IRequestScopedServiceProvider implementation. See the GitHub repository for how we do this internally. " +
-                    "https://github.com/json-api-dotnet/JsonApiDotNetCore/search?q=TestScopedServiceProvider&unscoped_q=TestScopedServiceProvider");
-            }
-
-            return _httpContextAccessor.HttpContext.RequestServices.GetService(serviceType);
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Configuration/ResourceDescriptor.cs b/src/JsonApiDotNetCore/Configuration/ResourceDescriptor.cs
index 70a14513ae..d673fe11a7 100644
--- a/src/JsonApiDotNetCore/Configuration/ResourceDescriptor.cs
+++ b/src/JsonApiDotNetCore/Configuration/ResourceDescriptor.cs
@@ -4,13 +4,13 @@ namespace JsonApiDotNetCore.Configuration
 {
     internal sealed class ResourceDescriptor
     {
-        public Type ResourceType { get; }
-        public Type IdType { get; }
+        public Type ResourceClrType { get; }
+        public Type IdClrType { get; }
 
-        public ResourceDescriptor(Type resourceType, Type idType)
+        public ResourceDescriptor(Type resourceClrType, Type idClrType)
         {
-            ResourceType = resourceType;
-            IdType = idType;
+            ResourceClrType = resourceClrType;
+            IdClrType = idClrType;
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Configuration/ResourceGraph.cs b/src/JsonApiDotNetCore/Configuration/ResourceGraph.cs
index f65755b38d..90df89c576 100644
--- a/src/JsonApiDotNetCore/Configuration/ResourceGraph.cs
+++ b/src/JsonApiDotNetCore/Configuration/ResourceGraph.cs
@@ -15,82 +15,82 @@ public sealed class ResourceGraph : IResourceGraph
     {
         private static readonly Type ProxyTargetAccessorType = Type.GetType("Castle.DynamicProxy.IProxyTargetAccessor, Castle.Core");
 
-        private readonly IReadOnlySet<ResourceContext> _resourceContextSet;
-        private readonly Dictionary<Type, ResourceContext> _resourceContextsByType = new();
-        private readonly Dictionary<string, ResourceContext> _resourceContextsByPublicName = new();
+        private readonly IReadOnlySet<ResourceType> _resourceTypeSet;
+        private readonly Dictionary<Type, ResourceType> _resourceTypesByClrType = new();
+        private readonly Dictionary<string, ResourceType> _resourceTypesByPublicName = new();
 
-        public ResourceGraph(IReadOnlySet<ResourceContext> resourceContexts)
+        public ResourceGraph(IReadOnlySet<ResourceType> resourceTypeSet)
         {
-            ArgumentGuard.NotNull(resourceContexts, nameof(resourceContexts));
+            ArgumentGuard.NotNull(resourceTypeSet, nameof(resourceTypeSet));
 
-            _resourceContextSet = resourceContexts;
+            _resourceTypeSet = resourceTypeSet;
 
-            foreach (ResourceContext resourceContext in resourceContexts)
+            foreach (ResourceType resourceType in resourceTypeSet)
             {
-                _resourceContextsByType.Add(resourceContext.ResourceType, resourceContext);
-                _resourceContextsByPublicName.Add(resourceContext.PublicName, resourceContext);
+                _resourceTypesByClrType.Add(resourceType.ClrType, resourceType);
+                _resourceTypesByPublicName.Add(resourceType.PublicName, resourceType);
             }
         }
 
         /// <inheritdoc />
-        public IReadOnlySet<ResourceContext> GetResourceContexts()
+        public IReadOnlySet<ResourceType> GetResourceTypes()
         {
-            return _resourceContextSet;
+            return _resourceTypeSet;
         }
 
         /// <inheritdoc />
-        public ResourceContext GetResourceContext(string publicName)
+        public ResourceType GetResourceType(string publicName)
         {
-            ResourceContext resourceContext = TryGetResourceContext(publicName);
+            ResourceType resourceType = TryGetResourceType(publicName);
 
-            if (resourceContext == null)
+            if (resourceType == null)
             {
                 throw new InvalidOperationException($"Resource type '{publicName}' does not exist.");
             }
 
-            return resourceContext;
+            return resourceType;
         }
 
         /// <inheritdoc />
-        public ResourceContext TryGetResourceContext(string publicName)
+        public ResourceType TryGetResourceType(string publicName)
         {
-            ArgumentGuard.NotNullNorEmpty(publicName, nameof(publicName));
+            ArgumentGuard.NotNull(publicName, nameof(publicName));
 
-            return _resourceContextsByPublicName.TryGetValue(publicName, out ResourceContext resourceContext) ? resourceContext : null;
+            return _resourceTypesByPublicName.TryGetValue(publicName, out ResourceType resourceType) ? resourceType : null;
         }
 
         /// <inheritdoc />
-        public ResourceContext GetResourceContext(Type resourceType)
+        public ResourceType GetResourceType(Type resourceClrType)
         {
-            ResourceContext resourceContext = TryGetResourceContext(resourceType);
+            ResourceType resourceType = TryGetResourceType(resourceClrType);
 
-            if (resourceContext == null)
+            if (resourceType == null)
             {
-                throw new InvalidOperationException($"Resource of type '{resourceType.Name}' does not exist.");
+                throw new InvalidOperationException($"Resource of type '{resourceClrType.Name}' does not exist.");
             }
 
-            return resourceContext;
+            return resourceType;
         }
 
         /// <inheritdoc />
-        public ResourceContext TryGetResourceContext(Type resourceType)
+        public ResourceType TryGetResourceType(Type resourceClrType)
         {
-            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
+            ArgumentGuard.NotNull(resourceClrType, nameof(resourceClrType));
 
-            Type typeToFind = IsLazyLoadingProxyForResourceType(resourceType) ? resourceType.BaseType : resourceType;
-            return _resourceContextsByType.TryGetValue(typeToFind!, out ResourceContext resourceContext) ? resourceContext : null;
+            Type typeToFind = IsLazyLoadingProxyForResourceType(resourceClrType) ? resourceClrType.BaseType : resourceClrType;
+            return _resourceTypesByClrType.TryGetValue(typeToFind!, out ResourceType resourceType) ? resourceType : null;
         }
 
-        private bool IsLazyLoadingProxyForResourceType(Type resourceType)
+        private bool IsLazyLoadingProxyForResourceType(Type resourceClrType)
         {
-            return ProxyTargetAccessorType?.IsAssignableFrom(resourceType) ?? false;
+            return ProxyTargetAccessorType?.IsAssignableFrom(resourceClrType) ?? false;
         }
 
         /// <inheritdoc />
-        public ResourceContext GetResourceContext<TResource>()
+        public ResourceType GetResourceType<TResource>()
             where TResource : class, IIdentifiable
         {
-            return GetResourceContext(typeof(TResource));
+            return GetResourceType(typeof(TResource));
         }
 
         /// <inheritdoc />
@@ -145,19 +145,19 @@ private IReadOnlyCollection<TField> FilterFields<TResource, TField>(Expression<F
         private IReadOnlyCollection<TKind> GetFieldsOfType<TResource, TKind>()
             where TKind : ResourceFieldAttribute
         {
-            ResourceContext resourceContext = GetResourceContext(typeof(TResource));
+            ResourceType resourceType = GetResourceType(typeof(TResource));
 
             if (typeof(TKind) == typeof(AttrAttribute))
             {
-                return (IReadOnlyCollection<TKind>)resourceContext.Attributes;
+                return (IReadOnlyCollection<TKind>)resourceType.Attributes;
             }
 
             if (typeof(TKind) == typeof(RelationshipAttribute))
             {
-                return (IReadOnlyCollection<TKind>)resourceContext.Relationships;
+                return (IReadOnlyCollection<TKind>)resourceType.Relationships;
             }
 
-            return (IReadOnlyCollection<TKind>)resourceContext.Fields;
+            return (IReadOnlyCollection<TKind>)resourceType.Fields;
         }
 
         private IEnumerable<string> ToMemberNames<TResource>(Expression<Func<TResource, dynamic>> selector)
diff --git a/src/JsonApiDotNetCore/Configuration/ResourceGraphBuilder.cs b/src/JsonApiDotNetCore/Configuration/ResourceGraphBuilder.cs
index 0ea1fb1a14..c063444d88 100644
--- a/src/JsonApiDotNetCore/Configuration/ResourceGraphBuilder.cs
+++ b/src/JsonApiDotNetCore/Configuration/ResourceGraphBuilder.cs
@@ -5,6 +5,9 @@
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Resources;
 using JsonApiDotNetCore.Resources.Annotations;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
 using Microsoft.Extensions.Logging;
 
 namespace JsonApiDotNetCore.Configuration
@@ -17,7 +20,7 @@ public class ResourceGraphBuilder
     {
         private readonly IJsonApiOptions _options;
         private readonly ILogger<ResourceGraphBuilder> _logger;
-        private readonly HashSet<ResourceContext> _resourceContexts = new();
+        private readonly HashSet<ResourceType> _resourceTypes = new();
         private readonly TypeLocator _typeLocator = new();
 
         public ResourceGraphBuilder(IJsonApiOptions options, ILoggerFactory loggerFactory)
@@ -34,18 +37,48 @@ public ResourceGraphBuilder(IJsonApiOptions options, ILoggerFactory loggerFactor
         /// </summary>
         public IResourceGraph Build()
         {
-            return new ResourceGraph(_resourceContexts);
+            var resourceGraph = new ResourceGraph(_resourceTypes);
+
+            foreach (RelationshipAttribute relationship in _resourceTypes.SelectMany(resourceType => resourceType.Relationships))
+            {
+                relationship.LeftType = resourceGraph.GetResourceType(relationship.LeftClrType);
+                relationship.RightType = resourceGraph.GetResourceType(relationship.RightClrType);
+            }
+
+            return resourceGraph;
+        }
+
+        public ResourceGraphBuilder Add(DbContext dbContext)
+        {
+            ArgumentGuard.NotNull(dbContext, nameof(dbContext));
+
+            foreach (IEntityType entityType in dbContext.Model.GetEntityTypes())
+            {
+                if (!IsImplicitManyToManyJoinEntity(entityType))
+                {
+                    Add(entityType.ClrType);
+                }
+            }
+
+            return this;
+        }
+
+        private static bool IsImplicitManyToManyJoinEntity(IEntityType entityType)
+        {
+#pragma warning disable EF1001 // Internal EF Core API usage.
+            return entityType is EntityType { IsImplicitlyCreatedJoinEntityType: true };
+#pragma warning restore EF1001 // Internal EF Core API usage.
         }
 
         /// <summary>
-        /// Adds a JSON:API resource with <code>int</code> as the identifier type.
+        /// Adds a JSON:API resource with <code>int</code> as the identifier CLR type.
         /// </summary>
         /// <typeparam name="TResource">
-        /// The resource model type.
+        /// The resource CLR type.
         /// </typeparam>
         /// <param name="publicName">
-        /// The name under which the resource is publicly exposed by the API. If nothing is specified, the configured naming convention formatter will be
-        /// applied.
+        /// The name under which the resource is publicly exposed by the API. If nothing is specified, the naming convention is applied on the pluralized CLR
+        /// type name.
         /// </param>
         public ResourceGraphBuilder Add<TResource>(string publicName = null)
             where TResource : class, IIdentifiable<int>
@@ -57,14 +90,14 @@ public ResourceGraphBuilder Add<TResource>(string publicName = null)
         /// Adds a JSON:API resource.
         /// </summary>
         /// <typeparam name="TResource">
-        /// The resource model type.
+        /// The resource CLR type.
         /// </typeparam>
         /// <typeparam name="TId">
-        /// The resource model identifier type.
+        /// The resource identifier CLR type.
         /// </typeparam>
         /// <param name="publicName">
-        /// The name under which the resource is publicly exposed by the API. If nothing is specified, the configured naming convention formatter will be
-        /// applied.
+        /// The name under which the resource is publicly exposed by the API. If nothing is specified, the naming convention is applied on the pluralized CLR
+        /// type name.
         /// </param>
         public ResourceGraphBuilder Add<TResource, TId>(string publicName = null)
             where TResource : class, IIdentifiable<TId>
@@ -75,60 +108,60 @@ public ResourceGraphBuilder Add<TResource, TId>(string publicName = null)
         /// <summary>
         /// Adds a JSON:API resource.
         /// </summary>
-        /// <param name="resourceType">
-        /// The resource model type.
+        /// <param name="resourceClrType">
+        /// The resource CLR type.
         /// </param>
-        /// <param name="idType">
-        /// The resource model identifier type.
+        /// <param name="idClrType">
+        /// The resource identifier CLR type.
         /// </param>
         /// <param name="publicName">
-        /// The name under which the resource is publicly exposed by the API. If nothing is specified, the configured naming convention formatter will be
-        /// applied.
+        /// The name under which the resource is publicly exposed by the API. If nothing is specified, the naming convention is applied on the pluralized CLR
+        /// type name.
         /// </param>
-        public ResourceGraphBuilder Add(Type resourceType, Type idType = null, string publicName = null)
+        public ResourceGraphBuilder Add(Type resourceClrType, Type idClrType = null, string publicName = null)
         {
-            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
+            ArgumentGuard.NotNull(resourceClrType, nameof(resourceClrType));
 
-            if (_resourceContexts.Any(resourceContext => resourceContext.ResourceType == resourceType))
+            if (_resourceTypes.Any(resourceType => resourceType.ClrType == resourceClrType))
             {
                 return this;
             }
 
-            if (resourceType.IsOrImplementsInterface(typeof(IIdentifiable)))
+            if (resourceClrType.IsOrImplementsInterface(typeof(IIdentifiable)))
             {
-                string effectivePublicName = publicName ?? FormatResourceName(resourceType);
-                Type effectiveIdType = idType ?? _typeLocator.TryGetIdType(resourceType);
+                string effectivePublicName = publicName ?? FormatResourceName(resourceClrType);
+                Type effectiveIdType = idClrType ?? _typeLocator.TryGetIdType(resourceClrType) ?? typeof(int);
 
-                ResourceContext resourceContext = CreateResourceContext(effectivePublicName, resourceType, effectiveIdType);
-                _resourceContexts.Add(resourceContext);
+                ResourceType resourceType = CreateResourceType(effectivePublicName, resourceClrType, effectiveIdType);
+                _resourceTypes.Add(resourceType);
             }
             else
             {
-                _logger.LogWarning($"Entity '{resourceType}' does not implement '{nameof(IIdentifiable)}'.");
+                _logger.LogWarning($"Entity '{resourceClrType}' does not implement '{nameof(IIdentifiable)}'.");
             }
 
             return this;
         }
 
-        private ResourceContext CreateResourceContext(string publicName, Type resourceType, Type idType)
+        private ResourceType CreateResourceType(string publicName, Type resourceClrType, Type idClrType)
         {
-            IReadOnlyCollection<AttrAttribute> attributes = GetAttributes(resourceType);
-            IReadOnlyCollection<RelationshipAttribute> relationships = GetRelationships(resourceType);
-            IReadOnlyCollection<EagerLoadAttribute> eagerLoads = GetEagerLoads(resourceType);
+            IReadOnlyCollection<AttrAttribute> attributes = GetAttributes(resourceClrType);
+            IReadOnlyCollection<RelationshipAttribute> relationships = GetRelationships(resourceClrType);
+            IReadOnlyCollection<EagerLoadAttribute> eagerLoads = GetEagerLoads(resourceClrType);
 
-            var linksAttribute = (ResourceLinksAttribute)resourceType.GetCustomAttribute(typeof(ResourceLinksAttribute));
+            var linksAttribute = (ResourceLinksAttribute)resourceClrType.GetCustomAttribute(typeof(ResourceLinksAttribute));
 
             return linksAttribute == null
-                ? new ResourceContext(publicName, resourceType, idType, attributes, relationships, eagerLoads)
-                : new ResourceContext(publicName, resourceType, idType, attributes, relationships, eagerLoads, linksAttribute.TopLevelLinks,
+                ? new ResourceType(publicName, resourceClrType, idClrType, attributes, relationships, eagerLoads)
+                : new ResourceType(publicName, resourceClrType, idClrType, attributes, relationships, eagerLoads, linksAttribute.TopLevelLinks,
                     linksAttribute.ResourceLinks, linksAttribute.RelationshipLinks);
         }
 
-        private IReadOnlyCollection<AttrAttribute> GetAttributes(Type resourceType)
+        private IReadOnlyCollection<AttrAttribute> GetAttributes(Type resourceClrType)
         {
             var attributes = new List<AttrAttribute>();
 
-            foreach (PropertyInfo property in resourceType.GetProperties())
+            foreach (PropertyInfo property in resourceClrType.GetProperties())
             {
                 var attribute = (AttrAttribute)property.GetCustomAttribute(typeof(AttrAttribute));
 
@@ -167,27 +200,27 @@ private IReadOnlyCollection<AttrAttribute> GetAttributes(Type resourceType)
             return attributes;
         }
 
-        private IReadOnlyCollection<RelationshipAttribute> GetRelationships(Type resourceType)
+        private IReadOnlyCollection<RelationshipAttribute> GetRelationships(Type resourceClrType)
         {
-            var attributes = new List<RelationshipAttribute>();
-            PropertyInfo[] properties = resourceType.GetProperties();
+            var relationships = new List<RelationshipAttribute>();
+            PropertyInfo[] properties = resourceClrType.GetProperties();
 
             foreach (PropertyInfo property in properties)
             {
-                var attribute = (RelationshipAttribute)property.GetCustomAttribute(typeof(RelationshipAttribute));
+                var relationship = (RelationshipAttribute)property.GetCustomAttribute(typeof(RelationshipAttribute));
 
-                if (attribute != null)
+                if (relationship != null)
                 {
-                    attribute.Property = property;
-                    attribute.PublicName ??= FormatPropertyName(property);
-                    attribute.LeftType = resourceType;
-                    attribute.RightType = GetRelationshipType(attribute, property);
+                    relationship.Property = property;
+                    relationship.PublicName ??= FormatPropertyName(property);
+                    relationship.LeftClrType = resourceClrType;
+                    relationship.RightClrType = GetRelationshipType(relationship, property);
 
-                    attributes.Add(attribute);
+                    relationships.Add(relationship);
                 }
             }
 
-            return attributes;
+            return relationships;
         }
 
         private Type GetRelationshipType(RelationshipAttribute relationship, PropertyInfo property)
@@ -198,12 +231,12 @@ private Type GetRelationshipType(RelationshipAttribute relationship, PropertyInf
             return relationship is HasOneAttribute ? property.PropertyType : property.PropertyType.GetGenericArguments()[0];
         }
 
-        private IReadOnlyCollection<EagerLoadAttribute> GetEagerLoads(Type resourceType, int recursionDepth = 0)
+        private IReadOnlyCollection<EagerLoadAttribute> GetEagerLoads(Type resourceClrType, int recursionDepth = 0)
         {
             AssertNoInfiniteRecursion(recursionDepth);
 
             var attributes = new List<EagerLoadAttribute>();
-            PropertyInfo[] properties = resourceType.GetProperties();
+            PropertyInfo[] properties = resourceClrType.GetProperties();
 
             foreach (PropertyInfo property in properties)
             {
@@ -241,10 +274,10 @@ private Type TypeOrElementType(Type type)
             return interfaces.Length == 1 ? interfaces.Single().GenericTypeArguments[0] : type;
         }
 
-        private string FormatResourceName(Type resourceType)
+        private string FormatResourceName(Type resourceClrType)
         {
             var formatter = new ResourceNameFormatter(_options.SerializerOptions.PropertyNamingPolicy);
-            return formatter.FormatResourceName(resourceType);
+            return formatter.FormatResourceName(resourceClrType);
         }
 
         private string FormatPropertyName(PropertyInfo resourceProperty)
diff --git a/src/JsonApiDotNetCore/Configuration/ResourceNameFormatter.cs b/src/JsonApiDotNetCore/Configuration/ResourceNameFormatter.cs
index 93e5dda4ff..d968c8eda7 100644
--- a/src/JsonApiDotNetCore/Configuration/ResourceNameFormatter.cs
+++ b/src/JsonApiDotNetCore/Configuration/ResourceNameFormatter.cs
@@ -16,16 +16,16 @@ public ResourceNameFormatter(JsonNamingPolicy namingPolicy)
         }
 
         /// <summary>
-        /// Gets the publicly visible resource name for the internal type name using the configured naming convention.
+        /// Gets the publicly exposed resource name by applying the configured naming convention on the pluralized CLR type name.
         /// </summary>
-        public string FormatResourceName(Type resourceType)
+        public string FormatResourceName(Type resourceClrType)
         {
-            if (resourceType.GetCustomAttribute(typeof(ResourceAttribute)) is ResourceAttribute attribute)
+            if (resourceClrType.GetCustomAttribute(typeof(ResourceAttribute)) is ResourceAttribute attribute)
             {
                 return attribute.PublicName;
             }
 
-            string publicName = resourceType.Name.Pluralize();
+            string publicName = resourceClrType.Name.Pluralize();
             return _namingPolicy != null ? _namingPolicy.ConvertName(publicName) : publicName;
         }
     }
diff --git a/src/JsonApiDotNetCore/Configuration/ResourceContext.cs b/src/JsonApiDotNetCore/Configuration/ResourceType.cs
similarity index 86%
rename from src/JsonApiDotNetCore/Configuration/ResourceContext.cs
rename to src/JsonApiDotNetCore/Configuration/ResourceType.cs
index f5b42e5499..75dddfbcc4 100644
--- a/src/JsonApiDotNetCore/Configuration/ResourceContext.cs
+++ b/src/JsonApiDotNetCore/Configuration/ResourceType.cs
@@ -10,7 +10,7 @@ namespace JsonApiDotNetCore.Configuration
     /// Metadata about the shape of a JSON:API resource in the resource graph.
     /// </summary>
     [PublicAPI]
-    public sealed class ResourceContext
+    public sealed class ResourceType
     {
         private readonly Dictionary<string, ResourceFieldAttribute> _fieldsByPublicName = new();
         private readonly Dictionary<string, ResourceFieldAttribute> _fieldsByPropertyName = new();
@@ -23,12 +23,12 @@ public sealed class ResourceContext
         /// <summary>
         /// The CLR type of the resource.
         /// </summary>
-        public Type ResourceType { get; }
+        public Type ClrType { get; }
 
         /// <summary>
-        /// The identity type of the resource.
+        /// The CLR type of the resource identity.
         /// </summary>
-        public Type IdentityType { get; }
+        public Type IdentityClrType { get; }
 
         /// <summary>
         /// Exposed resource attributes and relationships. See https://jsonapi.org/format/#document-resource-object-fields.
@@ -78,28 +78,25 @@ public sealed class ResourceContext
         /// </remarks>
         public LinkTypes RelationshipLinks { get; }
 
-        public ResourceContext(string publicName, Type resourceType, Type identityType, IReadOnlyCollection<AttrAttribute> attributes,
-            IReadOnlyCollection<RelationshipAttribute> relationships, IReadOnlyCollection<EagerLoadAttribute> eagerLoads,
+        public ResourceType(string publicName, Type clrType, Type identityClrType, IReadOnlyCollection<AttrAttribute> attributes = null,
+            IReadOnlyCollection<RelationshipAttribute> relationships = null, IReadOnlyCollection<EagerLoadAttribute> eagerLoads = null,
             LinkTypes topLevelLinks = LinkTypes.NotConfigured, LinkTypes resourceLinks = LinkTypes.NotConfigured,
             LinkTypes relationshipLinks = LinkTypes.NotConfigured)
         {
             ArgumentGuard.NotNullNorEmpty(publicName, nameof(publicName));
-            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
-            ArgumentGuard.NotNull(identityType, nameof(identityType));
-            ArgumentGuard.NotNull(attributes, nameof(attributes));
-            ArgumentGuard.NotNull(relationships, nameof(relationships));
-            ArgumentGuard.NotNull(eagerLoads, nameof(eagerLoads));
+            ArgumentGuard.NotNull(clrType, nameof(clrType));
+            ArgumentGuard.NotNull(identityClrType, nameof(identityClrType));
 
             PublicName = publicName;
-            ResourceType = resourceType;
-            IdentityType = identityType;
-            Fields = attributes.Cast<ResourceFieldAttribute>().Concat(relationships).ToArray();
-            Attributes = attributes;
-            Relationships = relationships;
-            EagerLoads = eagerLoads;
+            ClrType = clrType;
+            IdentityClrType = identityClrType;
+            Attributes = attributes ?? Array.Empty<AttrAttribute>();
+            Relationships = relationships ?? Array.Empty<RelationshipAttribute>();
+            EagerLoads = eagerLoads ?? Array.Empty<EagerLoadAttribute>();
             TopLevelLinks = topLevelLinks;
             ResourceLinks = resourceLinks;
             RelationshipLinks = relationshipLinks;
+            Fields = Attributes.Cast<ResourceFieldAttribute>().Concat(Relationships).ToArray();
 
             foreach (ResourceFieldAttribute field in Fields)
             {
@@ -126,7 +123,7 @@ public AttrAttribute GetAttributeByPropertyName(string propertyName)
             AttrAttribute attribute = TryGetAttributeByPropertyName(propertyName);
 
             return attribute ??
-                throw new InvalidOperationException($"Attribute for property '{propertyName}' does not exist on resource type '{ResourceType.Name}'.");
+                throw new InvalidOperationException($"Attribute for property '{propertyName}' does not exist on resource type '{ClrType.Name}'.");
         }
 
         public AttrAttribute TryGetAttributeByPropertyName(string propertyName)
@@ -156,7 +153,7 @@ public RelationshipAttribute GetRelationshipByPropertyName(string propertyName)
             RelationshipAttribute relationship = TryGetRelationshipByPropertyName(propertyName);
 
             return relationship ??
-                throw new InvalidOperationException($"Relationship for property '{propertyName}' does not exist on resource type '{ResourceType.Name}'.");
+                throw new InvalidOperationException($"Relationship for property '{propertyName}' does not exist on resource type '{ClrType.Name}'.");
         }
 
         public RelationshipAttribute TryGetRelationshipByPropertyName(string propertyName)
@@ -185,9 +182,9 @@ public override bool Equals(object obj)
                 return false;
             }
 
-            var other = (ResourceContext)obj;
+            var other = (ResourceType)obj;
 
-            return PublicName == other.PublicName && ResourceType == other.ResourceType && IdentityType == other.IdentityType &&
+            return PublicName == other.PublicName && ClrType == other.ClrType && IdentityClrType == other.IdentityClrType &&
                 Attributes.SequenceEqual(other.Attributes) && Relationships.SequenceEqual(other.Relationships) && EagerLoads.SequenceEqual(other.EagerLoads) &&
                 TopLevelLinks == other.TopLevelLinks && ResourceLinks == other.ResourceLinks && RelationshipLinks == other.RelationshipLinks;
         }
@@ -197,8 +194,8 @@ public override int GetHashCode()
             var hashCode = new HashCode();
 
             hashCode.Add(PublicName);
-            hashCode.Add(ResourceType);
-            hashCode.Add(IdentityType);
+            hashCode.Add(ClrType);
+            hashCode.Add(IdentityClrType);
 
             foreach (AttrAttribute attribute in Attributes)
             {
diff --git a/src/JsonApiDotNetCore/Configuration/ServiceCollectionExtensions.cs b/src/JsonApiDotNetCore/Configuration/ServiceCollectionExtensions.cs
index 2c8c1fc5a2..9accf54219 100644
--- a/src/JsonApiDotNetCore/Configuration/ServiceCollectionExtensions.cs
+++ b/src/JsonApiDotNetCore/Configuration/ServiceCollectionExtensions.cs
@@ -107,15 +107,15 @@ private static void RegisterForConstructedType(IServiceCollection services, Type
                     // e.g. IResourceService<TResource> is the shorthand for IResourceService<TResource, TId>
                     bool isShorthandInterface = openGenericInterface.GetTypeInfo().GenericTypeParameters.Length == 1;
 
-                    if (isShorthandInterface && resourceDescriptor.IdType != typeof(int))
+                    if (isShorthandInterface && resourceDescriptor.IdClrType != typeof(int))
                     {
                         // We can't create a shorthand for ID types other than int.
                         continue;
                     }
 
                     Type constructedType = isShorthandInterface
-                        ? openGenericInterface.MakeGenericType(resourceDescriptor.ResourceType)
-                        : openGenericInterface.MakeGenericType(resourceDescriptor.ResourceType, resourceDescriptor.IdType);
+                        ? openGenericInterface.MakeGenericType(resourceDescriptor.ResourceClrType)
+                        : openGenericInterface.MakeGenericType(resourceDescriptor.ResourceClrType, resourceDescriptor.IdClrType);
 
                     if (constructedType.IsAssignableFrom(implementationType))
                     {
diff --git a/src/JsonApiDotNetCore/Configuration/ServiceDiscoveryFacade.cs b/src/JsonApiDotNetCore/Configuration/ServiceDiscoveryFacade.cs
index 7a179e5784..3a8e7bd8d5 100644
--- a/src/JsonApiDotNetCore/Configuration/ServiceDiscoveryFacade.cs
+++ b/src/JsonApiDotNetCore/Configuration/ServiceDiscoveryFacade.cs
@@ -137,14 +137,14 @@ private void AddDbContextResolvers(Assembly assembly)
 
             foreach (Type dbContextType in dbContextTypes)
             {
-                Type resolverType = typeof(DbContextResolver<>).MakeGenericType(dbContextType);
-                _services.AddScoped(typeof(IDbContextResolver), resolverType);
+                Type dbContextResolverType = typeof(DbContextResolver<>).MakeGenericType(dbContextType);
+                _services.AddScoped(typeof(IDbContextResolver), dbContextResolverType);
             }
         }
 
         private void AddResource(ResourceDescriptor resourceDescriptor)
         {
-            _resourceGraphBuilder.Add(resourceDescriptor.ResourceType, resourceDescriptor.IdType);
+            _resourceGraphBuilder.Add(resourceDescriptor.ResourceClrType, resourceDescriptor.IdClrType);
         }
 
         private void AddServices(Assembly assembly, ResourceDescriptor resourceDescriptor)
@@ -174,8 +174,8 @@ private void AddResourceDefinitions(Assembly assembly, ResourceDescriptor resour
         private void RegisterImplementations(Assembly assembly, Type interfaceType, ResourceDescriptor resourceDescriptor)
         {
             Type[] genericArguments = interfaceType.GetTypeInfo().GenericTypeParameters.Length == 2
-                ? ArrayFactory.Create(resourceDescriptor.ResourceType, resourceDescriptor.IdType)
-                : ArrayFactory.Create(resourceDescriptor.ResourceType);
+                ? ArrayFactory.Create(resourceDescriptor.ResourceClrType, resourceDescriptor.IdClrType)
+                : ArrayFactory.Create(resourceDescriptor.ResourceClrType);
 
             (Type implementation, Type registrationInterface)? result =
                 _typeLocator.GetGenericInterfaceImplementation(assembly, interfaceType, genericArguments);
diff --git a/src/JsonApiDotNetCore/Configuration/TypeLocator.cs b/src/JsonApiDotNetCore/Configuration/TypeLocator.cs
index 7f6d266aa4..7f0e85371e 100644
--- a/src/JsonApiDotNetCore/Configuration/TypeLocator.cs
+++ b/src/JsonApiDotNetCore/Configuration/TypeLocator.cs
@@ -14,9 +14,9 @@ internal sealed class TypeLocator
         /// <summary>
         /// Attempts to lookup the ID type of the specified resource type. Returns <c>null</c> if it does not implement <see cref="IIdentifiable{TId}" />.
         /// </summary>
-        public Type TryGetIdType(Type resourceType)
+        public Type TryGetIdType(Type resourceClrType)
         {
-            Type identifiableInterface = resourceType.GetInterfaces().FirstOrDefault(@interface =>
+            Type identifiableInterface = resourceClrType.GetInterfaces().FirstOrDefault(@interface =>
                 @interface.IsGenericType && @interface.GetGenericTypeDefinition() == typeof(IIdentifiable<>));
 
             return identifiableInterface?.GetGenericArguments()[0];
diff --git a/src/JsonApiDotNetCore/Controllers/BaseJsonApiController.cs b/src/JsonApiDotNetCore/Controllers/BaseJsonApiController.cs
index 98a4c58afe..90a8f3078f 100644
--- a/src/JsonApiDotNetCore/Controllers/BaseJsonApiController.cs
+++ b/src/JsonApiDotNetCore/Controllers/BaseJsonApiController.cs
@@ -182,11 +182,6 @@ public virtual async Task<IActionResult> PostAsync([FromBody] TResource resource
                 throw new RequestMethodNotAllowedException(HttpMethod.Post);
             }
 
-            if (!_options.AllowClientGeneratedIds && resource.StringId != null)
-            {
-                throw new ResourceIdInCreateResourceNotAllowedException();
-            }
-
             if (_options.ValidateModelState && !ModelState.IsValid)
             {
                 throw new InvalidModelStateException(ModelState, typeof(TResource), _options.IncludeExceptionStackTraceInErrors,
diff --git a/src/JsonApiDotNetCore/Controllers/BaseJsonApiOperationsController.cs b/src/JsonApiDotNetCore/Controllers/BaseJsonApiOperationsController.cs
index 0ed536eb15..2960b23447 100644
--- a/src/JsonApiDotNetCore/Controllers/BaseJsonApiOperationsController.cs
+++ b/src/JsonApiDotNetCore/Controllers/BaseJsonApiOperationsController.cs
@@ -113,8 +113,6 @@ public virtual async Task<IActionResult> PostOperationsAsync([FromBody] IList<Op
 
             ArgumentGuard.NotNull(operations, nameof(operations));
 
-            ValidateClientGeneratedIds(operations);
-
             if (_options.ValidateModelState)
             {
                 ValidateModelState(operations);
@@ -124,24 +122,6 @@ public virtual async Task<IActionResult> PostOperationsAsync([FromBody] IList<Op
             return results.Any(result => result != null) ? Ok(results) : NoContent();
         }
 
-        protected virtual void ValidateClientGeneratedIds(IEnumerable<OperationContainer> operations)
-        {
-            if (!_options.AllowClientGeneratedIds)
-            {
-                int index = 0;
-
-                foreach (OperationContainer operation in operations)
-                {
-                    if (operation.Kind == WriteOperationKind.CreateResource && operation.Resource.StringId != null)
-                    {
-                        throw new ResourceIdInCreateResourceNotAllowedException(index);
-                    }
-
-                    index++;
-                }
-            }
-        }
-
         protected virtual void ValidateModelState(IEnumerable<OperationContainer> operations)
         {
             // We must validate the resource inside each operation manually, because they are typed as IIdentifiable.
@@ -150,14 +130,13 @@ protected virtual void ValidateModelState(IEnumerable<OperationContainer> operat
             var violations = new List<ModelStateViolation>();
 
             int index = 0;
+            using IDisposable _ = new RevertRequestStateOnDispose(_request, _targetedFields);
 
             foreach (OperationContainer operation in operations)
             {
-                if (operation.Kind == WriteOperationKind.CreateResource || operation.Kind == WriteOperationKind.UpdateResource)
+                if (operation.Request.WriteOperation is WriteOperationKind.CreateResource or WriteOperationKind.UpdateResource)
                 {
-                    _targetedFields.Attributes = operation.TargetedFields.Attributes;
-                    _targetedFields.Relationships = operation.TargetedFields.Relationships;
-
+                    _targetedFields.CopyFrom(operation.TargetedFields);
                     _request.CopyFrom(operation.Request);
 
                     var validationContext = new ActionContext();
@@ -178,21 +157,21 @@ protected virtual void ValidateModelState(IEnumerable<OperationContainer> operat
             }
         }
 
-        private static void AddValidationErrors(ModelStateDictionary modelState, Type resourceType, int operationIndex, List<ModelStateViolation> violations)
+        private static void AddValidationErrors(ModelStateDictionary modelState, Type resourceClrType, int operationIndex, List<ModelStateViolation> violations)
         {
             foreach ((string propertyName, ModelStateEntry entry) in modelState)
             {
-                AddValidationErrors(entry, propertyName, resourceType, operationIndex, violations);
+                AddValidationErrors(entry, propertyName, resourceClrType, operationIndex, violations);
             }
         }
 
-        private static void AddValidationErrors(ModelStateEntry entry, string propertyName, Type resourceType, int operationIndex,
+        private static void AddValidationErrors(ModelStateEntry entry, string propertyName, Type resourceClrType, int operationIndex,
             List<ModelStateViolation> violations)
         {
             foreach (ModelError error in entry.Errors)
             {
                 string prefix = $"/atomic:operations[{operationIndex}]/data/attributes/";
-                var violation = new ModelStateViolation(prefix, propertyName, resourceType, error);
+                var violation = new ModelStateViolation(prefix, propertyName, resourceClrType, error);
 
                 violations.Add(violation);
             }
diff --git a/src/JsonApiDotNetCore/Controllers/CoreJsonApiController.cs b/src/JsonApiDotNetCore/Controllers/CoreJsonApiController.cs
index 88d9614cc7..0f7ae00488 100644
--- a/src/JsonApiDotNetCore/Controllers/CoreJsonApiController.cs
+++ b/src/JsonApiDotNetCore/Controllers/CoreJsonApiController.cs
@@ -14,21 +14,21 @@ protected IActionResult Error(ErrorObject error)
         {
             ArgumentGuard.NotNull(error, nameof(error));
 
-            return Error(error.AsEnumerable());
+            return new ObjectResult(error)
+            {
+                StatusCode = (int)error.StatusCode
+            };
         }
 
         protected IActionResult Error(IEnumerable<ErrorObject> errors)
         {
             ArgumentGuard.NotNull(errors, nameof(errors));
 
-            var document = new Document
-            {
-                Errors = errors.ToList()
-            };
+            ErrorObject[] errorArray = errors.ToArray();
 
-            return new ObjectResult(document)
+            return new ObjectResult(errorArray)
             {
-                StatusCode = (int)document.GetErrorStatusCode()
+                StatusCode = (int)ErrorObject.GetResponseStatusCode(errorArray)
             };
         }
     }
diff --git a/src/JsonApiDotNetCore/Controllers/JsonApiQueryController.cs b/src/JsonApiDotNetCore/Controllers/JsonApiQueryController.cs
index 7ab85612c8..65d69c9d30 100644
--- a/src/JsonApiDotNetCore/Controllers/JsonApiQueryController.cs
+++ b/src/JsonApiDotNetCore/Controllers/JsonApiQueryController.cs
@@ -25,8 +25,8 @@ public abstract class JsonApiQueryController<TResource, TId> : BaseJsonApiContro
         /// <summary>
         /// Creates an instance from a read-only service.
         /// </summary>
-        protected JsonApiQueryController(IJsonApiOptions context, ILoggerFactory loggerFactory, IResourceQueryService<TResource, TId> queryService)
-            : base(context, loggerFactory, queryService)
+        protected JsonApiQueryController(IJsonApiOptions options, ILoggerFactory loggerFactory, IResourceQueryService<TResource, TId> queryService)
+            : base(options, loggerFactory, queryService)
         {
         }
 
diff --git a/src/JsonApiDotNetCore/Controllers/ModelStateViolation.cs b/src/JsonApiDotNetCore/Controllers/ModelStateViolation.cs
index 2a4c8cfb84..49a935a7ef 100644
--- a/src/JsonApiDotNetCore/Controllers/ModelStateViolation.cs
+++ b/src/JsonApiDotNetCore/Controllers/ModelStateViolation.cs
@@ -12,19 +12,19 @@ public sealed class ModelStateViolation
     {
         public string Prefix { get; }
         public string PropertyName { get; }
-        public Type ResourceType { get; set; }
+        public Type ResourceClrType { get; set; }
         public ModelError Error { get; }
 
-        public ModelStateViolation(string prefix, string propertyName, Type resourceType, ModelError error)
+        public ModelStateViolation(string prefix, string propertyName, Type resourceClrType, ModelError error)
         {
             ArgumentGuard.NotNullNorEmpty(prefix, nameof(prefix));
             ArgumentGuard.NotNullNorEmpty(propertyName, nameof(propertyName));
-            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
+            ArgumentGuard.NotNull(resourceClrType, nameof(resourceClrType));
             ArgumentGuard.NotNull(error, nameof(error));
 
             Prefix = prefix;
             PropertyName = propertyName;
-            ResourceType = resourceType;
+            ResourceClrType = resourceClrType;
             Error = error;
         }
     }
diff --git a/src/JsonApiDotNetCore/Diagnostics/CodeTimingSessionManager.cs b/src/JsonApiDotNetCore/Diagnostics/CodeTimingSessionManager.cs
index 9160791f87..47e64d8338 100644
--- a/src/JsonApiDotNetCore/Diagnostics/CodeTimingSessionManager.cs
+++ b/src/JsonApiDotNetCore/Diagnostics/CodeTimingSessionManager.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using System.Reflection;
 
 #pragma warning disable AV1008 // Class should not be static
 
@@ -32,7 +33,7 @@ public static ICodeTimer Current
         static CodeTimingSessionManager()
         {
 #if DEBUG
-            IsEnabled = !IsRunningInTest();
+            IsEnabled = !IsRunningInTest() && !IsRunningInBenchmark();
 #else
             IsEnabled = false;
 #endif
@@ -47,6 +48,12 @@ private static bool IsRunningInTest()
                 assembly.FullName != null && assembly.FullName.StartsWith(testAssemblyName, StringComparison.Ordinal));
         }
 
+        // ReSharper disable once UnusedMember.Local
+        private static bool IsRunningInBenchmark()
+        {
+            return Assembly.GetEntryAssembly()?.GetName().Name == "Benchmarks";
+        }
+
         private static void AssertHasActiveSession()
         {
             if (_session == null)
diff --git a/src/JsonApiDotNetCore/Errors/CannotClearRequiredRelationshipException.cs b/src/JsonApiDotNetCore/Errors/CannotClearRequiredRelationshipException.cs
index 782cf1f2ea..4a7c6b5e66 100644
--- a/src/JsonApiDotNetCore/Errors/CannotClearRequiredRelationshipException.cs
+++ b/src/JsonApiDotNetCore/Errors/CannotClearRequiredRelationshipException.cs
@@ -14,7 +14,7 @@ public CannotClearRequiredRelationshipException(string relationshipName, string
             : base(new ErrorObject(HttpStatusCode.BadRequest)
             {
                 Title = "Failed to clear a required relationship.",
-                Detail = $"The relationship '{relationshipName}' of resource type '{resourceType}' " +
+                Detail = $"The relationship '{relationshipName}' on resource type '{resourceType}' " +
                     $"with ID '{resourceId}' cannot be cleared because it is a required relationship."
             })
         {
diff --git a/src/JsonApiDotNetCore/Errors/DuplicateLocalIdValueException.cs b/src/JsonApiDotNetCore/Errors/DuplicateLocalIdValueException.cs
new file mode 100644
index 0000000000..ebf9a2fadd
--- /dev/null
+++ b/src/JsonApiDotNetCore/Errors/DuplicateLocalIdValueException.cs
@@ -0,0 +1,22 @@
+using System.Net;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Errors
+{
+    /// <summary>
+    /// The error that is thrown when assigning a local ID that was already assigned in an earlier operation.
+    /// </summary>
+    [PublicAPI]
+    public sealed class DuplicateLocalIdValueException : JsonApiException
+    {
+        public DuplicateLocalIdValueException(string localId)
+            : base(new ErrorObject(HttpStatusCode.BadRequest)
+            {
+                Title = "Another local ID with the same name is already defined at this point.",
+                Detail = $"Another local ID with name '{localId}' is already defined at this point."
+            })
+        {
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Errors/FailedOperationException.cs b/src/JsonApiDotNetCore/Errors/FailedOperationException.cs
new file mode 100644
index 0000000000..4ae21ef469
--- /dev/null
+++ b/src/JsonApiDotNetCore/Errors/FailedOperationException.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Net;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Errors
+{
+    /// <summary>
+    /// The error that is thrown when an operation in an atomic:operations request failed to be processed for unknown reasons.
+    /// </summary>
+    [PublicAPI]
+    public sealed class FailedOperationException : JsonApiException
+    {
+        public FailedOperationException(int operationIndex, Exception innerException)
+            : base(new ErrorObject(HttpStatusCode.InternalServerError)
+            {
+                Title = "An unhandled error occurred while processing an operation in this request.",
+                Detail = innerException.Message,
+                Source = new ErrorSource
+                {
+                    Pointer = $"/atomic:operations[{operationIndex}]"
+                }
+            }, innerException)
+        {
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Errors/IncompatibleLocalIdTypeException.cs b/src/JsonApiDotNetCore/Errors/IncompatibleLocalIdTypeException.cs
new file mode 100644
index 0000000000..9b2e46357c
--- /dev/null
+++ b/src/JsonApiDotNetCore/Errors/IncompatibleLocalIdTypeException.cs
@@ -0,0 +1,22 @@
+using System.Net;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Errors
+{
+    /// <summary>
+    /// The error that is thrown when referencing a local ID that was assigned to a different resource type.
+    /// </summary>
+    [PublicAPI]
+    public sealed class IncompatibleLocalIdTypeException : JsonApiException
+    {
+        public IncompatibleLocalIdTypeException(string localId, string declaredType, string currentType)
+            : base(new ErrorObject(HttpStatusCode.BadRequest)
+            {
+                Title = "Incompatible type in Local ID usage.",
+                Detail = $"Local ID '{localId}' belongs to resource type '{declaredType}' instead of '{currentType}'."
+            })
+        {
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Errors/InvalidModelStateException.cs b/src/JsonApiDotNetCore/Errors/InvalidModelStateException.cs
index 4ca8586b17..44066d430e 100644
--- a/src/JsonApiDotNetCore/Errors/InvalidModelStateException.cs
+++ b/src/JsonApiDotNetCore/Errors/InvalidModelStateException.cs
@@ -19,9 +19,9 @@ namespace JsonApiDotNetCore.Errors
     [PublicAPI]
     public sealed class InvalidModelStateException : JsonApiException
     {
-        public InvalidModelStateException(ModelStateDictionary modelState, Type resourceType, bool includeExceptionStackTraceInErrors,
+        public InvalidModelStateException(ModelStateDictionary modelState, Type resourceClrType, bool includeExceptionStackTraceInErrors,
             JsonNamingPolicy namingPolicy)
-            : this(FromModelStateDictionary(modelState, resourceType), includeExceptionStackTraceInErrors, namingPolicy)
+            : this(FromModelStateDictionary(modelState, resourceClrType), includeExceptionStackTraceInErrors, namingPolicy)
         {
         }
 
@@ -30,26 +30,26 @@ public InvalidModelStateException(IEnumerable<ModelStateViolation> violations, b
         {
         }
 
-        private static IEnumerable<ModelStateViolation> FromModelStateDictionary(ModelStateDictionary modelState, Type resourceType)
+        private static IEnumerable<ModelStateViolation> FromModelStateDictionary(ModelStateDictionary modelState, Type resourceClrType)
         {
             ArgumentGuard.NotNull(modelState, nameof(modelState));
-            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
+            ArgumentGuard.NotNull(resourceClrType, nameof(resourceClrType));
 
             var violations = new List<ModelStateViolation>();
 
             foreach ((string propertyName, ModelStateEntry entry) in modelState)
             {
-                AddValidationErrors(entry, propertyName, resourceType, violations);
+                AddValidationErrors(entry, propertyName, resourceClrType, violations);
             }
 
             return violations;
         }
 
-        private static void AddValidationErrors(ModelStateEntry entry, string propertyName, Type resourceType, List<ModelStateViolation> violations)
+        private static void AddValidationErrors(ModelStateEntry entry, string propertyName, Type resourceClrType, List<ModelStateViolation> violations)
         {
             foreach (ModelError error in entry.Errors)
             {
-                var violation = new ModelStateViolation("/data/attributes/", propertyName, resourceType, error);
+                var violation = new ModelStateViolation("/data/attributes/", propertyName, resourceClrType, error);
                 violations.Add(violation);
             }
         }
@@ -74,16 +74,16 @@ private static IEnumerable<ErrorObject> FromModelStateViolation(ModelStateViolat
             }
             else
             {
-                string attributeName = GetDisplayNameForProperty(violation.PropertyName, violation.ResourceType, namingPolicy);
+                string attributeName = GetDisplayNameForProperty(violation.PropertyName, violation.ResourceClrType, namingPolicy);
                 string attributePath = $"{violation.Prefix}{attributeName}";
 
                 yield return FromModelError(violation.Error, attributePath, includeExceptionStackTraceInErrors);
             }
         }
 
-        private static string GetDisplayNameForProperty(string propertyName, Type resourceType, JsonNamingPolicy namingPolicy)
+        private static string GetDisplayNameForProperty(string propertyName, Type resourceClrType, JsonNamingPolicy namingPolicy)
         {
-            PropertyInfo property = resourceType.GetProperty(propertyName);
+            PropertyInfo property = resourceClrType.GetProperty(propertyName);
 
             if (property != null)
             {
@@ -116,10 +116,14 @@ private static ErrorObject FromModelError(ModelError modelError, string attribut
 
             if (includeExceptionStackTraceInErrors && modelError.Exception != null)
             {
-                string[] stackTraceLines = modelError.Exception.Demystify().ToString().Split(Environment.NewLine);
+                Exception exception = modelError.Exception.Demystify();
+                string[] stackTraceLines = exception.ToString().Split(Environment.NewLine);
 
-                error.Meta ??= new Dictionary<string, object>();
-                error.Meta["StackTrace"] = stackTraceLines;
+                if (stackTraceLines.Any())
+                {
+                    error.Meta ??= new Dictionary<string, object>();
+                    error.Meta["StackTrace"] = stackTraceLines;
+                }
             }
 
             return error;
diff --git a/src/JsonApiDotNetCore/Errors/InvalidRequestBodyException.cs b/src/JsonApiDotNetCore/Errors/InvalidRequestBodyException.cs
index c435c66b2d..a508a82ad2 100644
--- a/src/JsonApiDotNetCore/Errors/InvalidRequestBodyException.cs
+++ b/src/JsonApiDotNetCore/Errors/InvalidRequestBodyException.cs
@@ -1,6 +1,6 @@
 using System;
+using System.Collections.Generic;
 using System.Net;
-using System.Text;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Serialization.Objects;
 
@@ -12,33 +12,26 @@ namespace JsonApiDotNetCore.Errors
     [PublicAPI]
     public sealed class InvalidRequestBodyException : JsonApiException
     {
-        public InvalidRequestBodyException(string reason, string details, string requestBody, Exception innerException = null)
-            : base(new ErrorObject(HttpStatusCode.UnprocessableEntity)
+        public InvalidRequestBodyException(string requestBody, string genericMessage, string specificMessage, string sourcePointer,
+            HttpStatusCode? alternativeStatusCode = null, Exception innerException = null)
+            : base(new ErrorObject(alternativeStatusCode ?? HttpStatusCode.UnprocessableEntity)
             {
-                Title = reason != null ? $"Failed to deserialize request body: {reason}" : "Failed to deserialize request body.",
-                Detail = FormatErrorDetail(details, requestBody, innerException)
+                Title = genericMessage != null ? $"Failed to deserialize request body: {genericMessage}" : "Failed to deserialize request body.",
+                Detail = specificMessage,
+                Source = sourcePointer == null
+                    ? null
+                    : new ErrorSource
+                    {
+                        Pointer = sourcePointer
+                    },
+                Meta = string.IsNullOrEmpty(requestBody)
+                    ? null
+                    : new Dictionary<string, object>
+                    {
+                        ["RequestBody"] = requestBody
+                    }
             }, innerException)
         {
         }
-
-        private static string FormatErrorDetail(string details, string requestBody, Exception innerException)
-        {
-            var builder = new StringBuilder();
-            builder.Append(details ?? innerException?.Message);
-
-            if (requestBody != null)
-            {
-                if (builder.Length > 0)
-                {
-                    builder.Append(" - ");
-                }
-
-                builder.Append("Request body: <<");
-                builder.Append(requestBody);
-                builder.Append(">>");
-            }
-
-            return builder.Length > 0 ? builder.ToString() : null;
-        }
     }
 }
diff --git a/src/JsonApiDotNetCore/Errors/JsonApiException.cs b/src/JsonApiDotNetCore/Errors/JsonApiException.cs
index 13d3b6a745..ae2cbcdca0 100644
--- a/src/JsonApiDotNetCore/Errors/JsonApiException.cs
+++ b/src/JsonApiDotNetCore/Errors/JsonApiException.cs
@@ -24,8 +24,6 @@ public class JsonApiException : Exception
 
         public IReadOnlyList<ErrorObject> Errors { get; }
 
-        public override string Message => $"Errors = {JsonSerializer.Serialize(Errors, SerializerOptions)}";
-
         public JsonApiException(ErrorObject error, Exception innerException = null)
             : base(null, innerException)
         {
@@ -42,5 +40,10 @@ public JsonApiException(IEnumerable<ErrorObject> errors, Exception innerExceptio
 
             Errors = errorList;
         }
+
+        public string GetSummary()
+        {
+            return $"{nameof(JsonApiException)}: Errors = {JsonSerializer.Serialize(Errors, SerializerOptions)}";
+        }
     }
 }
diff --git a/src/JsonApiDotNetCore/Errors/LocalIdSingleOperationException.cs b/src/JsonApiDotNetCore/Errors/LocalIdSingleOperationException.cs
new file mode 100644
index 0000000000..8dfa1bd842
--- /dev/null
+++ b/src/JsonApiDotNetCore/Errors/LocalIdSingleOperationException.cs
@@ -0,0 +1,22 @@
+using System.Net;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Errors
+{
+    /// <summary>
+    /// The error that is thrown when assigning and referencing a local ID within the same operation.
+    /// </summary>
+    [PublicAPI]
+    public sealed class LocalIdSingleOperationException : JsonApiException
+    {
+        public LocalIdSingleOperationException(string localId)
+            : base(new ErrorObject(HttpStatusCode.BadRequest)
+            {
+                Title = "Local ID cannot be both defined and used within the same operation.",
+                Detail = $"Local ID '{localId}' cannot be both defined and used within the same operation."
+            })
+        {
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Errors/ResourceIdInCreateResourceNotAllowedException.cs b/src/JsonApiDotNetCore/Errors/ResourceIdInCreateResourceNotAllowedException.cs
deleted file mode 100644
index 11a96cc436..0000000000
--- a/src/JsonApiDotNetCore/Errors/ResourceIdInCreateResourceNotAllowedException.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-using System.Net;
-using JetBrains.Annotations;
-using JsonApiDotNetCore.Serialization.Objects;
-
-namespace JsonApiDotNetCore.Errors
-{
-    /// <summary>
-    /// The error that is thrown when a resource creation request or operation is received that contains a client-generated ID.
-    /// </summary>
-    [PublicAPI]
-    public sealed class ResourceIdInCreateResourceNotAllowedException : JsonApiException
-    {
-        public ResourceIdInCreateResourceNotAllowedException(int? atomicOperationIndex = null)
-            : base(new ErrorObject(HttpStatusCode.Forbidden)
-            {
-                Title = atomicOperationIndex == null
-                    ? "Specifying the resource ID in POST requests is not allowed."
-                    : "Specifying the resource ID in operations that create a resource is not allowed.",
-                Source = new ErrorSource
-                {
-                    Pointer = atomicOperationIndex != null ? $"/atomic:operations[{atomicOperationIndex}]/data/id" : "/data/id"
-                }
-            })
-        {
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Errors/ResourceIdMismatchException.cs b/src/JsonApiDotNetCore/Errors/ResourceIdMismatchException.cs
deleted file mode 100644
index fdfd6b6fe9..0000000000
--- a/src/JsonApiDotNetCore/Errors/ResourceIdMismatchException.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-using System.Net;
-using JetBrains.Annotations;
-using JsonApiDotNetCore.Serialization.Objects;
-
-namespace JsonApiDotNetCore.Errors
-{
-    /// <summary>
-    /// The error that is thrown when the resource ID in the request body does not match the ID in the current endpoint URL.
-    /// </summary>
-    [PublicAPI]
-    public sealed class ResourceIdMismatchException : JsonApiException
-    {
-        public ResourceIdMismatchException(string bodyId, string endpointId, string requestPath)
-            : base(new ErrorObject(HttpStatusCode.Conflict)
-            {
-                Title = "Resource ID mismatch between request body and endpoint URL.",
-                Detail = $"Expected resource ID '{endpointId}' in PATCH request body at endpoint '{requestPath}', instead of '{bodyId}'."
-            })
-        {
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Errors/ResourceTypeMismatchException.cs b/src/JsonApiDotNetCore/Errors/ResourceTypeMismatchException.cs
deleted file mode 100644
index 9957694d0d..0000000000
--- a/src/JsonApiDotNetCore/Errors/ResourceTypeMismatchException.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-using System.Net;
-using System.Net.Http;
-using JetBrains.Annotations;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Serialization.Objects;
-
-namespace JsonApiDotNetCore.Errors
-{
-    /// <summary>
-    /// The error that is thrown when the resource type in the request body does not match the type expected at the current endpoint URL.
-    /// </summary>
-    [PublicAPI]
-    public sealed class ResourceTypeMismatchException : JsonApiException
-    {
-        public ResourceTypeMismatchException(HttpMethod method, string requestPath, ResourceContext expected, ResourceContext actual)
-            : base(new ErrorObject(HttpStatusCode.Conflict)
-            {
-                Title = "Resource type mismatch between request body and endpoint URL.",
-                Detail = $"Expected resource of type '{expected.PublicName}' in {method} request body at endpoint " +
-                    $"'{requestPath}', instead of '{actual.PublicName}'."
-            })
-        {
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Errors/ToManyRelationshipRequiredException.cs b/src/JsonApiDotNetCore/Errors/ToManyRelationshipRequiredException.cs
deleted file mode 100644
index c5b100904f..0000000000
--- a/src/JsonApiDotNetCore/Errors/ToManyRelationshipRequiredException.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-using System.Net;
-using JetBrains.Annotations;
-using JsonApiDotNetCore.Serialization.Objects;
-
-namespace JsonApiDotNetCore.Errors
-{
-    /// <summary>
-    /// The error that is thrown when an attempt is made to update a to-one relationship from a to-many relationship endpoint.
-    /// </summary>
-    [PublicAPI]
-    public sealed class ToManyRelationshipRequiredException : JsonApiException
-    {
-        public ToManyRelationshipRequiredException(string relationshipName)
-            : base(new ErrorObject(HttpStatusCode.Forbidden)
-            {
-                Title = "Only to-many relationships can be updated through this endpoint.",
-                Detail = $"Relationship '{relationshipName}' must be a to-many relationship."
-            })
-        {
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Errors/UnknownLocalIdValueException.cs b/src/JsonApiDotNetCore/Errors/UnknownLocalIdValueException.cs
new file mode 100644
index 0000000000..418acac662
--- /dev/null
+++ b/src/JsonApiDotNetCore/Errors/UnknownLocalIdValueException.cs
@@ -0,0 +1,22 @@
+using System.Net;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Errors
+{
+    /// <summary>
+    /// The error that is thrown when referencing a local ID that hasn't been assigned.
+    /// </summary>
+    [PublicAPI]
+    public sealed class UnknownLocalIdValueException : JsonApiException
+    {
+        public UnknownLocalIdValueException(string localId)
+            : base(new ErrorObject(HttpStatusCode.BadRequest)
+            {
+                Title = "Server-generated value for local ID is not available at this point.",
+                Detail = $"Server-generated value for local ID '{localId}' is not available at this point."
+            })
+        {
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Middleware/AsyncJsonApiExceptionFilter.cs b/src/JsonApiDotNetCore/Middleware/AsyncJsonApiExceptionFilter.cs
index d7d6349b68..d82cbddeed 100644
--- a/src/JsonApiDotNetCore/Middleware/AsyncJsonApiExceptionFilter.cs
+++ b/src/JsonApiDotNetCore/Middleware/AsyncJsonApiExceptionFilter.cs
@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Serialization.Objects;
@@ -26,11 +27,11 @@ public Task OnExceptionAsync(ExceptionContext context)
 
             if (context.HttpContext.IsJsonApiRequest())
             {
-                Document document = _exceptionHandler.HandleException(context.Exception);
+                IReadOnlyList<ErrorObject> errors = _exceptionHandler.HandleException(context.Exception);
 
-                context.Result = new ObjectResult(document)
+                context.Result = new ObjectResult(errors)
                 {
-                    StatusCode = (int)document.GetErrorStatusCode()
+                    StatusCode = (int)ErrorObject.GetResponseStatusCode(errors)
                 };
             }
 
diff --git a/src/JsonApiDotNetCore/Middleware/ExceptionHandler.cs b/src/JsonApiDotNetCore/Middleware/ExceptionHandler.cs
index 5dc6bf6e5d..3d7630b9bf 100644
--- a/src/JsonApiDotNetCore/Middleware/ExceptionHandler.cs
+++ b/src/JsonApiDotNetCore/Middleware/ExceptionHandler.cs
@@ -27,7 +27,7 @@ public ExceptionHandler(ILoggerFactory loggerFactory, IJsonApiOptions options)
             _logger = loggerFactory.CreateLogger<ExceptionHandler>();
         }
 
-        public Document HandleException(Exception exception)
+        public IReadOnlyList<ErrorObject> HandleException(Exception exception)
         {
             ArgumentGuard.NotNull(exception, nameof(exception));
 
@@ -35,7 +35,7 @@ public Document HandleException(Exception exception)
 
             LogException(demystified);
 
-            return CreateErrorDocument(demystified);
+            return CreateErrorResponse(demystified);
         }
 
         private void LogException(Exception exception)
@@ -55,7 +55,7 @@ protected virtual LogLevel GetLogLevel(Exception exception)
                 return LogLevel.None;
             }
 
-            if (exception is JsonApiException)
+            if (exception is JsonApiException and not FailedOperationException)
             {
                 return LogLevel.Information;
             }
@@ -67,10 +67,10 @@ protected virtual string GetLogMessage(Exception exception)
         {
             ArgumentGuard.NotNull(exception, nameof(exception));
 
-            return exception.Message;
+            return exception is JsonApiException jsonApiException ? jsonApiException.GetSummary() : exception.Message;
         }
 
-        protected virtual Document CreateErrorDocument(Exception exception)
+        protected virtual IReadOnlyList<ErrorObject> CreateErrorResponse(Exception exception)
         {
             ArgumentGuard.NotNull(exception, nameof(exception));
 
@@ -84,27 +84,25 @@ protected virtual Document CreateErrorDocument(Exception exception)
                     Detail = exception.Message
                 }.AsArray();
 
-            foreach (ErrorObject error in errors)
+            if (_options.IncludeExceptionStackTraceInErrors && exception is not InvalidModelStateException)
             {
-                ApplyOptions(error, exception);
+                IncludeStackTraces(exception, errors);
             }
 
-            return new Document
-            {
-                Errors = errors.ToList()
-            };
+            return errors;
         }
 
-        private void ApplyOptions(ErrorObject error, Exception exception)
+        private void IncludeStackTraces(Exception exception, IReadOnlyList<ErrorObject> errors)
         {
-            Exception resultException = exception is InvalidModelStateException ? null : exception;
+            string[] stackTraceLines = exception.ToString().Split(Environment.NewLine);
 
-            if (resultException != null && _options.IncludeExceptionStackTraceInErrors)
+            if (stackTraceLines.Any())
             {
-                string[] stackTraceLines = resultException.ToString().Split(Environment.NewLine);
-
-                error.Meta ??= new Dictionary<string, object>();
-                error.Meta["StackTrace"] = stackTraceLines;
+                foreach (ErrorObject error in errors)
+                {
+                    error.Meta ??= new Dictionary<string, object>();
+                    error.Meta["StackTrace"] = stackTraceLines;
+                }
             }
         }
     }
diff --git a/src/JsonApiDotNetCore/Middleware/IControllerResourceMapping.cs b/src/JsonApiDotNetCore/Middleware/IControllerResourceMapping.cs
index 4290b3b771..2ff155d324 100644
--- a/src/JsonApiDotNetCore/Middleware/IControllerResourceMapping.cs
+++ b/src/JsonApiDotNetCore/Middleware/IControllerResourceMapping.cs
@@ -1,4 +1,5 @@
 using System;
+using JsonApiDotNetCore.Configuration;
 
 namespace JsonApiDotNetCore.Middleware
 {
@@ -10,11 +11,11 @@ public interface IControllerResourceMapping
         /// <summary>
         /// Gets the associated resource type for the provided controller type.
         /// </summary>
-        Type GetResourceTypeForController(Type controllerType);
+        ResourceType TryGetResourceTypeForController(Type controllerType);
 
         /// <summary>
         /// Gets the associated controller name for the provided resource type.
         /// </summary>
-        string GetControllerNameForResourceType(Type resourceType);
+        string TryGetControllerNameForResourceType(ResourceType resourceType);
     }
 }
diff --git a/src/JsonApiDotNetCore/Middleware/IExceptionHandler.cs b/src/JsonApiDotNetCore/Middleware/IExceptionHandler.cs
index 9f44e33a96..a962d8cfdd 100644
--- a/src/JsonApiDotNetCore/Middleware/IExceptionHandler.cs
+++ b/src/JsonApiDotNetCore/Middleware/IExceptionHandler.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using JsonApiDotNetCore.Serialization.Objects;
 
 namespace JsonApiDotNetCore.Middleware
@@ -8,6 +9,6 @@ namespace JsonApiDotNetCore.Middleware
     /// </summary>
     public interface IExceptionHandler
     {
-        Document HandleException(Exception exception);
+        IReadOnlyList<ErrorObject> HandleException(Exception exception);
     }
 }
diff --git a/src/JsonApiDotNetCore/Middleware/IJsonApiRequest.cs b/src/JsonApiDotNetCore/Middleware/IJsonApiRequest.cs
index 888c01544a..f3f7dfcf81 100644
--- a/src/JsonApiDotNetCore/Middleware/IJsonApiRequest.cs
+++ b/src/JsonApiDotNetCore/Middleware/IJsonApiRequest.cs
@@ -19,15 +19,15 @@ public interface IJsonApiRequest
         string PrimaryId { get; }
 
         /// <summary>
-        /// The primary (top-level) resource for this request. This would be "blogs" in "/blogs", "/blogs/123" or "/blogs/123/author".
+        /// The primary (top-level) resource type for this request. This would be "blogs" in "/blogs", "/blogs/123" or "/blogs/123/author".
         /// </summary>
-        ResourceContext PrimaryResource { get; }
+        ResourceType PrimaryResourceType { get; }
 
         /// <summary>
-        /// The secondary (nested) resource for this request. This would be null in "/blogs", "/blogs/123" and "/blogs/123/unknownResource" or "people" in
+        /// The secondary (nested) resource type for this request. This would be null in "/blogs", "/blogs/123" and "/blogs/123/unknownResource" or "people" in
         /// "/blogs/123/author" and "/blogs/123/relationships/author".
         /// </summary>
-        ResourceContext SecondaryResource { get; }
+        ResourceType SecondaryResourceType { get; }
 
         /// <summary>
         /// The relationship for this nested request. This would be null in "/blogs", "/blogs/123" and "/blogs/123/unknownResource" or "author" in
diff --git a/src/JsonApiDotNetCore/Middleware/JsonApiInputFormatter.cs b/src/JsonApiDotNetCore/Middleware/JsonApiInputFormatter.cs
index fc5a1e2230..d22904bebc 100644
--- a/src/JsonApiDotNetCore/Middleware/JsonApiInputFormatter.cs
+++ b/src/JsonApiDotNetCore/Middleware/JsonApiInputFormatter.cs
@@ -1,5 +1,5 @@
 using System.Threading.Tasks;
-using JsonApiDotNetCore.Serialization;
+using JsonApiDotNetCore.Serialization.Request;
 using Microsoft.AspNetCore.Mvc.Formatters;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -22,7 +22,10 @@ public async Task<InputFormatterResult> ReadAsync(InputFormatterContext context)
             ArgumentGuard.NotNull(context, nameof(context));
 
             var reader = context.HttpContext.RequestServices.GetRequiredService<IJsonApiReader>();
-            return await reader.ReadAsync(context);
+
+            object model = await reader.ReadAsync(context.HttpContext.Request);
+
+            return model == null ? await InputFormatterResult.NoValueAsync() : await InputFormatterResult.SuccessAsync(model);
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Middleware/JsonApiMiddleware.cs b/src/JsonApiDotNetCore/Middleware/JsonApiMiddleware.cs
index 30ea5d9108..a41e172d18 100644
--- a/src/JsonApiDotNetCore/Middleware/JsonApiMiddleware.cs
+++ b/src/JsonApiDotNetCore/Middleware/JsonApiMiddleware.cs
@@ -39,13 +39,12 @@ public JsonApiMiddleware(RequestDelegate next, IHttpContextAccessor httpContextA
         }
 
         public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMapping controllerResourceMapping, IJsonApiOptions options,
-            IJsonApiRequest request, IResourceGraph resourceGraph, ILogger<JsonApiMiddleware> logger)
+            IJsonApiRequest request, ILogger<JsonApiMiddleware> logger)
         {
             ArgumentGuard.NotNull(httpContext, nameof(httpContext));
             ArgumentGuard.NotNull(controllerResourceMapping, nameof(controllerResourceMapping));
             ArgumentGuard.NotNull(options, nameof(options));
             ArgumentGuard.NotNull(request, nameof(request));
-            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
             ArgumentGuard.NotNull(logger, nameof(logger));
 
             using (CodeTimingSessionManager.Current.Measure("JSON:API middleware"))
@@ -56,9 +55,9 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin
                 }
 
                 RouteValueDictionary routeValues = httpContext.GetRouteData().Values;
-                ResourceContext primaryResourceContext = TryCreatePrimaryResourceContext(httpContext, controllerResourceMapping, resourceGraph);
+                ResourceType primaryResourceType = TryCreatePrimaryResourceType(httpContext, controllerResourceMapping);
 
-                if (primaryResourceContext != null)
+                if (primaryResourceType != null)
                 {
                     if (!await ValidateContentTypeHeaderAsync(HeaderConstants.MediaType, httpContext, options.SerializerWriteOptions) ||
                         !await ValidateAcceptHeaderAsync(MediaType, httpContext, options.SerializerWriteOptions))
@@ -66,7 +65,7 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin
                         return;
                     }
 
-                    SetupResourceRequest((JsonApiRequest)request, primaryResourceContext, routeValues, resourceGraph, httpContext.Request);
+                    SetupResourceRequest((JsonApiRequest)request, primaryResourceType, routeValues, httpContext.Request);
 
                     httpContext.RegisterJsonApiRequest();
                 }
@@ -119,24 +118,14 @@ private async Task<bool> ValidateIfMatchHeaderAsync(HttpContext httpContext, Jso
             return true;
         }
 
-        private static ResourceContext TryCreatePrimaryResourceContext(HttpContext httpContext, IControllerResourceMapping controllerResourceMapping,
-            IResourceGraph resourceGraph)
+        private static ResourceType TryCreatePrimaryResourceType(HttpContext httpContext, IControllerResourceMapping controllerResourceMapping)
         {
             Endpoint endpoint = httpContext.GetEndpoint();
             var controllerActionDescriptor = endpoint?.Metadata.GetMetadata<ControllerActionDescriptor>();
 
-            if (controllerActionDescriptor != null)
-            {
-                Type controllerType = controllerActionDescriptor.ControllerTypeInfo;
-                Type resourceType = controllerResourceMapping.GetResourceTypeForController(controllerType);
-
-                if (resourceType != null)
-                {
-                    return resourceGraph.GetResourceContext(resourceType);
-                }
-            }
-
-            return null;
+            return controllerActionDescriptor != null
+                ? controllerResourceMapping.TryGetResourceTypeForController(controllerActionDescriptor.ControllerTypeInfo)
+                : null;
         }
 
         private static async Task<bool> ValidateContentTypeHeaderAsync(string allowedContentType, HttpContext httpContext,
@@ -228,11 +217,11 @@ private static async Task FlushResponseAsync(HttpResponse httpResponse, JsonSeri
             await httpResponse.Body.FlushAsync();
         }
 
-        private static void SetupResourceRequest(JsonApiRequest request, ResourceContext primaryResourceContext, RouteValueDictionary routeValues,
-            IResourceGraph resourceGraph, HttpRequest httpRequest)
+        private static void SetupResourceRequest(JsonApiRequest request, ResourceType primaryResourceType, RouteValueDictionary routeValues,
+            HttpRequest httpRequest)
         {
             request.IsReadOnly = httpRequest.Method == HttpMethod.Get.Method || httpRequest.Method == HttpMethod.Head.Method;
-            request.PrimaryResource = primaryResourceContext;
+            request.PrimaryResourceType = primaryResourceType;
             request.PrimaryId = GetPrimaryRequestId(routeValues);
 
             string relationshipName = GetRelationshipNameForSecondaryRequest(routeValues);
@@ -252,12 +241,12 @@ private static void SetupResourceRequest(JsonApiRequest request, ResourceContext
                 // @formatter:keep_existing_linebreaks restore
                 // @formatter:wrap_chained_method_calls restore
 
-                RelationshipAttribute requestRelationship = primaryResourceContext.TryGetRelationshipByPublicName(relationshipName);
+                RelationshipAttribute requestRelationship = primaryResourceType.TryGetRelationshipByPublicName(relationshipName);
 
                 if (requestRelationship != null)
                 {
                     request.Relationship = requestRelationship;
-                    request.SecondaryResource = resourceGraph.GetResourceContext(requestRelationship.RightType);
+                    request.SecondaryResourceType = requestRelationship.RightType;
                 }
             }
             else
diff --git a/src/JsonApiDotNetCore/Middleware/JsonApiOutputFormatter.cs b/src/JsonApiDotNetCore/Middleware/JsonApiOutputFormatter.cs
index bd66f66067..93d531dc58 100644
--- a/src/JsonApiDotNetCore/Middleware/JsonApiOutputFormatter.cs
+++ b/src/JsonApiDotNetCore/Middleware/JsonApiOutputFormatter.cs
@@ -1,5 +1,5 @@
 using System.Threading.Tasks;
-using JsonApiDotNetCore.Serialization;
+using JsonApiDotNetCore.Serialization.Response;
 using Microsoft.AspNetCore.Mvc.Formatters;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -22,7 +22,7 @@ public async Task WriteAsync(OutputFormatterWriteContext context)
             ArgumentGuard.NotNull(context, nameof(context));
 
             var writer = context.HttpContext.RequestServices.GetRequiredService<IJsonApiWriter>();
-            await writer.WriteAsync(context);
+            await writer.WriteAsync(context.Object, context.HttpContext);
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Middleware/JsonApiRequest.cs b/src/JsonApiDotNetCore/Middleware/JsonApiRequest.cs
index 89bd6fa722..0c61b7ff38 100644
--- a/src/JsonApiDotNetCore/Middleware/JsonApiRequest.cs
+++ b/src/JsonApiDotNetCore/Middleware/JsonApiRequest.cs
@@ -15,10 +15,10 @@ public sealed class JsonApiRequest : IJsonApiRequest
         public string PrimaryId { get; set; }
 
         /// <inheritdoc />
-        public ResourceContext PrimaryResource { get; set; }
+        public ResourceType PrimaryResourceType { get; set; }
 
         /// <inheritdoc />
-        public ResourceContext SecondaryResource { get; set; }
+        public ResourceType SecondaryResourceType { get; set; }
 
         /// <inheritdoc />
         public RelationshipAttribute Relationship { get; set; }
@@ -42,8 +42,8 @@ public void CopyFrom(IJsonApiRequest other)
 
             Kind = other.Kind;
             PrimaryId = other.PrimaryId;
-            PrimaryResource = other.PrimaryResource;
-            SecondaryResource = other.SecondaryResource;
+            PrimaryResourceType = other.PrimaryResourceType;
+            SecondaryResourceType = other.SecondaryResourceType;
             Relationship = other.Relationship;
             IsCollection = other.IsCollection;
             IsReadOnly = other.IsReadOnly;
diff --git a/src/JsonApiDotNetCore/Middleware/JsonApiRoutingConvention.cs b/src/JsonApiDotNetCore/Middleware/JsonApiRoutingConvention.cs
index af38f89dad..fee1edad0f 100644
--- a/src/JsonApiDotNetCore/Middleware/JsonApiRoutingConvention.cs
+++ b/src/JsonApiDotNetCore/Middleware/JsonApiRoutingConvention.cs
@@ -34,8 +34,8 @@ public sealed class JsonApiRoutingConvention : IJsonApiRoutingConvention
         private readonly IJsonApiOptions _options;
         private readonly IResourceGraph _resourceGraph;
         private readonly Dictionary<string, string> _registeredControllerNameByTemplate = new();
-        private readonly Dictionary<Type, ResourceContext> _resourceContextPerControllerTypeMap = new();
-        private readonly Dictionary<ResourceContext, ControllerModel> _controllerPerResourceContextMap = new();
+        private readonly Dictionary<Type, ResourceType> _resourceTypePerControllerTypeMap = new();
+        private readonly Dictionary<ResourceType, ControllerModel> _controllerPerResourceTypeMap = new();
 
         public JsonApiRoutingConvention(IJsonApiOptions options, IResourceGraph resourceGraph)
         {
@@ -47,32 +47,19 @@ public JsonApiRoutingConvention(IJsonApiOptions options, IResourceGraph resource
         }
 
         /// <inheritdoc />
-        public Type GetResourceTypeForController(Type controllerType)
+        public ResourceType TryGetResourceTypeForController(Type controllerType)
         {
             ArgumentGuard.NotNull(controllerType, nameof(controllerType));
 
-            if (_resourceContextPerControllerTypeMap.TryGetValue(controllerType, out ResourceContext resourceContext))
-            {
-                return resourceContext.ResourceType;
-            }
-
-            return null;
+            return _resourceTypePerControllerTypeMap.TryGetValue(controllerType, out ResourceType resourceType) ? resourceType : null;
         }
 
         /// <inheritdoc />
-        public string GetControllerNameForResourceType(Type resourceType)
+        public string TryGetControllerNameForResourceType(ResourceType resourceType)
         {
             ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
-            ResourceContext resourceContext = _resourceGraph.GetResourceContext(resourceType);
-
-            if (_controllerPerResourceContextMap.TryGetValue(resourceContext, out ControllerModel controllerModel))
-
-            {
-                return controllerModel.ControllerName;
-            }
-
-            return null;
+            return _controllerPerResourceTypeMap.TryGetValue(resourceType, out ControllerModel controllerModel) ? controllerModel.ControllerName : null;
         }
 
         /// <inheritdoc />
@@ -86,16 +73,16 @@ public void Apply(ApplicationModel application)
 
                 if (!isOperationsController)
                 {
-                    Type resourceType = ExtractResourceTypeFromController(controller.ControllerType);
+                    Type resourceClrType = ExtractResourceClrTypeFromController(controller.ControllerType);
 
-                    if (resourceType != null)
+                    if (resourceClrType != null)
                     {
-                        ResourceContext resourceContext = _resourceGraph.TryGetResourceContext(resourceType);
+                        ResourceType resourceType = _resourceGraph.TryGetResourceType(resourceClrType);
 
-                        if (resourceContext != null)
+                        if (resourceType != null)
                         {
-                            _resourceContextPerControllerTypeMap.Add(controller.ControllerType, resourceContext);
-                            _controllerPerResourceContextMap.Add(resourceContext, controller);
+                            _resourceTypePerControllerTypeMap.Add(controller.ControllerType, resourceType);
+                            _controllerPerResourceTypeMap.Add(resourceType, controller);
                         }
                     }
                 }
@@ -133,9 +120,9 @@ private bool IsRoutingConventionEnabled(ControllerModel controller)
         /// </summary>
         private string TemplateFromResource(ControllerModel model)
         {
-            if (_resourceContextPerControllerTypeMap.TryGetValue(model.ControllerType, out ResourceContext resourceContext))
+            if (_resourceTypePerControllerTypeMap.TryGetValue(model.ControllerType, out ResourceType resourceType))
             {
-                return $"{_options.Namespace}/{resourceContext.PublicName}";
+                return $"{_options.Namespace}/{resourceType.PublicName}";
             }
 
             return null;
@@ -156,7 +143,7 @@ private string TemplateFromController(ControllerModel model)
         /// <summary>
         /// Determines the resource associated to a controller by inspecting generic arguments in its inheritance tree.
         /// </summary>
-        private Type ExtractResourceTypeFromController(Type type)
+        private Type ExtractResourceClrTypeFromController(Type type)
         {
             Type aspNetControllerType = typeof(ControllerBase);
             Type coreControllerType = typeof(CoreJsonApiController);
@@ -169,12 +156,12 @@ private Type ExtractResourceTypeFromController(Type type)
 
                 if ((nextBaseType == aspNetControllerType || nextBaseType == coreControllerType) && currentType.IsGenericType)
                 {
-                    Type resourceType = currentType.GetGenericArguments()
+                    Type resourceClrType = currentType.GetGenericArguments()
                         .FirstOrDefault(typeArgument => typeArgument.IsOrImplementsInterface(typeof(IIdentifiable)));
 
-                    if (resourceType != null)
+                    if (resourceClrType != null)
                     {
-                        return resourceType;
+                        return resourceClrType;
                     }
                 }
 
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/IncludeChainConverter.cs b/src/JsonApiDotNetCore/Queries/Expressions/IncludeChainConverter.cs
index dbe3b9b0dd..d1c097676b 100644
--- a/src/JsonApiDotNetCore/Queries/Expressions/IncludeChainConverter.cs
+++ b/src/JsonApiDotNetCore/Queries/Expressions/IncludeChainConverter.cs
@@ -68,11 +68,11 @@ public IncludeExpression FromRelationshipChains(IEnumerable<ResourceFieldChainEx
         {
             ArgumentGuard.NotNull(chains, nameof(chains));
 
-            IImmutableList<IncludeElementExpression> elements = ConvertChainsToElements(chains);
+            IImmutableSet<IncludeElementExpression> elements = ConvertChainsToElements(chains);
             return elements.Any() ? new IncludeExpression(elements) : IncludeExpression.Empty;
         }
 
-        private static IImmutableList<IncludeElementExpression> ConvertChainsToElements(IEnumerable<ResourceFieldChainExpression> chains)
+        private static IImmutableSet<IncludeElementExpression> ConvertChainsToElements(IEnumerable<ResourceFieldChainExpression> chains)
         {
             var rootNode = new MutableIncludeNode(null);
 
@@ -81,7 +81,7 @@ private static IImmutableList<IncludeElementExpression> ConvertChainsToElements(
                 ConvertChainToElement(chain, rootNode);
             }
 
-            return rootNode.Children.Values.Select(child => child.ToExpression()).ToImmutableArray();
+            return rootNode.Children.Values.Select(child => child.ToExpression()).ToImmutableHashSet();
         }
 
         private static void ConvertChainToElement(ResourceFieldChainExpression chain, MutableIncludeNode rootNode)
@@ -161,7 +161,7 @@ public MutableIncludeNode(RelationshipAttribute relationship)
 
             public IncludeElementExpression ToExpression()
             {
-                ImmutableArray<IncludeElementExpression> elementChildren = Children.Values.Select(child => child.ToExpression()).ToImmutableArray();
+                IImmutableSet<IncludeElementExpression> elementChildren = Children.Values.Select(child => child.ToExpression()).ToImmutableHashSet();
                 return new IncludeElementExpression(_relationship, elementChildren);
             }
         }
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/IncludeElementExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/IncludeElementExpression.cs
index a63db4c707..648986fe18 100644
--- a/src/JsonApiDotNetCore/Queries/Expressions/IncludeElementExpression.cs
+++ b/src/JsonApiDotNetCore/Queries/Expressions/IncludeElementExpression.cs
@@ -14,14 +14,14 @@ namespace JsonApiDotNetCore.Queries.Expressions
     public class IncludeElementExpression : QueryExpression
     {
         public RelationshipAttribute Relationship { get; }
-        public IImmutableList<IncludeElementExpression> Children { get; }
+        public IImmutableSet<IncludeElementExpression> Children { get; }
 
         public IncludeElementExpression(RelationshipAttribute relationship)
-            : this(relationship, ImmutableArray<IncludeElementExpression>.Empty)
+            : this(relationship, ImmutableHashSet<IncludeElementExpression>.Empty)
         {
         }
 
-        public IncludeElementExpression(RelationshipAttribute relationship, IImmutableList<IncludeElementExpression> children)
+        public IncludeElementExpression(RelationshipAttribute relationship, IImmutableSet<IncludeElementExpression> children)
         {
             ArgumentGuard.NotNull(relationship, nameof(relationship));
             ArgumentGuard.NotNull(children, nameof(children));
@@ -43,7 +43,7 @@ public override string ToString()
             if (Children.Any())
             {
                 builder.Append('{');
-                builder.Append(string.Join(",", Children.Select(child => child.ToString())));
+                builder.Append(string.Join(",", Children.Select(child => child.ToString()).OrderBy(name => name)));
                 builder.Append('}');
             }
 
@@ -64,7 +64,7 @@ public override bool Equals(object obj)
 
             var other = (IncludeElementExpression)obj;
 
-            return Relationship.Equals(other.Relationship) == Children.SequenceEqual(other.Children);
+            return Relationship.Equals(other.Relationship) && Children.SetEquals(other.Children);
         }
 
         public override int GetHashCode()
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/IncludeExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/IncludeExpression.cs
index 482ba0158d..632e04af30 100644
--- a/src/JsonApiDotNetCore/Queries/Expressions/IncludeExpression.cs
+++ b/src/JsonApiDotNetCore/Queries/Expressions/IncludeExpression.cs
@@ -16,9 +16,9 @@ public class IncludeExpression : QueryExpression
 
         public static readonly IncludeExpression Empty = new();
 
-        public IImmutableList<IncludeElementExpression> Elements { get; }
+        public IImmutableSet<IncludeElementExpression> Elements { get; }
 
-        public IncludeExpression(IImmutableList<IncludeElementExpression> elements)
+        public IncludeExpression(IImmutableSet<IncludeElementExpression> elements)
         {
             ArgumentGuard.NotNullNorEmpty(elements, nameof(elements));
 
@@ -27,7 +27,7 @@ public IncludeExpression(IImmutableList<IncludeElementExpression> elements)
 
         private IncludeExpression()
         {
-            Elements = ImmutableArray<IncludeElementExpression>.Empty;
+            Elements = ImmutableHashSet<IncludeElementExpression>.Empty;
         }
 
         public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgument, TResult> visitor, TArgument argument)
@@ -38,7 +38,7 @@ public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgum
         public override string ToString()
         {
             IReadOnlyCollection<ResourceFieldChainExpression> chains = IncludeChainConverter.GetRelationshipChains(this);
-            return string.Join(",", chains.Select(child => child.ToString()));
+            return string.Join(",", chains.Select(child => child.ToString()).OrderBy(name => name));
         }
 
         public override bool Equals(object obj)
@@ -55,7 +55,7 @@ public override bool Equals(object obj)
 
             var other = (IncludeExpression)obj;
 
-            return Elements.SequenceEqual(other.Elements);
+            return Elements.SetEquals(other.Elements);
         }
 
         public override int GetHashCode()
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/QueryExpressionRewriter.cs b/src/JsonApiDotNetCore/Queries/Expressions/QueryExpressionRewriter.cs
index bd4d1e4de8..e2049795f9 100644
--- a/src/JsonApiDotNetCore/Queries/Expressions/QueryExpressionRewriter.cs
+++ b/src/JsonApiDotNetCore/Queries/Expressions/QueryExpressionRewriter.cs
@@ -197,14 +197,14 @@ public override QueryExpression VisitSparseFieldTable(SparseFieldTableExpression
         {
             if (expression != null)
             {
-                ImmutableDictionary<ResourceContext, SparseFieldSetExpression>.Builder newTable =
-                    ImmutableDictionary.CreateBuilder<ResourceContext, SparseFieldSetExpression>();
+                ImmutableDictionary<ResourceType, SparseFieldSetExpression>.Builder newTable =
+                    ImmutableDictionary.CreateBuilder<ResourceType, SparseFieldSetExpression>();
 
-                foreach ((ResourceContext resourceContext, SparseFieldSetExpression sparseFieldSet) in expression.Table)
+                foreach ((ResourceType resourceType, SparseFieldSetExpression sparseFieldSet) in expression.Table)
                 {
                     if (Visit(sparseFieldSet, argument) is SparseFieldSetExpression newSparseFieldSet)
                     {
-                        newTable[resourceContext] = newSparseFieldSet;
+                        newTable[resourceType] = newSparseFieldSet;
                     }
                 }
 
@@ -268,7 +268,7 @@ public override QueryExpression VisitInclude(IncludeExpression expression, TArgu
         {
             if (expression != null)
             {
-                IImmutableList<IncludeElementExpression> newElements = VisitList(expression.Elements, argument);
+                IImmutableSet<IncludeElementExpression> newElements = VisitSet(expression.Elements, argument);
 
                 if (newElements.Count == 0)
                 {
@@ -286,7 +286,7 @@ public override QueryExpression VisitIncludeElement(IncludeElementExpression exp
         {
             if (expression != null)
             {
-                IImmutableList<IncludeElementExpression> newElements = VisitList(expression.Children, argument);
+                IImmutableSet<IncludeElementExpression> newElements = VisitSet(expression.Children, argument);
 
                 var newExpression = new IncludeElementExpression(expression.Relationship, newElements);
                 return newExpression.Equals(expression) ? expression : newExpression;
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/SparseFieldTableExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/SparseFieldTableExpression.cs
index 9cf7922349..4f1bca8127 100644
--- a/src/JsonApiDotNetCore/Queries/Expressions/SparseFieldTableExpression.cs
+++ b/src/JsonApiDotNetCore/Queries/Expressions/SparseFieldTableExpression.cs
@@ -12,9 +12,9 @@ namespace JsonApiDotNetCore.Queries.Expressions
     [PublicAPI]
     public class SparseFieldTableExpression : QueryExpression
     {
-        public IImmutableDictionary<ResourceContext, SparseFieldSetExpression> Table { get; }
+        public IImmutableDictionary<ResourceType, SparseFieldSetExpression> Table { get; }
 
-        public SparseFieldTableExpression(IImmutableDictionary<ResourceContext, SparseFieldSetExpression> table)
+        public SparseFieldTableExpression(IImmutableDictionary<ResourceType, SparseFieldSetExpression> table)
         {
             ArgumentGuard.NotNullNorEmpty(table, nameof(table), "entries");
 
@@ -30,7 +30,7 @@ public override string ToString()
         {
             var builder = new StringBuilder();
 
-            foreach ((ResourceContext resource, SparseFieldSetExpression fields) in Table)
+            foreach ((ResourceType resource, SparseFieldSetExpression fields) in Table)
             {
                 if (builder.Length > 0)
                 {
@@ -67,9 +67,9 @@ public override int GetHashCode()
         {
             var hashCode = new HashCode();
 
-            foreach ((ResourceContext resourceContext, SparseFieldSetExpression sparseFieldSet) in Table)
+            foreach ((ResourceType resourceType, SparseFieldSetExpression sparseFieldSet) in Table)
             {
-                hashCode.Add(resourceContext);
+                hashCode.Add(resourceType);
                 hashCode.Add(sparseFieldSet);
             }
 
diff --git a/src/JsonApiDotNetCore/Queries/IQueryLayerComposer.cs b/src/JsonApiDotNetCore/Queries/IQueryLayerComposer.cs
index c3fa8428e4..a6ef61605d 100644
--- a/src/JsonApiDotNetCore/Queries/IQueryLayerComposer.cs
+++ b/src/JsonApiDotNetCore/Queries/IQueryLayerComposer.cs
@@ -14,34 +14,34 @@ public interface IQueryLayerComposer
         /// <summary>
         /// Builds a top-level filter from constraints, used to determine total resource count.
         /// </summary>
-        FilterExpression GetTopFilterFromConstraints(ResourceContext resourceContext);
+        FilterExpression GetTopFilterFromConstraints(ResourceType primaryResourceType);
 
         /// <summary>
         /// Collects constraints and builds a <see cref="QueryLayer" /> out of them, used to retrieve the actual resources.
         /// </summary>
-        QueryLayer ComposeFromConstraints(ResourceContext requestResource);
+        QueryLayer ComposeFromConstraints(ResourceType requestResourceType);
 
         /// <summary>
         /// Collects constraints and builds a <see cref="QueryLayer" /> out of them, used to retrieve one resource.
         /// </summary>
-        QueryLayer ComposeForGetById<TId>(TId id, ResourceContext resourceContext, TopFieldSelection fieldSelection);
+        QueryLayer ComposeForGetById<TId>(TId id, ResourceType primaryResourceType, TopFieldSelection fieldSelection);
 
         /// <summary>
         /// Collects constraints and builds the secondary layer for a relationship endpoint.
         /// </summary>
-        QueryLayer ComposeSecondaryLayerForRelationship(ResourceContext secondaryResourceContext);
+        QueryLayer ComposeSecondaryLayerForRelationship(ResourceType secondaryResourceType);
 
         /// <summary>
         /// Wraps a layer for a secondary endpoint into a primary layer, rewriting top-level includes.
         /// </summary>
-        QueryLayer WrapLayerForSecondaryEndpoint<TId>(QueryLayer secondaryLayer, ResourceContext primaryResourceContext, TId primaryId,
-            RelationshipAttribute secondaryRelationship);
+        QueryLayer WrapLayerForSecondaryEndpoint<TId>(QueryLayer secondaryLayer, ResourceType primaryResourceType, TId primaryId,
+            RelationshipAttribute relationship);
 
         /// <summary>
         /// Builds a query that retrieves the primary resource, including all of its attributes and all targeted relationships, during a create/update/delete
         /// request.
         /// </summary>
-        QueryLayer ComposeForUpdate<TId>(TId id, ResourceContext primaryResource);
+        QueryLayer ComposeForUpdate<TId>(TId id, ResourceType primaryResource);
 
         /// <summary>
         /// Builds a query for each targeted relationship with a filter to match on its right resource IDs.
diff --git a/src/JsonApiDotNetCore/Queries/Internal/ISparseFieldSetCache.cs b/src/JsonApiDotNetCore/Queries/Internal/ISparseFieldSetCache.cs
new file mode 100644
index 0000000000..cb3ab1f2d3
--- /dev/null
+++ b/src/JsonApiDotNetCore/Queries/Internal/ISparseFieldSetCache.cs
@@ -0,0 +1,40 @@
+using System.Collections.Immutable;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCore.Queries.Internal
+{
+    /// <summary>
+    /// Takes sparse fieldsets from <see cref="IQueryConstraintProvider" />s and invokes
+    /// <see cref="IResourceDefinition{TResource,TId}.OnApplySparseFieldSet" /> on them.
+    /// </summary>
+    /// <remarks>
+    /// This cache ensures that for each request (or operation per request), the resource definition callback is executed only twice per resource type. The
+    /// first invocation is used to obtain the fields to retrieve from the underlying data store, while the second invocation is used to determine which
+    /// fields to write to the response body.
+    /// </remarks>
+    public interface ISparseFieldSetCache
+    {
+        /// <summary>
+        /// Gets the set of sparse fields to retrieve from the underlying data store. Returns an empty set to retrieve all fields.
+        /// </summary>
+        IImmutableSet<ResourceFieldAttribute> GetSparseFieldSetForQuery(ResourceType resourceType);
+
+        /// <summary>
+        /// Gets the set of attributes to retrieve from the underlying data store for relationship endpoints. This always returns 'id', along with any additional
+        /// attributes from resource definition callback.
+        /// </summary>
+        IImmutableSet<AttrAttribute> GetIdAttributeSetForRelationshipQuery(ResourceType resourceType);
+
+        /// <summary>
+        /// Gets the evaluated set of sparse fields to serialize into the response body.
+        /// </summary>
+        IImmutableSet<ResourceFieldAttribute> GetSparseFieldSetForSerializer(ResourceType resourceType);
+
+        /// <summary>
+        /// Resets the cached results from resource definition callbacks.
+        /// </summary>
+        void Reset();
+    }
+}
diff --git a/src/JsonApiDotNetCore/Queries/Internal/Parsing/FilterParser.cs b/src/JsonApiDotNetCore/Queries/Internal/Parsing/FilterParser.cs
index d375f72a16..ef6ffd234e 100644
--- a/src/JsonApiDotNetCore/Queries/Internal/Parsing/FilterParser.cs
+++ b/src/JsonApiDotNetCore/Queries/Internal/Parsing/FilterParser.cs
@@ -13,28 +13,23 @@ namespace JsonApiDotNetCore.Queries.Internal.Parsing
     [PublicAPI]
     public class FilterParser : QueryExpressionParser
     {
-        private readonly IResourceGraph _resourceGraph;
         private readonly IResourceFactory _resourceFactory;
-        private readonly Action<ResourceFieldAttribute, ResourceContext, string> _validateSingleFieldCallback;
-        private ResourceContext _resourceContextInScope;
+        private readonly Action<ResourceFieldAttribute, ResourceType, string> _validateSingleFieldCallback;
+        private ResourceType _resourceTypeInScope;
 
-        public FilterParser(IResourceGraph resourceGraph, IResourceFactory resourceFactory,
-            Action<ResourceFieldAttribute, ResourceContext, string> validateSingleFieldCallback = null)
-            : base(resourceGraph)
+        public FilterParser(IResourceFactory resourceFactory, Action<ResourceFieldAttribute, ResourceType, string> validateSingleFieldCallback = null)
         {
-            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
             ArgumentGuard.NotNull(resourceFactory, nameof(resourceFactory));
 
-            _resourceGraph = resourceGraph;
             _resourceFactory = resourceFactory;
             _validateSingleFieldCallback = validateSingleFieldCallback;
         }
 
-        public FilterExpression Parse(string source, ResourceContext resourceContextInScope)
+        public FilterExpression Parse(string source, ResourceType resourceTypeInScope)
         {
-            ArgumentGuard.NotNull(resourceContextInScope, nameof(resourceContextInScope));
+            ArgumentGuard.NotNull(resourceTypeInScope, nameof(resourceTypeInScope));
 
-            _resourceContextInScope = resourceContextInScope;
+            _resourceTypeInScope = resourceTypeInScope;
 
             Tokenize(source);
 
@@ -265,14 +260,13 @@ protected HasExpression ParseHas()
 
         private FilterExpression ParseFilterInHas(HasManyAttribute hasManyRelationship)
         {
-            ResourceContext outerScopeBackup = _resourceContextInScope;
+            ResourceType outerScopeBackup = _resourceTypeInScope;
 
-            Type innerResourceType = hasManyRelationship.RightType;
-            _resourceContextInScope = _resourceGraph.GetResourceContext(innerResourceType);
+            _resourceTypeInScope = hasManyRelationship.RightType;
 
             FilterExpression filter = ParseFilter();
 
-            _resourceContextInScope = outerScopeBackup;
+            _resourceTypeInScope = outerScopeBackup;
             return filter;
         }
 
@@ -337,9 +331,9 @@ protected LiteralConstantExpression ParseConstant()
             throw new QueryParseException("Value between quotes expected.");
         }
 
-        private string DeObfuscateStringId(Type resourceType, string stringId)
+        private string DeObfuscateStringId(Type resourceClrType, string stringId)
         {
-            IIdentifiable tempResource = _resourceFactory.CreateInstance(resourceType);
+            IIdentifiable tempResource = _resourceFactory.CreateInstance(resourceClrType);
             tempResource.StringId = stringId;
             return tempResource.GetTypedId().ToString();
         }
@@ -348,17 +342,17 @@ protected override IImmutableList<ResourceFieldAttribute> OnResolveFieldChain(st
         {
             if (chainRequirements == FieldChainRequirements.EndsInToMany)
             {
-                return ChainResolver.ResolveToOneChainEndingInToMany(_resourceContextInScope, path, _validateSingleFieldCallback);
+                return ChainResolver.ResolveToOneChainEndingInToMany(_resourceTypeInScope, path, _validateSingleFieldCallback);
             }
 
             if (chainRequirements == FieldChainRequirements.EndsInAttribute)
             {
-                return ChainResolver.ResolveToOneChainEndingInAttribute(_resourceContextInScope, path, _validateSingleFieldCallback);
+                return ChainResolver.ResolveToOneChainEndingInAttribute(_resourceTypeInScope, path, _validateSingleFieldCallback);
             }
 
             if (chainRequirements.HasFlag(FieldChainRequirements.EndsInAttribute) && chainRequirements.HasFlag(FieldChainRequirements.EndsInToOne))
             {
-                return ChainResolver.ResolveToOneChainEndingInAttributeOrToOne(_resourceContextInScope, path, _validateSingleFieldCallback);
+                return ChainResolver.ResolveToOneChainEndingInAttributeOrToOne(_resourceTypeInScope, path, _validateSingleFieldCallback);
             }
 
             throw new InvalidOperationException($"Unexpected combination of chain requirement flags '{chainRequirements}'.");
diff --git a/src/JsonApiDotNetCore/Queries/Internal/Parsing/IncludeParser.cs b/src/JsonApiDotNetCore/Queries/Internal/Parsing/IncludeParser.cs
index 9d6f394d75..1646c3bcb0 100644
--- a/src/JsonApiDotNetCore/Queries/Internal/Parsing/IncludeParser.cs
+++ b/src/JsonApiDotNetCore/Queries/Internal/Parsing/IncludeParser.cs
@@ -14,20 +14,19 @@ public class IncludeParser : QueryExpressionParser
     {
         private static readonly IncludeChainConverter IncludeChainConverter = new();
 
-        private readonly Action<RelationshipAttribute, ResourceContext, string> _validateSingleRelationshipCallback;
-        private ResourceContext _resourceContextInScope;
+        private readonly Action<RelationshipAttribute, ResourceType, string> _validateSingleRelationshipCallback;
+        private ResourceType _resourceTypeInScope;
 
-        public IncludeParser(IResourceGraph resourceGraph, Action<RelationshipAttribute, ResourceContext, string> validateSingleRelationshipCallback = null)
-            : base(resourceGraph)
+        public IncludeParser(Action<RelationshipAttribute, ResourceType, string> validateSingleRelationshipCallback = null)
         {
             _validateSingleRelationshipCallback = validateSingleRelationshipCallback;
         }
 
-        public IncludeExpression Parse(string source, ResourceContext resourceContextInScope, int? maximumDepth)
+        public IncludeExpression Parse(string source, ResourceType resourceTypeInScope, int? maximumDepth)
         {
-            ArgumentGuard.NotNull(resourceContextInScope, nameof(resourceContextInScope));
+            ArgumentGuard.NotNull(resourceTypeInScope, nameof(resourceTypeInScope));
 
-            _resourceContextInScope = resourceContextInScope;
+            _resourceTypeInScope = resourceTypeInScope;
 
             Tokenize(source);
 
@@ -74,7 +73,7 @@ private static void ValidateMaximumIncludeDepth(int? maximumDepth, IEnumerable<R
 
         protected override IImmutableList<ResourceFieldAttribute> OnResolveFieldChain(string path, FieldChainRequirements chainRequirements)
         {
-            return ChainResolver.ResolveRelationshipChain(_resourceContextInScope, path, _validateSingleRelationshipCallback);
+            return ChainResolver.ResolveRelationshipChain(_resourceTypeInScope, path, _validateSingleRelationshipCallback);
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Queries/Internal/Parsing/PaginationParser.cs b/src/JsonApiDotNetCore/Queries/Internal/Parsing/PaginationParser.cs
index 62f8dd6a91..980ec8450a 100644
--- a/src/JsonApiDotNetCore/Queries/Internal/Parsing/PaginationParser.cs
+++ b/src/JsonApiDotNetCore/Queries/Internal/Parsing/PaginationParser.cs
@@ -11,20 +11,19 @@ namespace JsonApiDotNetCore.Queries.Internal.Parsing
     [PublicAPI]
     public class PaginationParser : QueryExpressionParser
     {
-        private readonly Action<ResourceFieldAttribute, ResourceContext, string> _validateSingleFieldCallback;
-        private ResourceContext _resourceContextInScope;
+        private readonly Action<ResourceFieldAttribute, ResourceType, string> _validateSingleFieldCallback;
+        private ResourceType _resourceTypeInScope;
 
-        public PaginationParser(IResourceGraph resourceGraph, Action<ResourceFieldAttribute, ResourceContext, string> validateSingleFieldCallback = null)
-            : base(resourceGraph)
+        public PaginationParser(Action<ResourceFieldAttribute, ResourceType, string> validateSingleFieldCallback = null)
         {
             _validateSingleFieldCallback = validateSingleFieldCallback;
         }
 
-        public PaginationQueryStringValueExpression Parse(string source, ResourceContext resourceContextInScope)
+        public PaginationQueryStringValueExpression Parse(string source, ResourceType resourceTypeInScope)
         {
-            ArgumentGuard.NotNull(resourceContextInScope, nameof(resourceContextInScope));
+            ArgumentGuard.NotNull(resourceTypeInScope, nameof(resourceTypeInScope));
 
-            _resourceContextInScope = resourceContextInScope;
+            _resourceTypeInScope = resourceTypeInScope;
 
             Tokenize(source);
 
@@ -107,7 +106,7 @@ protected PaginationElementQueryStringValueExpression ParsePaginationElement()
 
         protected override IImmutableList<ResourceFieldAttribute> OnResolveFieldChain(string path, FieldChainRequirements chainRequirements)
         {
-            return ChainResolver.ResolveToManyChain(_resourceContextInScope, path, _validateSingleFieldCallback);
+            return ChainResolver.ResolveToManyChain(_resourceTypeInScope, path, _validateSingleFieldCallback);
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Queries/Internal/Parsing/QueryExpressionParser.cs b/src/JsonApiDotNetCore/Queries/Internal/Parsing/QueryExpressionParser.cs
index 65cf321347..b33e01aaf3 100644
--- a/src/JsonApiDotNetCore/Queries/Internal/Parsing/QueryExpressionParser.cs
+++ b/src/JsonApiDotNetCore/Queries/Internal/Parsing/QueryExpressionParser.cs
@@ -2,7 +2,6 @@
 using System.Collections.Immutable;
 using System.Linq;
 using JetBrains.Annotations;
-using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Queries.Expressions;
 using JsonApiDotNetCore.Resources.Annotations;
 
@@ -21,9 +20,9 @@ public abstract class QueryExpressionParser
         protected Stack<Token> TokenStack { get; private set; }
         private protected ResourceFieldChainResolver ChainResolver { get; }
 
-        protected QueryExpressionParser(IResourceGraph resourceGraph)
+        protected QueryExpressionParser()
         {
-            ChainResolver = new ResourceFieldChainResolver(resourceGraph);
+            ChainResolver = new ResourceFieldChainResolver();
         }
 
         /// <summary>
diff --git a/src/JsonApiDotNetCore/Queries/Internal/Parsing/QueryStringParameterScopeParser.cs b/src/JsonApiDotNetCore/Queries/Internal/Parsing/QueryStringParameterScopeParser.cs
index 7d98110362..7d9f848862 100644
--- a/src/JsonApiDotNetCore/Queries/Internal/Parsing/QueryStringParameterScopeParser.cs
+++ b/src/JsonApiDotNetCore/Queries/Internal/Parsing/QueryStringParameterScopeParser.cs
@@ -11,22 +11,21 @@ namespace JsonApiDotNetCore.Queries.Internal.Parsing
     public class QueryStringParameterScopeParser : QueryExpressionParser
     {
         private readonly FieldChainRequirements _chainRequirements;
-        private readonly Action<ResourceFieldAttribute, ResourceContext, string> _validateSingleFieldCallback;
-        private ResourceContext _resourceContextInScope;
+        private readonly Action<ResourceFieldAttribute, ResourceType, string> _validateSingleFieldCallback;
+        private ResourceType _resourceTypeInScope;
 
-        public QueryStringParameterScopeParser(IResourceGraph resourceGraph, FieldChainRequirements chainRequirements,
-            Action<ResourceFieldAttribute, ResourceContext, string> validateSingleFieldCallback = null)
-            : base(resourceGraph)
+        public QueryStringParameterScopeParser(FieldChainRequirements chainRequirements,
+            Action<ResourceFieldAttribute, ResourceType, string> validateSingleFieldCallback = null)
         {
             _chainRequirements = chainRequirements;
             _validateSingleFieldCallback = validateSingleFieldCallback;
         }
 
-        public QueryStringParameterScopeExpression Parse(string source, ResourceContext resourceContextInScope)
+        public QueryStringParameterScopeExpression Parse(string source, ResourceType resourceTypeInScope)
         {
-            ArgumentGuard.NotNull(resourceContextInScope, nameof(resourceContextInScope));
+            ArgumentGuard.NotNull(resourceTypeInScope, nameof(resourceTypeInScope));
 
-            _resourceContextInScope = resourceContextInScope;
+            _resourceTypeInScope = resourceTypeInScope;
 
             Tokenize(source);
 
@@ -65,12 +64,12 @@ protected override IImmutableList<ResourceFieldAttribute> OnResolveFieldChain(st
             if (chainRequirements == FieldChainRequirements.EndsInToMany)
             {
                 // The mismatch here (ends-in-to-many being interpreted as entire-chain-must-be-to-many) is intentional.
-                return ChainResolver.ResolveToManyChain(_resourceContextInScope, path, _validateSingleFieldCallback);
+                return ChainResolver.ResolveToManyChain(_resourceTypeInScope, path, _validateSingleFieldCallback);
             }
 
             if (chainRequirements == FieldChainRequirements.IsRelationship)
             {
-                return ChainResolver.ResolveRelationshipChain(_resourceContextInScope, path, _validateSingleFieldCallback);
+                return ChainResolver.ResolveRelationshipChain(_resourceTypeInScope, path, _validateSingleFieldCallback);
             }
 
             throw new InvalidOperationException($"Unexpected combination of chain requirement flags '{chainRequirements}'.");
diff --git a/src/JsonApiDotNetCore/Queries/Internal/Parsing/ResourceFieldChainResolver.cs b/src/JsonApiDotNetCore/Queries/Internal/Parsing/ResourceFieldChainResolver.cs
index edb7a774f2..6b0900ef96 100644
--- a/src/JsonApiDotNetCore/Queries/Internal/Parsing/ResourceFieldChainResolver.cs
+++ b/src/JsonApiDotNetCore/Queries/Internal/Parsing/ResourceFieldChainResolver.cs
@@ -11,40 +11,31 @@ namespace JsonApiDotNetCore.Queries.Internal.Parsing
     /// </summary>
     internal sealed class ResourceFieldChainResolver
     {
-        private readonly IResourceGraph _resourceGraph;
-
-        public ResourceFieldChainResolver(IResourceGraph resourceGraph)
-        {
-            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
-
-            _resourceGraph = resourceGraph;
-        }
-
         /// <summary>
         /// Resolves a chain of relationships that ends in a to-many relationship, for example: blogs.owner.articles.comments
         /// </summary>
-        public IImmutableList<ResourceFieldAttribute> ResolveToManyChain(ResourceContext resourceContext, string path,
-            Action<ResourceFieldAttribute, ResourceContext, string> validateCallback = null)
+        public IImmutableList<ResourceFieldAttribute> ResolveToManyChain(ResourceType resourceType, string path,
+            Action<ResourceFieldAttribute, ResourceType, string> validateCallback = null)
         {
             ImmutableArray<ResourceFieldAttribute>.Builder chainBuilder = ImmutableArray.CreateBuilder<ResourceFieldAttribute>();
 
             string[] publicNameParts = path.Split(".");
-            ResourceContext nextResourceContext = resourceContext;
+            ResourceType nextResourceType = resourceType;
 
             foreach (string publicName in publicNameParts[..^1])
             {
-                RelationshipAttribute relationship = GetRelationship(publicName, nextResourceContext, path);
+                RelationshipAttribute relationship = GetRelationship(publicName, nextResourceType, path);
 
-                validateCallback?.Invoke(relationship, nextResourceContext, path);
+                validateCallback?.Invoke(relationship, nextResourceType, path);
 
                 chainBuilder.Add(relationship);
-                nextResourceContext = _resourceGraph.GetResourceContext(relationship.RightType);
+                nextResourceType = relationship.RightType;
             }
 
             string lastName = publicNameParts[^1];
-            RelationshipAttribute lastToManyRelationship = GetToManyRelationship(lastName, nextResourceContext, path);
+            RelationshipAttribute lastToManyRelationship = GetToManyRelationship(lastName, nextResourceType, path);
 
-            validateCallback?.Invoke(lastToManyRelationship, nextResourceContext, path);
+            validateCallback?.Invoke(lastToManyRelationship, nextResourceType, path);
 
             chainBuilder.Add(lastToManyRelationship);
             return chainBuilder.ToImmutable();
@@ -62,20 +53,20 @@ public IImmutableList<ResourceFieldAttribute> ResolveToManyChain(ResourceContext
         /// articles.revisions.author
         /// </example>
         /// </summary>
-        public IImmutableList<ResourceFieldAttribute> ResolveRelationshipChain(ResourceContext resourceContext, string path,
-            Action<RelationshipAttribute, ResourceContext, string> validateCallback = null)
+        public IImmutableList<ResourceFieldAttribute> ResolveRelationshipChain(ResourceType resourceType, string path,
+            Action<RelationshipAttribute, ResourceType, string> validateCallback = null)
         {
             ImmutableArray<ResourceFieldAttribute>.Builder chainBuilder = ImmutableArray.CreateBuilder<ResourceFieldAttribute>();
-            ResourceContext nextResourceContext = resourceContext;
+            ResourceType nextResourceType = resourceType;
 
             foreach (string publicName in path.Split("."))
             {
-                RelationshipAttribute relationship = GetRelationship(publicName, nextResourceContext, path);
+                RelationshipAttribute relationship = GetRelationship(publicName, nextResourceType, path);
 
-                validateCallback?.Invoke(relationship, nextResourceContext, path);
+                validateCallback?.Invoke(relationship, nextResourceType, path);
 
                 chainBuilder.Add(relationship);
-                nextResourceContext = _resourceGraph.GetResourceContext(relationship.RightType);
+                nextResourceType = relationship.RightType;
             }
 
             return chainBuilder.ToImmutable();
@@ -88,28 +79,28 @@ public IImmutableList<ResourceFieldAttribute> ResolveRelationshipChain(ResourceC
         /// </example>
         /// <example>name</example>
         /// </summary>
-        public IImmutableList<ResourceFieldAttribute> ResolveToOneChainEndingInAttribute(ResourceContext resourceContext, string path,
-            Action<ResourceFieldAttribute, ResourceContext, string> validateCallback = null)
+        public IImmutableList<ResourceFieldAttribute> ResolveToOneChainEndingInAttribute(ResourceType resourceType, string path,
+            Action<ResourceFieldAttribute, ResourceType, string> validateCallback = null)
         {
             ImmutableArray<ResourceFieldAttribute>.Builder chainBuilder = ImmutableArray.CreateBuilder<ResourceFieldAttribute>();
 
             string[] publicNameParts = path.Split(".");
-            ResourceContext nextResourceContext = resourceContext;
+            ResourceType nextResourceType = resourceType;
 
             foreach (string publicName in publicNameParts[..^1])
             {
-                RelationshipAttribute toOneRelationship = GetToOneRelationship(publicName, nextResourceContext, path);
+                RelationshipAttribute toOneRelationship = GetToOneRelationship(publicName, nextResourceType, path);
 
-                validateCallback?.Invoke(toOneRelationship, nextResourceContext, path);
+                validateCallback?.Invoke(toOneRelationship, nextResourceType, path);
 
                 chainBuilder.Add(toOneRelationship);
-                nextResourceContext = _resourceGraph.GetResourceContext(toOneRelationship.RightType);
+                nextResourceType = toOneRelationship.RightType;
             }
 
             string lastName = publicNameParts[^1];
-            AttrAttribute lastAttribute = GetAttribute(lastName, nextResourceContext, path);
+            AttrAttribute lastAttribute = GetAttribute(lastName, nextResourceType, path);
 
-            validateCallback?.Invoke(lastAttribute, nextResourceContext, path);
+            validateCallback?.Invoke(lastAttribute, nextResourceType, path);
 
             chainBuilder.Add(lastAttribute);
             return chainBuilder.ToImmutable();
@@ -124,29 +115,29 @@ public IImmutableList<ResourceFieldAttribute> ResolveToOneChainEndingInAttribute
         /// comments
         /// </example>
         /// </summary>
-        public IImmutableList<ResourceFieldAttribute> ResolveToOneChainEndingInToMany(ResourceContext resourceContext, string path,
-            Action<ResourceFieldAttribute, ResourceContext, string> validateCallback = null)
+        public IImmutableList<ResourceFieldAttribute> ResolveToOneChainEndingInToMany(ResourceType resourceType, string path,
+            Action<ResourceFieldAttribute, ResourceType, string> validateCallback = null)
         {
             ImmutableArray<ResourceFieldAttribute>.Builder chainBuilder = ImmutableArray.CreateBuilder<ResourceFieldAttribute>();
 
             string[] publicNameParts = path.Split(".");
-            ResourceContext nextResourceContext = resourceContext;
+            ResourceType nextResourceType = resourceType;
 
             foreach (string publicName in publicNameParts[..^1])
             {
-                RelationshipAttribute toOneRelationship = GetToOneRelationship(publicName, nextResourceContext, path);
+                RelationshipAttribute toOneRelationship = GetToOneRelationship(publicName, nextResourceType, path);
 
-                validateCallback?.Invoke(toOneRelationship, nextResourceContext, path);
+                validateCallback?.Invoke(toOneRelationship, nextResourceType, path);
 
                 chainBuilder.Add(toOneRelationship);
-                nextResourceContext = _resourceGraph.GetResourceContext(toOneRelationship.RightType);
+                nextResourceType = toOneRelationship.RightType;
             }
 
             string lastName = publicNameParts[^1];
 
-            RelationshipAttribute toManyRelationship = GetToManyRelationship(lastName, nextResourceContext, path);
+            RelationshipAttribute toManyRelationship = GetToManyRelationship(lastName, nextResourceType, path);
 
-            validateCallback?.Invoke(toManyRelationship, nextResourceContext, path);
+            validateCallback?.Invoke(toManyRelationship, nextResourceType, path);
 
             chainBuilder.Add(toManyRelationship);
             return chainBuilder.ToImmutable();
@@ -161,105 +152,105 @@ public IImmutableList<ResourceFieldAttribute> ResolveToOneChainEndingInToMany(Re
         /// author.address
         /// </example>
         /// </summary>
-        public IImmutableList<ResourceFieldAttribute> ResolveToOneChainEndingInAttributeOrToOne(ResourceContext resourceContext, string path,
-            Action<ResourceFieldAttribute, ResourceContext, string> validateCallback = null)
+        public IImmutableList<ResourceFieldAttribute> ResolveToOneChainEndingInAttributeOrToOne(ResourceType resourceType, string path,
+            Action<ResourceFieldAttribute, ResourceType, string> validateCallback = null)
         {
             ImmutableArray<ResourceFieldAttribute>.Builder chainBuilder = ImmutableArray.CreateBuilder<ResourceFieldAttribute>();
 
             string[] publicNameParts = path.Split(".");
-            ResourceContext nextResourceContext = resourceContext;
+            ResourceType nextResourceType = resourceType;
 
             foreach (string publicName in publicNameParts[..^1])
             {
-                RelationshipAttribute toOneRelationship = GetToOneRelationship(publicName, nextResourceContext, path);
+                RelationshipAttribute toOneRelationship = GetToOneRelationship(publicName, nextResourceType, path);
 
-                validateCallback?.Invoke(toOneRelationship, nextResourceContext, path);
+                validateCallback?.Invoke(toOneRelationship, nextResourceType, path);
 
                 chainBuilder.Add(toOneRelationship);
-                nextResourceContext = _resourceGraph.GetResourceContext(toOneRelationship.RightType);
+                nextResourceType = toOneRelationship.RightType;
             }
 
             string lastName = publicNameParts[^1];
-            ResourceFieldAttribute lastField = GetField(lastName, nextResourceContext, path);
+            ResourceFieldAttribute lastField = GetField(lastName, nextResourceType, path);
 
             if (lastField is HasManyAttribute)
             {
                 throw new QueryParseException(path == lastName
-                    ? $"Field '{lastName}' must be an attribute or a to-one relationship on resource '{nextResourceContext.PublicName}'."
-                    : $"Field '{lastName}' in '{path}' must be an attribute or a to-one relationship on resource '{nextResourceContext.PublicName}'.");
+                    ? $"Field '{lastName}' must be an attribute or a to-one relationship on resource type '{nextResourceType.PublicName}'."
+                    : $"Field '{lastName}' in '{path}' must be an attribute or a to-one relationship on resource type '{nextResourceType.PublicName}'.");
             }
 
-            validateCallback?.Invoke(lastField, nextResourceContext, path);
+            validateCallback?.Invoke(lastField, nextResourceType, path);
 
             chainBuilder.Add(lastField);
             return chainBuilder.ToImmutable();
         }
 
-        private RelationshipAttribute GetRelationship(string publicName, ResourceContext resourceContext, string path)
+        private RelationshipAttribute GetRelationship(string publicName, ResourceType resourceType, string path)
         {
-            RelationshipAttribute relationship = resourceContext.TryGetRelationshipByPublicName(publicName);
+            RelationshipAttribute relationship = resourceType.TryGetRelationshipByPublicName(publicName);
 
             if (relationship == null)
             {
                 throw new QueryParseException(path == publicName
-                    ? $"Relationship '{publicName}' does not exist on resource '{resourceContext.PublicName}'."
-                    : $"Relationship '{publicName}' in '{path}' does not exist on resource '{resourceContext.PublicName}'.");
+                    ? $"Relationship '{publicName}' does not exist on resource type '{resourceType.PublicName}'."
+                    : $"Relationship '{publicName}' in '{path}' does not exist on resource type '{resourceType.PublicName}'.");
             }
 
             return relationship;
         }
 
-        private RelationshipAttribute GetToManyRelationship(string publicName, ResourceContext resourceContext, string path)
+        private RelationshipAttribute GetToManyRelationship(string publicName, ResourceType resourceType, string path)
         {
-            RelationshipAttribute relationship = GetRelationship(publicName, resourceContext, path);
+            RelationshipAttribute relationship = GetRelationship(publicName, resourceType, path);
 
             if (relationship is not HasManyAttribute)
             {
                 throw new QueryParseException(path == publicName
-                    ? $"Relationship '{publicName}' must be a to-many relationship on resource '{resourceContext.PublicName}'."
-                    : $"Relationship '{publicName}' in '{path}' must be a to-many relationship on resource '{resourceContext.PublicName}'.");
+                    ? $"Relationship '{publicName}' must be a to-many relationship on resource type '{resourceType.PublicName}'."
+                    : $"Relationship '{publicName}' in '{path}' must be a to-many relationship on resource type '{resourceType.PublicName}'.");
             }
 
             return relationship;
         }
 
-        private RelationshipAttribute GetToOneRelationship(string publicName, ResourceContext resourceContext, string path)
+        private RelationshipAttribute GetToOneRelationship(string publicName, ResourceType resourceType, string path)
         {
-            RelationshipAttribute relationship = GetRelationship(publicName, resourceContext, path);
+            RelationshipAttribute relationship = GetRelationship(publicName, resourceType, path);
 
             if (relationship is not HasOneAttribute)
             {
                 throw new QueryParseException(path == publicName
-                    ? $"Relationship '{publicName}' must be a to-one relationship on resource '{resourceContext.PublicName}'."
-                    : $"Relationship '{publicName}' in '{path}' must be a to-one relationship on resource '{resourceContext.PublicName}'.");
+                    ? $"Relationship '{publicName}' must be a to-one relationship on resource type '{resourceType.PublicName}'."
+                    : $"Relationship '{publicName}' in '{path}' must be a to-one relationship on resource type '{resourceType.PublicName}'.");
             }
 
             return relationship;
         }
 
-        private AttrAttribute GetAttribute(string publicName, ResourceContext resourceContext, string path)
+        private AttrAttribute GetAttribute(string publicName, ResourceType resourceType, string path)
         {
-            AttrAttribute attribute = resourceContext.TryGetAttributeByPublicName(publicName);
+            AttrAttribute attribute = resourceType.TryGetAttributeByPublicName(publicName);
 
             if (attribute == null)
             {
                 throw new QueryParseException(path == publicName
-                    ? $"Attribute '{publicName}' does not exist on resource '{resourceContext.PublicName}'."
-                    : $"Attribute '{publicName}' in '{path}' does not exist on resource '{resourceContext.PublicName}'.");
+                    ? $"Attribute '{publicName}' does not exist on resource type '{resourceType.PublicName}'."
+                    : $"Attribute '{publicName}' in '{path}' does not exist on resource type '{resourceType.PublicName}'.");
             }
 
             return attribute;
         }
 
-        public ResourceFieldAttribute GetField(string publicName, ResourceContext resourceContext, string path)
+        public ResourceFieldAttribute GetField(string publicName, ResourceType resourceType, string path)
         {
-            ResourceFieldAttribute field = resourceContext.Fields.FirstOrDefault(nextField => nextField.PublicName == publicName);
+            ResourceFieldAttribute field = resourceType.Fields.FirstOrDefault(nextField => nextField.PublicName == publicName);
 
             if (field == null)
             {
                 throw new QueryParseException(path == publicName
-                    ? $"Field '{publicName}' does not exist on resource '{resourceContext.PublicName}'."
-                    : $"Field '{publicName}' in '{path}' does not exist on resource '{resourceContext.PublicName}'.");
+                    ? $"Field '{publicName}' does not exist on resource type '{resourceType.PublicName}'."
+                    : $"Field '{publicName}' in '{path}' does not exist on resource type '{resourceType.PublicName}'.");
             }
 
             return field;
diff --git a/src/JsonApiDotNetCore/Queries/Internal/Parsing/SortParser.cs b/src/JsonApiDotNetCore/Queries/Internal/Parsing/SortParser.cs
index 4d588bacbb..4b14f2d996 100644
--- a/src/JsonApiDotNetCore/Queries/Internal/Parsing/SortParser.cs
+++ b/src/JsonApiDotNetCore/Queries/Internal/Parsing/SortParser.cs
@@ -11,20 +11,19 @@ namespace JsonApiDotNetCore.Queries.Internal.Parsing
     [PublicAPI]
     public class SortParser : QueryExpressionParser
     {
-        private readonly Action<ResourceFieldAttribute, ResourceContext, string> _validateSingleFieldCallback;
-        private ResourceContext _resourceContextInScope;
+        private readonly Action<ResourceFieldAttribute, ResourceType, string> _validateSingleFieldCallback;
+        private ResourceType _resourceTypeInScope;
 
-        public SortParser(IResourceGraph resourceGraph, Action<ResourceFieldAttribute, ResourceContext, string> validateSingleFieldCallback = null)
-            : base(resourceGraph)
+        public SortParser(Action<ResourceFieldAttribute, ResourceType, string> validateSingleFieldCallback = null)
         {
             _validateSingleFieldCallback = validateSingleFieldCallback;
         }
 
-        public SortExpression Parse(string source, ResourceContext resourceContextInScope)
+        public SortExpression Parse(string source, ResourceType resourceTypeInScope)
         {
-            ArgumentGuard.NotNull(resourceContextInScope, nameof(resourceContextInScope));
+            ArgumentGuard.NotNull(resourceTypeInScope, nameof(resourceTypeInScope));
 
-            _resourceContextInScope = resourceContextInScope;
+            _resourceTypeInScope = resourceTypeInScope;
 
             Tokenize(source);
 
@@ -79,12 +78,12 @@ protected override IImmutableList<ResourceFieldAttribute> OnResolveFieldChain(st
         {
             if (chainRequirements == FieldChainRequirements.EndsInToMany)
             {
-                return ChainResolver.ResolveToOneChainEndingInToMany(_resourceContextInScope, path);
+                return ChainResolver.ResolveToOneChainEndingInToMany(_resourceTypeInScope, path);
             }
 
             if (chainRequirements == FieldChainRequirements.EndsInAttribute)
             {
-                return ChainResolver.ResolveToOneChainEndingInAttribute(_resourceContextInScope, path, _validateSingleFieldCallback);
+                return ChainResolver.ResolveToOneChainEndingInAttribute(_resourceTypeInScope, path, _validateSingleFieldCallback);
             }
 
             throw new InvalidOperationException($"Unexpected combination of chain requirement flags '{chainRequirements}'.");
diff --git a/src/JsonApiDotNetCore/Queries/Internal/Parsing/SparseFieldSetParser.cs b/src/JsonApiDotNetCore/Queries/Internal/Parsing/SparseFieldSetParser.cs
index ea44dca7e5..be8daf350c 100644
--- a/src/JsonApiDotNetCore/Queries/Internal/Parsing/SparseFieldSetParser.cs
+++ b/src/JsonApiDotNetCore/Queries/Internal/Parsing/SparseFieldSetParser.cs
@@ -11,20 +11,19 @@ namespace JsonApiDotNetCore.Queries.Internal.Parsing
     [PublicAPI]
     public class SparseFieldSetParser : QueryExpressionParser
     {
-        private readonly Action<ResourceFieldAttribute, ResourceContext, string> _validateSingleFieldCallback;
-        private ResourceContext _resourceContext;
+        private readonly Action<ResourceFieldAttribute, ResourceType, string> _validateSingleFieldCallback;
+        private ResourceType _resourceType;
 
-        public SparseFieldSetParser(IResourceGraph resourceGraph, Action<ResourceFieldAttribute, ResourceContext, string> validateSingleFieldCallback = null)
-            : base(resourceGraph)
+        public SparseFieldSetParser(Action<ResourceFieldAttribute, ResourceType, string> validateSingleFieldCallback = null)
         {
             _validateSingleFieldCallback = validateSingleFieldCallback;
         }
 
-        public SparseFieldSetExpression Parse(string source, ResourceContext resourceContext)
+        public SparseFieldSetExpression Parse(string source, ResourceType resourceType)
         {
-            ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));
+            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
-            _resourceContext = resourceContext;
+            _resourceType = resourceType;
 
             Tokenize(source);
 
@@ -56,9 +55,9 @@ protected SparseFieldSetExpression ParseSparseFieldSet()
 
         protected override IImmutableList<ResourceFieldAttribute> OnResolveFieldChain(string path, FieldChainRequirements chainRequirements)
         {
-            ResourceFieldAttribute field = ChainResolver.GetField(path, _resourceContext, path);
+            ResourceFieldAttribute field = ChainResolver.GetField(path, _resourceType, path);
 
-            _validateSingleFieldCallback?.Invoke(field, _resourceContext, path);
+            _validateSingleFieldCallback?.Invoke(field, _resourceType, path);
 
             return ImmutableArray.Create(field);
         }
diff --git a/src/JsonApiDotNetCore/Queries/Internal/Parsing/SparseFieldTypeParser.cs b/src/JsonApiDotNetCore/Queries/Internal/Parsing/SparseFieldTypeParser.cs
index fec5356282..d071514a1a 100644
--- a/src/JsonApiDotNetCore/Queries/Internal/Parsing/SparseFieldTypeParser.cs
+++ b/src/JsonApiDotNetCore/Queries/Internal/Parsing/SparseFieldTypeParser.cs
@@ -12,23 +12,24 @@ public class SparseFieldTypeParser : QueryExpressionParser
         private readonly IResourceGraph _resourceGraph;
 
         public SparseFieldTypeParser(IResourceGraph resourceGraph)
-            : base(resourceGraph)
         {
+            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
+
             _resourceGraph = resourceGraph;
         }
 
-        public ResourceContext Parse(string source)
+        public ResourceType Parse(string source)
         {
             Tokenize(source);
 
-            ResourceContext resourceContext = ParseSparseFieldTarget();
+            ResourceType resourceType = ParseSparseFieldTarget();
 
             AssertTokenStackIsEmpty();
 
-            return resourceContext;
+            return resourceType;
         }
 
-        private ResourceContext ParseSparseFieldTarget()
+        private ResourceType ParseSparseFieldTarget()
         {
             if (!TokenStack.TryPop(out Token token) || token.Kind != TokenKind.Text)
             {
@@ -37,33 +38,33 @@ private ResourceContext ParseSparseFieldTarget()
 
             EatSingleCharacterToken(TokenKind.OpenBracket);
 
-            ResourceContext resourceContext = ParseResourceName();
+            ResourceType resourceType = ParseResourceName();
 
             EatSingleCharacterToken(TokenKind.CloseBracket);
 
-            return resourceContext;
+            return resourceType;
         }
 
-        private ResourceContext ParseResourceName()
+        private ResourceType ParseResourceName()
         {
             if (TokenStack.TryPop(out Token token) && token.Kind == TokenKind.Text)
             {
-                return GetResourceContext(token.Value);
+                return GetResourceType(token.Value);
             }
 
             throw new QueryParseException("Resource type expected.");
         }
 
-        private ResourceContext GetResourceContext(string publicName)
+        private ResourceType GetResourceType(string publicName)
         {
-            ResourceContext resourceContext = _resourceGraph.TryGetResourceContext(publicName);
+            ResourceType resourceType = _resourceGraph.TryGetResourceType(publicName);
 
-            if (resourceContext == null)
+            if (resourceType == null)
             {
                 throw new QueryParseException($"Resource type '{publicName}' does not exist.");
             }
 
-            return resourceContext;
+            return resourceType;
         }
 
         protected override IImmutableList<ResourceFieldAttribute> OnResolveFieldChain(string path, FieldChainRequirements chainRequirements)
diff --git a/src/JsonApiDotNetCore/Queries/Internal/QueryLayerComposer.cs b/src/JsonApiDotNetCore/Queries/Internal/QueryLayerComposer.cs
index 6bc933cfc0..165ce5b032 100644
--- a/src/JsonApiDotNetCore/Queries/Internal/QueryLayerComposer.cs
+++ b/src/JsonApiDotNetCore/Queries/Internal/QueryLayerComposer.cs
@@ -17,38 +17,36 @@ public class QueryLayerComposer : IQueryLayerComposer
     {
         private readonly CollectionConverter _collectionConverter = new();
         private readonly IEnumerable<IQueryConstraintProvider> _constraintProviders;
-        private readonly IResourceGraph _resourceGraph;
         private readonly IResourceDefinitionAccessor _resourceDefinitionAccessor;
         private readonly IJsonApiOptions _options;
         private readonly IPaginationContext _paginationContext;
         private readonly ITargetedFields _targetedFields;
         private readonly IEvaluatedIncludeCache _evaluatedIncludeCache;
-        private readonly SparseFieldSetCache _sparseFieldSetCache;
+        private readonly ISparseFieldSetCache _sparseFieldSetCache;
 
-        public QueryLayerComposer(IEnumerable<IQueryConstraintProvider> constraintProviders, IResourceGraph resourceGraph,
-            IResourceDefinitionAccessor resourceDefinitionAccessor, IJsonApiOptions options, IPaginationContext paginationContext,
-            ITargetedFields targetedFields, IEvaluatedIncludeCache evaluatedIncludeCache)
+        public QueryLayerComposer(IEnumerable<IQueryConstraintProvider> constraintProviders, IResourceDefinitionAccessor resourceDefinitionAccessor,
+            IJsonApiOptions options, IPaginationContext paginationContext, ITargetedFields targetedFields, IEvaluatedIncludeCache evaluatedIncludeCache,
+            ISparseFieldSetCache sparseFieldSetCache)
         {
             ArgumentGuard.NotNull(constraintProviders, nameof(constraintProviders));
-            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
             ArgumentGuard.NotNull(resourceDefinitionAccessor, nameof(resourceDefinitionAccessor));
             ArgumentGuard.NotNull(options, nameof(options));
             ArgumentGuard.NotNull(paginationContext, nameof(paginationContext));
             ArgumentGuard.NotNull(targetedFields, nameof(targetedFields));
             ArgumentGuard.NotNull(evaluatedIncludeCache, nameof(evaluatedIncludeCache));
+            ArgumentGuard.NotNull(sparseFieldSetCache, nameof(sparseFieldSetCache));
 
             _constraintProviders = constraintProviders;
-            _resourceGraph = resourceGraph;
             _resourceDefinitionAccessor = resourceDefinitionAccessor;
             _options = options;
             _paginationContext = paginationContext;
             _targetedFields = targetedFields;
             _evaluatedIncludeCache = evaluatedIncludeCache;
-            _sparseFieldSetCache = new SparseFieldSetCache(_constraintProviders, resourceDefinitionAccessor);
+            _sparseFieldSetCache = sparseFieldSetCache;
         }
 
         /// <inheritdoc />
-        public FilterExpression GetTopFilterFromConstraints(ResourceContext resourceContext)
+        public FilterExpression GetTopFilterFromConstraints(ResourceType primaryResourceType)
         {
             ExpressionInScope[] constraints = _constraintProviders.SelectMany(provider => provider.GetConstraints()).ToArray();
 
@@ -64,17 +62,17 @@ public FilterExpression GetTopFilterFromConstraints(ResourceContext resourceCont
             // @formatter:keep_existing_linebreaks restore
             // @formatter:wrap_chained_method_calls restore
 
-            return GetFilter(filtersInTopScope, resourceContext);
+            return GetFilter(filtersInTopScope, primaryResourceType);
         }
 
         /// <inheritdoc />
-        public QueryLayer ComposeFromConstraints(ResourceContext requestResource)
+        public QueryLayer ComposeFromConstraints(ResourceType requestResourceType)
         {
-            ArgumentGuard.NotNull(requestResource, nameof(requestResource));
+            ArgumentGuard.NotNull(requestResourceType, nameof(requestResourceType));
 
             ExpressionInScope[] constraints = _constraintProviders.SelectMany(provider => provider.GetConstraints()).ToArray();
 
-            QueryLayer topLayer = ComposeTopLayer(constraints, requestResource);
+            QueryLayer topLayer = ComposeTopLayer(constraints, requestResourceType);
             topLayer.Include = ComposeChildren(topLayer, constraints);
 
             _evaluatedIncludeCache.Set(topLayer.Include);
@@ -82,7 +80,7 @@ public QueryLayer ComposeFromConstraints(ResourceContext requestResource)
             return topLayer;
         }
 
-        private QueryLayer ComposeTopLayer(IEnumerable<ExpressionInScope> constraints, ResourceContext resourceContext)
+        private QueryLayer ComposeTopLayer(IEnumerable<ExpressionInScope> constraints, ResourceType resourceType)
         {
             using IDisposable _ = CodeTimingSessionManager.Current.Measure("Top-level query composition");
 
@@ -97,7 +95,7 @@ private QueryLayer ComposeTopLayer(IEnumerable<ExpressionInScope> constraints, R
             // @formatter:keep_existing_linebreaks restore
             // @formatter:wrap_chained_method_calls restore
 
-            PaginationExpression topPagination = GetPagination(expressionsInTopScope, resourceContext);
+            PaginationExpression topPagination = GetPagination(expressionsInTopScope, resourceType);
 
             if (topPagination != null)
             {
@@ -105,12 +103,12 @@ private QueryLayer ComposeTopLayer(IEnumerable<ExpressionInScope> constraints, R
                 _paginationContext.PageNumber = topPagination.PageNumber;
             }
 
-            return new QueryLayer(resourceContext)
+            return new QueryLayer(resourceType)
             {
-                Filter = GetFilter(expressionsInTopScope, resourceContext),
-                Sort = GetSort(expressionsInTopScope, resourceContext),
+                Filter = GetFilter(expressionsInTopScope, resourceType),
+                Sort = GetSort(expressionsInTopScope, resourceType),
                 Pagination = ((JsonApiOptions)_options).DisableTopPagination ? null : topPagination,
-                Projection = GetProjectionForSparseAttributeSet(resourceContext)
+                Projection = GetProjectionForSparseAttributeSet(resourceType)
             };
         }
 
@@ -130,7 +128,7 @@ private IncludeExpression ComposeChildren(QueryLayer topLayer, ICollection<Expre
             // @formatter:keep_existing_linebreaks restore
             // @formatter:wrap_chained_method_calls restore
 
-            IImmutableList<IncludeElementExpression> includeElements =
+            IImmutableSet<IncludeElementExpression> includeElements =
                 ProcessIncludeSet(include.Elements, topLayer, new List<RelationshipAttribute>(), constraints);
 
             return !ReferenceEquals(includeElements, include.Elements)
@@ -138,13 +136,13 @@ private IncludeExpression ComposeChildren(QueryLayer topLayer, ICollection<Expre
                 : include;
         }
 
-        private IImmutableList<IncludeElementExpression> ProcessIncludeSet(IImmutableList<IncludeElementExpression> includeElements, QueryLayer parentLayer,
+        private IImmutableSet<IncludeElementExpression> ProcessIncludeSet(IImmutableSet<IncludeElementExpression> includeElements, QueryLayer parentLayer,
             ICollection<RelationshipAttribute> parentRelationshipChain, ICollection<ExpressionInScope> constraints)
         {
-            IImmutableList<IncludeElementExpression> includeElementsEvaluated =
-                GetIncludeElements(includeElements, parentLayer.ResourceContext) ?? ImmutableArray<IncludeElementExpression>.Empty;
+            IImmutableSet<IncludeElementExpression> includeElementsEvaluated =
+                GetIncludeElements(includeElements, parentLayer.ResourceType) ?? ImmutableHashSet<IncludeElementExpression>.Empty;
 
-            var updatesInChildren = new Dictionary<IncludeElementExpression, IImmutableList<IncludeElementExpression>>();
+            var updatesInChildren = new Dictionary<IncludeElementExpression, IImmutableSet<IncludeElementExpression>>();
 
             foreach (IncludeElementExpression includeElement in includeElementsEvaluated)
             {
@@ -169,30 +167,26 @@ private IImmutableList<IncludeElementExpression> ProcessIncludeSet(IImmutableLis
                     // @formatter:keep_existing_linebreaks restore
                     // @formatter:wrap_chained_method_calls restore
 
-                    ResourceContext resourceContext = _resourceGraph.GetResourceContext(includeElement.Relationship.RightType);
+                    ResourceType resourceType = includeElement.Relationship.RightType;
                     bool isToManyRelationship = includeElement.Relationship is HasManyAttribute;
 
-                    var child = new QueryLayer(resourceContext)
+                    var child = new QueryLayer(resourceType)
                     {
-                        Filter = isToManyRelationship ? GetFilter(expressionsInCurrentScope, resourceContext) : null,
-                        Sort = isToManyRelationship ? GetSort(expressionsInCurrentScope, resourceContext) : null,
+                        Filter = isToManyRelationship ? GetFilter(expressionsInCurrentScope, resourceType) : null,
+                        Sort = isToManyRelationship ? GetSort(expressionsInCurrentScope, resourceType) : null,
                         Pagination = isToManyRelationship
-                            ? ((JsonApiOptions)_options).DisableChildrenPagination ? null : GetPagination(expressionsInCurrentScope, resourceContext)
+                            ? ((JsonApiOptions)_options).DisableChildrenPagination ? null : GetPagination(expressionsInCurrentScope, resourceType)
                             : null,
-                        Projection = GetProjectionForSparseAttributeSet(resourceContext)
+                        Projection = GetProjectionForSparseAttributeSet(resourceType)
                     };
 
                     parentLayer.Projection.Add(includeElement.Relationship, child);
 
-                    if (includeElement.Children.Any())
-                    {
-                        IImmutableList<IncludeElementExpression> updatedChildren =
-                            ProcessIncludeSet(includeElement.Children, child, relationshipChain, constraints);
+                    IImmutableSet<IncludeElementExpression> updatedChildren = ProcessIncludeSet(includeElement.Children, child, relationshipChain, constraints);
 
-                        if (!ReferenceEquals(includeElement.Children, updatedChildren))
-                        {
-                            updatesInChildren.Add(includeElement, updatedChildren);
-                        }
+                    if (!ReferenceEquals(includeElement.Children, updatedChildren))
+                    {
+                        updatesInChildren.Add(includeElement, updatedChildren);
                     }
                 }
             }
@@ -200,29 +194,29 @@ private IImmutableList<IncludeElementExpression> ProcessIncludeSet(IImmutableLis
             return !updatesInChildren.Any() ? includeElementsEvaluated : ApplyIncludeElementUpdates(includeElementsEvaluated, updatesInChildren);
         }
 
-        private static IImmutableList<IncludeElementExpression> ApplyIncludeElementUpdates(IImmutableList<IncludeElementExpression> includeElements,
-            IDictionary<IncludeElementExpression, IImmutableList<IncludeElementExpression>> updatesInChildren)
+        private static IImmutableSet<IncludeElementExpression> ApplyIncludeElementUpdates(IImmutableSet<IncludeElementExpression> includeElements,
+            IDictionary<IncludeElementExpression, IImmutableSet<IncludeElementExpression>> updatesInChildren)
         {
-            ImmutableArray<IncludeElementExpression>.Builder newElementsBuilder = ImmutableArray.CreateBuilder<IncludeElementExpression>(includeElements.Count);
+            ImmutableHashSet<IncludeElementExpression>.Builder newElementsBuilder = ImmutableHashSet.CreateBuilder<IncludeElementExpression>();
             newElementsBuilder.AddRange(includeElements);
 
-            foreach ((IncludeElementExpression existingElement, IImmutableList<IncludeElementExpression> updatedChildren) in updatesInChildren)
+            foreach ((IncludeElementExpression existingElement, IImmutableSet<IncludeElementExpression> updatedChildren) in updatesInChildren)
             {
-                int existingIndex = newElementsBuilder.IndexOf(existingElement);
-                newElementsBuilder[existingIndex] = new IncludeElementExpression(existingElement.Relationship, updatedChildren);
+                newElementsBuilder.Remove(existingElement);
+                newElementsBuilder.Add(new IncludeElementExpression(existingElement.Relationship, updatedChildren));
             }
 
             return newElementsBuilder.ToImmutable();
         }
 
         /// <inheritdoc />
-        public QueryLayer ComposeForGetById<TId>(TId id, ResourceContext resourceContext, TopFieldSelection fieldSelection)
+        public QueryLayer ComposeForGetById<TId>(TId id, ResourceType primaryResourceType, TopFieldSelection fieldSelection)
         {
-            ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));
+            ArgumentGuard.NotNull(primaryResourceType, nameof(primaryResourceType));
 
-            AttrAttribute idAttribute = GetIdAttribute(resourceContext);
+            AttrAttribute idAttribute = GetIdAttribute(primaryResourceType);
 
-            QueryLayer queryLayer = ComposeFromConstraints(resourceContext);
+            QueryLayer queryLayer = ComposeFromConstraints(primaryResourceType);
             queryLayer.Sort = null;
             queryLayer.Pagination = null;
             queryLayer.Filter = CreateFilterByIds(id.AsArray(), idAttribute, queryLayer.Filter);
@@ -247,48 +241,48 @@ public QueryLayer ComposeForGetById<TId>(TId id, ResourceContext resourceContext
         }
 
         /// <inheritdoc />
-        public QueryLayer ComposeSecondaryLayerForRelationship(ResourceContext secondaryResourceContext)
+        public QueryLayer ComposeSecondaryLayerForRelationship(ResourceType secondaryResourceType)
         {
-            ArgumentGuard.NotNull(secondaryResourceContext, nameof(secondaryResourceContext));
+            ArgumentGuard.NotNull(secondaryResourceType, nameof(secondaryResourceType));
 
-            QueryLayer secondaryLayer = ComposeFromConstraints(secondaryResourceContext);
-            secondaryLayer.Projection = GetProjectionForRelationship(secondaryResourceContext);
+            QueryLayer secondaryLayer = ComposeFromConstraints(secondaryResourceType);
+            secondaryLayer.Projection = GetProjectionForRelationship(secondaryResourceType);
             secondaryLayer.Include = null;
 
             return secondaryLayer;
         }
 
-        private IDictionary<ResourceFieldAttribute, QueryLayer> GetProjectionForRelationship(ResourceContext secondaryResourceContext)
+        private IDictionary<ResourceFieldAttribute, QueryLayer> GetProjectionForRelationship(ResourceType secondaryResourceType)
         {
-            IImmutableSet<AttrAttribute> secondaryAttributeSet = _sparseFieldSetCache.GetIdAttributeSetForRelationshipQuery(secondaryResourceContext);
+            IImmutableSet<AttrAttribute> secondaryAttributeSet = _sparseFieldSetCache.GetIdAttributeSetForRelationshipQuery(secondaryResourceType);
 
             return secondaryAttributeSet.ToDictionary(key => (ResourceFieldAttribute)key, _ => (QueryLayer)null);
         }
 
         /// <inheritdoc />
-        public QueryLayer WrapLayerForSecondaryEndpoint<TId>(QueryLayer secondaryLayer, ResourceContext primaryResourceContext, TId primaryId,
-            RelationshipAttribute secondaryRelationship)
+        public QueryLayer WrapLayerForSecondaryEndpoint<TId>(QueryLayer secondaryLayer, ResourceType primaryResourceType, TId primaryId,
+            RelationshipAttribute relationship)
         {
             ArgumentGuard.NotNull(secondaryLayer, nameof(secondaryLayer));
-            ArgumentGuard.NotNull(primaryResourceContext, nameof(primaryResourceContext));
-            ArgumentGuard.NotNull(secondaryRelationship, nameof(secondaryRelationship));
+            ArgumentGuard.NotNull(primaryResourceType, nameof(primaryResourceType));
+            ArgumentGuard.NotNull(relationship, nameof(relationship));
 
             IncludeExpression innerInclude = secondaryLayer.Include;
             secondaryLayer.Include = null;
 
-            IImmutableSet<AttrAttribute> primaryAttributeSet = _sparseFieldSetCache.GetIdAttributeSetForRelationshipQuery(primaryResourceContext);
+            IImmutableSet<AttrAttribute> primaryAttributeSet = _sparseFieldSetCache.GetIdAttributeSetForRelationshipQuery(primaryResourceType);
 
             Dictionary<ResourceFieldAttribute, QueryLayer> primaryProjection =
                 primaryAttributeSet.ToDictionary(key => (ResourceFieldAttribute)key, _ => (QueryLayer)null);
 
-            primaryProjection[secondaryRelationship] = secondaryLayer;
+            primaryProjection[relationship] = secondaryLayer;
 
-            FilterExpression primaryFilter = GetFilter(Array.Empty<QueryExpression>(), primaryResourceContext);
-            AttrAttribute primaryIdAttribute = GetIdAttribute(primaryResourceContext);
+            FilterExpression primaryFilter = GetFilter(Array.Empty<QueryExpression>(), primaryResourceType);
+            AttrAttribute primaryIdAttribute = GetIdAttribute(primaryResourceType);
 
-            return new QueryLayer(primaryResourceContext)
+            return new QueryLayer(primaryResourceType)
             {
-                Include = RewriteIncludeForSecondaryEndpoint(innerInclude, secondaryRelationship),
+                Include = RewriteIncludeForSecondaryEndpoint(innerInclude, relationship),
                 Filter = CreateFilterByIds(primaryId.AsArray(), primaryIdAttribute, primaryFilter),
                 Projection = primaryProjection
             };
@@ -300,7 +294,7 @@ private IncludeExpression RewriteIncludeForSecondaryEndpoint(IncludeExpression r
                 ? new IncludeElementExpression(secondaryRelationship, relativeInclude.Elements)
                 : new IncludeElementExpression(secondaryRelationship);
 
-            return new IncludeExpression(ImmutableArray.Create(parentElement));
+            return new IncludeExpression(ImmutableHashSet.Create(parentElement));
         }
 
         private FilterExpression CreateFilterByIds<TId>(IReadOnlyCollection<TId> ids, AttrAttribute idAttribute, FilterExpression existingFilter)
@@ -324,12 +318,12 @@ private FilterExpression CreateFilterByIds<TId>(IReadOnlyCollection<TId> ids, At
         }
 
         /// <inheritdoc />
-        public QueryLayer ComposeForUpdate<TId>(TId id, ResourceContext primaryResource)
+        public QueryLayer ComposeForUpdate<TId>(TId id, ResourceType primaryResource)
         {
             ArgumentGuard.NotNull(primaryResource, nameof(primaryResource));
 
-            ImmutableArray<IncludeElementExpression> includeElements = _targetedFields.Relationships
-                .Select(relationship => new IncludeElementExpression(relationship)).ToImmutableArray();
+            IImmutableSet<IncludeElementExpression> includeElements = _targetedFields.Relationships
+                .Select(relationship => new IncludeElementExpression(relationship)).ToImmutableHashSet();
 
             AttrAttribute primaryIdAttribute = GetIdAttribute(primaryResource);
 
@@ -367,15 +361,14 @@ public QueryLayer ComposeForGetRelationshipRightIds(RelationshipAttribute relati
             ArgumentGuard.NotNull(relationship, nameof(relationship));
             ArgumentGuard.NotNull(rightResourceIds, nameof(rightResourceIds));
 
-            ResourceContext rightResourceContext = _resourceGraph.GetResourceContext(relationship.RightType);
-            AttrAttribute rightIdAttribute = GetIdAttribute(rightResourceContext);
+            AttrAttribute rightIdAttribute = GetIdAttribute(relationship.RightType);
 
             object[] typedIds = rightResourceIds.Select(resource => resource.GetTypedId()).ToArray();
 
-            FilterExpression baseFilter = GetFilter(Array.Empty<QueryExpression>(), rightResourceContext);
+            FilterExpression baseFilter = GetFilter(Array.Empty<QueryExpression>(), relationship.RightType);
             FilterExpression filter = CreateFilterByIds(typedIds, rightIdAttribute, baseFilter);
 
-            return new QueryLayer(rightResourceContext)
+            return new QueryLayer(relationship.RightType)
             {
                 Include = IncludeExpression.Empty,
                 Filter = filter,
@@ -392,23 +385,20 @@ public QueryLayer ComposeForHasMany<TId>(HasManyAttribute hasManyRelationship, T
             ArgumentGuard.NotNull(hasManyRelationship, nameof(hasManyRelationship));
             ArgumentGuard.NotNull(rightResourceIds, nameof(rightResourceIds));
 
-            ResourceContext leftResourceContext = _resourceGraph.GetResourceContext(hasManyRelationship.LeftType);
-            AttrAttribute leftIdAttribute = GetIdAttribute(leftResourceContext);
-
-            ResourceContext rightResourceContext = _resourceGraph.GetResourceContext(hasManyRelationship.RightType);
-            AttrAttribute rightIdAttribute = GetIdAttribute(rightResourceContext);
+            AttrAttribute leftIdAttribute = GetIdAttribute(hasManyRelationship.LeftType);
+            AttrAttribute rightIdAttribute = GetIdAttribute(hasManyRelationship.RightType);
             object[] rightTypedIds = rightResourceIds.Select(resource => resource.GetTypedId()).ToArray();
 
             FilterExpression leftFilter = CreateFilterByIds(leftId.AsArray(), leftIdAttribute, null);
             FilterExpression rightFilter = CreateFilterByIds(rightTypedIds, rightIdAttribute, null);
 
-            return new QueryLayer(leftResourceContext)
+            return new QueryLayer(hasManyRelationship.LeftType)
             {
-                Include = new IncludeExpression(ImmutableArray.Create(new IncludeElementExpression(hasManyRelationship))),
+                Include = new IncludeExpression(ImmutableHashSet.Create(new IncludeElementExpression(hasManyRelationship))),
                 Filter = leftFilter,
                 Projection = new Dictionary<ResourceFieldAttribute, QueryLayer>
                 {
-                    [hasManyRelationship] = new(rightResourceContext)
+                    [hasManyRelationship] = new(hasManyRelationship.RightType)
                     {
                         Filter = rightFilter,
                         Projection = new Dictionary<ResourceFieldAttribute, QueryLayer>
@@ -421,37 +411,37 @@ public QueryLayer ComposeForHasMany<TId>(HasManyAttribute hasManyRelationship, T
             };
         }
 
-        protected virtual IImmutableList<IncludeElementExpression> GetIncludeElements(IImmutableList<IncludeElementExpression> includeElements,
-            ResourceContext resourceContext)
+        protected virtual IImmutableSet<IncludeElementExpression> GetIncludeElements(IImmutableSet<IncludeElementExpression> includeElements,
+            ResourceType resourceType)
         {
-            ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));
+            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
-            return _resourceDefinitionAccessor.OnApplyIncludes(resourceContext.ResourceType, includeElements);
+            return _resourceDefinitionAccessor.OnApplyIncludes(resourceType, includeElements);
         }
 
-        protected virtual FilterExpression GetFilter(IReadOnlyCollection<QueryExpression> expressionsInScope, ResourceContext resourceContext)
+        protected virtual FilterExpression GetFilter(IReadOnlyCollection<QueryExpression> expressionsInScope, ResourceType resourceType)
         {
             ArgumentGuard.NotNull(expressionsInScope, nameof(expressionsInScope));
-            ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));
+            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
             ImmutableArray<FilterExpression> filters = expressionsInScope.OfType<FilterExpression>().ToImmutableArray();
             FilterExpression filter = filters.Length > 1 ? new LogicalExpression(LogicalOperator.And, filters) : filters.FirstOrDefault();
 
-            return _resourceDefinitionAccessor.OnApplyFilter(resourceContext.ResourceType, filter);
+            return _resourceDefinitionAccessor.OnApplyFilter(resourceType, filter);
         }
 
-        protected virtual SortExpression GetSort(IReadOnlyCollection<QueryExpression> expressionsInScope, ResourceContext resourceContext)
+        protected virtual SortExpression GetSort(IReadOnlyCollection<QueryExpression> expressionsInScope, ResourceType resourceType)
         {
             ArgumentGuard.NotNull(expressionsInScope, nameof(expressionsInScope));
-            ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));
+            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
             SortExpression sort = expressionsInScope.OfType<SortExpression>().FirstOrDefault();
 
-            sort = _resourceDefinitionAccessor.OnApplySort(resourceContext.ResourceType, sort);
+            sort = _resourceDefinitionAccessor.OnApplySort(resourceType, sort);
 
             if (sort == null)
             {
-                AttrAttribute idAttribute = GetIdAttribute(resourceContext);
+                AttrAttribute idAttribute = GetIdAttribute(resourceType);
                 var idAscendingSort = new SortElementExpression(new ResourceFieldChainExpression(idAttribute), true);
                 sort = new SortExpression(ImmutableArray.Create(idAscendingSort));
             }
@@ -459,25 +449,25 @@ protected virtual SortExpression GetSort(IReadOnlyCollection<QueryExpression> ex
             return sort;
         }
 
-        protected virtual PaginationExpression GetPagination(IReadOnlyCollection<QueryExpression> expressionsInScope, ResourceContext resourceContext)
+        protected virtual PaginationExpression GetPagination(IReadOnlyCollection<QueryExpression> expressionsInScope, ResourceType resourceType)
         {
             ArgumentGuard.NotNull(expressionsInScope, nameof(expressionsInScope));
-            ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));
+            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
             PaginationExpression pagination = expressionsInScope.OfType<PaginationExpression>().FirstOrDefault();
 
-            pagination = _resourceDefinitionAccessor.OnApplyPagination(resourceContext.ResourceType, pagination);
+            pagination = _resourceDefinitionAccessor.OnApplyPagination(resourceType, pagination);
 
             pagination ??= new PaginationExpression(PageNumber.ValueOne, _options.DefaultPageSize);
 
             return pagination;
         }
 
-        protected virtual IDictionary<ResourceFieldAttribute, QueryLayer> GetProjectionForSparseAttributeSet(ResourceContext resourceContext)
+        protected virtual IDictionary<ResourceFieldAttribute, QueryLayer> GetProjectionForSparseAttributeSet(ResourceType resourceType)
         {
-            ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));
+            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
-            IImmutableSet<ResourceFieldAttribute> fieldSet = _sparseFieldSetCache.GetSparseFieldSetForQuery(resourceContext);
+            IImmutableSet<ResourceFieldAttribute> fieldSet = _sparseFieldSetCache.GetSparseFieldSetForQuery(resourceType);
 
             if (!fieldSet.Any())
             {
@@ -485,15 +475,15 @@ protected virtual IDictionary<ResourceFieldAttribute, QueryLayer> GetProjectionF
             }
 
             HashSet<AttrAttribute> attributeSet = fieldSet.OfType<AttrAttribute>().ToHashSet();
-            AttrAttribute idAttribute = GetIdAttribute(resourceContext);
+            AttrAttribute idAttribute = GetIdAttribute(resourceType);
             attributeSet.Add(idAttribute);
 
             return attributeSet.ToDictionary(key => (ResourceFieldAttribute)key, _ => (QueryLayer)null);
         }
 
-        private static AttrAttribute GetIdAttribute(ResourceContext resourceContext)
+        private static AttrAttribute GetIdAttribute(ResourceType resourceType)
         {
-            return resourceContext.GetAttributeByPropertyName(nameof(Identifiable.Id));
+            return resourceType.GetAttributeByPropertyName(nameof(Identifiable.Id));
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/IncludeClauseBuilder.cs b/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/IncludeClauseBuilder.cs
index 081cf0be34..4dce446d7c 100644
--- a/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/IncludeClauseBuilder.cs
+++ b/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/IncludeClauseBuilder.cs
@@ -18,19 +18,16 @@ public class IncludeClauseBuilder : QueryClauseBuilder<object>
         private static readonly IncludeChainConverter IncludeChainConverter = new();
 
         private readonly Expression _source;
-        private readonly ResourceContext _resourceContext;
-        private readonly IResourceGraph _resourceGraph;
+        private readonly ResourceType _resourceType;
 
-        public IncludeClauseBuilder(Expression source, LambdaScope lambdaScope, ResourceContext resourceContext, IResourceGraph resourceGraph)
+        public IncludeClauseBuilder(Expression source, LambdaScope lambdaScope, ResourceType resourceType)
             : base(lambdaScope)
         {
             ArgumentGuard.NotNull(source, nameof(source));
-            ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));
-            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
+            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
             _source = source;
-            _resourceContext = resourceContext;
-            _resourceGraph = resourceGraph;
+            _resourceType = resourceType;
         }
 
         public Expression ApplyInclude(IncludeExpression include)
@@ -42,7 +39,7 @@ public Expression ApplyInclude(IncludeExpression include)
 
         public override Expression VisitInclude(IncludeExpression expression, object argument)
         {
-            Expression source = ApplyEagerLoads(_source, _resourceContext.EagerLoads, null);
+            Expression source = ApplyEagerLoads(_source, _resourceType.EagerLoads, null);
 
             foreach (ResourceFieldChainExpression chain in IncludeChainConverter.GetRelationshipChains(expression))
             {
@@ -61,8 +58,7 @@ private Expression ProcessRelationshipChain(ResourceFieldChainExpression chain,
             {
                 path = path == null ? relationship.Property.Name : $"{path}.{relationship.Property.Name}";
 
-                ResourceContext resourceContext = _resourceGraph.GetResourceContext(relationship.RightType);
-                result = ApplyEagerLoads(result, resourceContext.EagerLoads, path);
+                result = ApplyEagerLoads(result, relationship.RightType.EagerLoads, path);
             }
 
             return IncludeExtensionMethodCall(result, path);
diff --git a/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/QueryClauseBuilder.cs b/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/QueryClauseBuilder.cs
index 2a51b561c9..1defb30729 100644
--- a/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/QueryClauseBuilder.cs
+++ b/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/QueryClauseBuilder.cs
@@ -49,7 +49,7 @@ private static Expression TryGetCollectionCount(Expression collectionExpression)
 
             foreach (PropertyInfo property in properties)
             {
-                if (property.Name == "Count" || property.Name == "Length")
+                if (property.Name is "Count" or "Length")
                 {
                     return Expression.Property(collectionExpression, property);
                 }
diff --git a/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/QueryableBuilder.cs b/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/QueryableBuilder.cs
index b32c4246d3..d1412eee39 100644
--- a/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/QueryableBuilder.cs
+++ b/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/QueryableBuilder.cs
@@ -21,19 +21,17 @@ public class QueryableBuilder
         private readonly Type _extensionType;
         private readonly LambdaParameterNameFactory _nameFactory;
         private readonly IResourceFactory _resourceFactory;
-        private readonly IResourceGraph _resourceGraph;
         private readonly IModel _entityModel;
         private readonly LambdaScopeFactory _lambdaScopeFactory;
 
         public QueryableBuilder(Expression source, Type elementType, Type extensionType, LambdaParameterNameFactory nameFactory,
-            IResourceFactory resourceFactory, IResourceGraph resourceGraph, IModel entityModel, LambdaScopeFactory lambdaScopeFactory = null)
+            IResourceFactory resourceFactory, IModel entityModel, LambdaScopeFactory lambdaScopeFactory = null)
         {
             ArgumentGuard.NotNull(source, nameof(source));
             ArgumentGuard.NotNull(elementType, nameof(elementType));
             ArgumentGuard.NotNull(extensionType, nameof(extensionType));
             ArgumentGuard.NotNull(nameFactory, nameof(nameFactory));
             ArgumentGuard.NotNull(resourceFactory, nameof(resourceFactory));
-            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
             ArgumentGuard.NotNull(entityModel, nameof(entityModel));
 
             _source = source;
@@ -41,7 +39,6 @@ public QueryableBuilder(Expression source, Type elementType, Type extensionType,
             _extensionType = extensionType;
             _nameFactory = nameFactory;
             _resourceFactory = resourceFactory;
-            _resourceGraph = resourceGraph;
             _entityModel = entityModel;
             _lambdaScopeFactory = lambdaScopeFactory ?? new LambdaScopeFactory(_nameFactory);
         }
@@ -54,7 +51,7 @@ public virtual Expression ApplyQuery(QueryLayer layer)
 
             if (layer.Include != null)
             {
-                expression = ApplyInclude(expression, layer.Include, layer.ResourceContext);
+                expression = ApplyInclude(expression, layer.Include, layer.ResourceType);
             }
 
             if (layer.Filter != null)
@@ -74,17 +71,17 @@ public virtual Expression ApplyQuery(QueryLayer layer)
 
             if (!layer.Projection.IsNullOrEmpty())
             {
-                expression = ApplyProjection(expression, layer.Projection, layer.ResourceContext);
+                expression = ApplyProjection(expression, layer.Projection, layer.ResourceType);
             }
 
             return expression;
         }
 
-        protected virtual Expression ApplyInclude(Expression source, IncludeExpression include, ResourceContext resourceContext)
+        protected virtual Expression ApplyInclude(Expression source, IncludeExpression include, ResourceType resourceType)
         {
             using LambdaScope lambdaScope = _lambdaScopeFactory.CreateScope(_elementType);
 
-            var builder = new IncludeClauseBuilder(source, lambdaScope, resourceContext, _resourceGraph);
+            var builder = new IncludeClauseBuilder(source, lambdaScope, resourceType);
             return builder.ApplyInclude(include);
         }
 
@@ -112,13 +109,12 @@ protected virtual Expression ApplyPagination(Expression source, PaginationExpres
             return builder.ApplySkipTake(pagination);
         }
 
-        protected virtual Expression ApplyProjection(Expression source, IDictionary<ResourceFieldAttribute, QueryLayer> projection,
-            ResourceContext resourceContext)
+        protected virtual Expression ApplyProjection(Expression source, IDictionary<ResourceFieldAttribute, QueryLayer> projection, ResourceType resourceType)
         {
             using LambdaScope lambdaScope = _lambdaScopeFactory.CreateScope(_elementType);
 
-            var builder = new SelectClauseBuilder(source, lambdaScope, _entityModel, _extensionType, _nameFactory, _resourceFactory, _resourceGraph);
-            return builder.ApplySelect(projection, resourceContext);
+            var builder = new SelectClauseBuilder(source, lambdaScope, _entityModel, _extensionType, _nameFactory, _resourceFactory);
+            return builder.ApplySelect(projection, resourceType);
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/SelectClauseBuilder.cs b/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/SelectClauseBuilder.cs
index f37b2f329e..2fc9c773fc 100644
--- a/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/SelectClauseBuilder.cs
+++ b/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/SelectClauseBuilder.cs
@@ -28,10 +28,9 @@ public class SelectClauseBuilder : QueryClauseBuilder<object>
         private readonly Type _extensionType;
         private readonly LambdaParameterNameFactory _nameFactory;
         private readonly IResourceFactory _resourceFactory;
-        private readonly IResourceGraph _resourceGraph;
 
         public SelectClauseBuilder(Expression source, LambdaScope lambdaScope, IModel entityModel, Type extensionType, LambdaParameterNameFactory nameFactory,
-            IResourceFactory resourceFactory, IResourceGraph resourceGraph)
+            IResourceFactory resourceFactory)
             : base(lambdaScope)
         {
             ArgumentGuard.NotNull(source, nameof(source));
@@ -39,17 +38,15 @@ public SelectClauseBuilder(Expression source, LambdaScope lambdaScope, IModel en
             ArgumentGuard.NotNull(extensionType, nameof(extensionType));
             ArgumentGuard.NotNull(nameFactory, nameof(nameFactory));
             ArgumentGuard.NotNull(resourceFactory, nameof(resourceFactory));
-            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
 
             _source = source;
             _entityModel = entityModel;
             _extensionType = extensionType;
             _nameFactory = nameFactory;
             _resourceFactory = resourceFactory;
-            _resourceGraph = resourceGraph;
         }
 
-        public Expression ApplySelect(IDictionary<ResourceFieldAttribute, QueryLayer> selectors, ResourceContext resourceContext)
+        public Expression ApplySelect(IDictionary<ResourceFieldAttribute, QueryLayer> selectors, ResourceType resourceType)
         {
             ArgumentGuard.NotNull(selectors, nameof(selectors));
 
@@ -58,17 +55,17 @@ public Expression ApplySelect(IDictionary<ResourceFieldAttribute, QueryLayer> se
                 return _source;
             }
 
-            Expression bodyInitializer = CreateLambdaBodyInitializer(selectors, resourceContext, LambdaScope, false);
+            Expression bodyInitializer = CreateLambdaBodyInitializer(selectors, resourceType, LambdaScope, false);
 
             LambdaExpression lambda = Expression.Lambda(bodyInitializer, LambdaScope.Parameter);
 
             return SelectExtensionMethodCall(_source, LambdaScope.Parameter.Type, lambda);
         }
 
-        private Expression CreateLambdaBodyInitializer(IDictionary<ResourceFieldAttribute, QueryLayer> selectors, ResourceContext resourceContext,
+        private Expression CreateLambdaBodyInitializer(IDictionary<ResourceFieldAttribute, QueryLayer> selectors, ResourceType resourceType,
             LambdaScope lambdaScope, bool lambdaAccessorRequiresTestForNull)
         {
-            ICollection<PropertySelector> propertySelectors = ToPropertySelectors(selectors, resourceContext, lambdaScope.Accessor.Type);
+            ICollection<PropertySelector> propertySelectors = ToPropertySelectors(selectors, resourceType, lambdaScope.Accessor.Type);
 
             MemberBinding[] propertyAssignments =
                 propertySelectors.Select(selector => CreatePropertyAssignment(selector, lambdaScope)).Cast<MemberBinding>().ToArray();
@@ -85,7 +82,7 @@ private Expression CreateLambdaBodyInitializer(IDictionary<ResourceFieldAttribut
         }
 
         private ICollection<PropertySelector> ToPropertySelectors(IDictionary<ResourceFieldAttribute, QueryLayer> resourceFieldSelectors,
-            ResourceContext resourceContext, Type elementType)
+            ResourceType resourceType, Type elementType)
         {
             var propertySelectors = new Dictionary<PropertyInfo, PropertySelector>();
 
@@ -121,7 +118,7 @@ private ICollection<PropertySelector> ToPropertySelectors(IDictionary<ResourceFi
                 }
             }
 
-            foreach (EagerLoadAttribute eagerLoad in resourceContext.EagerLoads)
+            foreach (EagerLoadAttribute eagerLoad in resourceType.EagerLoads)
             {
                 var propertySelector = new PropertySelector(eagerLoad.Property);
 
@@ -172,7 +169,7 @@ private Expression CreateAssignmentRightHandSideForLayer(QueryLayer layer, Lambd
             }
 
             using LambdaScope scope = lambdaScopeFactory.CreateScope(bodyElementType, propertyAccess);
-            return CreateLambdaBodyInitializer(layer.Projection, layer.ResourceContext, scope, true);
+            return CreateLambdaBodyInitializer(layer.Projection, layer.ResourceType, scope, true);
         }
 
         private Expression CreateCollectionInitializer(LambdaScope lambdaScope, PropertyInfo collectionProperty, Type elementType, QueryLayer layer,
@@ -180,8 +177,8 @@ private Expression CreateCollectionInitializer(LambdaScope lambdaScope, Property
         {
             MemberExpression propertyExpression = Expression.Property(lambdaScope.Accessor, collectionProperty);
 
-            var builder = new QueryableBuilder(propertyExpression, elementType, typeof(Enumerable), _nameFactory, _resourceFactory, _resourceGraph,
-                _entityModel, lambdaScopeFactory);
+            var builder = new QueryableBuilder(propertyExpression, elementType, typeof(Enumerable), _nameFactory, _resourceFactory, _entityModel,
+                lambdaScopeFactory);
 
             Expression layerExpression = builder.ApplyQuery(layer);
 
diff --git a/src/JsonApiDotNetCore/Queries/Internal/SparseFieldSetCache.cs b/src/JsonApiDotNetCore/Queries/Internal/SparseFieldSetCache.cs
index 573b19e4a4..8f745086af 100644
--- a/src/JsonApiDotNetCore/Queries/Internal/SparseFieldSetCache.cs
+++ b/src/JsonApiDotNetCore/Queries/Internal/SparseFieldSetCache.cs
@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
-using JetBrains.Annotations;
 using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Queries.Expressions;
 using JsonApiDotNetCore.Resources;
@@ -10,16 +9,12 @@
 
 namespace JsonApiDotNetCore.Queries.Internal
 {
-    /// <summary>
-    /// Takes sparse fieldsets from <see cref="IQueryConstraintProvider" />s and invokes
-    /// <see cref="IResourceDefinition{TResource,TId}.OnApplySparseFieldSet" /> on them.
-    /// </summary>
-    [PublicAPI]
-    public sealed class SparseFieldSetCache
+    /// <inheritdoc />
+    public sealed class SparseFieldSetCache : ISparseFieldSetCache
     {
         private readonly IResourceDefinitionAccessor _resourceDefinitionAccessor;
-        private readonly Lazy<IDictionary<ResourceContext, IImmutableSet<ResourceFieldAttribute>>> _lazySourceTable;
-        private readonly IDictionary<ResourceContext, IImmutableSet<ResourceFieldAttribute>> _visitedTable;
+        private readonly Lazy<IDictionary<ResourceType, IImmutableSet<ResourceFieldAttribute>>> _lazySourceTable;
+        private readonly IDictionary<ResourceType, IImmutableSet<ResourceFieldAttribute>> _visitedTable;
 
         public SparseFieldSetCache(IEnumerable<IQueryConstraintProvider> constraintProviders, IResourceDefinitionAccessor resourceDefinitionAccessor)
         {
@@ -27,17 +22,17 @@ public SparseFieldSetCache(IEnumerable<IQueryConstraintProvider> constraintProvi
             ArgumentGuard.NotNull(resourceDefinitionAccessor, nameof(resourceDefinitionAccessor));
 
             _resourceDefinitionAccessor = resourceDefinitionAccessor;
-            _lazySourceTable = new Lazy<IDictionary<ResourceContext, IImmutableSet<ResourceFieldAttribute>>>(() => BuildSourceTable(constraintProviders));
-            _visitedTable = new Dictionary<ResourceContext, IImmutableSet<ResourceFieldAttribute>>();
+            _lazySourceTable = new Lazy<IDictionary<ResourceType, IImmutableSet<ResourceFieldAttribute>>>(() => BuildSourceTable(constraintProviders));
+            _visitedTable = new Dictionary<ResourceType, IImmutableSet<ResourceFieldAttribute>>();
         }
 
-        private static IDictionary<ResourceContext, IImmutableSet<ResourceFieldAttribute>> BuildSourceTable(
+        private static IDictionary<ResourceType, IImmutableSet<ResourceFieldAttribute>> BuildSourceTable(
             IEnumerable<IQueryConstraintProvider> constraintProviders)
         {
             // @formatter:wrap_chained_method_calls chop_always
             // @formatter:keep_existing_linebreaks true
 
-            KeyValuePair<ResourceContext, SparseFieldSetExpression>[] sparseFieldTables = constraintProviders
+            KeyValuePair<ResourceType, SparseFieldSetExpression>[] sparseFieldTables = constraintProviders
                 .SelectMany(provider => provider.GetConstraints())
                 .Where(constraint => constraint.Scope == null)
                 .Select(constraint => constraint.Expression)
@@ -49,16 +44,16 @@ private static IDictionary<ResourceContext, IImmutableSet<ResourceFieldAttribute
             // @formatter:keep_existing_linebreaks restore
             // @formatter:wrap_chained_method_calls restore
 
-            var mergedTable = new Dictionary<ResourceContext, ImmutableHashSet<ResourceFieldAttribute>.Builder>();
+            var mergedTable = new Dictionary<ResourceType, ImmutableHashSet<ResourceFieldAttribute>.Builder>();
 
-            foreach ((ResourceContext resourceContext, SparseFieldSetExpression sparseFieldSet) in sparseFieldTables)
+            foreach ((ResourceType resourceType, SparseFieldSetExpression sparseFieldSet) in sparseFieldTables)
             {
-                if (!mergedTable.ContainsKey(resourceContext))
+                if (!mergedTable.ContainsKey(resourceType))
                 {
-                    mergedTable[resourceContext] = ImmutableHashSet.CreateBuilder<ResourceFieldAttribute>();
+                    mergedTable[resourceType] = ImmutableHashSet.CreateBuilder<ResourceFieldAttribute>();
                 }
 
-                AddSparseFieldsToSet(sparseFieldSet.Fields, mergedTable[resourceContext]);
+                AddSparseFieldsToSet(sparseFieldSet.Fields, mergedTable[resourceType]);
             }
 
             return mergedTable.ToDictionary(pair => pair.Key, pair => (IImmutableSet<ResourceFieldAttribute>)pair.Value.ToImmutable());
@@ -73,37 +68,39 @@ private static void AddSparseFieldsToSet(IImmutableSet<ResourceFieldAttribute> s
             }
         }
 
-        public IImmutableSet<ResourceFieldAttribute> GetSparseFieldSetForQuery(ResourceContext resourceContext)
+        /// <inheritdoc />
+        public IImmutableSet<ResourceFieldAttribute> GetSparseFieldSetForQuery(ResourceType resourceType)
         {
-            ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));
+            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
-            if (!_visitedTable.ContainsKey(resourceContext))
+            if (!_visitedTable.ContainsKey(resourceType))
             {
-                SparseFieldSetExpression inputExpression = _lazySourceTable.Value.ContainsKey(resourceContext)
-                    ? new SparseFieldSetExpression(_lazySourceTable.Value[resourceContext])
+                SparseFieldSetExpression inputExpression = _lazySourceTable.Value.ContainsKey(resourceType)
+                    ? new SparseFieldSetExpression(_lazySourceTable.Value[resourceType])
                     : null;
 
-                SparseFieldSetExpression outputExpression = _resourceDefinitionAccessor.OnApplySparseFieldSet(resourceContext.ResourceType, inputExpression);
+                SparseFieldSetExpression outputExpression = _resourceDefinitionAccessor.OnApplySparseFieldSet(resourceType, inputExpression);
 
                 IImmutableSet<ResourceFieldAttribute> outputFields = outputExpression == null
                     ? ImmutableHashSet<ResourceFieldAttribute>.Empty
                     : outputExpression.Fields;
 
-                _visitedTable[resourceContext] = outputFields;
+                _visitedTable[resourceType] = outputFields;
             }
 
-            return _visitedTable[resourceContext];
+            return _visitedTable[resourceType];
         }
 
-        public IImmutableSet<AttrAttribute> GetIdAttributeSetForRelationshipQuery(ResourceContext resourceContext)
+        /// <inheritdoc />
+        public IImmutableSet<AttrAttribute> GetIdAttributeSetForRelationshipQuery(ResourceType resourceType)
         {
-            ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));
+            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
-            AttrAttribute idAttribute = resourceContext.GetAttributeByPropertyName(nameof(Identifiable.Id));
+            AttrAttribute idAttribute = resourceType.GetAttributeByPropertyName(nameof(Identifiable.Id));
             var inputExpression = new SparseFieldSetExpression(ImmutableHashSet.Create<ResourceFieldAttribute>(idAttribute));
 
             // Intentionally not cached, as we are fetching ID only (ignoring any sparse fieldset that came from query string).
-            SparseFieldSetExpression outputExpression = _resourceDefinitionAccessor.OnApplySparseFieldSet(resourceContext.ResourceType, inputExpression);
+            SparseFieldSetExpression outputExpression = _resourceDefinitionAccessor.OnApplySparseFieldSet(resourceType, inputExpression);
 
             ImmutableHashSet<AttrAttribute> outputAttributes = outputExpression == null
                 ? ImmutableHashSet<AttrAttribute>.Empty
@@ -113,40 +110,41 @@ public IImmutableSet<AttrAttribute> GetIdAttributeSetForRelationshipQuery(Resour
             return outputAttributes;
         }
 
-        public IImmutableSet<ResourceFieldAttribute> GetSparseFieldSetForSerializer(ResourceContext resourceContext)
+        /// <inheritdoc />
+        public IImmutableSet<ResourceFieldAttribute> GetSparseFieldSetForSerializer(ResourceType resourceType)
         {
-            ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));
+            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
-            if (!_visitedTable.ContainsKey(resourceContext))
+            if (!_visitedTable.ContainsKey(resourceType))
             {
-                IImmutableSet<ResourceFieldAttribute> inputFields = _lazySourceTable.Value.ContainsKey(resourceContext)
-                    ? _lazySourceTable.Value[resourceContext]
-                    : GetResourceFields(resourceContext);
+                IImmutableSet<ResourceFieldAttribute> inputFields = _lazySourceTable.Value.ContainsKey(resourceType)
+                    ? _lazySourceTable.Value[resourceType]
+                    : GetResourceFields(resourceType);
 
                 var inputExpression = new SparseFieldSetExpression(inputFields);
-                SparseFieldSetExpression outputExpression = _resourceDefinitionAccessor.OnApplySparseFieldSet(resourceContext.ResourceType, inputExpression);
+                SparseFieldSetExpression outputExpression = _resourceDefinitionAccessor.OnApplySparseFieldSet(resourceType, inputExpression);
 
                 IImmutableSet<ResourceFieldAttribute> outputFields =
-                    outputExpression == null ? GetResourceFields(resourceContext) : inputFields.Intersect(outputExpression.Fields);
+                    outputExpression == null ? GetResourceFields(resourceType) : inputFields.Intersect(outputExpression.Fields);
 
-                _visitedTable[resourceContext] = outputFields;
+                _visitedTable[resourceType] = outputFields;
             }
 
-            return _visitedTable[resourceContext];
+            return _visitedTable[resourceType];
         }
 
-        private IImmutableSet<ResourceFieldAttribute> GetResourceFields(ResourceContext resourceContext)
+        private IImmutableSet<ResourceFieldAttribute> GetResourceFields(ResourceType resourceType)
         {
-            ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));
+            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
             ImmutableHashSet<ResourceFieldAttribute>.Builder fieldSetBuilder = ImmutableHashSet.CreateBuilder<ResourceFieldAttribute>();
 
-            foreach (AttrAttribute attribute in resourceContext.Attributes.Where(attr => attr.Capabilities.HasFlag(AttrCapabilities.AllowView)))
+            foreach (AttrAttribute attribute in resourceType.Attributes.Where(attr => attr.Capabilities.HasFlag(AttrCapabilities.AllowView)))
             {
                 fieldSetBuilder.Add(attribute);
             }
 
-            fieldSetBuilder.AddRange(resourceContext.Relationships);
+            fieldSetBuilder.AddRange(resourceType.Relationships);
 
             return fieldSetBuilder.ToImmutable();
         }
diff --git a/src/JsonApiDotNetCore/Queries/QueryLayer.cs b/src/JsonApiDotNetCore/Queries/QueryLayer.cs
index 9340181743..e8fa0e6cfa 100644
--- a/src/JsonApiDotNetCore/Queries/QueryLayer.cs
+++ b/src/JsonApiDotNetCore/Queries/QueryLayer.cs
@@ -14,7 +14,7 @@ namespace JsonApiDotNetCore.Queries
     [PublicAPI]
     public sealed class QueryLayer
     {
-        public ResourceContext ResourceContext { get; }
+        public ResourceType ResourceType { get; }
 
         public IncludeExpression Include { get; set; }
         public FilterExpression Filter { get; set; }
@@ -22,11 +22,11 @@ public sealed class QueryLayer
         public PaginationExpression Pagination { get; set; }
         public IDictionary<ResourceFieldAttribute, QueryLayer> Projection { get; set; }
 
-        public QueryLayer(ResourceContext resourceContext)
+        public QueryLayer(ResourceType resourceType)
         {
-            ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));
+            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
-            ResourceContext = resourceContext;
+            ResourceType = resourceType;
         }
 
         public override string ToString()
@@ -41,7 +41,7 @@ public override string ToString()
 
         private static void WriteLayer(IndentingStringWriter writer, QueryLayer layer, string prefix = null)
         {
-            writer.WriteLine($"{prefix}{nameof(QueryLayer)}<{layer.ResourceContext.ResourceType.Name}>");
+            writer.WriteLine($"{prefix}{nameof(QueryLayer)}<{layer.ResourceType.ClrType.Name}>");
 
             using (writer.Indent())
             {
diff --git a/src/JsonApiDotNetCore/QueryStrings/Internal/FilterQueryStringParameterReader.cs b/src/JsonApiDotNetCore/QueryStrings/Internal/FilterQueryStringParameterReader.cs
index 354cb4b8ec..9cf8ede3dc 100644
--- a/src/JsonApiDotNetCore/QueryStrings/Internal/FilterQueryStringParameterReader.cs
+++ b/src/JsonApiDotNetCore/QueryStrings/Internal/FilterQueryStringParameterReader.cs
@@ -36,11 +36,11 @@ public FilterQueryStringParameterReader(IJsonApiRequest request, IResourceGraph
             ArgumentGuard.NotNull(options, nameof(options));
 
             _options = options;
-            _scopeParser = new QueryStringParameterScopeParser(resourceGraph, FieldChainRequirements.EndsInToMany);
-            _filterParser = new FilterParser(resourceGraph, resourceFactory, ValidateSingleField);
+            _scopeParser = new QueryStringParameterScopeParser(FieldChainRequirements.EndsInToMany);
+            _filterParser = new FilterParser(resourceFactory, ValidateSingleField);
         }
 
-        protected void ValidateSingleField(ResourceFieldAttribute field, ResourceContext resourceContext, string path)
+        protected void ValidateSingleField(ResourceFieldAttribute field, ResourceType resourceType, string path)
         {
             if (field is AttrAttribute attribute && !attribute.Capabilities.HasFlag(AttrCapabilities.AllowFilter))
             {
@@ -117,7 +117,7 @@ private void ReadSingleValue(string parameterName, string parameterValue)
 
         private ResourceFieldChainExpression GetScope(string parameterName)
         {
-            QueryStringParameterScopeExpression parameterScope = _scopeParser.Parse(parameterName, RequestResource);
+            QueryStringParameterScopeExpression parameterScope = _scopeParser.Parse(parameterName, RequestResourceType);
 
             if (parameterScope.Scope == null)
             {
@@ -129,8 +129,8 @@ private ResourceFieldChainExpression GetScope(string parameterName)
 
         private FilterExpression GetFilter(string parameterValue, ResourceFieldChainExpression scope)
         {
-            ResourceContext resourceContextInScope = GetResourceContextForScope(scope);
-            return _filterParser.Parse(parameterValue, resourceContextInScope);
+            ResourceType resourceTypeInScope = GetResourceTypeForScope(scope);
+            return _filterParser.Parse(parameterValue, resourceTypeInScope);
         }
 
         private void StoreFilterInScope(FilterExpression filter, ResourceFieldChainExpression scope)
diff --git a/src/JsonApiDotNetCore/QueryStrings/Internal/IncludeQueryStringParameterReader.cs b/src/JsonApiDotNetCore/QueryStrings/Internal/IncludeQueryStringParameterReader.cs
index 2bed425170..9bdf16851a 100644
--- a/src/JsonApiDotNetCore/QueryStrings/Internal/IncludeQueryStringParameterReader.cs
+++ b/src/JsonApiDotNetCore/QueryStrings/Internal/IncludeQueryStringParameterReader.cs
@@ -27,17 +27,17 @@ public IncludeQueryStringParameterReader(IJsonApiRequest request, IResourceGraph
             ArgumentGuard.NotNull(options, nameof(options));
 
             _options = options;
-            _includeParser = new IncludeParser(resourceGraph, ValidateSingleRelationship);
+            _includeParser = new IncludeParser(ValidateSingleRelationship);
         }
 
-        protected void ValidateSingleRelationship(RelationshipAttribute relationship, ResourceContext resourceContext, string path)
+        protected void ValidateSingleRelationship(RelationshipAttribute relationship, ResourceType resourceType, string path)
         {
             if (!relationship.CanInclude)
             {
                 throw new InvalidQueryStringParameterException(_lastParameterName, "Including the requested relationship is not allowed.",
                     path == relationship.PublicName
-                        ? $"Including the relationship '{relationship.PublicName}' on '{resourceContext.PublicName}' is not allowed."
-                        : $"Including the relationship '{relationship.PublicName}' in '{path}' on '{resourceContext.PublicName}' is not allowed.");
+                        ? $"Including the relationship '{relationship.PublicName}' on '{resourceType.PublicName}' is not allowed."
+                        : $"Including the relationship '{relationship.PublicName}' in '{path}' on '{resourceType.PublicName}' is not allowed.");
             }
         }
 
@@ -72,7 +72,7 @@ public virtual void Read(string parameterName, StringValues parameterValue)
 
         private IncludeExpression GetInclude(string parameterValue)
         {
-            return _includeParser.Parse(parameterValue, RequestResource, _options.MaximumIncludeDepth);
+            return _includeParser.Parse(parameterValue, RequestResourceType, _options.MaximumIncludeDepth);
         }
 
         /// <inheritdoc />
diff --git a/src/JsonApiDotNetCore/QueryStrings/Internal/PaginationQueryStringParameterReader.cs b/src/JsonApiDotNetCore/QueryStrings/Internal/PaginationQueryStringParameterReader.cs
index 47c6ec595e..e54d9617b0 100644
--- a/src/JsonApiDotNetCore/QueryStrings/Internal/PaginationQueryStringParameterReader.cs
+++ b/src/JsonApiDotNetCore/QueryStrings/Internal/PaginationQueryStringParameterReader.cs
@@ -31,7 +31,7 @@ public PaginationQueryStringParameterReader(IJsonApiRequest request, IResourceGr
             ArgumentGuard.NotNull(options, nameof(options));
 
             _options = options;
-            _paginationParser = new PaginationParser(resourceGraph);
+            _paginationParser = new PaginationParser();
         }
 
         /// <inheritdoc />
@@ -45,7 +45,7 @@ public virtual bool IsEnabled(DisableQueryStringAttribute disableQueryStringAttr
         /// <inheritdoc />
         public virtual bool CanRead(string parameterName)
         {
-            return parameterName == PageSizeParameterName || parameterName == PageNumberParameterName;
+            return parameterName is PageSizeParameterName or PageNumberParameterName;
         }
 
         /// <inheritdoc />
@@ -79,7 +79,7 @@ public virtual void Read(string parameterName, StringValues parameterValue)
 
         private PaginationQueryStringValueExpression GetPageConstraint(string parameterValue)
         {
-            return _paginationParser.Parse(parameterValue, RequestResource);
+            return _paginationParser.Parse(parameterValue, RequestResourceType);
         }
 
         protected virtual void ValidatePageSize(PaginationQueryStringValueExpression constraint)
@@ -120,12 +120,12 @@ protected virtual void ValidatePageNumber(PaginationQueryStringValueExpression c
         /// <inheritdoc />
         public virtual IReadOnlyCollection<ExpressionInScope> GetConstraints()
         {
-            var context = new PaginationContext();
+            var paginationState = new PaginationState();
 
             foreach (PaginationElementQueryStringValueExpression element in _pageSizeConstraint?.Elements ??
                 ImmutableArray<PaginationElementQueryStringValueExpression>.Empty)
             {
-                MutablePaginationEntry entry = context.ResolveEntryInScope(element.Scope);
+                MutablePaginationEntry entry = paginationState.ResolveEntryInScope(element.Scope);
                 entry.PageSize = element.Value == 0 ? null : new PageSize(element.Value);
                 entry.HasSetPageSize = true;
             }
@@ -133,16 +133,16 @@ public virtual IReadOnlyCollection<ExpressionInScope> GetConstraints()
             foreach (PaginationElementQueryStringValueExpression element in _pageNumberConstraint?.Elements ??
                 ImmutableArray<PaginationElementQueryStringValueExpression>.Empty)
             {
-                MutablePaginationEntry entry = context.ResolveEntryInScope(element.Scope);
+                MutablePaginationEntry entry = paginationState.ResolveEntryInScope(element.Scope);
                 entry.PageNumber = new PageNumber(element.Value);
             }
 
-            context.ApplyOptions(_options);
+            paginationState.ApplyOptions(_options);
 
-            return context.GetExpressionsInScope();
+            return paginationState.GetExpressionsInScope();
         }
 
-        private sealed class PaginationContext
+        private sealed class PaginationState
         {
             private readonly MutablePaginationEntry _globalScope = new();
             private readonly Dictionary<ResourceFieldChainExpression, MutablePaginationEntry> _nestedScopes = new();
diff --git a/src/JsonApiDotNetCore/QueryStrings/Internal/QueryStringParameterReader.cs b/src/JsonApiDotNetCore/QueryStrings/Internal/QueryStringParameterReader.cs
index b026ae7587..615bf8ced8 100644
--- a/src/JsonApiDotNetCore/QueryStrings/Internal/QueryStringParameterReader.cs
+++ b/src/JsonApiDotNetCore/QueryStrings/Internal/QueryStringParameterReader.cs
@@ -1,4 +1,3 @@
-using System;
 using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Middleware;
 using JsonApiDotNetCore.Queries.Expressions;
@@ -12,7 +11,7 @@ public abstract class QueryStringParameterReader
         private readonly IResourceGraph _resourceGraph;
         private readonly bool _isCollectionRequest;
 
-        protected ResourceContext RequestResource { get; }
+        protected ResourceType RequestResourceType { get; }
         protected bool IsAtomicOperationsRequest { get; }
 
         protected QueryStringParameterReader(IJsonApiRequest request, IResourceGraph resourceGraph)
@@ -22,21 +21,25 @@ protected QueryStringParameterReader(IJsonApiRequest request, IResourceGraph res
 
             _resourceGraph = resourceGraph;
             _isCollectionRequest = request.IsCollection;
-            RequestResource = request.SecondaryResource ?? request.PrimaryResource;
+            RequestResourceType = request.SecondaryResourceType ?? request.PrimaryResourceType;
             IsAtomicOperationsRequest = request.Kind == EndpointKind.AtomicOperations;
         }
 
-        protected ResourceContext GetResourceContextForScope(ResourceFieldChainExpression scope)
+        protected ResourceType GetResourceTypeForScope(ResourceFieldChainExpression scope)
         {
             if (scope == null)
             {
-                return RequestResource;
+                return RequestResourceType;
             }
 
             ResourceFieldAttribute lastField = scope.Fields[^1];
-            Type type = lastField is RelationshipAttribute relationship ? relationship.RightType : lastField.Property.PropertyType;
 
-            return _resourceGraph.GetResourceContext(type);
+            if (lastField is RelationshipAttribute relationship)
+            {
+                return relationship.RightType;
+            }
+
+            return _resourceGraph.GetResourceType(lastField.Property.PropertyType);
         }
 
         protected void AssertIsCollectionRequest()
diff --git a/src/JsonApiDotNetCore/QueryStrings/Internal/ResourceDefinitionQueryableParameterReader.cs b/src/JsonApiDotNetCore/QueryStrings/Internal/ResourceDefinitionQueryableParameterReader.cs
index 5a3e1cab3c..98994c4c6c 100644
--- a/src/JsonApiDotNetCore/QueryStrings/Internal/ResourceDefinitionQueryableParameterReader.cs
+++ b/src/JsonApiDotNetCore/QueryStrings/Internal/ResourceDefinitionQueryableParameterReader.cs
@@ -56,8 +56,8 @@ public virtual void Read(string parameterName, StringValues parameterValue)
 
         private object GetQueryableHandler(string parameterName)
         {
-            Type resourceType = (_request.SecondaryResource ?? _request.PrimaryResource).ResourceType;
-            object handler = _resourceDefinitionAccessor.GetQueryableHandlerForQueryStringParameter(resourceType, parameterName);
+            Type resourceClrType = (_request.SecondaryResourceType ?? _request.PrimaryResourceType).ClrType;
+            object handler = _resourceDefinitionAccessor.GetQueryableHandlerForQueryStringParameter(resourceClrType, parameterName);
 
             if (handler != null && _request.Kind != EndpointKind.Primary)
             {
diff --git a/src/JsonApiDotNetCore/QueryStrings/Internal/SortQueryStringParameterReader.cs b/src/JsonApiDotNetCore/QueryStrings/Internal/SortQueryStringParameterReader.cs
index e1ca5e0cd8..c9583b5edf 100644
--- a/src/JsonApiDotNetCore/QueryStrings/Internal/SortQueryStringParameterReader.cs
+++ b/src/JsonApiDotNetCore/QueryStrings/Internal/SortQueryStringParameterReader.cs
@@ -24,11 +24,11 @@ public class SortQueryStringParameterReader : QueryStringParameterReader, ISortQ
         public SortQueryStringParameterReader(IJsonApiRequest request, IResourceGraph resourceGraph)
             : base(request, resourceGraph)
         {
-            _scopeParser = new QueryStringParameterScopeParser(resourceGraph, FieldChainRequirements.EndsInToMany);
-            _sortParser = new SortParser(resourceGraph, ValidateSingleField);
+            _scopeParser = new QueryStringParameterScopeParser(FieldChainRequirements.EndsInToMany);
+            _sortParser = new SortParser(ValidateSingleField);
         }
 
-        protected void ValidateSingleField(ResourceFieldAttribute field, ResourceContext resourceContext, string path)
+        protected void ValidateSingleField(ResourceFieldAttribute field, ResourceType resourceType, string path)
         {
             if (field is AttrAttribute attribute && !attribute.Capabilities.HasFlag(AttrCapabilities.AllowSort))
             {
@@ -75,7 +75,7 @@ public virtual void Read(string parameterName, StringValues parameterValue)
 
         private ResourceFieldChainExpression GetScope(string parameterName)
         {
-            QueryStringParameterScopeExpression parameterScope = _scopeParser.Parse(parameterName, RequestResource);
+            QueryStringParameterScopeExpression parameterScope = _scopeParser.Parse(parameterName, RequestResourceType);
 
             if (parameterScope.Scope == null)
             {
@@ -87,8 +87,8 @@ private ResourceFieldChainExpression GetScope(string parameterName)
 
         private SortExpression GetSort(string parameterValue, ResourceFieldChainExpression scope)
         {
-            ResourceContext resourceContextInScope = GetResourceContextForScope(scope);
-            return _sortParser.Parse(parameterValue, resourceContextInScope);
+            ResourceType resourceTypeInScope = GetResourceTypeForScope(scope);
+            return _sortParser.Parse(parameterValue, resourceTypeInScope);
         }
 
         /// <inheritdoc />
diff --git a/src/JsonApiDotNetCore/QueryStrings/Internal/SparseFieldSetQueryStringParameterReader.cs b/src/JsonApiDotNetCore/QueryStrings/Internal/SparseFieldSetQueryStringParameterReader.cs
index 096b31a7a1..2872351bd9 100644
--- a/src/JsonApiDotNetCore/QueryStrings/Internal/SparseFieldSetQueryStringParameterReader.cs
+++ b/src/JsonApiDotNetCore/QueryStrings/Internal/SparseFieldSetQueryStringParameterReader.cs
@@ -22,8 +22,8 @@ public class SparseFieldSetQueryStringParameterReader : QueryStringParameterRead
         private readonly SparseFieldTypeParser _sparseFieldTypeParser;
         private readonly SparseFieldSetParser _sparseFieldSetParser;
 
-        private readonly ImmutableDictionary<ResourceContext, SparseFieldSetExpression>.Builder _sparseFieldTableBuilder =
-            ImmutableDictionary.CreateBuilder<ResourceContext, SparseFieldSetExpression>();
+        private readonly ImmutableDictionary<ResourceType, SparseFieldSetExpression>.Builder _sparseFieldTableBuilder =
+            ImmutableDictionary.CreateBuilder<ResourceType, SparseFieldSetExpression>();
 
         private string _lastParameterName;
 
@@ -34,10 +34,10 @@ public SparseFieldSetQueryStringParameterReader(IJsonApiRequest request, IResour
             : base(request, resourceGraph)
         {
             _sparseFieldTypeParser = new SparseFieldTypeParser(resourceGraph);
-            _sparseFieldSetParser = new SparseFieldSetParser(resourceGraph, ValidateSingleField);
+            _sparseFieldSetParser = new SparseFieldSetParser(ValidateSingleField);
         }
 
-        protected void ValidateSingleField(ResourceFieldAttribute field, ResourceContext resourceContext, string path)
+        protected void ValidateSingleField(ResourceFieldAttribute field, ResourceType resourceType, string path)
         {
             if (field is AttrAttribute attribute && !attribute.Capabilities.HasFlag(AttrCapabilities.AllowView))
             {
@@ -69,7 +69,7 @@ public virtual void Read(string parameterName, StringValues parameterValue)
 
             try
             {
-                ResourceContext targetResource = GetSparseFieldType(parameterName);
+                ResourceType targetResource = GetSparseFieldType(parameterName);
                 SparseFieldSetExpression sparseFieldSet = GetSparseFieldSet(parameterValue, targetResource);
 
                 _sparseFieldTableBuilder[targetResource] = sparseFieldSet;
@@ -80,19 +80,19 @@ public virtual void Read(string parameterName, StringValues parameterValue)
             }
         }
 
-        private ResourceContext GetSparseFieldType(string parameterName)
+        private ResourceType GetSparseFieldType(string parameterName)
         {
             return _sparseFieldTypeParser.Parse(parameterName);
         }
 
-        private SparseFieldSetExpression GetSparseFieldSet(string parameterValue, ResourceContext resourceContext)
+        private SparseFieldSetExpression GetSparseFieldSet(string parameterValue, ResourceType resourceType)
         {
-            SparseFieldSetExpression sparseFieldSet = _sparseFieldSetParser.Parse(parameterValue, resourceContext);
+            SparseFieldSetExpression sparseFieldSet = _sparseFieldSetParser.Parse(parameterValue, resourceType);
 
             if (sparseFieldSet == null)
             {
                 // We add ID on an incoming empty fieldset, so that callers can distinguish between no fieldset and an empty one.
-                AttrAttribute idAttribute = resourceContext.GetAttributeByPropertyName(nameof(Identifiable.Id));
+                AttrAttribute idAttribute = resourceType.GetAttributeByPropertyName(nameof(Identifiable.Id));
                 return new SparseFieldSetExpression(ImmutableHashSet.Create<ResourceFieldAttribute>(idAttribute));
             }
 
diff --git a/src/JsonApiDotNetCore/Repositories/DbContextExtensions.cs b/src/JsonApiDotNetCore/Repositories/DbContextExtensions.cs
index 4610beb0e6..f80bb3833c 100644
--- a/src/JsonApiDotNetCore/Repositories/DbContextExtensions.cs
+++ b/src/JsonApiDotNetCore/Repositories/DbContextExtensions.cs
@@ -37,17 +37,17 @@ public static object GetTrackedIdentifiable(this DbContext dbContext, IIdentifia
             ArgumentGuard.NotNull(dbContext, nameof(dbContext));
             ArgumentGuard.NotNull(identifiable, nameof(identifiable));
 
-            Type resourceType = identifiable.GetType();
+            Type resourceClrType = identifiable.GetType();
             string stringId = identifiable.StringId;
 
-            EntityEntry entityEntry = dbContext.ChangeTracker.Entries().FirstOrDefault(entry => IsResource(entry, resourceType, stringId));
+            EntityEntry entityEntry = dbContext.ChangeTracker.Entries().FirstOrDefault(entry => IsResource(entry, resourceClrType, stringId));
 
             return entityEntry?.Entity;
         }
 
-        private static bool IsResource(EntityEntry entry, Type resourceType, string stringId)
+        private static bool IsResource(EntityEntry entry, Type resourceClrType, string stringId)
         {
-            return entry.Entity.GetType() == resourceType && ((IIdentifiable)entry.Entity).StringId == stringId;
+            return entry.Entity.GetType() == resourceClrType && ((IIdentifiable)entry.Entity).StringId == stringId;
         }
 
         /// <summary>
diff --git a/src/JsonApiDotNetCore/Repositories/DbContextResolver.cs b/src/JsonApiDotNetCore/Repositories/DbContextResolver.cs
index 4e1c7b4552..61dfcb388d 100644
--- a/src/JsonApiDotNetCore/Repositories/DbContextResolver.cs
+++ b/src/JsonApiDotNetCore/Repositories/DbContextResolver.cs
@@ -8,23 +8,23 @@ namespace JsonApiDotNetCore.Repositories
     public sealed class DbContextResolver<TDbContext> : IDbContextResolver
         where TDbContext : DbContext
     {
-        private readonly TDbContext _context;
+        private readonly TDbContext _dbContext;
 
-        public DbContextResolver(TDbContext context)
+        public DbContextResolver(TDbContext dbContext)
         {
-            ArgumentGuard.NotNull(context, nameof(context));
+            ArgumentGuard.NotNull(dbContext, nameof(dbContext));
 
-            _context = context;
+            _dbContext = dbContext;
         }
 
         public DbContext GetContext()
         {
-            return _context;
+            return _dbContext;
         }
 
         public TDbContext GetTypedContext()
         {
-            return _context;
+            return _dbContext;
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Repositories/EntityFrameworkCoreRepository.cs b/src/JsonApiDotNetCore/Repositories/EntityFrameworkCoreRepository.cs
index c6ba15f10d..802d9cb100 100644
--- a/src/JsonApiDotNetCore/Repositories/EntityFrameworkCoreRepository.cs
+++ b/src/JsonApiDotNetCore/Repositories/EntityFrameworkCoreRepository.cs
@@ -41,12 +41,12 @@ public class EntityFrameworkCoreRepository<TResource, TId> : IResourceRepository
         /// <inheritdoc />
         public virtual string TransactionId => _dbContext.Database.CurrentTransaction?.TransactionId.ToString();
 
-        public EntityFrameworkCoreRepository(ITargetedFields targetedFields, IDbContextResolver contextResolver, IResourceGraph resourceGraph,
+        public EntityFrameworkCoreRepository(ITargetedFields targetedFields, IDbContextResolver dbContextResolver, IResourceGraph resourceGraph,
             IResourceFactory resourceFactory, IEnumerable<IQueryConstraintProvider> constraintProviders, ILoggerFactory loggerFactory,
             IResourceDefinitionAccessor resourceDefinitionAccessor)
         {
             ArgumentGuard.NotNull(targetedFields, nameof(targetedFields));
-            ArgumentGuard.NotNull(contextResolver, nameof(contextResolver));
+            ArgumentGuard.NotNull(dbContextResolver, nameof(dbContextResolver));
             ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
             ArgumentGuard.NotNull(resourceFactory, nameof(resourceFactory));
             ArgumentGuard.NotNull(constraintProviders, nameof(constraintProviders));
@@ -54,7 +54,7 @@ public EntityFrameworkCoreRepository(ITargetedFields targetedFields, IDbContextR
             ArgumentGuard.NotNull(resourceDefinitionAccessor, nameof(resourceDefinitionAccessor));
 
             _targetedFields = targetedFields;
-            _dbContext = contextResolver.GetContext();
+            _dbContext = dbContextResolver.GetContext();
             _resourceGraph = resourceGraph;
             _resourceFactory = resourceFactory;
             _constraintProviders = constraintProviders;
@@ -93,9 +93,9 @@ public virtual async Task<int> CountAsync(FilterExpression topFilter, Cancellati
 
             using (CodeTimingSessionManager.Current.Measure("Repository - Count resources"))
             {
-                ResourceContext resourceContext = _resourceGraph.GetResourceContext<TResource>();
+                ResourceType resourceType = _resourceGraph.GetResourceType<TResource>();
 
-                var layer = new QueryLayer(resourceContext)
+                var layer = new QueryLayer(resourceType)
                 {
                     Filter = topFilter
                 };
@@ -142,8 +142,7 @@ protected virtual IQueryable<TResource> ApplyQueryLayer(QueryLayer layer)
 
                 var nameFactory = new LambdaParameterNameFactory();
 
-                var builder = new QueryableBuilder(source.Expression, source.ElementType, typeof(Queryable), nameFactory, _resourceFactory, _resourceGraph,
-                    _dbContext.Model);
+                var builder = new QueryableBuilder(source.Expression, source.ElementType, typeof(Queryable), nameFactory, _resourceFactory, _dbContext.Model);
 
                 Expression expression = builder.ApplyQuery(layer);
 
@@ -297,8 +296,8 @@ protected void AssertIsNotClearingRequiredRelationship(RelationshipAttribute rel
 
             if (relationshipIsRequired && relationshipIsBeingCleared)
             {
-                string resourceType = _resourceGraph.GetResourceContext<TResource>().PublicName;
-                throw new CannotClearRequiredRelationshipException(relationship.PublicName, leftResource.StringId, resourceType);
+                string resourceName = _resourceGraph.GetResourceType<TResource>().PublicName;
+                throw new CannotClearRequiredRelationshipException(relationship.PublicName, leftResource.StringId, resourceName);
             }
         }
 
@@ -335,7 +334,7 @@ public virtual async Task DeleteAsync(TId id, CancellationToken cancellationToke
 
             var resourceTracked = (TResource)_dbContext.GetTrackedOrAttach(placeholderResource);
 
-            foreach (RelationshipAttribute relationship in _resourceGraph.GetResourceContext<TResource>().Relationships)
+            foreach (RelationshipAttribute relationship in _resourceGraph.GetResourceType<TResource>().Relationships)
             {
                 // Loads the data of the relationship, if in EF Core it is configured in such a way that loading the related
                 // entities into memory is required for successfully executing the selected deletion behavior.
@@ -570,7 +569,7 @@ protected virtual async Task SaveChangesAsync(CancellationToken cancellationToke
 
                 await _dbContext.SaveChangesAsync(cancellationToken);
             }
-            catch (Exception exception) when (exception is DbUpdateException || exception is InvalidOperationException)
+            catch (Exception exception) when (exception is DbUpdateException or InvalidOperationException)
             {
                 if (_dbContext.Database.CurrentTransaction != null)
                 {
@@ -593,10 +592,10 @@ protected virtual async Task SaveChangesAsync(CancellationToken cancellationToke
     public class EntityFrameworkCoreRepository<TResource> : EntityFrameworkCoreRepository<TResource, int>, IResourceRepository<TResource>
         where TResource : class, IIdentifiable<int>
     {
-        public EntityFrameworkCoreRepository(ITargetedFields targetedFields, IDbContextResolver contextResolver, IResourceGraph resourceGraph,
+        public EntityFrameworkCoreRepository(ITargetedFields targetedFields, IDbContextResolver dbContextResolver, IResourceGraph resourceGraph,
             IResourceFactory resourceFactory, IEnumerable<IQueryConstraintProvider> constraintProviders, ILoggerFactory loggerFactory,
             IResourceDefinitionAccessor resourceDefinitionAccessor)
-            : base(targetedFields, contextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
+            : base(targetedFields, dbContextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
         {
         }
     }
diff --git a/src/JsonApiDotNetCore/Repositories/IResourceRepositoryAccessor.cs b/src/JsonApiDotNetCore/Repositories/IResourceRepositoryAccessor.cs
index 4925697112..bf67a0a480 100644
--- a/src/JsonApiDotNetCore/Repositories/IResourceRepositoryAccessor.cs
+++ b/src/JsonApiDotNetCore/Repositories/IResourceRepositoryAccessor.cs
@@ -1,7 +1,7 @@
-using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
+using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Queries;
 using JsonApiDotNetCore.Queries.Expressions;
 using JsonApiDotNetCore.Resources;
@@ -22,7 +22,7 @@ Task<IReadOnlyCollection<TResource>> GetAsync<TResource>(QueryLayer layer, Cance
         /// <summary>
         /// Invokes <see cref="IResourceReadRepository{TResource,TId}.GetAsync" /> for the specified resource type.
         /// </summary>
-        Task<IReadOnlyCollection<IIdentifiable>> GetAsync(Type resourceType, QueryLayer layer, CancellationToken cancellationToken);
+        Task<IReadOnlyCollection<IIdentifiable>> GetAsync(ResourceType resourceType, QueryLayer layer, CancellationToken cancellationToken);
 
         /// <summary>
         /// Invokes <see cref="IResourceReadRepository{TResource,TId}.CountAsync" /> for the specified resource type.
diff --git a/src/JsonApiDotNetCore/Repositories/ResourceRepositoryAccessor.cs b/src/JsonApiDotNetCore/Repositories/ResourceRepositoryAccessor.cs
index d1ccdb418d..1e71016a15 100644
--- a/src/JsonApiDotNetCore/Repositories/ResourceRepositoryAccessor.cs
+++ b/src/JsonApiDotNetCore/Repositories/ResourceRepositoryAccessor.cs
@@ -41,7 +41,7 @@ public async Task<IReadOnlyCollection<TResource>> GetAsync<TResource>(QueryLayer
         }
 
         /// <inheritdoc />
-        public async Task<IReadOnlyCollection<IIdentifiable>> GetAsync(Type resourceType, QueryLayer layer, CancellationToken cancellationToken)
+        public async Task<IReadOnlyCollection<IIdentifiable>> GetAsync(ResourceType resourceType, QueryLayer layer, CancellationToken cancellationToken)
         {
             ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
@@ -122,13 +122,17 @@ public async Task RemoveFromToManyRelationshipAsync<TResource>(TResource leftRes
             await repository.RemoveFromToManyRelationshipAsync(leftResource, rightResourceIds, cancellationToken);
         }
 
-        protected virtual object ResolveReadRepository(Type resourceType)
+        protected object ResolveReadRepository(Type resourceClrType)
         {
-            ResourceContext resourceContext = _resourceGraph.GetResourceContext(resourceType);
+            ResourceType resourceType = _resourceGraph.GetResourceType(resourceClrType);
+            return ResolveReadRepository(resourceType);
+        }
 
-            if (resourceContext.IdentityType == typeof(int))
+        protected virtual object ResolveReadRepository(ResourceType resourceType)
+        {
+            if (resourceType.IdentityClrType == typeof(int))
             {
-                Type intRepositoryType = typeof(IResourceReadRepository<>).MakeGenericType(resourceContext.ResourceType);
+                Type intRepositoryType = typeof(IResourceReadRepository<>).MakeGenericType(resourceType.ClrType);
                 object intRepository = _serviceProvider.GetService(intRepositoryType);
 
                 if (intRepository != null)
@@ -137,20 +141,20 @@ protected virtual object ResolveReadRepository(Type resourceType)
                 }
             }
 
-            Type resourceDefinitionType = typeof(IResourceReadRepository<,>).MakeGenericType(resourceContext.ResourceType, resourceContext.IdentityType);
+            Type resourceDefinitionType = typeof(IResourceReadRepository<,>).MakeGenericType(resourceType.ClrType, resourceType.IdentityClrType);
             return _serviceProvider.GetRequiredService(resourceDefinitionType);
         }
 
-        private object GetWriteRepository(Type resourceType)
+        private object GetWriteRepository(Type resourceClrType)
         {
-            object writeRepository = ResolveWriteRepository(resourceType);
+            object writeRepository = ResolveWriteRepository(resourceClrType);
 
             if (_request.TransactionId != null)
             {
                 if (writeRepository is not IRepositorySupportsTransaction repository)
                 {
-                    ResourceContext resourceContext = _resourceGraph.GetResourceContext(resourceType);
-                    throw new MissingTransactionSupportException(resourceContext.PublicName);
+                    ResourceType resourceType = _resourceGraph.GetResourceType(resourceClrType);
+                    throw new MissingTransactionSupportException(resourceType.PublicName);
                 }
 
                 if (repository.TransactionId != _request.TransactionId)
@@ -162,13 +166,13 @@ private object GetWriteRepository(Type resourceType)
             return writeRepository;
         }
 
-        protected virtual object ResolveWriteRepository(Type resourceType)
+        protected virtual object ResolveWriteRepository(Type resourceClrType)
         {
-            ResourceContext resourceContext = _resourceGraph.GetResourceContext(resourceType);
+            ResourceType resourceType = _resourceGraph.GetResourceType(resourceClrType);
 
-            if (resourceContext.IdentityType == typeof(int))
+            if (resourceType.IdentityClrType == typeof(int))
             {
-                Type intRepositoryType = typeof(IResourceWriteRepository<>).MakeGenericType(resourceContext.ResourceType);
+                Type intRepositoryType = typeof(IResourceWriteRepository<>).MakeGenericType(resourceType.ClrType);
                 object intRepository = _serviceProvider.GetService(intRepositoryType);
 
                 if (intRepository != null)
@@ -177,7 +181,7 @@ protected virtual object ResolveWriteRepository(Type resourceType)
                 }
             }
 
-            Type resourceDefinitionType = typeof(IResourceWriteRepository<,>).MakeGenericType(resourceContext.ResourceType, resourceContext.IdentityType);
+            Type resourceDefinitionType = typeof(IResourceWriteRepository<,>).MakeGenericType(resourceType.ClrType, resourceType.IdentityClrType);
             return _serviceProvider.GetRequiredService(resourceDefinitionType);
         }
     }
diff --git a/src/JsonApiDotNetCore/Resources/Annotations/RelationshipAttribute.cs b/src/JsonApiDotNetCore/Resources/Annotations/RelationshipAttribute.cs
index eaeb10360d..732da4c4fc 100644
--- a/src/JsonApiDotNetCore/Resources/Annotations/RelationshipAttribute.cs
+++ b/src/JsonApiDotNetCore/Resources/Annotations/RelationshipAttribute.cs
@@ -16,19 +16,36 @@ public abstract class RelationshipAttribute : ResourceFieldAttribute
         private protected static readonly CollectionConverter CollectionConverter = new();
 
         /// <summary>
-        /// The property name of the EF Core inverse navigation, which may or may not exist. Even if it exists, it may not be exposed as a JSON:API relationship.
+        /// The CLR type in which this relationship is declared.
+        /// </summary>
+        internal Type LeftClrType { get; set; }
+
+        /// <summary>
+        /// The CLR type this relationship points to. In the case of a <see cref="HasManyAttribute" /> relationship, this value will be the collection element
+        /// type.
+        /// </summary>
+        /// <example>
+        /// <code><![CDATA[
+        /// public ISet<Tag> Tags { get; set; } // RightClrType: typeof(Tag)
+        /// ]]></code>
+        /// </example>
+        internal Type RightClrType { get; set; }
+
+        /// <summary>
+        /// The <see cref="PropertyInfo" /> of the EF Core inverse navigation, which may or may not exist. Even if it exists, it may not be exposed as a JSON:API
+        /// relationship.
         /// </summary>
         /// <example>
         /// <code><![CDATA[
         /// public class Article : Identifiable
         /// {
-        ///     [HasOne] // InverseNavigationProperty = Person.Articles
+        ///     [HasOne] // InverseNavigationProperty: Person.Articles
         ///     public Person Owner { get; set; }
         /// }
         /// 
         /// public class Person : Identifiable
         /// {
-        ///     [HasMany] // InverseNavigationProperty = Article.Owner
+        ///     [HasMany] // InverseNavigationProperty: Article.Owner
         ///     public ICollection<Article> Articles { get; set; }
         /// }
         /// ]]></code>
@@ -36,20 +53,15 @@ public abstract class RelationshipAttribute : ResourceFieldAttribute
         public PropertyInfo InverseNavigationProperty { get; set; }
 
         /// <summary>
-        /// The containing type in which this relationship is declared.
+        /// The containing resource type in which this relationship is declared.
         /// </summary>
-        public Type LeftType { get; internal set; }
+        public ResourceType LeftType { get; internal set; }
 
         /// <summary>
-        /// The type this relationship points to. This does not necessarily match the relationship property type. In the case of a
-        /// <see cref="HasManyAttribute" /> relationship, this value will be the collection element type.
+        /// The resource type this relationship points to. In the case of a <see cref="HasManyAttribute" /> relationship, this value will be the collection
+        /// element type.
         /// </summary>
-        /// <example>
-        /// <code><![CDATA[
-        /// public List<Tag> Tags { get; set; } // RightType == typeof(Tag)
-        /// ]]></code>
-        /// </example>
-        public Type RightType { get; internal set; }
+        public ResourceType RightType { get; internal set; }
 
         /// <summary>
         /// Configures which links to show in the <see cref="Serialization.Objects.RelationshipLinks" /> object for this relationship. Defaults to
@@ -101,12 +113,13 @@ public override bool Equals(object obj)
 
             var other = (RelationshipAttribute)obj;
 
-            return LeftType == other.LeftType && RightType == other.RightType && Links == other.Links && CanInclude == other.CanInclude && base.Equals(other);
+            return LeftClrType == other.LeftClrType && RightClrType == other.RightClrType && Links == other.Links && CanInclude == other.CanInclude &&
+                base.Equals(other);
         }
 
         public override int GetHashCode()
         {
-            return HashCode.Combine(LeftType, RightType, Links, CanInclude, base.GetHashCode());
+            return HashCode.Combine(LeftClrType, RightClrType, Links, CanInclude, base.GetHashCode());
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Resources/IResourceDefinition.cs b/src/JsonApiDotNetCore/Resources/IResourceDefinition.cs
index 4fae023853..a310790fdc 100644
--- a/src/JsonApiDotNetCore/Resources/IResourceDefinition.cs
+++ b/src/JsonApiDotNetCore/Resources/IResourceDefinition.cs
@@ -44,7 +44,7 @@ public interface IResourceDefinition<TResource, in TId>
         /// <returns>
         /// The new set of includes. Return an empty collection to remove all inclusions (never return <c>null</c>).
         /// </returns>
-        IImmutableList<IncludeElementExpression> OnApplyIncludes(IImmutableList<IncludeElementExpression> existingIncludes);
+        IImmutableSet<IncludeElementExpression> OnApplyIncludes(IImmutableSet<IncludeElementExpression> existingIncludes);
 
         /// <summary>
         /// Enables to extend, replace or remove a filter that is being applied on a set of this resource type.
diff --git a/src/JsonApiDotNetCore/Resources/IResourceDefinitionAccessor.cs b/src/JsonApiDotNetCore/Resources/IResourceDefinitionAccessor.cs
index 8c804d3602..c4b91365bd 100644
--- a/src/JsonApiDotNetCore/Resources/IResourceDefinitionAccessor.cs
+++ b/src/JsonApiDotNetCore/Resources/IResourceDefinitionAccessor.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Middleware;
 using JsonApiDotNetCore.Queries.Expressions;
 using JsonApiDotNetCore.Resources.Annotations;
@@ -18,38 +19,38 @@ public interface IResourceDefinitionAccessor
         /// <summary>
         /// Invokes <see cref="IResourceDefinition{TResource,TId}.OnApplyIncludes" /> for the specified resource type.
         /// </summary>
-        IImmutableList<IncludeElementExpression> OnApplyIncludes(Type resourceType, IImmutableList<IncludeElementExpression> existingIncludes);
+        IImmutableSet<IncludeElementExpression> OnApplyIncludes(ResourceType resourceType, IImmutableSet<IncludeElementExpression> existingIncludes);
 
         /// <summary>
         /// Invokes <see cref="IResourceDefinition{TResource,TId}.OnApplyFilter" /> for the specified resource type.
         /// </summary>
-        FilterExpression OnApplyFilter(Type resourceType, FilterExpression existingFilter);
+        FilterExpression OnApplyFilter(ResourceType resourceType, FilterExpression existingFilter);
 
         /// <summary>
         /// Invokes <see cref="IResourceDefinition{TResource,TId}.OnApplySort" /> for the specified resource type.
         /// </summary>
-        SortExpression OnApplySort(Type resourceType, SortExpression existingSort);
+        SortExpression OnApplySort(ResourceType resourceType, SortExpression existingSort);
 
         /// <summary>
         /// Invokes <see cref="IResourceDefinition{TResource,TId}.OnApplyPagination" /> for the specified resource type.
         /// </summary>
-        PaginationExpression OnApplyPagination(Type resourceType, PaginationExpression existingPagination);
+        PaginationExpression OnApplyPagination(ResourceType resourceType, PaginationExpression existingPagination);
 
         /// <summary>
         /// Invokes <see cref="IResourceDefinition{TResource,TId}.OnApplySparseFieldSet" /> for the specified resource type.
         /// </summary>
-        SparseFieldSetExpression OnApplySparseFieldSet(Type resourceType, SparseFieldSetExpression existingSparseFieldSet);
+        SparseFieldSetExpression OnApplySparseFieldSet(ResourceType resourceType, SparseFieldSetExpression existingSparseFieldSet);
 
         /// <summary>
         /// Invokes <see cref="IResourceDefinition{TResource,TId}.OnRegisterQueryableHandlersForQueryStringParameters" /> for the specified resource type, then
         /// returns the <see cref="IQueryable{T}" /> expression for the specified parameter name.
         /// </summary>
-        object GetQueryableHandlerForQueryStringParameter(Type resourceType, string parameterName);
+        object GetQueryableHandlerForQueryStringParameter(Type resourceClrType, string parameterName);
 
         /// <summary>
         /// Invokes <see cref="IResourceDefinition{TResource,TId}.GetMeta" /> for the specified resource.
         /// </summary>
-        IDictionary<string, object> GetMeta(Type resourceType, IIdentifiable resourceInstance);
+        IDictionary<string, object> GetMeta(ResourceType resourceType, IIdentifiable resourceInstance);
 
         /// <summary>
         /// Invokes <see cref="IResourceDefinition{TResource,TId}.OnPrepareWriteAsync" /> for the specified resource.
diff --git a/src/JsonApiDotNetCore/Resources/IResourceFactory.cs b/src/JsonApiDotNetCore/Resources/IResourceFactory.cs
index 38a25ad996..1e37304528 100644
--- a/src/JsonApiDotNetCore/Resources/IResourceFactory.cs
+++ b/src/JsonApiDotNetCore/Resources/IResourceFactory.cs
@@ -11,7 +11,7 @@ public interface IResourceFactory
         /// <summary>
         /// Creates a new resource object instance.
         /// </summary>
-        public IIdentifiable CreateInstance(Type resourceType);
+        public IIdentifiable CreateInstance(Type resourceClrType);
 
         /// <summary>
         /// Creates a new resource object instance.
@@ -22,6 +22,6 @@ public TResource CreateInstance<TResource>()
         /// <summary>
         /// Returns an expression tree that represents creating a new resource object instance.
         /// </summary>
-        public NewExpression CreateNewExpression(Type resourceType);
+        public NewExpression CreateNewExpression(Type resourceClrType);
     }
 }
diff --git a/src/JsonApiDotNetCore/Resources/ITargetedFields.cs b/src/JsonApiDotNetCore/Resources/ITargetedFields.cs
index 5cdb36950d..1498f96744 100644
--- a/src/JsonApiDotNetCore/Resources/ITargetedFields.cs
+++ b/src/JsonApiDotNetCore/Resources/ITargetedFields.cs
@@ -4,18 +4,23 @@
 namespace JsonApiDotNetCore.Resources
 {
     /// <summary>
-    /// Container to register which resource attributes and relationships are targeted by a request.
+    /// Container to register which resource fields (attributes and relationships) are targeted by a request.
     /// </summary>
     public interface ITargetedFields
     {
         /// <summary>
         /// The set of attributes that are targeted by a request.
         /// </summary>
-        ISet<AttrAttribute> Attributes { get; set; }
+        IReadOnlySet<AttrAttribute> Attributes { get; }
 
         /// <summary>
         /// The set of relationships that are targeted by a request.
         /// </summary>
-        ISet<RelationshipAttribute> Relationships { get; set; }
+        IReadOnlySet<RelationshipAttribute> Relationships { get; }
+
+        /// <summary>
+        /// Performs a shallow copy.
+        /// </summary>
+        void CopyFrom(ITargetedFields other);
     }
 }
diff --git a/src/JsonApiDotNetCore/Resources/Internal/RuntimeTypeConverter.cs b/src/JsonApiDotNetCore/Resources/Internal/RuntimeTypeConverter.cs
index f7aaad9192..826b375bd3 100644
--- a/src/JsonApiDotNetCore/Resources/Internal/RuntimeTypeConverter.cs
+++ b/src/JsonApiDotNetCore/Resources/Internal/RuntimeTypeConverter.cs
@@ -71,8 +71,7 @@ public static object ConvertType(object value, Type type)
                 // https://bradwilson.typepad.com/blog/2008/07/creating-nullab.html
                 return Convert.ChangeType(stringValue, nonNullableType);
             }
-            catch (Exception exception) when (exception is FormatException || exception is OverflowException || exception is InvalidCastException ||
-                exception is ArgumentException)
+            catch (Exception exception) when (exception is FormatException or OverflowException or InvalidCastException or ArgumentException)
             {
                 string runtimeTypeName = runtimeType.GetFriendlyTypeName();
                 string targetTypeName = type.GetFriendlyTypeName();
diff --git a/src/JsonApiDotNetCore/Resources/JsonApiResourceDefinition.cs b/src/JsonApiDotNetCore/Resources/JsonApiResourceDefinition.cs
index 755ce781cb..b4110b28cd 100644
--- a/src/JsonApiDotNetCore/Resources/JsonApiResourceDefinition.cs
+++ b/src/JsonApiDotNetCore/Resources/JsonApiResourceDefinition.cs
@@ -41,18 +41,18 @@ public class JsonApiResourceDefinition<TResource, TId> : IResourceDefinition<TRe
         /// <summary>
         /// Provides metadata for the resource type <typeparamref name="TResource" />.
         /// </summary>
-        protected ResourceContext ResourceContext { get; }
+        protected ResourceType ResourceType { get; }
 
         public JsonApiResourceDefinition(IResourceGraph resourceGraph)
         {
             ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
 
             ResourceGraph = resourceGraph;
-            ResourceContext = resourceGraph.GetResourceContext<TResource>();
+            ResourceType = resourceGraph.GetResourceType<TResource>();
         }
 
         /// <inheritdoc />
-        public virtual IImmutableList<IncludeElementExpression> OnApplyIncludes(IImmutableList<IncludeElementExpression> existingIncludes)
+        public virtual IImmutableSet<IncludeElementExpression> OnApplyIncludes(IImmutableSet<IncludeElementExpression> existingIncludes)
         {
             return existingIncludes;
         }
diff --git a/src/JsonApiDotNetCore/Resources/OperationContainer.cs b/src/JsonApiDotNetCore/Resources/OperationContainer.cs
index d5350a34dc..ada612de59 100644
--- a/src/JsonApiDotNetCore/Resources/OperationContainer.cs
+++ b/src/JsonApiDotNetCore/Resources/OperationContainer.cs
@@ -13,18 +13,16 @@ public sealed class OperationContainer
     {
         private static readonly CollectionConverter CollectionConverter = new();
 
-        public WriteOperationKind Kind { get; }
         public IIdentifiable Resource { get; }
         public ITargetedFields TargetedFields { get; }
         public IJsonApiRequest Request { get; }
 
-        public OperationContainer(WriteOperationKind kind, IIdentifiable resource, ITargetedFields targetedFields, IJsonApiRequest request)
+        public OperationContainer(IIdentifiable resource, ITargetedFields targetedFields, IJsonApiRequest request)
         {
             ArgumentGuard.NotNull(resource, nameof(resource));
             ArgumentGuard.NotNull(targetedFields, nameof(targetedFields));
             ArgumentGuard.NotNull(request, nameof(request));
 
-            Kind = kind;
             Resource = resource;
             TargetedFields = targetedFields;
             Request = request;
@@ -39,7 +37,7 @@ public OperationContainer WithResource(IIdentifiable resource)
         {
             ArgumentGuard.NotNull(resource, nameof(resource));
 
-            return new OperationContainer(Kind, resource, TargetedFields, Request);
+            return new OperationContainer(resource, TargetedFields, Request);
         }
 
         public ISet<IIdentifiable> GetSecondaryResources()
diff --git a/src/JsonApiDotNetCore/Resources/ResourceChangeTracker.cs b/src/JsonApiDotNetCore/Resources/ResourceChangeTracker.cs
index b29fe33ef1..1158df6183 100644
--- a/src/JsonApiDotNetCore/Resources/ResourceChangeTracker.cs
+++ b/src/JsonApiDotNetCore/Resources/ResourceChangeTracker.cs
@@ -11,7 +11,7 @@ namespace JsonApiDotNetCore.Resources
     public sealed class ResourceChangeTracker<TResource> : IResourceChangeTracker<TResource>
         where TResource : class, IIdentifiable
     {
-        private readonly IResourceGraph _resourceGraph;
+        private readonly ResourceType _resourceType;
         private readonly ITargetedFields _targetedFields;
 
         private IDictionary<string, string> _initiallyStoredAttributeValues;
@@ -23,7 +23,7 @@ public ResourceChangeTracker(IResourceGraph resourceGraph, ITargetedFields targe
             ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
             ArgumentGuard.NotNull(targetedFields, nameof(targetedFields));
 
-            _resourceGraph = resourceGraph;
+            _resourceType = resourceGraph.GetResourceType<TResource>();
             _targetedFields = targetedFields;
         }
 
@@ -32,8 +32,7 @@ public void SetInitiallyStoredAttributeValues(TResource resource)
         {
             ArgumentGuard.NotNull(resource, nameof(resource));
 
-            ResourceContext resourceContext = _resourceGraph.GetResourceContext<TResource>();
-            _initiallyStoredAttributeValues = CreateAttributeDictionary(resource, resourceContext.Attributes);
+            _initiallyStoredAttributeValues = CreateAttributeDictionary(resource, _resourceType.Attributes);
         }
 
         /// <inheritdoc />
@@ -49,8 +48,7 @@ public void SetFinallyStoredAttributeValues(TResource resource)
         {
             ArgumentGuard.NotNull(resource, nameof(resource));
 
-            ResourceContext resourceContext = _resourceGraph.GetResourceContext<TResource>();
-            _finallyStoredAttributeValues = CreateAttributeDictionary(resource, resourceContext.Attributes);
+            _finallyStoredAttributeValues = CreateAttributeDictionary(resource, _resourceType.Attributes);
         }
 
         private IDictionary<string, string> CreateAttributeDictionary(TResource resource, IEnumerable<AttrAttribute> attributes)
diff --git a/src/JsonApiDotNetCore/Resources/ResourceDefinitionAccessor.cs b/src/JsonApiDotNetCore/Resources/ResourceDefinitionAccessor.cs
index 1923c33156..36e8f008d3 100644
--- a/src/JsonApiDotNetCore/Resources/ResourceDefinitionAccessor.cs
+++ b/src/JsonApiDotNetCore/Resources/ResourceDefinitionAccessor.cs
@@ -29,7 +29,7 @@ public ResourceDefinitionAccessor(IResourceGraph resourceGraph, IServiceProvider
         }
 
         /// <inheritdoc />
-        public IImmutableList<IncludeElementExpression> OnApplyIncludes(Type resourceType, IImmutableList<IncludeElementExpression> existingIncludes)
+        public IImmutableSet<IncludeElementExpression> OnApplyIncludes(ResourceType resourceType, IImmutableSet<IncludeElementExpression> existingIncludes)
         {
             ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
@@ -38,7 +38,7 @@ public IImmutableList<IncludeElementExpression> OnApplyIncludes(Type resourceTyp
         }
 
         /// <inheritdoc />
-        public FilterExpression OnApplyFilter(Type resourceType, FilterExpression existingFilter)
+        public FilterExpression OnApplyFilter(ResourceType resourceType, FilterExpression existingFilter)
         {
             ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
@@ -47,7 +47,7 @@ public FilterExpression OnApplyFilter(Type resourceType, FilterExpression existi
         }
 
         /// <inheritdoc />
-        public SortExpression OnApplySort(Type resourceType, SortExpression existingSort)
+        public SortExpression OnApplySort(ResourceType resourceType, SortExpression existingSort)
         {
             ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
@@ -56,7 +56,7 @@ public SortExpression OnApplySort(Type resourceType, SortExpression existingSort
         }
 
         /// <inheritdoc />
-        public PaginationExpression OnApplyPagination(Type resourceType, PaginationExpression existingPagination)
+        public PaginationExpression OnApplyPagination(ResourceType resourceType, PaginationExpression existingPagination)
         {
             ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
@@ -65,7 +65,7 @@ public PaginationExpression OnApplyPagination(Type resourceType, PaginationExpre
         }
 
         /// <inheritdoc />
-        public SparseFieldSetExpression OnApplySparseFieldSet(Type resourceType, SparseFieldSetExpression existingSparseFieldSet)
+        public SparseFieldSetExpression OnApplySparseFieldSet(ResourceType resourceType, SparseFieldSetExpression existingSparseFieldSet)
         {
             ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
@@ -74,19 +74,19 @@ public SparseFieldSetExpression OnApplySparseFieldSet(Type resourceType, SparseF
         }
 
         /// <inheritdoc />
-        public object GetQueryableHandlerForQueryStringParameter(Type resourceType, string parameterName)
+        public object GetQueryableHandlerForQueryStringParameter(Type resourceClrType, string parameterName)
         {
-            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
+            ArgumentGuard.NotNull(resourceClrType, nameof(resourceClrType));
             ArgumentGuard.NotNullNorEmpty(parameterName, nameof(parameterName));
 
-            dynamic resourceDefinition = ResolveResourceDefinition(resourceType);
+            dynamic resourceDefinition = ResolveResourceDefinition(resourceClrType);
             dynamic handlers = resourceDefinition.OnRegisterQueryableHandlersForQueryStringParameters();
 
             return handlers != null && handlers.ContainsKey(parameterName) ? handlers[parameterName] : null;
         }
 
         /// <inheritdoc />
-        public IDictionary<string, object> GetMeta(Type resourceType, IIdentifiable resourceInstance)
+        public IDictionary<string, object> GetMeta(ResourceType resourceType, IIdentifiable resourceInstance)
         {
             ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
@@ -192,13 +192,17 @@ public void OnSerialize(IIdentifiable resource)
             resourceDefinition.OnSerialize((dynamic)resource);
         }
 
-        protected virtual object ResolveResourceDefinition(Type resourceType)
+        protected object ResolveResourceDefinition(Type resourceClrType)
         {
-            ResourceContext resourceContext = _resourceGraph.GetResourceContext(resourceType);
+            ResourceType resourceType = _resourceGraph.GetResourceType(resourceClrType);
+            return ResolveResourceDefinition(resourceType);
+        }
 
-            if (resourceContext.IdentityType == typeof(int))
+        protected virtual object ResolveResourceDefinition(ResourceType resourceType)
+        {
+            if (resourceType.IdentityClrType == typeof(int))
             {
-                Type intResourceDefinitionType = typeof(IResourceDefinition<>).MakeGenericType(resourceContext.ResourceType);
+                Type intResourceDefinitionType = typeof(IResourceDefinition<>).MakeGenericType(resourceType.ClrType);
                 object intResourceDefinition = _serviceProvider.GetService(intResourceDefinitionType);
 
                 if (intResourceDefinition != null)
@@ -207,7 +211,7 @@ protected virtual object ResolveResourceDefinition(Type resourceType)
                 }
             }
 
-            Type resourceDefinitionType = typeof(IResourceDefinition<,>).MakeGenericType(resourceContext.ResourceType, resourceContext.IdentityType);
+            Type resourceDefinitionType = typeof(IResourceDefinition<,>).MakeGenericType(resourceType.ClrType, resourceType.IdentityClrType);
             return _serviceProvider.GetRequiredService(resourceDefinitionType);
         }
     }
diff --git a/src/JsonApiDotNetCore/Resources/ResourceFactory.cs b/src/JsonApiDotNetCore/Resources/ResourceFactory.cs
index 6ab75ded5b..dd5a03306e 100644
--- a/src/JsonApiDotNetCore/Resources/ResourceFactory.cs
+++ b/src/JsonApiDotNetCore/Resources/ResourceFactory.cs
@@ -20,11 +20,11 @@ public ResourceFactory(IServiceProvider serviceProvider)
         }
 
         /// <inheritdoc />
-        public IIdentifiable CreateInstance(Type resourceType)
+        public IIdentifiable CreateInstance(Type resourceClrType)
         {
-            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
+            ArgumentGuard.NotNull(resourceClrType, nameof(resourceClrType));
 
-            return InnerCreateInstance(resourceType, _serviceProvider);
+            return InnerCreateInstance(resourceClrType, _serviceProvider);
         }
 
         /// <inheritdoc />
@@ -56,18 +56,18 @@ private static IIdentifiable InnerCreateInstance(Type type, IServiceProvider ser
         }
 
         /// <inheritdoc />
-        public NewExpression CreateNewExpression(Type resourceType)
+        public NewExpression CreateNewExpression(Type resourceClrType)
         {
-            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
+            ArgumentGuard.NotNull(resourceClrType, nameof(resourceClrType));
 
-            if (HasSingleConstructorWithoutParameters(resourceType))
+            if (HasSingleConstructorWithoutParameters(resourceClrType))
             {
-                return Expression.New(resourceType);
+                return Expression.New(resourceClrType);
             }
 
             var constructorArguments = new List<Expression>();
 
-            ConstructorInfo longestConstructor = GetLongestConstructor(resourceType);
+            ConstructorInfo longestConstructor = GetLongestConstructor(resourceClrType);
 
             foreach (ParameterInfo constructorParameter in longestConstructor.GetParameters())
             {
@@ -84,7 +84,7 @@ public NewExpression CreateNewExpression(Type resourceType)
 #pragma warning restore AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException
                 {
                     throw new InvalidOperationException(
-                        $"Failed to create an instance of '{resourceType.FullName}': Parameter '{constructorParameter.Name}' could not be resolved.",
+                        $"Failed to create an instance of '{resourceClrType.FullName}': Parameter '{constructorParameter.Name}' could not be resolved.",
                         exception);
                 }
             }
diff --git a/src/JsonApiDotNetCore/Resources/TargetedFields.cs b/src/JsonApiDotNetCore/Resources/TargetedFields.cs
index 46cd2fed6a..4e2d571e5c 100644
--- a/src/JsonApiDotNetCore/Resources/TargetedFields.cs
+++ b/src/JsonApiDotNetCore/Resources/TargetedFields.cs
@@ -1,15 +1,32 @@
 using System.Collections.Generic;
+using JetBrains.Annotations;
 using JsonApiDotNetCore.Resources.Annotations;
 
 namespace JsonApiDotNetCore.Resources
 {
     /// <inheritdoc />
+    [PublicAPI]
     public sealed class TargetedFields : ITargetedFields
     {
-        /// <inheritdoc />
-        public ISet<AttrAttribute> Attributes { get; set; } = new HashSet<AttrAttribute>();
+        IReadOnlySet<AttrAttribute> ITargetedFields.Attributes => Attributes;
+        IReadOnlySet<RelationshipAttribute> ITargetedFields.Relationships => Relationships;
+
+        public HashSet<AttrAttribute> Attributes { get; } = new();
+        public HashSet<RelationshipAttribute> Relationships { get; } = new();
 
         /// <inheritdoc />
-        public ISet<RelationshipAttribute> Relationships { get; set; } = new HashSet<RelationshipAttribute>();
+        public void CopyFrom(ITargetedFields other)
+        {
+            Clear();
+
+            Attributes.AddRange(other.Attributes);
+            Relationships.AddRange(other.Relationships);
+        }
+
+        public void Clear()
+        {
+            Attributes.Clear();
+            Relationships.Clear();
+        }
     }
 }
diff --git a/src/JsonApiDotNetCore/Serialization/AtomicOperationsResponseSerializer.cs b/src/JsonApiDotNetCore/Serialization/AtomicOperationsResponseSerializer.cs
deleted file mode 100644
index a7892755c5..0000000000
--- a/src/JsonApiDotNetCore/Serialization/AtomicOperationsResponseSerializer.cs
+++ /dev/null
@@ -1,135 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using JetBrains.Annotations;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Middleware;
-using JsonApiDotNetCore.Queries.Internal;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization.Building;
-using JsonApiDotNetCore.Serialization.Objects;
-
-namespace JsonApiDotNetCore.Serialization
-{
-    /// <summary>
-    /// Server serializer implementation of <see cref="BaseSerializer" /> for atomic:operations responses.
-    /// </summary>
-    [PublicAPI]
-    public sealed class AtomicOperationsResponseSerializer : BaseSerializer, IJsonApiSerializer
-    {
-        private readonly IMetaBuilder _metaBuilder;
-        private readonly ILinkBuilder _linkBuilder;
-        private readonly IFieldsToSerialize _fieldsToSerialize;
-        private readonly IResourceDefinitionAccessor _resourceDefinitionAccessor;
-        private readonly IEvaluatedIncludeCache _evaluatedIncludeCache;
-        private readonly IJsonApiRequest _request;
-        private readonly IJsonApiOptions _options;
-
-        /// <inheritdoc />
-        public string ContentType { get; } = HeaderConstants.AtomicOperationsMediaType;
-
-        public AtomicOperationsResponseSerializer(IResourceObjectBuilder resourceObjectBuilder, IMetaBuilder metaBuilder, ILinkBuilder linkBuilder,
-            IFieldsToSerialize fieldsToSerialize, IResourceDefinitionAccessor resourceDefinitionAccessor, IEvaluatedIncludeCache evaluatedIncludeCache,
-            IJsonApiRequest request, IJsonApiOptions options)
-            : base(resourceObjectBuilder)
-        {
-            ArgumentGuard.NotNull(metaBuilder, nameof(metaBuilder));
-            ArgumentGuard.NotNull(linkBuilder, nameof(linkBuilder));
-            ArgumentGuard.NotNull(fieldsToSerialize, nameof(fieldsToSerialize));
-            ArgumentGuard.NotNull(resourceDefinitionAccessor, nameof(resourceDefinitionAccessor));
-            ArgumentGuard.NotNull(evaluatedIncludeCache, nameof(evaluatedIncludeCache));
-            ArgumentGuard.NotNull(request, nameof(request));
-            ArgumentGuard.NotNull(options, nameof(options));
-
-            _metaBuilder = metaBuilder;
-            _linkBuilder = linkBuilder;
-            _fieldsToSerialize = fieldsToSerialize;
-            _resourceDefinitionAccessor = resourceDefinitionAccessor;
-            _evaluatedIncludeCache = evaluatedIncludeCache;
-            _request = request;
-            _options = options;
-        }
-
-        /// <inheritdoc />
-        public string Serialize(object content)
-        {
-            if (content is IList<OperationContainer> operations)
-            {
-                return SerializeOperationsDocument(operations);
-            }
-
-            if (content is Document errorDocument)
-            {
-                return SerializeErrorDocument(errorDocument);
-            }
-
-            throw new InvalidOperationException("Data being returned must be errors or operations.");
-        }
-
-        private string SerializeOperationsDocument(IEnumerable<OperationContainer> operations)
-        {
-            var document = new Document
-            {
-                Results = operations.Select(SerializeOperation).ToList(),
-                Meta = _metaBuilder.Build()
-            };
-
-            SetApiVersion(document);
-
-            return SerializeObject(document, _options.SerializerWriteOptions);
-        }
-
-        private void SetApiVersion(Document document)
-        {
-            if (_options.IncludeJsonApiVersion)
-            {
-                document.JsonApi = new JsonApiObject
-                {
-                    Version = "1.1",
-                    Ext = new List<string>
-                    {
-                        "https://jsonapi.org/ext/atomic"
-                    }
-                };
-            }
-        }
-
-        private AtomicResultObject SerializeOperation(OperationContainer operation)
-        {
-            ResourceObject resourceObject = null;
-
-            if (operation != null)
-            {
-                _request.CopyFrom(operation.Request);
-                _fieldsToSerialize.ResetCache();
-                _evaluatedIncludeCache.Set(null);
-
-                _resourceDefinitionAccessor.OnSerialize(operation.Resource);
-
-                Type resourceType = operation.Resource.GetType();
-                IReadOnlyCollection<AttrAttribute> attributes = _fieldsToSerialize.GetAttributes(resourceType);
-                IReadOnlyCollection<RelationshipAttribute> relationships = _fieldsToSerialize.GetRelationships(resourceType);
-
-                resourceObject = ResourceObjectBuilder.Build(operation.Resource, attributes, relationships);
-            }
-
-            if (resourceObject != null)
-            {
-                resourceObject.Links = _linkBuilder.GetResourceLinks(resourceObject.Type, resourceObject.Id);
-            }
-
-            return new AtomicResultObject
-            {
-                Data = new SingleOrManyData<ResourceObject>(resourceObject)
-            };
-        }
-
-        private string SerializeErrorDocument(Document document)
-        {
-            SetApiVersion(document);
-
-            return SerializeObject(document, _options.SerializerWriteOptions);
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/BaseDeserializer.cs b/src/JsonApiDotNetCore/Serialization/BaseDeserializer.cs
deleted file mode 100644
index dfba94691c..0000000000
--- a/src/JsonApiDotNetCore/Serialization/BaseDeserializer.cs
+++ /dev/null
@@ -1,359 +0,0 @@
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text.Json;
-using JetBrains.Annotations;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Diagnostics;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization.Objects;
-
-namespace JsonApiDotNetCore.Serialization
-{
-    /// <summary>
-    /// Abstract base class for deserialization. Deserializes JSON content into <see cref="Objects.Document" />s and constructs instances of the resource(s)
-    /// in the document body.
-    /// </summary>
-    [PublicAPI]
-    public abstract class BaseDeserializer
-    {
-        private protected static readonly CollectionConverter CollectionConverter = new();
-
-        protected IResourceGraph ResourceGraph { get; }
-        protected IResourceFactory ResourceFactory { get; }
-        protected int? AtomicOperationIndex { get; set; }
-
-        protected BaseDeserializer(IResourceGraph resourceGraph, IResourceFactory resourceFactory)
-        {
-            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
-            ArgumentGuard.NotNull(resourceFactory, nameof(resourceFactory));
-
-            ResourceGraph = resourceGraph;
-            ResourceFactory = resourceFactory;
-        }
-
-        /// <summary>
-        /// This method is called each time a <paramref name="resource" /> is constructed from the serialized content, which is used to do additional processing
-        /// depending on the type of deserializer.
-        /// </summary>
-        /// <remarks>
-        /// See the implementation of this method in <see cref="RequestDeserializer" /> for usage.
-        /// </remarks>
-        /// <param name="resource">
-        /// The resource that was constructed from the document's body.
-        /// </param>
-        /// <param name="field">
-        /// The metadata for the exposed field.
-        /// </param>
-        /// <param name="data">
-        /// Relationship data for <paramref name="resource" />. Is null when <paramref name="field" /> is not a <see cref="RelationshipAttribute" />.
-        /// </param>
-        protected abstract void AfterProcessField(IIdentifiable resource, ResourceFieldAttribute field, RelationshipObject data = null);
-
-        protected Document DeserializeDocument(string body, JsonSerializerOptions serializerOptions)
-        {
-            ArgumentGuard.NotNullNorEmpty(body, nameof(body));
-
-            try
-            {
-                using (CodeTimingSessionManager.Current.Measure("JsonSerializer.Deserialize", MeasurementSettings.ExcludeJsonSerializationInPercentages))
-                {
-                    return JsonSerializer.Deserialize<Document>(body, serializerOptions);
-                }
-            }
-            catch (JsonException exception)
-            {
-                // JsonException.Path looks great for setting error.source.pointer, but unfortunately it is wrong in most cases.
-                // This is due to the use of custom converters, which are unable to interact with internal position tracking.
-                // https://github.com/dotnet/runtime/issues/50205#issuecomment-808401245
-                throw new JsonApiSerializationException(null, exception.Message, exception);
-            }
-        }
-
-        protected object DeserializeData(string body, JsonSerializerOptions serializerOptions)
-        {
-            Document document = DeserializeDocument(body, serializerOptions);
-
-            if (document != null)
-            {
-                if (document.Data.ManyValue != null)
-                {
-                    using (CodeTimingSessionManager.Current.Measure("Deserializer.Build (list)"))
-                    {
-                        return document.Data.ManyValue.Select(ParseResourceObject).ToHashSet(IdentifiableComparer.Instance);
-                    }
-                }
-
-                if (document.Data.SingleValue != null)
-                {
-                    using (CodeTimingSessionManager.Current.Measure("Deserializer.Build (single)"))
-                    {
-                        return ParseResourceObject(document.Data.SingleValue);
-                    }
-                }
-            }
-
-            return null;
-        }
-
-        /// <summary>
-        /// Sets the attributes on a parsed resource.
-        /// </summary>
-        /// <param name="resource">
-        /// The parsed resource.
-        /// </param>
-        /// <param name="attributeValues">
-        /// Attributes and their values, as in the serialized content.
-        /// </param>
-        /// <param name="attributes">
-        /// Exposed attributes for <paramref name="resource" />.
-        /// </param>
-        private IIdentifiable SetAttributes(IIdentifiable resource, IDictionary<string, object> attributeValues, IReadOnlyCollection<AttrAttribute> attributes)
-        {
-            ArgumentGuard.NotNull(resource, nameof(resource));
-            ArgumentGuard.NotNull(attributes, nameof(attributes));
-
-            if (attributeValues.IsNullOrEmpty())
-            {
-                return resource;
-            }
-
-            foreach (AttrAttribute attr in attributes)
-            {
-                if (attributeValues.TryGetValue(attr.PublicName, out object newValue))
-                {
-                    if (attr.Property.SetMethod == null)
-                    {
-                        throw new JsonApiSerializationException("Attribute is read-only.", $"Attribute '{attr.PublicName}' is read-only.",
-                            atomicOperationIndex: AtomicOperationIndex);
-                    }
-
-                    if (newValue is JsonInvalidAttributeInfo info)
-                    {
-                        if (newValue == JsonInvalidAttributeInfo.Id)
-                        {
-                            throw new JsonApiSerializationException(null, "Resource ID is read-only.", atomicOperationIndex: AtomicOperationIndex);
-                        }
-
-                        string typeName = info.AttributeType.GetFriendlyTypeName();
-
-                        throw new JsonApiSerializationException(null,
-                            $"Failed to convert attribute '{info.AttributeName}' with value '{info.JsonValue}' of type '{info.JsonType}' to type '{typeName}'.",
-                            atomicOperationIndex: AtomicOperationIndex);
-                    }
-
-                    attr.SetValue(resource, newValue);
-                    AfterProcessField(resource, attr);
-                }
-            }
-
-            return resource;
-        }
-
-        /// <summary>
-        /// Sets the relationships on a parsed resource.
-        /// </summary>
-        /// <param name="resource">
-        /// The parsed resource.
-        /// </param>
-        /// <param name="relationshipValues">
-        /// Relationships and their values, as in the serialized content.
-        /// </param>
-        /// <param name="relationshipAttributes">
-        /// Exposed relationships for <paramref name="resource" />.
-        /// </param>
-        private IIdentifiable SetRelationships(IIdentifiable resource, IDictionary<string, RelationshipObject> relationshipValues,
-            IReadOnlyCollection<RelationshipAttribute> relationshipAttributes)
-        {
-            ArgumentGuard.NotNull(resource, nameof(resource));
-            ArgumentGuard.NotNull(relationshipAttributes, nameof(relationshipAttributes));
-
-            if (relationshipValues.IsNullOrEmpty())
-            {
-                return resource;
-            }
-
-            foreach (RelationshipAttribute attr in relationshipAttributes)
-            {
-                bool relationshipIsProvided = relationshipValues.TryGetValue(attr.PublicName, out RelationshipObject relationshipData);
-
-                if (!relationshipIsProvided || !relationshipData.Data.IsAssigned)
-                {
-                    continue;
-                }
-
-                if (attr is HasOneAttribute hasOneAttribute)
-                {
-                    SetHasOneRelationship(resource, hasOneAttribute, relationshipData);
-                }
-                else if (attr is HasManyAttribute hasManyAttribute)
-                {
-                    SetHasManyRelationship(resource, hasManyAttribute, relationshipData);
-                }
-            }
-
-            return resource;
-        }
-
-        /// <summary>
-        /// Creates an instance of the referenced type in <paramref name="data" /> and sets its attributes and relationships.
-        /// </summary>
-        /// <returns>
-        /// The parsed resource.
-        /// </returns>
-        protected IIdentifiable ParseResourceObject(ResourceObject data)
-        {
-            AssertHasType(data, null);
-
-            if (AtomicOperationIndex == null)
-            {
-                AssertHasNoLid(data);
-            }
-
-            ResourceContext resourceContext = GetExistingResourceContext(data.Type);
-            IIdentifiable resource = ResourceFactory.CreateInstance(resourceContext.ResourceType);
-
-            resource = SetAttributes(resource, data.Attributes, resourceContext.Attributes);
-            resource = SetRelationships(resource, data.Relationships, resourceContext.Relationships);
-
-            if (data.Id != null)
-            {
-                resource.StringId = data.Id;
-            }
-
-            resource.LocalId = data.Lid;
-
-            return resource;
-        }
-
-        protected ResourceContext GetExistingResourceContext(string publicName)
-        {
-            ResourceContext resourceContext = ResourceGraph.TryGetResourceContext(publicName);
-
-            if (resourceContext == null)
-            {
-                throw new JsonApiSerializationException("Request body includes unknown resource type.", $"Resource type '{publicName}' does not exist.",
-                    atomicOperationIndex: AtomicOperationIndex);
-            }
-
-            return resourceContext;
-        }
-
-        /// <summary>
-        /// Sets a HasOne relationship on a parsed resource.
-        /// </summary>
-        private void SetHasOneRelationship(IIdentifiable resource, HasOneAttribute hasOneRelationship, RelationshipObject relationshipData)
-        {
-            if (relationshipData.Data.ManyValue != null)
-            {
-                throw new JsonApiSerializationException("Expected single data element for to-one relationship.",
-                    $"Expected single data element for '{hasOneRelationship.PublicName}' relationship.", atomicOperationIndex: AtomicOperationIndex);
-            }
-
-            IIdentifiable rightResource = CreateRightResource(hasOneRelationship, relationshipData.Data.SingleValue);
-            hasOneRelationship.SetValue(resource, rightResource);
-
-            // depending on if this base parser is used client-side or server-side,
-            // different additional processing per field needs to be executed.
-            AfterProcessField(resource, hasOneRelationship, relationshipData);
-        }
-
-        /// <summary>
-        /// Sets a HasMany relationship.
-        /// </summary>
-        private void SetHasManyRelationship(IIdentifiable resource, HasManyAttribute hasManyRelationship, RelationshipObject relationshipData)
-        {
-            if (relationshipData.Data.ManyValue == null)
-            {
-                throw new JsonApiSerializationException("Expected data[] element for to-many relationship.",
-                    $"Expected data[] element for '{hasManyRelationship.PublicName}' relationship.", atomicOperationIndex: AtomicOperationIndex);
-            }
-
-            HashSet<IIdentifiable> rightResources = relationshipData.Data.ManyValue.Select(rio => CreateRightResource(hasManyRelationship, rio))
-                .ToHashSet(IdentifiableComparer.Instance);
-
-            IEnumerable convertedCollection = CollectionConverter.CopyToTypedCollection(rightResources, hasManyRelationship.Property.PropertyType);
-            hasManyRelationship.SetValue(resource, convertedCollection);
-
-            AfterProcessField(resource, hasManyRelationship, relationshipData);
-        }
-
-        private IIdentifiable CreateRightResource(RelationshipAttribute relationship, ResourceIdentifierObject resourceIdentifierObject)
-        {
-            if (resourceIdentifierObject != null)
-            {
-                AssertHasType(resourceIdentifierObject, relationship);
-                AssertHasIdOrLid(resourceIdentifierObject, relationship);
-
-                ResourceContext rightResourceContext = GetExistingResourceContext(resourceIdentifierObject.Type);
-                AssertRightTypeIsCompatible(rightResourceContext, relationship);
-
-                IIdentifiable rightInstance = ResourceFactory.CreateInstance(rightResourceContext.ResourceType);
-                rightInstance.StringId = resourceIdentifierObject.Id;
-                rightInstance.LocalId = resourceIdentifierObject.Lid;
-
-                return rightInstance;
-            }
-
-            return null;
-        }
-
-        [AssertionMethod]
-        private void AssertHasType(IResourceIdentity resourceIdentity, RelationshipAttribute relationship)
-        {
-            if (resourceIdentity.Type == null)
-            {
-                string details = relationship != null
-                    ? $"Expected 'type' element in '{relationship.PublicName}' relationship."
-                    : "Expected 'type' element in 'data' element.";
-
-                throw new JsonApiSerializationException("Request body must include 'type' element.", details, atomicOperationIndex: AtomicOperationIndex);
-            }
-        }
-
-        private void AssertHasIdOrLid(ResourceIdentifierObject resourceIdentifierObject, RelationshipAttribute relationship)
-        {
-            if (AtomicOperationIndex != null)
-            {
-                bool hasNone = resourceIdentifierObject.Id == null && resourceIdentifierObject.Lid == null;
-                bool hasBoth = resourceIdentifierObject.Id != null && resourceIdentifierObject.Lid != null;
-
-                if (hasNone || hasBoth)
-                {
-                    throw new JsonApiSerializationException("Request body must include 'id' or 'lid' element.",
-                        $"Expected 'id' or 'lid' element in '{relationship.PublicName}' relationship.", atomicOperationIndex: AtomicOperationIndex);
-                }
-            }
-            else
-            {
-                if (resourceIdentifierObject.Id == null)
-                {
-                    throw new JsonApiSerializationException("Request body must include 'id' element.",
-                        $"Expected 'id' element in '{relationship.PublicName}' relationship.", atomicOperationIndex: AtomicOperationIndex);
-                }
-
-                AssertHasNoLid(resourceIdentifierObject);
-            }
-        }
-
-        [AssertionMethod]
-        private void AssertHasNoLid(IResourceIdentity resourceIdentityObject)
-        {
-            if (resourceIdentityObject.Lid != null)
-            {
-                throw new JsonApiSerializationException(null, "Local IDs cannot be used at this endpoint.", atomicOperationIndex: AtomicOperationIndex);
-            }
-        }
-
-        private void AssertRightTypeIsCompatible(ResourceContext rightResourceContext, RelationshipAttribute relationship)
-        {
-            if (!relationship.RightType.IsAssignableFrom(rightResourceContext.ResourceType))
-            {
-                throw new JsonApiSerializationException("Relationship contains incompatible resource type.",
-                    $"Relationship '{relationship.PublicName}' contains incompatible resource type '{rightResourceContext.PublicName}'.",
-                    atomicOperationIndex: AtomicOperationIndex);
-            }
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/BaseSerializer.cs b/src/JsonApiDotNetCore/Serialization/BaseSerializer.cs
deleted file mode 100644
index d096a4ea6c..0000000000
--- a/src/JsonApiDotNetCore/Serialization/BaseSerializer.cs
+++ /dev/null
@@ -1,102 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text.Json;
-using JsonApiDotNetCore.Diagnostics;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization.Building;
-using JsonApiDotNetCore.Serialization.Objects;
-
-namespace JsonApiDotNetCore.Serialization
-{
-    /// <summary>
-    /// Abstract base class for serialization. Uses <see cref="IResourceObjectBuilder" /> to convert resources into <see cref="ResourceObject" />s and wraps
-    /// them in a <see cref="Document" />.
-    /// </summary>
-    public abstract class BaseSerializer
-    {
-        protected IResourceObjectBuilder ResourceObjectBuilder { get; }
-
-        protected BaseSerializer(IResourceObjectBuilder resourceObjectBuilder)
-        {
-            ArgumentGuard.NotNull(resourceObjectBuilder, nameof(resourceObjectBuilder));
-
-            ResourceObjectBuilder = resourceObjectBuilder;
-        }
-
-        /// <summary>
-        /// Builds a <see cref="Document" /> for <paramref name="resource" />. Adds the attributes and relationships that are enlisted in
-        /// <paramref name="attributes" /> and <paramref name="relationships" />.
-        /// </summary>
-        /// <param name="resource">
-        /// Resource to build a <see cref="ResourceObject" /> for.
-        /// </param>
-        /// <param name="attributes">
-        /// Attributes to include in the building process.
-        /// </param>
-        /// <param name="relationships">
-        /// Relationships to include in the building process.
-        /// </param>
-        /// <returns>
-        /// The resource object that was built.
-        /// </returns>
-        protected Document Build(IIdentifiable resource, IReadOnlyCollection<AttrAttribute> attributes,
-            IReadOnlyCollection<RelationshipAttribute> relationships)
-        {
-            using IDisposable _ = CodeTimingSessionManager.Current.Measure("Serializer.Build (single)");
-
-            ResourceObject resourceObject = resource != null ? ResourceObjectBuilder.Build(resource, attributes, relationships) : null;
-
-            return new Document
-            {
-                Data = new SingleOrManyData<ResourceObject>(resourceObject)
-            };
-        }
-
-        /// <summary>
-        /// Builds a <see cref="Document" /> for <paramref name="resources" />. Adds the attributes and relationships that are enlisted in
-        /// <paramref name="attributes" /> and <paramref name="relationships" />.
-        /// </summary>
-        /// <param name="resources">
-        /// Resource to build a <see cref="ResourceObject" /> for.
-        /// </param>
-        /// <param name="attributes">
-        /// Attributes to include in the building process.
-        /// </param>
-        /// <param name="relationships">
-        /// Relationships to include in the building process.
-        /// </param>
-        /// <returns>
-        /// The resource object that was built.
-        /// </returns>
-        protected Document Build(IReadOnlyCollection<IIdentifiable> resources, IReadOnlyCollection<AttrAttribute> attributes,
-            IReadOnlyCollection<RelationshipAttribute> relationships)
-        {
-            ArgumentGuard.NotNull(resources, nameof(resources));
-
-            using IDisposable _ = CodeTimingSessionManager.Current.Measure("Serializer.Build (list)");
-
-            var resourceObjects = new List<ResourceObject>();
-
-            foreach (IIdentifiable resource in resources)
-            {
-                resourceObjects.Add(ResourceObjectBuilder.Build(resource, attributes, relationships));
-            }
-
-            return new Document
-            {
-                Data = new SingleOrManyData<ResourceObject>(resourceObjects)
-            };
-        }
-
-        protected string SerializeObject(object value, JsonSerializerOptions serializerOptions)
-        {
-            ArgumentGuard.NotNull(serializerOptions, nameof(serializerOptions));
-
-            using IDisposable _ =
-                CodeTimingSessionManager.Current.Measure("JsonSerializer.Serialize", MeasurementSettings.ExcludeJsonSerializationInPercentages);
-
-            return JsonSerializer.Serialize(value, serializerOptions);
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/Building/IIncludedResourceObjectBuilder.cs b/src/JsonApiDotNetCore/Serialization/Building/IIncludedResourceObjectBuilder.cs
deleted file mode 100644
index 3a49f0d413..0000000000
--- a/src/JsonApiDotNetCore/Serialization/Building/IIncludedResourceObjectBuilder.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using System.Collections.Generic;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization.Objects;
-
-namespace JsonApiDotNetCore.Serialization.Building
-{
-    public interface IIncludedResourceObjectBuilder
-    {
-        /// <summary>
-        /// Gets the list of resource objects representing the included resources.
-        /// </summary>
-        IList<ResourceObject> Build();
-
-        /// <summary>
-        /// Extracts the included resources from <paramref name="rootResource" /> using the (arbitrarily deeply nested) included relationships in
-        /// <paramref name="inclusionChain" />.
-        /// </summary>
-        void IncludeRelationshipChain(IReadOnlyCollection<RelationshipAttribute> inclusionChain, IIdentifiable rootResource);
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/Building/IResourceObjectBuilder.cs b/src/JsonApiDotNetCore/Serialization/Building/IResourceObjectBuilder.cs
deleted file mode 100644
index ff182c2dab..0000000000
--- a/src/JsonApiDotNetCore/Serialization/Building/IResourceObjectBuilder.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-using System.Collections.Generic;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization.Objects;
-
-namespace JsonApiDotNetCore.Serialization.Building
-{
-    /// <summary>
-    /// Responsible for converting resources into <see cref="ResourceObject" />s given a collection of attributes and relationships.
-    /// </summary>
-    public interface IResourceObjectBuilder
-    {
-        /// <summary>
-        /// Converts <paramref name="resource" /> into a <see cref="ResourceObject" />. Adds the attributes and relationships that are enlisted in
-        /// <paramref name="attributes" /> and <paramref name="relationships" />.
-        /// </summary>
-        /// <param name="resource">
-        /// Resource to build a <see cref="ResourceObject" /> for.
-        /// </param>
-        /// <param name="attributes">
-        /// Attributes to include in the building process.
-        /// </param>
-        /// <param name="relationships">
-        /// Relationships to include in the building process.
-        /// </param>
-        /// <returns>
-        /// The resource object that was built.
-        /// </returns>
-        ResourceObject Build(IIdentifiable resource, IReadOnlyCollection<AttrAttribute> attributes, IReadOnlyCollection<RelationshipAttribute> relationships);
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/Building/IncludedResourceObjectBuilder.cs b/src/JsonApiDotNetCore/Serialization/Building/IncludedResourceObjectBuilder.cs
deleted file mode 100644
index 299c270f91..0000000000
--- a/src/JsonApiDotNetCore/Serialization/Building/IncludedResourceObjectBuilder.cs
+++ /dev/null
@@ -1,227 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using JetBrains.Annotations;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Queries;
-using JsonApiDotNetCore.Queries.Internal;
-using JsonApiDotNetCore.QueryStrings;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization.Objects;
-
-namespace JsonApiDotNetCore.Serialization.Building
-{
-    [PublicAPI]
-    public class IncludedResourceObjectBuilder : ResourceObjectBuilder, IIncludedResourceObjectBuilder
-    {
-        private readonly HashSet<ResourceObject> _included;
-        private readonly IFieldsToSerialize _fieldsToSerialize;
-        private readonly ILinkBuilder _linkBuilder;
-        private readonly IResourceDefinitionAccessor _resourceDefinitionAccessor;
-        private readonly IRequestQueryStringAccessor _queryStringAccessor;
-        private readonly SparseFieldSetCache _sparseFieldSetCache;
-
-        public IncludedResourceObjectBuilder(IFieldsToSerialize fieldsToSerialize, ILinkBuilder linkBuilder, IResourceGraph resourceGraph,
-            IEnumerable<IQueryConstraintProvider> constraintProviders, IResourceDefinitionAccessor resourceDefinitionAccessor,
-            IRequestQueryStringAccessor queryStringAccessor, IJsonApiOptions options)
-            : base(resourceGraph, options)
-        {
-            ArgumentGuard.NotNull(fieldsToSerialize, nameof(fieldsToSerialize));
-            ArgumentGuard.NotNull(linkBuilder, nameof(linkBuilder));
-            ArgumentGuard.NotNull(constraintProviders, nameof(constraintProviders));
-            ArgumentGuard.NotNull(resourceDefinitionAccessor, nameof(resourceDefinitionAccessor));
-            ArgumentGuard.NotNull(queryStringAccessor, nameof(queryStringAccessor));
-
-            _included = new HashSet<ResourceObject>(ResourceIdentityComparer.Instance);
-            _fieldsToSerialize = fieldsToSerialize;
-            _linkBuilder = linkBuilder;
-            _resourceDefinitionAccessor = resourceDefinitionAccessor;
-            _queryStringAccessor = queryStringAccessor;
-            _sparseFieldSetCache = new SparseFieldSetCache(constraintProviders, resourceDefinitionAccessor);
-        }
-
-        /// <inheritdoc />
-        public IList<ResourceObject> Build()
-        {
-            if (_included.Any())
-            {
-                // Cleans relationship dictionaries and adds links of resources.
-                foreach (ResourceObject resourceObject in _included)
-                {
-                    if (resourceObject.Relationships != null)
-                    {
-                        UpdateRelationships(resourceObject);
-                    }
-
-                    resourceObject.Links = _linkBuilder.GetResourceLinks(resourceObject.Type, resourceObject.Id);
-                }
-
-                return _included.ToArray();
-            }
-
-            return _queryStringAccessor.Query.ContainsKey("include") ? Array.Empty<ResourceObject>() : null;
-        }
-
-        private void UpdateRelationships(ResourceObject resourceObject)
-        {
-            foreach (string relationshipName in resourceObject.Relationships.Keys)
-            {
-                ResourceContext resourceContext = ResourceGraph.GetResourceContext(resourceObject.Type);
-                RelationshipAttribute relationship = resourceContext.GetRelationshipByPublicName(relationshipName);
-
-                if (!IsRelationshipInSparseFieldSet(relationship))
-                {
-                    resourceObject.Relationships.Remove(relationshipName);
-                }
-            }
-
-            resourceObject.Relationships = PruneRelationshipObjects(resourceObject);
-        }
-
-        private static IDictionary<string, RelationshipObject> PruneRelationshipObjects(ResourceObject resourceObject)
-        {
-            Dictionary<string, RelationshipObject> pruned = resourceObject.Relationships.Where(pair => pair.Value.Data.IsAssigned || pair.Value.Links != null)
-                .ToDictionary(pair => pair.Key, pair => pair.Value);
-
-            return !pruned.Any() ? null : pruned;
-        }
-
-        private bool IsRelationshipInSparseFieldSet(RelationshipAttribute relationship)
-        {
-            ResourceContext resourceContext = ResourceGraph.GetResourceContext(relationship.LeftType);
-
-            IImmutableSet<ResourceFieldAttribute> fieldSet = _sparseFieldSetCache.GetSparseFieldSetForSerializer(resourceContext);
-            return fieldSet.Contains(relationship);
-        }
-
-        /// <inheritdoc />
-        public override ResourceObject Build(IIdentifiable resource, IReadOnlyCollection<AttrAttribute> attributes = null,
-            IReadOnlyCollection<RelationshipAttribute> relationships = null)
-        {
-            ResourceObject resourceObject = base.Build(resource, attributes, relationships);
-
-            resourceObject.Meta = _resourceDefinitionAccessor.GetMeta(resource.GetType(), resource);
-
-            return resourceObject;
-        }
-
-        /// <inheritdoc />
-        public void IncludeRelationshipChain(IReadOnlyCollection<RelationshipAttribute> inclusionChain, IIdentifiable rootResource)
-        {
-            ArgumentGuard.NotNull(inclusionChain, nameof(inclusionChain));
-            ArgumentGuard.NotNull(rootResource, nameof(rootResource));
-
-            // We don't have to build a resource object for the root resource because
-            // this one is already encoded in the documents primary data, so we process the chain
-            // starting from the first related resource.
-            RelationshipAttribute relationship = inclusionChain.First();
-            IList<RelationshipAttribute> chainRemainder = ShiftChain(inclusionChain);
-            object related = relationship.GetValue(rootResource);
-            ProcessChain(related, chainRemainder);
-        }
-
-        private void ProcessChain(object related, IList<RelationshipAttribute> inclusionChain)
-        {
-            if (related is IEnumerable children)
-            {
-                foreach (IIdentifiable child in children)
-                {
-                    ProcessRelationship(child, inclusionChain);
-                }
-            }
-            else
-            {
-                ProcessRelationship((IIdentifiable)related, inclusionChain);
-            }
-        }
-
-        private void ProcessRelationship(IIdentifiable parent, IList<RelationshipAttribute> inclusionChain)
-        {
-            if (parent == null)
-            {
-                return;
-            }
-
-            ResourceObject resourceObject = TryGetBuiltResourceObjectFor(parent);
-
-            if (resourceObject == null)
-            {
-                _resourceDefinitionAccessor.OnSerialize(parent);
-
-                resourceObject = BuildCachedResourceObjectFor(parent);
-            }
-
-            if (!inclusionChain.Any())
-            {
-                return;
-            }
-
-            RelationshipAttribute nextRelationship = inclusionChain.First();
-            List<RelationshipAttribute> chainRemainder = inclusionChain.ToList();
-            chainRemainder.RemoveAt(0);
-
-            string nextRelationshipName = nextRelationship.PublicName;
-            IDictionary<string, RelationshipObject> relationshipsObject = resourceObject.Relationships;
-
-            if (!relationshipsObject.TryGetValue(nextRelationshipName, out RelationshipObject relationshipObject))
-            {
-                relationshipObject = GetRelationshipData(nextRelationship, parent);
-                relationshipsObject[nextRelationshipName] = relationshipObject;
-            }
-
-            relationshipObject.Data = GetRelatedResourceLinkage(nextRelationship, parent);
-
-            if (relationshipObject.Data.IsAssigned && relationshipObject.Data.Value != null)
-            {
-                // if the relationship is set, continue parsing the chain.
-                object related = nextRelationship.GetValue(parent);
-                ProcessChain(related, chainRemainder);
-            }
-        }
-
-        private IList<RelationshipAttribute> ShiftChain(IReadOnlyCollection<RelationshipAttribute> chain)
-        {
-            List<RelationshipAttribute> chainRemainder = chain.ToList();
-            chainRemainder.RemoveAt(0);
-            return chainRemainder;
-        }
-
-        /// <summary>
-        /// We only need an empty relationship object here. It will be populated in the ProcessRelationships method.
-        /// </summary>
-        protected override RelationshipObject GetRelationshipData(RelationshipAttribute relationship, IIdentifiable resource)
-        {
-            ArgumentGuard.NotNull(relationship, nameof(relationship));
-            ArgumentGuard.NotNull(resource, nameof(resource));
-
-            return new RelationshipObject
-            {
-                Links = _linkBuilder.GetRelationshipLinks(relationship, resource)
-            };
-        }
-
-        private ResourceObject TryGetBuiltResourceObjectFor(IIdentifiable resource)
-        {
-            Type resourceType = resource.GetType();
-            ResourceContext resourceContext = ResourceGraph.GetResourceContext(resourceType);
-
-            return _included.SingleOrDefault(resourceObject => resourceObject.Type == resourceContext.PublicName && resourceObject.Id == resource.StringId);
-        }
-
-        private ResourceObject BuildCachedResourceObjectFor(IIdentifiable resource)
-        {
-            Type resourceType = resource.GetType();
-            IReadOnlyCollection<AttrAttribute> attributes = _fieldsToSerialize.GetAttributes(resourceType);
-            IReadOnlyCollection<RelationshipAttribute> relationships = _fieldsToSerialize.GetRelationships(resourceType);
-
-            ResourceObject resourceObject = Build(resource, attributes, relationships);
-
-            _included.Add(resourceObject);
-
-            return resourceObject;
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/Building/ResourceIdentityComparer.cs b/src/JsonApiDotNetCore/Serialization/Building/ResourceIdentityComparer.cs
deleted file mode 100644
index 722008815e..0000000000
--- a/src/JsonApiDotNetCore/Serialization/Building/ResourceIdentityComparer.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-using System;
-using System.Collections.Generic;
-using JsonApiDotNetCore.Serialization.Objects;
-
-namespace JsonApiDotNetCore.Serialization.Building
-{
-    internal sealed class ResourceIdentityComparer : IEqualityComparer<IResourceIdentity>
-    {
-        public static readonly ResourceIdentityComparer Instance = new();
-
-        private ResourceIdentityComparer()
-        {
-        }
-
-        public bool Equals(IResourceIdentity x, IResourceIdentity y)
-        {
-            if (ReferenceEquals(x, y))
-            {
-                return true;
-            }
-
-            if (x is null || y is null || x.GetType() != y.GetType())
-            {
-                return false;
-            }
-
-            return x.Type == y.Type && x.Id == y.Id && x.Lid == y.Lid;
-        }
-
-        public int GetHashCode(IResourceIdentity obj)
-        {
-            return HashCode.Combine(obj.Type, obj.Id, obj.Lid);
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/Building/ResourceObjectBuilder.cs b/src/JsonApiDotNetCore/Serialization/Building/ResourceObjectBuilder.cs
deleted file mode 100644
index 6f78367108..0000000000
--- a/src/JsonApiDotNetCore/Serialization/Building/ResourceObjectBuilder.cs
+++ /dev/null
@@ -1,181 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Text.Json.Serialization;
-using JetBrains.Annotations;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Resources.Internal;
-using JsonApiDotNetCore.Serialization.Objects;
-
-namespace JsonApiDotNetCore.Serialization.Building
-{
-    /// <inheritdoc />
-    [PublicAPI]
-    public class ResourceObjectBuilder : IResourceObjectBuilder
-    {
-        private static readonly CollectionConverter CollectionConverter = new();
-        private readonly IJsonApiOptions _options;
-
-        protected IResourceGraph ResourceGraph { get; }
-
-        public ResourceObjectBuilder(IResourceGraph resourceGraph, IJsonApiOptions options)
-        {
-            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
-            ArgumentGuard.NotNull(options, nameof(options));
-
-            ResourceGraph = resourceGraph;
-            _options = options;
-        }
-
-        /// <inheritdoc />
-        public virtual ResourceObject Build(IIdentifiable resource, IReadOnlyCollection<AttrAttribute> attributes = null,
-            IReadOnlyCollection<RelationshipAttribute> relationships = null)
-        {
-            ArgumentGuard.NotNull(resource, nameof(resource));
-
-            ResourceContext resourceContext = ResourceGraph.GetResourceContext(resource.GetType());
-
-            // populating the top-level "type" and "id" members.
-            var resourceObject = new ResourceObject
-            {
-                Type = resourceContext.PublicName,
-                Id = resource.StringId
-            };
-
-            // populating the top-level "attribute" member of a resource object. never include "id" as an attribute
-            if (attributes != null)
-            {
-                AttrAttribute[] attributesWithoutId = attributes.Where(attr => attr.Property.Name != nameof(Identifiable.Id)).ToArray();
-
-                if (attributesWithoutId.Any())
-                {
-                    ProcessAttributes(resource, attributesWithoutId, resourceObject);
-                }
-            }
-
-            // populating the top-level "relationship" member of a resource object.
-            if (relationships != null)
-            {
-                ProcessRelationships(resource, relationships, resourceObject);
-            }
-
-            return resourceObject;
-        }
-
-        /// <summary>
-        /// Builds a <see cref="RelationshipObject" />. The default behavior is to just construct a resource linkage with the "data" field populated with
-        /// "single" or "many" data.
-        /// </summary>
-        protected virtual RelationshipObject GetRelationshipData(RelationshipAttribute relationship, IIdentifiable resource)
-        {
-            ArgumentGuard.NotNull(relationship, nameof(relationship));
-            ArgumentGuard.NotNull(resource, nameof(resource));
-
-            return new RelationshipObject
-            {
-                Data = GetRelatedResourceLinkage(relationship, resource)
-            };
-        }
-
-        /// <summary>
-        /// Gets the value for the data property.
-        /// </summary>
-        protected SingleOrManyData<ResourceIdentifierObject> GetRelatedResourceLinkage(RelationshipAttribute relationship, IIdentifiable resource)
-        {
-            ArgumentGuard.NotNull(relationship, nameof(relationship));
-            ArgumentGuard.NotNull(resource, nameof(resource));
-
-            return relationship is HasOneAttribute hasOne
-                ? GetRelatedResourceLinkageForHasOne(hasOne, resource)
-                : GetRelatedResourceLinkageForHasMany((HasManyAttribute)relationship, resource);
-        }
-
-        /// <summary>
-        /// Builds a <see cref="ResourceIdentifierObject" /> for a HasOne relationship.
-        /// </summary>
-        private SingleOrManyData<ResourceIdentifierObject> GetRelatedResourceLinkageForHasOne(HasOneAttribute relationship, IIdentifiable resource)
-        {
-            var relatedResource = (IIdentifiable)relationship.GetValue(resource);
-            ResourceIdentifierObject resourceIdentifierObject = relatedResource != null ? GetResourceIdentifier(relatedResource) : null;
-            return new SingleOrManyData<ResourceIdentifierObject>(resourceIdentifierObject);
-        }
-
-        /// <summary>
-        /// Builds the <see cref="ResourceIdentifierObject" />s for a HasMany relationship.
-        /// </summary>
-        private SingleOrManyData<ResourceIdentifierObject> GetRelatedResourceLinkageForHasMany(HasManyAttribute relationship, IIdentifiable resource)
-        {
-            object value = relationship.GetValue(resource);
-            ICollection<IIdentifiable> relatedResources = CollectionConverter.ExtractResources(value);
-
-            var manyData = new List<ResourceIdentifierObject>();
-
-            if (relatedResources != null)
-            {
-                foreach (IIdentifiable relatedResource in relatedResources)
-                {
-                    manyData.Add(GetResourceIdentifier(relatedResource));
-                }
-            }
-
-            return new SingleOrManyData<ResourceIdentifierObject>(manyData);
-        }
-
-        /// <summary>
-        /// Creates a <see cref="ResourceIdentifierObject" /> from <paramref name="resource" />.
-        /// </summary>
-        private ResourceIdentifierObject GetResourceIdentifier(IIdentifiable resource)
-        {
-            string publicName = ResourceGraph.GetResourceContext(resource.GetType()).PublicName;
-
-            return new ResourceIdentifierObject
-            {
-                Type = publicName,
-                Id = resource.StringId
-            };
-        }
-
-        /// <summary>
-        /// Puts the relationships of the resource into the resource object.
-        /// </summary>
-        private void ProcessRelationships(IIdentifiable resource, IEnumerable<RelationshipAttribute> relationships, ResourceObject ro)
-        {
-            foreach (RelationshipAttribute rel in relationships)
-            {
-                RelationshipObject relData = GetRelationshipData(rel, resource);
-
-                if (relData != null)
-                {
-                    (ro.Relationships ??= new Dictionary<string, RelationshipObject>()).Add(rel.PublicName, relData);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Puts the attributes of the resource into the resource object.
-        /// </summary>
-        private void ProcessAttributes(IIdentifiable resource, IEnumerable<AttrAttribute> attributes, ResourceObject ro)
-        {
-            ro.Attributes = new Dictionary<string, object>();
-
-            foreach (AttrAttribute attr in attributes)
-            {
-                object value = attr.GetValue(resource);
-
-                if (_options.SerializerOptions.DefaultIgnoreCondition == JsonIgnoreCondition.WhenWritingNull && value == null)
-                {
-                    continue;
-                }
-
-                if (_options.SerializerOptions.DefaultIgnoreCondition == JsonIgnoreCondition.WhenWritingDefault &&
-                    Equals(value, RuntimeTypeConverter.GetDefaultValue(attr.Property.PropertyType)))
-                {
-                    continue;
-                }
-
-                ro.Attributes.Add(attr.PublicName, value);
-            }
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/Building/ResponseResourceObjectBuilder.cs b/src/JsonApiDotNetCore/Serialization/Building/ResponseResourceObjectBuilder.cs
deleted file mode 100644
index 7138b6a12b..0000000000
--- a/src/JsonApiDotNetCore/Serialization/Building/ResponseResourceObjectBuilder.cs
+++ /dev/null
@@ -1,142 +0,0 @@
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using JetBrains.Annotations;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Queries;
-using JsonApiDotNetCore.Queries.Expressions;
-using JsonApiDotNetCore.Queries.Internal;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization.Objects;
-
-namespace JsonApiDotNetCore.Serialization.Building
-{
-    [PublicAPI]
-    public class ResponseResourceObjectBuilder : ResourceObjectBuilder
-    {
-        private static readonly IncludeChainConverter IncludeChainConverter = new();
-
-        private readonly ILinkBuilder _linkBuilder;
-        private readonly IIncludedResourceObjectBuilder _includedBuilder;
-        private readonly IResourceDefinitionAccessor _resourceDefinitionAccessor;
-        private readonly IEvaluatedIncludeCache _evaluatedIncludeCache;
-        private readonly SparseFieldSetCache _sparseFieldSetCache;
-
-        private RelationshipAttribute _requestRelationship;
-
-        public ResponseResourceObjectBuilder(ILinkBuilder linkBuilder, IIncludedResourceObjectBuilder includedBuilder,
-            IEnumerable<IQueryConstraintProvider> constraintProviders, IResourceGraph resourceGraph, IResourceDefinitionAccessor resourceDefinitionAccessor,
-            IJsonApiOptions options, IEvaluatedIncludeCache evaluatedIncludeCache)
-            : base(resourceGraph, options)
-        {
-            ArgumentGuard.NotNull(linkBuilder, nameof(linkBuilder));
-            ArgumentGuard.NotNull(includedBuilder, nameof(includedBuilder));
-            ArgumentGuard.NotNull(constraintProviders, nameof(constraintProviders));
-            ArgumentGuard.NotNull(resourceDefinitionAccessor, nameof(resourceDefinitionAccessor));
-            ArgumentGuard.NotNull(evaluatedIncludeCache, nameof(evaluatedIncludeCache));
-
-            _linkBuilder = linkBuilder;
-            _includedBuilder = includedBuilder;
-            _resourceDefinitionAccessor = resourceDefinitionAccessor;
-            _evaluatedIncludeCache = evaluatedIncludeCache;
-            _sparseFieldSetCache = new SparseFieldSetCache(constraintProviders, resourceDefinitionAccessor);
-        }
-
-        public RelationshipObject Build(IIdentifiable resource, RelationshipAttribute requestRelationship)
-        {
-            ArgumentGuard.NotNull(resource, nameof(resource));
-            ArgumentGuard.NotNull(requestRelationship, nameof(requestRelationship));
-
-            _requestRelationship = requestRelationship;
-            return GetRelationshipData(requestRelationship, resource);
-        }
-
-        /// <inheritdoc />
-        public override ResourceObject Build(IIdentifiable resource, IReadOnlyCollection<AttrAttribute> attributes = null,
-            IReadOnlyCollection<RelationshipAttribute> relationships = null)
-        {
-            ResourceObject resourceObject = base.Build(resource, attributes, relationships);
-
-            resourceObject.Meta = _resourceDefinitionAccessor.GetMeta(resource.GetType(), resource);
-
-            return resourceObject;
-        }
-
-        /// <summary>
-        /// Builds a <see cref="RelationshipObject" /> for the specified relationship on a resource. The serializer only populates the "data" member when the
-        /// relationship is included, and adds links unless these are turned off. This means that if a relationship is not included and links are turned off, the
-        /// object would be completely empty, ie { }, which is not conform JSON:API spec. In that case we return null, which will omit the object from the
-        /// output.
-        /// </summary>
-        protected override RelationshipObject GetRelationshipData(RelationshipAttribute relationship, IIdentifiable resource)
-        {
-            ArgumentGuard.NotNull(relationship, nameof(relationship));
-            ArgumentGuard.NotNull(resource, nameof(resource));
-
-            RelationshipObject relationshipObject = null;
-            IReadOnlyCollection<IReadOnlyCollection<RelationshipAttribute>> relationshipChains = GetInclusionChainsStartingWith(relationship);
-
-            if (Equals(relationship, _requestRelationship) || relationshipChains.Any())
-            {
-                relationshipObject = base.GetRelationshipData(relationship, resource);
-
-                if (relationshipChains.Any() && relationshipObject.Data.Value != null)
-                {
-                    foreach (IReadOnlyCollection<RelationshipAttribute> chain in relationshipChains)
-                    {
-                        // traverses (recursively) and extracts all (nested) related resources for the current inclusion chain.
-                        _includedBuilder.IncludeRelationshipChain(chain, resource);
-                    }
-                }
-            }
-
-            if (!IsRelationshipInSparseFieldSet(relationship))
-            {
-                return null;
-            }
-
-            RelationshipLinks links = _linkBuilder.GetRelationshipLinks(relationship, resource);
-
-            if (links != null)
-            {
-                // if relationshipLinks should be built, populate the "links" field.
-                relationshipObject ??= new RelationshipObject();
-                relationshipObject.Links = links;
-            }
-
-            // if neither "links" nor "data" was populated, return null, which will omit this object from the output.
-            // (see the NullValueHandling settings on <see cref="ResourceObject"/>)
-            return relationshipObject;
-        }
-
-        private bool IsRelationshipInSparseFieldSet(RelationshipAttribute relationship)
-        {
-            ResourceContext resourceContext = ResourceGraph.GetResourceContext(relationship.LeftType);
-
-            IImmutableSet<ResourceFieldAttribute> fieldSet = _sparseFieldSetCache.GetSparseFieldSetForSerializer(resourceContext);
-            return fieldSet.Contains(relationship);
-        }
-
-        /// <summary>
-        /// Inspects the included relationship chains and selects the ones that starts with the specified relationship.
-        /// </summary>
-        private IReadOnlyCollection<IReadOnlyCollection<RelationshipAttribute>> GetInclusionChainsStartingWith(RelationshipAttribute relationship)
-        {
-            IncludeExpression include = _evaluatedIncludeCache.Get() ?? IncludeExpression.Empty;
-            IReadOnlyCollection<ResourceFieldChainExpression> chains = IncludeChainConverter.GetRelationshipChains(include);
-
-            var inclusionChains = new List<IReadOnlyCollection<RelationshipAttribute>>();
-
-            foreach (ResourceFieldChainExpression chain in chains)
-            {
-                if (chain.Fields[0].Equals(relationship))
-                {
-                    inclusionChains.Add(chain.Fields.Cast<RelationshipAttribute>().ToArray());
-                }
-            }
-
-            return inclusionChains;
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/FieldsToSerialize.cs b/src/JsonApiDotNetCore/Serialization/FieldsToSerialize.cs
deleted file mode 100644
index e19ff666d3..0000000000
--- a/src/JsonApiDotNetCore/Serialization/FieldsToSerialize.cs
+++ /dev/null
@@ -1,89 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using JetBrains.Annotations;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Middleware;
-using JsonApiDotNetCore.Queries;
-using JsonApiDotNetCore.Queries.Internal;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-
-namespace JsonApiDotNetCore.Serialization
-{
-    /// <inheritdoc />
-    [PublicAPI]
-    public class FieldsToSerialize : IFieldsToSerialize
-    {
-        private readonly IResourceGraph _resourceGraph;
-        private readonly IJsonApiRequest _request;
-        private readonly SparseFieldSetCache _sparseFieldSetCache;
-
-        /// <inheritdoc />
-        public bool ShouldSerialize => _request.Kind != EndpointKind.Relationship;
-
-        public FieldsToSerialize(IResourceGraph resourceGraph, IEnumerable<IQueryConstraintProvider> constraintProviders,
-            IResourceDefinitionAccessor resourceDefinitionAccessor, IJsonApiRequest request)
-        {
-            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
-            ArgumentGuard.NotNull(request, nameof(request));
-
-            _resourceGraph = resourceGraph;
-            _request = request;
-            _sparseFieldSetCache = new SparseFieldSetCache(constraintProviders, resourceDefinitionAccessor);
-        }
-
-        /// <inheritdoc />
-        public IReadOnlyCollection<AttrAttribute> GetAttributes(Type resourceType)
-        {
-            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
-
-            if (!ShouldSerialize)
-            {
-                return Array.Empty<AttrAttribute>();
-            }
-
-            ResourceContext resourceContext = _resourceGraph.GetResourceContext(resourceType);
-            IImmutableSet<ResourceFieldAttribute> fieldSet = _sparseFieldSetCache.GetSparseFieldSetForSerializer(resourceContext);
-
-            return SortAttributesInDeclarationOrder(fieldSet, resourceContext).ToArray();
-        }
-
-        private IEnumerable<AttrAttribute> SortAttributesInDeclarationOrder(IImmutableSet<ResourceFieldAttribute> fieldSet, ResourceContext resourceContext)
-        {
-            foreach (AttrAttribute attribute in resourceContext.Attributes)
-            {
-                if (fieldSet.Contains(attribute))
-                {
-                    yield return attribute;
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        /// <remarks>
-        /// Note: this method does NOT check if a relationship is included to determine if it should be serialized. This is because completely hiding a
-        /// relationship is not the same as not including. In the case of the latter, we may still want to add the relationship to expose the navigation link to
-        /// the client.
-        /// </remarks>
-        public IReadOnlyCollection<RelationshipAttribute> GetRelationships(Type resourceType)
-        {
-            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
-
-            if (!ShouldSerialize)
-            {
-                return Array.Empty<RelationshipAttribute>();
-            }
-
-            ResourceContext resourceContext = _resourceGraph.GetResourceContext(resourceType);
-            return resourceContext.Relationships;
-        }
-
-        /// <inheritdoc />
-        public void ResetCache()
-        {
-            _sparseFieldSetCache.Reset();
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/IFieldsToSerialize.cs b/src/JsonApiDotNetCore/Serialization/IFieldsToSerialize.cs
deleted file mode 100644
index 682301b040..0000000000
--- a/src/JsonApiDotNetCore/Serialization/IFieldsToSerialize.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-using System;
-using System.Collections.Generic;
-using JsonApiDotNetCore.Resources.Annotations;
-
-namespace JsonApiDotNetCore.Serialization
-{
-    /// <summary>
-    /// Responsible for getting the set of fields that are to be included for a given type in the serialization result. Typically combines various sources of
-    /// information, like application-wide and request-wide sparse fieldsets.
-    /// </summary>
-    public interface IFieldsToSerialize
-    {
-        /// <summary>
-        /// Indicates whether attributes and relationships should be serialized, based on the current endpoint.
-        /// </summary>
-        bool ShouldSerialize { get; }
-
-        /// <summary>
-        /// Gets the collection of attributes that are to be serialized for resources of type <paramref name="resourceType" />.
-        /// </summary>
-        IReadOnlyCollection<AttrAttribute> GetAttributes(Type resourceType);
-
-        /// <summary>
-        /// Gets the collection of relationships that are to be serialized for resources of type <paramref name="resourceType" />.
-        /// </summary>
-        IReadOnlyCollection<RelationshipAttribute> GetRelationships(Type resourceType);
-
-        /// <summary>
-        /// Clears internal caches.
-        /// </summary>
-        void ResetCache();
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/IJsonApiDeserializer.cs b/src/JsonApiDotNetCore/Serialization/IJsonApiDeserializer.cs
deleted file mode 100644
index ea392575b9..0000000000
--- a/src/JsonApiDotNetCore/Serialization/IJsonApiDeserializer.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-using JsonApiDotNetCore.Serialization.Objects;
-
-namespace JsonApiDotNetCore.Serialization
-{
-    /// <summary>
-    /// Deserializer used internally in JsonApiDotNetCore to deserialize requests.
-    /// </summary>
-    public interface IJsonApiDeserializer
-    {
-        /// <summary>
-        /// Deserializes JSON into a <see cref="Document" /> and constructs resources from the 'data' element.
-        /// </summary>
-        /// <param name="body">
-        /// The JSON to be deserialized.
-        /// </param>
-        object Deserialize(string body);
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/IJsonApiReader.cs b/src/JsonApiDotNetCore/Serialization/IJsonApiReader.cs
deleted file mode 100644
index dbc851a492..0000000000
--- a/src/JsonApiDotNetCore/Serialization/IJsonApiReader.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-using System.Threading.Tasks;
-using JetBrains.Annotations;
-using Microsoft.AspNetCore.Mvc.Formatters;
-
-namespace JsonApiDotNetCore.Serialization
-{
-    /// <summary>
-    /// The deserializer of the body, used in ASP.NET Core internally to process `FromBody`.
-    /// </summary>
-    [PublicAPI]
-    public interface IJsonApiReader
-    {
-        Task<InputFormatterResult> ReadAsync(InputFormatterContext context);
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/IJsonApiSerializer.cs b/src/JsonApiDotNetCore/Serialization/IJsonApiSerializer.cs
deleted file mode 100644
index 97f0a15747..0000000000
--- a/src/JsonApiDotNetCore/Serialization/IJsonApiSerializer.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-namespace JsonApiDotNetCore.Serialization
-{
-    /// <summary>
-    /// Serializer used internally in JsonApiDotNetCore to serialize responses.
-    /// </summary>
-    public interface IJsonApiSerializer
-    {
-        /// <summary>
-        /// Gets the Content-Type HTTP header value.
-        /// </summary>
-        string ContentType { get; }
-
-        /// <summary>
-        /// Serializes a single resource or a collection of resources.
-        /// </summary>
-        string Serialize(object content);
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/IJsonApiSerializerFactory.cs b/src/JsonApiDotNetCore/Serialization/IJsonApiSerializerFactory.cs
deleted file mode 100644
index 38796a596e..0000000000
--- a/src/JsonApiDotNetCore/Serialization/IJsonApiSerializerFactory.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-using JetBrains.Annotations;
-
-namespace JsonApiDotNetCore.Serialization
-{
-    [PublicAPI]
-    public interface IJsonApiSerializerFactory
-    {
-        /// <summary>
-        /// Instantiates the serializer to process the servers response.
-        /// </summary>
-        IJsonApiSerializer GetSerializer();
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/IJsonApiWriter.cs b/src/JsonApiDotNetCore/Serialization/IJsonApiWriter.cs
deleted file mode 100644
index ac29395115..0000000000
--- a/src/JsonApiDotNetCore/Serialization/IJsonApiWriter.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using System.Threading.Tasks;
-using JetBrains.Annotations;
-using Microsoft.AspNetCore.Mvc.Formatters;
-
-namespace JsonApiDotNetCore.Serialization
-{
-    [PublicAPI]
-    public interface IJsonApiWriter
-    {
-        Task WriteAsync(OutputFormatterWriteContext context);
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/JsonApiReader.cs b/src/JsonApiDotNetCore/Serialization/JsonApiReader.cs
deleted file mode 100644
index af634f9876..0000000000
--- a/src/JsonApiDotNetCore/Serialization/JsonApiReader.cs
+++ /dev/null
@@ -1,278 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Net;
-using System.Net.Http;
-using System.Threading.Tasks;
-using JetBrains.Annotations;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Diagnostics;
-using JsonApiDotNetCore.Errors;
-using JsonApiDotNetCore.Middleware;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization.Objects;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Http.Extensions;
-using Microsoft.AspNetCore.Mvc.Formatters;
-using Microsoft.Extensions.Logging;
-
-namespace JsonApiDotNetCore.Serialization
-{
-    /// <inheritdoc />
-    [PublicAPI]
-    public class JsonApiReader : IJsonApiReader
-    {
-        private readonly IJsonApiDeserializer _deserializer;
-        private readonly IJsonApiRequest _request;
-        private readonly IResourceGraph _resourceGraph;
-        private readonly TraceLogWriter<JsonApiReader> _traceWriter;
-
-        public JsonApiReader(IJsonApiDeserializer deserializer, IJsonApiRequest request, IResourceGraph resourceGraph, ILoggerFactory loggerFactory)
-        {
-            ArgumentGuard.NotNull(deserializer, nameof(deserializer));
-            ArgumentGuard.NotNull(request, nameof(request));
-            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
-            ArgumentGuard.NotNull(loggerFactory, nameof(loggerFactory));
-
-            _deserializer = deserializer;
-            _request = request;
-            _resourceGraph = resourceGraph;
-            _traceWriter = new TraceLogWriter<JsonApiReader>(loggerFactory);
-        }
-
-        public async Task<InputFormatterResult> ReadAsync(InputFormatterContext context)
-        {
-            ArgumentGuard.NotNull(context, nameof(context));
-
-            using IDisposable _ = CodeTimingSessionManager.Current.Measure("Read request body");
-
-            string body = await GetRequestBodyAsync(context.HttpContext.Request.Body);
-
-            string url = context.HttpContext.Request.GetEncodedUrl();
-            _traceWriter.LogMessage(() => $"Received {context.HttpContext.Request.Method} request at '{url}' with body: <<{body}>>");
-
-            object model = null;
-
-            if (!string.IsNullOrWhiteSpace(body))
-            {
-                try
-                {
-                    model = _deserializer.Deserialize(body);
-                }
-                catch (JsonApiSerializationException exception)
-                {
-                    throw ToInvalidRequestBodyException(exception, body);
-                }
-#pragma warning disable AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException
-                catch (Exception exception)
-#pragma warning restore AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException
-                {
-                    throw new InvalidRequestBodyException(null, null, body, exception);
-                }
-            }
-
-            if (_request.Kind == EndpointKind.AtomicOperations)
-            {
-                AssertHasRequestBody(model, body);
-            }
-            else if (RequiresRequestBody(context.HttpContext.Request.Method))
-            {
-                ValidateRequestBody(model, body, context.HttpContext.Request);
-            }
-
-            // ReSharper disable once AssignNullToNotNullAttribute
-            // Justification: According to JSON:API we must return 200 OK without a body in some cases.
-            return await InputFormatterResult.SuccessAsync(model);
-        }
-
-        private async Task<string> GetRequestBodyAsync(Stream bodyStream)
-        {
-            using var reader = new StreamReader(bodyStream, leaveOpen: true);
-            return await reader.ReadToEndAsync();
-        }
-
-        private InvalidRequestBodyException ToInvalidRequestBodyException(JsonApiSerializationException exception, string body)
-        {
-            if (_request.Kind != EndpointKind.AtomicOperations)
-            {
-                return new InvalidRequestBodyException(exception.GenericMessage, exception.SpecificMessage, body, exception);
-            }
-
-            // In contrast to resource endpoints, we don't include the request body for operations because they are usually very long.
-            var requestException = new InvalidRequestBodyException(exception.GenericMessage, exception.SpecificMessage, null, exception.InnerException);
-
-            if (exception.AtomicOperationIndex != null)
-            {
-                foreach (ErrorObject error in requestException.Errors)
-                {
-                    error.Source ??= new ErrorSource();
-                    error.Source.Pointer = $"/atomic:operations[{exception.AtomicOperationIndex}]";
-                }
-            }
-
-            return requestException;
-        }
-
-        private bool RequiresRequestBody(string requestMethod)
-        {
-            if (requestMethod == HttpMethods.Post || requestMethod == HttpMethods.Patch)
-            {
-                return true;
-            }
-
-            return requestMethod == HttpMethods.Delete && _request.Kind == EndpointKind.Relationship;
-        }
-
-        private void ValidateRequestBody(object model, string body, HttpRequest httpRequest)
-        {
-            AssertHasRequestBody(model, body);
-
-            ValidateIncomingResourceType(model, httpRequest);
-
-            if (httpRequest.Method != HttpMethods.Post || _request.Kind == EndpointKind.Relationship)
-            {
-                ValidateRequestIncludesId(model, body);
-                ValidatePrimaryIdValue(model, httpRequest.Path);
-            }
-
-            if (_request.Kind == EndpointKind.Relationship)
-            {
-                ValidateForRelationshipType(httpRequest.Method, model, body);
-            }
-        }
-
-        [AssertionMethod]
-        private static void AssertHasRequestBody(object model, string body)
-        {
-            if (model == null && string.IsNullOrWhiteSpace(body))
-            {
-                throw new JsonApiException(new ErrorObject(HttpStatusCode.BadRequest)
-                {
-                    Title = "Missing request body."
-                });
-            }
-        }
-
-        private void ValidateIncomingResourceType(object model, HttpRequest httpRequest)
-        {
-            Type endpointResourceType = GetResourceTypeFromEndpoint();
-
-            if (endpointResourceType == null)
-            {
-                return;
-            }
-
-            IEnumerable<Type> bodyResourceTypes = GetResourceTypesFromRequestBody(model);
-
-            foreach (Type bodyResourceType in bodyResourceTypes)
-            {
-                if (!endpointResourceType.IsAssignableFrom(bodyResourceType))
-                {
-                    ResourceContext resourceFromEndpoint = _resourceGraph.GetResourceContext(endpointResourceType);
-                    ResourceContext resourceFromBody = _resourceGraph.GetResourceContext(bodyResourceType);
-
-                    throw new ResourceTypeMismatchException(new HttpMethod(httpRequest.Method), httpRequest.Path, resourceFromEndpoint, resourceFromBody);
-                }
-            }
-        }
-
-        private Type GetResourceTypeFromEndpoint()
-        {
-            return _request.Kind == EndpointKind.Primary ? _request.PrimaryResource.ResourceType : _request.SecondaryResource?.ResourceType;
-        }
-
-        private IEnumerable<Type> GetResourceTypesFromRequestBody(object model)
-        {
-            if (model is IEnumerable<IIdentifiable> resourceCollection)
-            {
-                return resourceCollection.Select(resource => resource.GetType()).Distinct();
-            }
-
-            return model == null ? Enumerable.Empty<Type>() : model.GetType().AsEnumerable();
-        }
-
-        private void ValidateRequestIncludesId(object model, string body)
-        {
-            bool hasMissingId = model is IEnumerable list ? HasMissingId(list) : HasMissingId(model);
-
-            if (hasMissingId)
-            {
-                throw new InvalidRequestBodyException("Request body must include 'id' element.", null, body);
-            }
-        }
-
-        private void ValidatePrimaryIdValue(object model, PathString requestPath)
-        {
-            if (_request.Kind == EndpointKind.Primary)
-            {
-                if (TryGetId(model, out string bodyId) && bodyId != _request.PrimaryId)
-                {
-                    throw new ResourceIdMismatchException(bodyId, _request.PrimaryId, requestPath);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Checks if the deserialized request body has an ID included.
-        /// </summary>
-        private bool HasMissingId(object model)
-        {
-            return TryGetId(model, out string id) && id == null;
-        }
-
-        /// <summary>
-        /// Checks if all elements in the deserialized request body have an ID included.
-        /// </summary>
-        private bool HasMissingId(IEnumerable models)
-        {
-            foreach (object model in models)
-            {
-                if (TryGetId(model, out string id) && id == null)
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        private static bool TryGetId(object model, out string id)
-        {
-            if (model is IIdentifiable identifiable)
-            {
-                id = identifiable.StringId;
-                return true;
-            }
-
-            id = null;
-            return false;
-        }
-
-        [AssertionMethod]
-        private void ValidateForRelationshipType(string requestMethod, object model, string body)
-        {
-            if (_request.Relationship is HasOneAttribute)
-            {
-                if (requestMethod == HttpMethods.Post || requestMethod == HttpMethods.Delete)
-                {
-                    throw new ToManyRelationshipRequiredException(_request.Relationship.PublicName);
-                }
-
-                if (model is { } and not IIdentifiable)
-                {
-                    throw new InvalidRequestBodyException("Expected single data element for to-one relationship.",
-                        $"Expected single data element for '{_request.Relationship.PublicName}' relationship.", body);
-                }
-            }
-
-            if (_request.Relationship is HasManyAttribute && model is not IEnumerable<IIdentifiable>)
-            {
-                throw new InvalidRequestBodyException("Expected data[] element for to-many relationship.",
-                    $"Expected data[] element for '{_request.Relationship.PublicName}' relationship.", body);
-            }
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/JsonApiSerializationException.cs b/src/JsonApiDotNetCore/Serialization/JsonApiSerializationException.cs
deleted file mode 100644
index 15fd8c8075..0000000000
--- a/src/JsonApiDotNetCore/Serialization/JsonApiSerializationException.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System;
-using JetBrains.Annotations;
-
-namespace JsonApiDotNetCore.Serialization
-{
-    /// <summary>
-    /// The error that is thrown when (de)serialization of a JSON:API body fails.
-    /// </summary>
-    [PublicAPI]
-    public sealed class JsonApiSerializationException : Exception
-    {
-        public string GenericMessage { get; }
-        public string SpecificMessage { get; }
-        public int? AtomicOperationIndex { get; }
-
-        public JsonApiSerializationException(string genericMessage, string specificMessage, Exception innerException = null, int? atomicOperationIndex = null)
-            : base(genericMessage, innerException)
-        {
-            GenericMessage = genericMessage;
-            SpecificMessage = specificMessage;
-            AtomicOperationIndex = atomicOperationIndex;
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/JsonApiWriter.cs b/src/JsonApiDotNetCore/Serialization/JsonApiWriter.cs
deleted file mode 100644
index 5ca93865c7..0000000000
--- a/src/JsonApiDotNetCore/Serialization/JsonApiWriter.cs
+++ /dev/null
@@ -1,189 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Net;
-using System.Net.Http;
-using System.Text;
-using System.Threading.Tasks;
-using JetBrains.Annotations;
-using JsonApiDotNetCore.Diagnostics;
-using JsonApiDotNetCore.Errors;
-using JsonApiDotNetCore.Middleware;
-using JsonApiDotNetCore.Serialization.Objects;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Http.Extensions;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.Mvc.Formatters;
-using Microsoft.Extensions.Logging;
-using Microsoft.Net.Http.Headers;
-
-namespace JsonApiDotNetCore.Serialization
-{
-    /// <summary>
-    /// Formats the response data used (see https://docs.microsoft.com/en-us/aspnet/core/web-api/advanced/formatting?view=aspnetcore-3.0). It was intended to
-    /// have as little dependencies as possible in formatting layer for greater extensibility.
-    /// </summary>
-    [PublicAPI]
-    public class JsonApiWriter : IJsonApiWriter
-    {
-        private readonly IJsonApiSerializer _serializer;
-        private readonly IExceptionHandler _exceptionHandler;
-        private readonly IETagGenerator _eTagGenerator;
-        private readonly TraceLogWriter<JsonApiWriter> _traceWriter;
-
-        public JsonApiWriter(IJsonApiSerializer serializer, IExceptionHandler exceptionHandler, IETagGenerator eTagGenerator, ILoggerFactory loggerFactory)
-        {
-            ArgumentGuard.NotNull(serializer, nameof(serializer));
-            ArgumentGuard.NotNull(exceptionHandler, nameof(exceptionHandler));
-            ArgumentGuard.NotNull(eTagGenerator, nameof(eTagGenerator));
-            ArgumentGuard.NotNull(loggerFactory, nameof(loggerFactory));
-
-            _serializer = serializer;
-            _exceptionHandler = exceptionHandler;
-            _eTagGenerator = eTagGenerator;
-            _traceWriter = new TraceLogWriter<JsonApiWriter>(loggerFactory);
-        }
-
-        public async Task WriteAsync(OutputFormatterWriteContext context)
-        {
-            ArgumentGuard.NotNull(context, nameof(context));
-
-            using IDisposable _ = CodeTimingSessionManager.Current.Measure("Write response body");
-
-            HttpRequest request = context.HttpContext.Request;
-            HttpResponse response = context.HttpContext.Response;
-
-            await using TextWriter writer = context.WriterFactory(response.Body, Encoding.UTF8);
-            string responseContent;
-
-            try
-            {
-                responseContent = SerializeResponse(context.Object, (HttpStatusCode)response.StatusCode);
-            }
-#pragma warning disable AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException
-            catch (Exception exception)
-#pragma warning restore AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException
-            {
-                Document document = _exceptionHandler.HandleException(exception);
-                responseContent = _serializer.Serialize(document);
-
-                response.StatusCode = (int)document.GetErrorStatusCode();
-            }
-
-            bool hasMatchingETag = SetETagResponseHeader(request, response, responseContent);
-
-            if (hasMatchingETag)
-            {
-                response.StatusCode = (int)HttpStatusCode.NotModified;
-                responseContent = string.Empty;
-            }
-
-            if (request.Method == HttpMethod.Head.Method)
-            {
-                responseContent = string.Empty;
-            }
-
-            string url = request.GetEncodedUrl();
-
-            if (!string.IsNullOrEmpty(responseContent))
-            {
-                response.ContentType = _serializer.ContentType;
-            }
-
-            _traceWriter.LogMessage(() => $"Sending {response.StatusCode} response for {request.Method} request at '{url}' with body: <<{responseContent}>>");
-
-            await writer.WriteAsync(responseContent);
-            await writer.FlushAsync();
-        }
-
-        private string SerializeResponse(object contextObject, HttpStatusCode statusCode)
-        {
-            if (contextObject is ProblemDetails problemDetails)
-            {
-                throw new UnsuccessfulActionResultException(problemDetails);
-            }
-
-            if (contextObject == null)
-            {
-                if (!IsSuccessStatusCode(statusCode))
-                {
-                    throw new UnsuccessfulActionResultException(statusCode);
-                }
-
-                if (statusCode == HttpStatusCode.NoContent || statusCode == HttpStatusCode.ResetContent || statusCode == HttpStatusCode.NotModified)
-                {
-                    // Prevent exception from Kestrel server, caused by writing data:null json response.
-                    return null;
-                }
-            }
-
-            object contextObjectWrapped = WrapErrors(contextObject);
-
-            return _serializer.Serialize(contextObjectWrapped);
-        }
-
-        private bool IsSuccessStatusCode(HttpStatusCode statusCode)
-        {
-            return new HttpResponseMessage(statusCode).IsSuccessStatusCode;
-        }
-
-        private static object WrapErrors(object contextObject)
-        {
-            if (contextObject is IEnumerable<ErrorObject> errors)
-            {
-                return new Document
-                {
-                    Errors = errors.ToList()
-                };
-            }
-
-            if (contextObject is ErrorObject error)
-            {
-                return new Document
-                {
-                    Errors = error.AsList()
-                };
-            }
-
-            return contextObject;
-        }
-
-        private bool SetETagResponseHeader(HttpRequest request, HttpResponse response, string responseContent)
-        {
-            bool isReadOnly = request.Method == HttpMethod.Get.Method || request.Method == HttpMethod.Head.Method;
-
-            if (isReadOnly && response.StatusCode == (int)HttpStatusCode.OK)
-            {
-                string url = request.GetEncodedUrl();
-                EntityTagHeaderValue responseETag = _eTagGenerator.Generate(url, responseContent);
-
-                if (responseETag != null)
-                {
-                    response.Headers.Add(HeaderNames.ETag, responseETag.ToString());
-
-                    return RequestContainsMatchingETag(request.Headers, responseETag);
-                }
-            }
-
-            return false;
-        }
-
-        private static bool RequestContainsMatchingETag(IHeaderDictionary requestHeaders, EntityTagHeaderValue responseETag)
-        {
-            if (requestHeaders.Keys.Contains(HeaderNames.IfNoneMatch) &&
-                EntityTagHeaderValue.TryParseList(requestHeaders[HeaderNames.IfNoneMatch], out IList<EntityTagHeaderValue> requestETags))
-            {
-                foreach (EntityTagHeaderValue requestETag in requestETags)
-                {
-                    if (responseETag.Equals(requestETag))
-                    {
-                        return true;
-                    }
-                }
-            }
-
-            return false;
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/JsonObjectConverter.cs b/src/JsonApiDotNetCore/Serialization/JsonConverters/JsonObjectConverter.cs
similarity index 95%
rename from src/JsonApiDotNetCore/Serialization/JsonObjectConverter.cs
rename to src/JsonApiDotNetCore/Serialization/JsonConverters/JsonObjectConverter.cs
index 2a365317c4..51f19ac274 100644
--- a/src/JsonApiDotNetCore/Serialization/JsonObjectConverter.cs
+++ b/src/JsonApiDotNetCore/Serialization/JsonConverters/JsonObjectConverter.cs
@@ -1,7 +1,7 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace JsonApiDotNetCore.Serialization
+namespace JsonApiDotNetCore.Serialization.JsonConverters
 {
     public abstract class JsonObjectConverter<TObject> : JsonConverter<TObject>
     {
diff --git a/src/JsonApiDotNetCore/Serialization/JsonConverters/ResourceObjectConverter.cs b/src/JsonApiDotNetCore/Serialization/JsonConverters/ResourceObjectConverter.cs
index 4f0758fff0..a5e12175ba 100644
--- a/src/JsonApiDotNetCore/Serialization/JsonConverters/ResourceObjectConverter.cs
+++ b/src/JsonApiDotNetCore/Serialization/JsonConverters/ResourceObjectConverter.cs
@@ -7,6 +7,7 @@
 using JsonApiDotNetCore.Resources;
 using JsonApiDotNetCore.Resources.Annotations;
 using JsonApiDotNetCore.Serialization.Objects;
+using JsonApiDotNetCore.Serialization.Request;
 
 namespace JsonApiDotNetCore.Serialization.JsonConverters
 {
@@ -28,6 +29,8 @@ public sealed class ResourceObjectConverter : JsonObjectConverter<ResourceObject
 
         public ResourceObjectConverter(IResourceGraph resourceGraph)
         {
+            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
+
             _resourceGraph = resourceGraph;
         }
 
@@ -48,7 +51,7 @@ public override ResourceObject Read(ref Utf8JsonReader reader, Type typeToConver
                 Type = TryPeekType(ref reader)
             };
 
-            ResourceContext resourceContext = resourceObject.Type != null ? _resourceGraph.TryGetResourceContext(resourceObject.Type) : null;
+            ResourceType resourceType = resourceObject.Type != null ? _resourceGraph.TryGetResourceType(resourceObject.Type) : null;
 
             while (reader.Read())
             {
@@ -85,9 +88,9 @@ public override ResourceObject Read(ref Utf8JsonReader reader, Type typeToConver
                             }
                             case "attributes":
                             {
-                                if (resourceContext != null)
+                                if (resourceType != null)
                                 {
-                                    resourceObject.Attributes = ReadAttributes(ref reader, options, resourceContext);
+                                    resourceObject.Attributes = ReadAttributes(ref reader, options, resourceType);
                                 }
                                 else
                                 {
@@ -156,7 +159,7 @@ private static string TryPeekType(ref Utf8JsonReader reader)
             return null;
         }
 
-        private static IDictionary<string, object> ReadAttributes(ref Utf8JsonReader reader, JsonSerializerOptions options, ResourceContext resourceContext)
+        private static IDictionary<string, object> ReadAttributes(ref Utf8JsonReader reader, JsonSerializerOptions options, ResourceType resourceType)
         {
             var attributes = new Dictionary<string, object>();
 
@@ -173,7 +176,7 @@ private static IDictionary<string, object> ReadAttributes(ref Utf8JsonReader rea
                         string attributeName = reader.GetString();
                         reader.Read();
 
-                        AttrAttribute attribute = resourceContext.TryGetAttributeByPublicName(attributeName);
+                        AttrAttribute attribute = resourceType.TryGetAttributeByPublicName(attributeName);
                         PropertyInfo property = attribute?.Property;
 
                         if (property != null)
@@ -206,6 +209,7 @@ private static IDictionary<string, object> ReadAttributes(ref Utf8JsonReader rea
                         }
                         else
                         {
+                            attributes.Add(attributeName!, null);
                             reader.Skip();
                         }
 
diff --git a/src/JsonApiDotNetCore/Serialization/Objects/Document.cs b/src/JsonApiDotNetCore/Serialization/Objects/Document.cs
index ae3a09b9b1..995b2070e8 100644
--- a/src/JsonApiDotNetCore/Serialization/Objects/Document.cs
+++ b/src/JsonApiDotNetCore/Serialization/Objects/Document.cs
@@ -1,7 +1,4 @@
-using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Net;
 using System.Text.Json.Serialization;
 
 namespace JsonApiDotNetCore.Serialization.Objects
@@ -42,23 +39,5 @@ public sealed class Document
         [JsonPropertyName("meta")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public IDictionary<string, object> Meta { 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;
-        }
     }
 }
diff --git a/src/JsonApiDotNetCore/Serialization/Objects/ErrorObject.cs b/src/JsonApiDotNetCore/Serialization/Objects/ErrorObject.cs
index a5ac6be1a8..38326d2ae5 100644
--- a/src/JsonApiDotNetCore/Serialization/Objects/ErrorObject.cs
+++ b/src/JsonApiDotNetCore/Serialization/Objects/ErrorObject.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Net;
 using System.Text.Json.Serialization;
 using JetBrains.Annotations;
@@ -55,5 +56,23 @@ public ErrorObject(HttpStatusCode statusCode)
         {
             StatusCode = statusCode;
         }
+
+        public static HttpStatusCode GetResponseStatusCode(IReadOnlyList<ErrorObject> errorObjects)
+        {
+            if (errorObjects.IsNullOrEmpty())
+            {
+                return HttpStatusCode.InternalServerError;
+            }
+
+            int[] statusCodes = errorObjects.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;
+        }
     }
 }
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/AtomicOperationObjectAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/AtomicOperationObjectAdapter.cs
new file mode 100644
index 0000000000..317404fafe
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/AtomicOperationObjectAdapter.cs
@@ -0,0 +1,157 @@
+using System;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <inheritdoc />
+    public sealed class AtomicOperationObjectAdapter : IAtomicOperationObjectAdapter
+    {
+        private readonly IResourceDataInOperationsRequestAdapter _resourceDataInOperationsRequestAdapter;
+        private readonly IAtomicReferenceAdapter _atomicReferenceAdapter;
+        private readonly IRelationshipDataAdapter _relationshipDataAdapter;
+        private readonly IJsonApiOptions _options;
+
+        public AtomicOperationObjectAdapter(IJsonApiOptions options, IAtomicReferenceAdapter atomicReferenceAdapter,
+            IResourceDataInOperationsRequestAdapter resourceDataInOperationsRequestAdapter, IRelationshipDataAdapter relationshipDataAdapter)
+        {
+            ArgumentGuard.NotNull(options, nameof(options));
+            ArgumentGuard.NotNull(atomicReferenceAdapter, nameof(atomicReferenceAdapter));
+            ArgumentGuard.NotNull(resourceDataInOperationsRequestAdapter, nameof(resourceDataInOperationsRequestAdapter));
+            ArgumentGuard.NotNull(relationshipDataAdapter, nameof(relationshipDataAdapter));
+
+            _options = options;
+            _atomicReferenceAdapter = atomicReferenceAdapter;
+            _resourceDataInOperationsRequestAdapter = resourceDataInOperationsRequestAdapter;
+            _relationshipDataAdapter = relationshipDataAdapter;
+        }
+
+        /// <inheritdoc />
+        public OperationContainer Convert(AtomicOperationObject atomicOperationObject, RequestAdapterState state)
+        {
+            AssertNoHref(atomicOperationObject, state);
+
+            WriteOperationKind writeOperation = ConvertOperationCode(atomicOperationObject, state);
+
+            state.WritableTargetedFields = new TargetedFields();
+
+            state.WritableRequest = new JsonApiRequest
+            {
+                Kind = EndpointKind.AtomicOperations,
+                WriteOperation = writeOperation
+            };
+
+            (ResourceIdentityRequirements requirements, IIdentifiable primaryResource) = ConvertRef(atomicOperationObject, state);
+
+            if (writeOperation is WriteOperationKind.CreateResource or WriteOperationKind.UpdateResource)
+            {
+                primaryResource = _resourceDataInOperationsRequestAdapter.Convert(atomicOperationObject.Data, requirements, state);
+            }
+
+            return new OperationContainer(primaryResource, state.WritableTargetedFields, state.Request);
+        }
+
+        private static void AssertNoHref(AtomicOperationObject atomicOperationObject, RequestAdapterState state)
+        {
+            if (atomicOperationObject.Href != null)
+            {
+                using IDisposable _ = state.Position.PushElement("href");
+                throw new ModelConversionException(state.Position, "The 'href' element is not supported.", null);
+            }
+        }
+
+        private WriteOperationKind ConvertOperationCode(AtomicOperationObject atomicOperationObject, RequestAdapterState state)
+        {
+            switch (atomicOperationObject.Code)
+            {
+                case AtomicOperationCode.Add:
+                {
+                    if (atomicOperationObject.Ref is { Relationship: null })
+                    {
+                        using IDisposable _ = state.Position.PushElement("ref");
+                        throw new ModelConversionException(state.Position, "The 'relationship' element is required.", null);
+                    }
+
+                    return atomicOperationObject.Ref == null ? WriteOperationKind.CreateResource : WriteOperationKind.AddToRelationship;
+                }
+                case AtomicOperationCode.Update:
+                {
+                    return atomicOperationObject.Ref?.Relationship != null ? WriteOperationKind.SetRelationship : WriteOperationKind.UpdateResource;
+                }
+                case AtomicOperationCode.Remove:
+                {
+                    if (atomicOperationObject.Ref == null)
+                    {
+                        throw new ModelConversionException(state.Position, "The 'ref' element is required.", null);
+                    }
+
+                    return atomicOperationObject.Ref.Relationship != null ? WriteOperationKind.RemoveFromRelationship : WriteOperationKind.DeleteResource;
+                }
+            }
+
+            throw new NotSupportedException($"Unknown operation code '{atomicOperationObject.Code}'.");
+        }
+
+        private (ResourceIdentityRequirements requirements, IIdentifiable primaryResource) ConvertRef(AtomicOperationObject atomicOperationObject,
+            RequestAdapterState state)
+        {
+            ResourceIdentityRequirements requirements = CreateIdentityRequirements(state);
+            IIdentifiable primaryResource = null;
+
+            AtomicReferenceResult refResult = atomicOperationObject.Ref != null
+                ? _atomicReferenceAdapter.Convert(atomicOperationObject.Ref, requirements, state)
+                : null;
+
+            if (refResult != null)
+            {
+                requirements = new ResourceIdentityRequirements
+                {
+                    ResourceType = refResult.ResourceType,
+                    IdConstraint = requirements.IdConstraint,
+                    IdValue = refResult.Resource.StringId,
+                    LidValue = refResult.Resource.LocalId,
+                    RelationshipName = refResult.Relationship?.PublicName
+                };
+
+                state.WritableRequest.PrimaryId = refResult.Resource.StringId;
+                state.WritableRequest.PrimaryResourceType = refResult.ResourceType;
+                state.WritableRequest.Relationship = refResult.Relationship;
+                state.WritableRequest.IsCollection = refResult.Relationship is HasManyAttribute;
+
+                ConvertRefRelationship(atomicOperationObject.Data, refResult, state);
+
+                primaryResource = refResult.Resource;
+            }
+
+            return (requirements, primaryResource);
+        }
+
+        private ResourceIdentityRequirements CreateIdentityRequirements(RequestAdapterState state)
+        {
+            JsonElementConstraint? idConstraint = state.Request.WriteOperation == WriteOperationKind.CreateResource
+                ? _options.AllowClientGeneratedIds ? null : JsonElementConstraint.Forbidden
+                : JsonElementConstraint.Required;
+
+            return new ResourceIdentityRequirements
+            {
+                IdConstraint = idConstraint
+            };
+        }
+
+        private void ConvertRefRelationship(SingleOrManyData<ResourceObject> relationshipData, AtomicReferenceResult refResult, RequestAdapterState state)
+        {
+            if (refResult.Relationship != null)
+            {
+                state.WritableRequest.SecondaryResourceType = refResult.Relationship.RightType;
+
+                state.WritableTargetedFields.Relationships.Add(refResult.Relationship);
+
+                object rightValue = _relationshipDataAdapter.Convert(relationshipData, refResult.Relationship, true, state);
+                refResult.Relationship.SetValue(refResult.Resource, rightValue);
+            }
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/AtomicReferenceAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/AtomicReferenceAdapter.cs
new file mode 100644
index 0000000000..9ff01bc770
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/AtomicReferenceAdapter.cs
@@ -0,0 +1,45 @@
+using System;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <inheritdoc cref="IAtomicReferenceAdapter" />
+    public sealed class AtomicReferenceAdapter : ResourceIdentityAdapter, IAtomicReferenceAdapter
+    {
+        public AtomicReferenceAdapter(IResourceGraph resourceGraph, IResourceFactory resourceFactory)
+            : base(resourceGraph, resourceFactory)
+        {
+        }
+
+        /// <inheritdoc />
+        public AtomicReferenceResult Convert(AtomicReference atomicReference, ResourceIdentityRequirements requirements, RequestAdapterState state)
+        {
+            ArgumentGuard.NotNull(atomicReference, nameof(atomicReference));
+            ArgumentGuard.NotNull(requirements, nameof(requirements));
+            ArgumentGuard.NotNull(state, nameof(state));
+
+            using IDisposable _ = state.Position.PushElement("ref");
+            (IIdentifiable resource, ResourceType resourceType) = ConvertResourceIdentity(atomicReference, requirements, state);
+
+            RelationshipAttribute relationship = atomicReference.Relationship != null
+                ? ConvertRelationship(atomicReference.Relationship, resourceType, state)
+                : null;
+
+            return new AtomicReferenceResult(resource, resourceType, relationship);
+        }
+
+        private RelationshipAttribute ConvertRelationship(string relationshipName, ResourceType resourceType, RequestAdapterState state)
+        {
+            using IDisposable _ = state.Position.PushElement("relationship");
+            RelationshipAttribute relationship = resourceType.TryGetRelationshipByPublicName(relationshipName);
+
+            AssertIsKnownRelationship(relationship, relationshipName, resourceType, state);
+            AssertToManyInAddOrRemoveRelationship(relationship, state);
+
+            return relationship;
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/AtomicReferenceResult.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/AtomicReferenceResult.cs
new file mode 100644
index 0000000000..1b85f7021b
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/AtomicReferenceResult.cs
@@ -0,0 +1,28 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// The result of validating and converting "ref" in an entry of an atomic:operations request.
+    /// </summary>
+    [PublicAPI]
+    public sealed class AtomicReferenceResult
+    {
+        public IIdentifiable Resource { get; }
+        public ResourceType ResourceType { get; }
+        public RelationshipAttribute Relationship { get; }
+
+        public AtomicReferenceResult(IIdentifiable resource, ResourceType resourceType, RelationshipAttribute relationship)
+        {
+            ArgumentGuard.NotNull(resource, nameof(resource));
+            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
+
+            Resource = resource;
+            ResourceType = resourceType;
+            Relationship = relationship;
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/BaseDataAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/BaseDataAdapter.cs
new file mode 100644
index 0000000000..2dffca2653
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/BaseDataAdapter.cs
@@ -0,0 +1,55 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// Contains shared assertions for derived types.
+    /// </summary>
+    public abstract class BaseDataAdapter
+    {
+        [AssertionMethod]
+        protected static void AssertHasData<T>(SingleOrManyData<T> data, RequestAdapterState state)
+            where T : class, IResourceIdentity
+        {
+            if (!data.IsAssigned)
+            {
+                throw new ModelConversionException(state.Position, "The 'data' element is required.", null);
+            }
+        }
+
+        [AssertionMethod]
+        protected static void AssertHasSingleValue<T>(SingleOrManyData<T> data, bool allowNull, RequestAdapterState state)
+            where T : class, IResourceIdentity
+        {
+            if (data.SingleValue == null)
+            {
+                if (!allowNull)
+                {
+                    throw new ModelConversionException(state.Position,
+                        data.ManyValue == null
+                            ? "Expected an object in 'data' element, instead of 'null'."
+                            : "Expected an object in 'data' element, instead of an array.", null);
+                }
+
+                if (data.ManyValue != null)
+                {
+                    throw new ModelConversionException(state.Position, "Expected an object or 'null' in 'data' element, instead of an array.", null);
+                }
+            }
+        }
+
+        [AssertionMethod]
+        protected static void AssertHasManyValue<T>(SingleOrManyData<T> data, RequestAdapterState state)
+            where T : class, IResourceIdentity
+        {
+            if (data.ManyValue == null)
+            {
+                throw new ModelConversionException(state.Position,
+                    data.SingleValue == null
+                        ? "Expected an array in 'data' element, instead of 'null'."
+                        : "Expected an array in 'data' element, instead of an object.", null);
+            }
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/DocumentAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/DocumentAdapter.cs
new file mode 100644
index 0000000000..eea4c7849b
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/DocumentAdapter.cs
@@ -0,0 +1,42 @@
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <inheritdoc />
+    public sealed class DocumentAdapter : IDocumentAdapter
+    {
+        private readonly IJsonApiRequest _request;
+        private readonly ITargetedFields _targetedFields;
+        private readonly IDocumentInResourceOrRelationshipRequestAdapter _documentInResourceOrRelationshipRequestAdapter;
+        private readonly IDocumentInOperationsRequestAdapter _documentInOperationsRequestAdapter;
+
+        public DocumentAdapter(IJsonApiRequest request, ITargetedFields targetedFields,
+            IDocumentInResourceOrRelationshipRequestAdapter documentInResourceOrRelationshipRequestAdapter,
+            IDocumentInOperationsRequestAdapter documentInOperationsRequestAdapter)
+        {
+            ArgumentGuard.NotNull(request, nameof(request));
+            ArgumentGuard.NotNull(targetedFields, nameof(targetedFields));
+            ArgumentGuard.NotNull(documentInResourceOrRelationshipRequestAdapter, nameof(documentInResourceOrRelationshipRequestAdapter));
+            ArgumentGuard.NotNull(documentInOperationsRequestAdapter, nameof(documentInOperationsRequestAdapter));
+
+            _request = request;
+            _targetedFields = targetedFields;
+            _documentInResourceOrRelationshipRequestAdapter = documentInResourceOrRelationshipRequestAdapter;
+            _documentInOperationsRequestAdapter = documentInOperationsRequestAdapter;
+        }
+
+        /// <inheritdoc />
+        public object Convert(Document document)
+        {
+            ArgumentGuard.NotNull(document, nameof(document));
+
+            using var adapterState = new RequestAdapterState(_request, _targetedFields);
+
+            return adapterState.Request.Kind == EndpointKind.AtomicOperations
+                ? _documentInOperationsRequestAdapter.Convert(document, adapterState)
+                : _documentInResourceOrRelationshipRequestAdapter.Convert(document, adapterState);
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/DocumentInOperationsRequestAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/DocumentInOperationsRequestAdapter.cs
new file mode 100644
index 0000000000..0c283e9bf0
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/DocumentInOperationsRequestAdapter.cs
@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <inheritdoc />
+    public sealed class DocumentInOperationsRequestAdapter : IDocumentInOperationsRequestAdapter
+    {
+        private readonly IJsonApiOptions _options;
+        private readonly IAtomicOperationObjectAdapter _atomicOperationObjectAdapter;
+
+        public DocumentInOperationsRequestAdapter(IJsonApiOptions options, IAtomicOperationObjectAdapter atomicOperationObjectAdapter)
+        {
+            ArgumentGuard.NotNull(options, nameof(options));
+            ArgumentGuard.NotNull(atomicOperationObjectAdapter, nameof(atomicOperationObjectAdapter));
+
+            _options = options;
+            _atomicOperationObjectAdapter = atomicOperationObjectAdapter;
+        }
+
+        /// <inheritdoc />
+        public IList<OperationContainer> Convert(Document document, RequestAdapterState state)
+        {
+            ArgumentGuard.NotNull(state, nameof(state));
+            AssertHasOperations(document.Operations, state);
+
+            using IDisposable _ = state.Position.PushElement("atomic:operations");
+            AssertMaxOperationsNotExceeded(document.Operations, state);
+
+            return ConvertOperations(document.Operations, state);
+        }
+
+        private static void AssertHasOperations(IEnumerable<AtomicOperationObject> atomicOperationObjects, RequestAdapterState state)
+        {
+            if (atomicOperationObjects.IsNullOrEmpty())
+            {
+                throw new ModelConversionException(state.Position, "No operations found.", null);
+            }
+        }
+
+        private void AssertMaxOperationsNotExceeded(ICollection<AtomicOperationObject> atomicOperationObjects, RequestAdapterState state)
+        {
+            if (atomicOperationObjects.Count > _options.MaximumOperationsPerRequest)
+            {
+                throw new ModelConversionException(state.Position, "Too many operations in request.",
+                    $"The number of operations in this request ({atomicOperationObjects.Count}) is higher " +
+                    $"than the maximum of {_options.MaximumOperationsPerRequest}.");
+            }
+        }
+
+        private IList<OperationContainer> ConvertOperations(IEnumerable<AtomicOperationObject> atomicOperationObjects, RequestAdapterState state)
+        {
+            var operations = new List<OperationContainer>();
+            int operationIndex = 0;
+
+            foreach (AtomicOperationObject atomicOperationObject in atomicOperationObjects)
+            {
+                using IDisposable _ = state.Position.PushArrayIndex(operationIndex);
+
+                OperationContainer operation = _atomicOperationObjectAdapter.Convert(atomicOperationObject, state);
+                operations.Add(operation);
+
+                operationIndex++;
+            }
+
+            return operations;
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/DocumentInResourceOrRelationshipRequestAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/DocumentInResourceOrRelationshipRequestAdapter.cs
new file mode 100644
index 0000000000..2a0080cc4b
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/DocumentInResourceOrRelationshipRequestAdapter.cs
@@ -0,0 +1,77 @@
+using System.Collections.Generic;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <inheritdoc />
+    public sealed class DocumentInResourceOrRelationshipRequestAdapter : IDocumentInResourceOrRelationshipRequestAdapter
+    {
+        private readonly IJsonApiOptions _options;
+        private readonly IResourceDataAdapter _resourceDataAdapter;
+        private readonly IRelationshipDataAdapter _relationshipDataAdapter;
+
+        public DocumentInResourceOrRelationshipRequestAdapter(IJsonApiOptions options, IResourceDataAdapter resourceDataAdapter,
+            IRelationshipDataAdapter relationshipDataAdapter)
+        {
+            ArgumentGuard.NotNull(options, nameof(options));
+            ArgumentGuard.NotNull(resourceDataAdapter, nameof(resourceDataAdapter));
+            ArgumentGuard.NotNull(relationshipDataAdapter, nameof(relationshipDataAdapter));
+
+            _options = options;
+            _resourceDataAdapter = resourceDataAdapter;
+            _relationshipDataAdapter = relationshipDataAdapter;
+        }
+
+        /// <inheritdoc />
+        public object Convert(Document document, RequestAdapterState state)
+        {
+            state.WritableTargetedFields = new TargetedFields();
+
+            switch (state.Request.WriteOperation)
+            {
+                case WriteOperationKind.CreateResource:
+                case WriteOperationKind.UpdateResource:
+                {
+                    ResourceIdentityRequirements requirements = CreateIdentityRequirements(state);
+                    return _resourceDataAdapter.Convert(document.Data, requirements, state);
+                }
+                case WriteOperationKind.SetRelationship:
+                case WriteOperationKind.AddToRelationship:
+                case WriteOperationKind.RemoveFromRelationship:
+                {
+                    if (state.Request.Relationship == null)
+                    {
+                        // Let the controller throw for unknown relationship, because it knows the relationship name that was used.
+                        return new HashSet<IIdentifiable>(IdentifiableComparer.Instance);
+                    }
+
+                    ResourceIdentityAdapter.AssertToManyInAddOrRemoveRelationship(state.Request.Relationship, state);
+
+                    state.WritableTargetedFields.Relationships.Add(state.Request.Relationship);
+                    return _relationshipDataAdapter.Convert(document.Data, state.Request.Relationship, false, state);
+                }
+            }
+
+            return null;
+        }
+
+        private ResourceIdentityRequirements CreateIdentityRequirements(RequestAdapterState state)
+        {
+            JsonElementConstraint? idConstraint = state.Request.WriteOperation == WriteOperationKind.CreateResource
+                ? _options.AllowClientGeneratedIds ? null : JsonElementConstraint.Forbidden
+                : JsonElementConstraint.Required;
+
+            var requirements = new ResourceIdentityRequirements
+            {
+                ResourceType = state.Request.PrimaryResourceType,
+                IdConstraint = idConstraint,
+                IdValue = state.Request.PrimaryId
+            };
+
+            return requirements;
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/IAtomicOperationObjectAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IAtomicOperationObjectAdapter.cs
new file mode 100644
index 0000000000..5fb2c1d680
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IAtomicOperationObjectAdapter.cs
@@ -0,0 +1,16 @@
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// Validates and converts a single operation inside an atomic:operations request.
+    /// </summary>
+    public interface IAtomicOperationObjectAdapter
+    {
+        /// <summary>
+        /// Validates and converts the specified <paramref name="atomicOperationObject" />.
+        /// </summary>
+        OperationContainer Convert(AtomicOperationObject atomicOperationObject, RequestAdapterState state);
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/IAtomicReferenceAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IAtomicReferenceAdapter.cs
new file mode 100644
index 0000000000..bd4a12b2de
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IAtomicReferenceAdapter.cs
@@ -0,0 +1,16 @@
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// Validates and converts a 'ref' element in an entry of an atomic:operations request. It appears in most kinds of operations and typically indicates
+    /// what would otherwise have been in the endpoint URL, if it were a resource request.
+    /// </summary>
+    public interface IAtomicReferenceAdapter
+    {
+        /// <summary>
+        /// Validates and converts the specified <paramref name="atomicReference" />.
+        /// </summary>
+        AtomicReferenceResult Convert(AtomicReference atomicReference, ResourceIdentityRequirements requirements, RequestAdapterState state);
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/IDocumentAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IDocumentAdapter.cs
new file mode 100644
index 0000000000..3f13b25685
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IDocumentAdapter.cs
@@ -0,0 +1,38 @@
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// The entry point for validating and converting the deserialized <see cref="Document" /> from the request body into a model. The produced models are
+    /// used in ASP.NET Model Binding.
+    /// </summary>
+    public interface IDocumentAdapter
+    {
+        /// <summary>
+        /// Validates and converts the specified <paramref name="document" />. Possible return values:
+        /// <list type="bullet">
+        /// <item>
+        /// <description>
+        /// <code><![CDATA[IList<OperationContainer>]]></code> (operations)
+        /// </description>
+        /// </item>
+        /// <item>
+        /// <description>
+        /// <code><![CDATA[ISet<IIdentifiable>]]></code> (to-many relationship, unknown relationship)
+        /// </description>
+        /// </item>
+        /// <item>
+        /// <description>
+        /// <code><![CDATA[IIdentifiable]]></code> (resource, to-one relationship)
+        /// </description>
+        /// </item>
+        /// <item>
+        /// <description>
+        /// <code><![CDATA[null]]></code> (to-one relationship)
+        /// </description>
+        /// </item>
+        /// </list>
+        /// </summary>
+        object Convert(Document document);
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/IDocumentInOperationsRequestAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IDocumentInOperationsRequestAdapter.cs
new file mode 100644
index 0000000000..de39fa6c91
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IDocumentInOperationsRequestAdapter.cs
@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// Validates and converts a <see cref="Document" /> belonging to an atomic:operations request.
+    /// </summary>
+    public interface IDocumentInOperationsRequestAdapter
+    {
+        /// <summary>
+        /// Validates and converts the specified <paramref name="document" />.
+        /// </summary>
+        IList<OperationContainer> Convert(Document document, RequestAdapterState state);
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/IDocumentInResourceOrRelationshipRequestAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IDocumentInResourceOrRelationshipRequestAdapter.cs
new file mode 100644
index 0000000000..da6222e166
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IDocumentInResourceOrRelationshipRequestAdapter.cs
@@ -0,0 +1,15 @@
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// Validates and converts a <see cref="Document" /> belonging to a resource or relationship request.
+    /// </summary>
+    public interface IDocumentInResourceOrRelationshipRequestAdapter
+    {
+        /// <summary>
+        /// Validates and converts the specified <paramref name="document" />.
+        /// </summary>
+        object Convert(Document document, RequestAdapterState state);
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/IRelationshipDataAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IRelationshipDataAdapter.cs
new file mode 100644
index 0000000000..cc4da5bc5e
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IRelationshipDataAdapter.cs
@@ -0,0 +1,24 @@
+using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// Validates and converts the data from a relationship. It appears in a relationship request, in the relationships of a POST/PATCH resource request, in
+    /// an entry of an atomic:operations request that targets a relationship and in the relationships of an operations entry that creates or updates a
+    /// resource.
+    /// </summary>
+    public interface IRelationshipDataAdapter
+    {
+        /// <summary>
+        /// Validates and converts the specified <paramref name="data" />.
+        /// </summary>
+        object Convert(SingleOrManyData<ResourceObject> data, RelationshipAttribute relationship, bool useToManyElementType, RequestAdapterState state);
+
+        /// <summary>
+        /// Validates and converts the specified <paramref name="data" />.
+        /// </summary>
+        object Convert(SingleOrManyData<ResourceIdentifierObject> data, RelationshipAttribute relationship, bool useToManyElementType,
+            RequestAdapterState state);
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/IResourceDataAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IResourceDataAdapter.cs
new file mode 100644
index 0000000000..e7dd737cfb
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IResourceDataAdapter.cs
@@ -0,0 +1,16 @@
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// Validates and converts the data from a resource in a POST/PATCH resource request.
+    /// </summary>
+    public interface IResourceDataAdapter
+    {
+        /// <summary>
+        /// Validates and converts the specified <paramref name="data" />.
+        /// </summary>
+        IIdentifiable Convert(SingleOrManyData<ResourceObject> data, ResourceIdentityRequirements requirements, RequestAdapterState state);
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/IResourceDataInOperationsRequestAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IResourceDataInOperationsRequestAdapter.cs
new file mode 100644
index 0000000000..38a841d45d
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IResourceDataInOperationsRequestAdapter.cs
@@ -0,0 +1,16 @@
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// Validates and converts the data from an entry in an atomic:operations request that creates or updates a resource.
+    /// </summary>
+    public interface IResourceDataInOperationsRequestAdapter
+    {
+        /// <summary>
+        /// Validates and converts the specified <paramref name="data" />.
+        /// </summary>
+        IIdentifiable Convert(SingleOrManyData<ResourceObject> data, ResourceIdentityRequirements requirements, RequestAdapterState state);
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/IResourceIdentifierObjectAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IResourceIdentifierObjectAdapter.cs
new file mode 100644
index 0000000000..3105143908
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IResourceIdentifierObjectAdapter.cs
@@ -0,0 +1,16 @@
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// Validates and converts a <see cref="ResourceIdentifierObject" />. It appears in the data object(s) of a relationship.
+    /// </summary>
+    public interface IResourceIdentifierObjectAdapter
+    {
+        /// <summary>
+        /// Validates and converts the specified <paramref name="resourceIdentifierObject" />.
+        /// </summary>
+        IIdentifiable Convert(ResourceIdentifierObject resourceIdentifierObject, ResourceIdentityRequirements requirements, RequestAdapterState state);
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/IResourceObjectAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IResourceObjectAdapter.cs
new file mode 100644
index 0000000000..8245444e08
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/IResourceObjectAdapter.cs
@@ -0,0 +1,19 @@
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// Validates and converts a <see cref="ResourceObject" />. It appears in a POST/PATCH resource request and an entry in an atomic:operations request that
+    /// creates or updates a resource.
+    /// </summary>
+    public interface IResourceObjectAdapter
+    {
+        /// <summary>
+        /// Validates and converts the specified <paramref name="resourceObject" />.
+        /// </summary>
+        (IIdentifiable resource, ResourceType resourceType) Convert(ResourceObject resourceObject, ResourceIdentityRequirements requirements,
+            RequestAdapterState state);
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/JsonElementConstraint.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/JsonElementConstraint.cs
new file mode 100644
index 0000000000..ebdd76945a
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/JsonElementConstraint.cs
@@ -0,0 +1,21 @@
+using JetBrains.Annotations;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// Lists constraints for the presence or absence of a JSON element.
+    /// </summary>
+    [PublicAPI]
+    public enum JsonElementConstraint
+    {
+        /// <summary>
+        /// A value for the element is not allowed.
+        /// </summary>
+        Forbidden,
+
+        /// <summary>
+        /// A value for the element is required.
+        /// </summary>
+        Required
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/RelationshipDataAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/RelationshipDataAdapter.cs
new file mode 100644
index 0000000000..ad5aebac9e
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/RelationshipDataAdapter.cs
@@ -0,0 +1,121 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <inheritdoc cref="IRelationshipDataAdapter" />
+    public sealed class RelationshipDataAdapter : BaseDataAdapter, IRelationshipDataAdapter
+    {
+        private static readonly CollectionConverter CollectionConverter = new();
+
+        private readonly IResourceIdentifierObjectAdapter _resourceIdentifierObjectAdapter;
+
+        public RelationshipDataAdapter(IResourceIdentifierObjectAdapter resourceIdentifierObjectAdapter)
+        {
+            ArgumentGuard.NotNull(resourceIdentifierObjectAdapter, nameof(resourceIdentifierObjectAdapter));
+
+            _resourceIdentifierObjectAdapter = resourceIdentifierObjectAdapter;
+        }
+
+        /// <inheritdoc />
+        public object Convert(SingleOrManyData<ResourceObject> data, RelationshipAttribute relationship, bool useToManyElementType, RequestAdapterState state)
+        {
+            SingleOrManyData<ResourceIdentifierObject> identifierData = ToIdentifierData(data);
+            return Convert(identifierData, relationship, useToManyElementType, state);
+        }
+
+        private static SingleOrManyData<ResourceIdentifierObject> ToIdentifierData(SingleOrManyData<ResourceObject> data)
+        {
+            if (!data.IsAssigned)
+            {
+                return default;
+            }
+
+            object newValue = null;
+
+            if (data.ManyValue != null)
+            {
+                newValue = data.ManyValue.Select(resourceObject => new ResourceIdentifierObject
+                {
+                    Type = resourceObject.Type,
+                    Id = resourceObject.Id,
+                    Lid = resourceObject.Lid
+                });
+            }
+            else if (data.SingleValue != null)
+            {
+                newValue = new ResourceIdentifierObject
+                {
+                    Type = data.SingleValue.Type,
+                    Id = data.SingleValue.Id,
+                    Lid = data.SingleValue.Lid
+                };
+            }
+
+            return new SingleOrManyData<ResourceIdentifierObject>(newValue);
+        }
+
+        /// <inheritdoc />
+        public object Convert(SingleOrManyData<ResourceIdentifierObject> data, RelationshipAttribute relationship, bool useToManyElementType,
+            RequestAdapterState state)
+        {
+            ArgumentGuard.NotNull(relationship, nameof(relationship));
+            ArgumentGuard.NotNull(state, nameof(state));
+            AssertHasData(data, state);
+
+            using IDisposable _ = state.Position.PushElement("data");
+
+            var requirements = new ResourceIdentityRequirements
+            {
+                ResourceType = relationship.RightType,
+                IdConstraint = JsonElementConstraint.Required,
+                RelationshipName = relationship.PublicName
+            };
+
+            return relationship is HasOneAttribute
+                ? ConvertToOneRelationshipData(data, requirements, state)
+                : ConvertToManyRelationshipData(data, relationship, requirements, useToManyElementType, state);
+        }
+
+        private IIdentifiable ConvertToOneRelationshipData(SingleOrManyData<ResourceIdentifierObject> data, ResourceIdentityRequirements requirements,
+            RequestAdapterState state)
+        {
+            AssertHasSingleValue(data, true, state);
+
+            return data.SingleValue != null ? _resourceIdentifierObjectAdapter.Convert(data.SingleValue, requirements, state) : null;
+        }
+
+        private IEnumerable ConvertToManyRelationshipData(SingleOrManyData<ResourceIdentifierObject> data, RelationshipAttribute relationship,
+            ResourceIdentityRequirements requirements, bool useToManyElementType, RequestAdapterState state)
+        {
+            AssertHasManyValue(data, state);
+
+            int arrayIndex = 0;
+            var rightResources = new List<IIdentifiable>();
+
+            foreach (ResourceIdentifierObject resourceIdentifierObject in data.ManyValue)
+            {
+                using IDisposable _ = state.Position.PushArrayIndex(arrayIndex);
+
+                IIdentifiable rightResource = _resourceIdentifierObjectAdapter.Convert(resourceIdentifierObject, requirements, state);
+                rightResources.Add(rightResource);
+
+                arrayIndex++;
+            }
+
+            if (useToManyElementType)
+            {
+                return CollectionConverter.CopyToTypedCollection(rightResources, relationship.Property.PropertyType);
+            }
+
+            var resourceSet = new HashSet<IIdentifiable>(IdentifiableComparer.Instance);
+            resourceSet.AddRange(rightResources);
+            return resourceSet;
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/RequestAdapterPosition.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/RequestAdapterPosition.cs
new file mode 100644
index 0000000000..4c2d34b28d
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/RequestAdapterPosition.cs
@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using JetBrains.Annotations;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// Tracks the location within an object tree when validating and converting a request body.
+    /// </summary>
+    [PublicAPI]
+    public sealed class RequestAdapterPosition
+    {
+        private readonly Stack<string> _stack = new();
+        private readonly IDisposable _disposable;
+
+        public RequestAdapterPosition()
+        {
+            _disposable = new PopStackOnDispose(this);
+        }
+
+        public IDisposable PushElement(string name)
+        {
+            ArgumentGuard.NotNullNorEmpty(name, nameof(name));
+
+            _stack.Push($"/{name}");
+            return _disposable;
+        }
+
+        public IDisposable PushArrayIndex(int index)
+        {
+            _stack.Push($"[{index}]");
+            return _disposable;
+        }
+
+        public string ToSourcePointer()
+        {
+            if (!_stack.Any())
+            {
+                return null;
+            }
+
+            var builder = new StringBuilder();
+            var clone = new Stack<string>(_stack);
+
+            while (clone.Any())
+            {
+                string element = clone.Pop();
+                builder.Append(element);
+            }
+
+            return builder.ToString();
+        }
+
+        public override string ToString()
+        {
+            return ToSourcePointer() ?? string.Empty;
+        }
+
+        private sealed class PopStackOnDispose : IDisposable
+        {
+            private readonly RequestAdapterPosition _owner;
+
+            public PopStackOnDispose(RequestAdapterPosition owner)
+            {
+                _owner = owner;
+            }
+
+            public void Dispose()
+            {
+                _owner._stack.Pop();
+            }
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/RequestAdapterState.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/RequestAdapterState.cs
new file mode 100644
index 0000000000..2730bcbf9b
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/RequestAdapterState.cs
@@ -0,0 +1,68 @@
+using System;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.AtomicOperations;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Resources;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// Tracks state while adapting objects from <see cref="JsonApiDotNetCore.Serialization.Objects" /> into the shape that controller actions accept.
+    /// </summary>
+    [PublicAPI]
+    public sealed class RequestAdapterState : IDisposable
+    {
+        private readonly IDisposable _backupRequestState;
+
+        public IJsonApiRequest InjectableRequest { get; }
+        public ITargetedFields InjectableTargetedFields { get; }
+
+        public JsonApiRequest WritableRequest { get; set; }
+        public TargetedFields WritableTargetedFields { get; set; }
+
+        public RequestAdapterPosition Position { get; } = new();
+        public IJsonApiRequest Request => WritableRequest ?? InjectableRequest;
+
+        public RequestAdapterState(IJsonApiRequest request, ITargetedFields targetedFields)
+        {
+            ArgumentGuard.NotNull(request, nameof(request));
+            ArgumentGuard.NotNull(targetedFields, nameof(targetedFields));
+
+            InjectableRequest = request;
+            InjectableTargetedFields = targetedFields;
+
+            if (request.Kind == EndpointKind.AtomicOperations)
+            {
+                _backupRequestState = new RevertRequestStateOnDispose(request, targetedFields);
+            }
+        }
+
+        public void RefreshInjectables()
+        {
+            if (WritableRequest != null)
+            {
+                InjectableRequest.CopyFrom(WritableRequest);
+            }
+
+            if (WritableTargetedFields != null)
+            {
+                InjectableTargetedFields.CopyFrom(WritableTargetedFields);
+            }
+        }
+
+        public void Dispose()
+        {
+            // For resource requests, we'd like the injected state to become the final state.
+            // But for operations, it makes more sense to reset than to reflect the last operation.
+
+            if (_backupRequestState != null)
+            {
+                _backupRequestState.Dispose();
+            }
+            else
+            {
+                RefreshInjectables();
+            }
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceDataAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceDataAdapter.cs
new file mode 100644
index 0000000000..f1747fffc8
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceDataAdapter.cs
@@ -0,0 +1,49 @@
+using System;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <inheritdoc cref="IResourceDataAdapter" />
+    public class ResourceDataAdapter : BaseDataAdapter, IResourceDataAdapter
+    {
+        private readonly IResourceDefinitionAccessor _resourceDefinitionAccessor;
+        private readonly IResourceObjectAdapter _resourceObjectAdapter;
+
+        public ResourceDataAdapter(IResourceDefinitionAccessor resourceDefinitionAccessor, IResourceObjectAdapter resourceObjectAdapter)
+        {
+            ArgumentGuard.NotNull(resourceDefinitionAccessor, nameof(resourceDefinitionAccessor));
+            ArgumentGuard.NotNull(resourceObjectAdapter, nameof(resourceObjectAdapter));
+
+            _resourceDefinitionAccessor = resourceDefinitionAccessor;
+            _resourceObjectAdapter = resourceObjectAdapter;
+        }
+
+        /// <inheritdoc />
+        public IIdentifiable Convert(SingleOrManyData<ResourceObject> data, ResourceIdentityRequirements requirements, RequestAdapterState state)
+        {
+            ArgumentGuard.NotNull(requirements, nameof(requirements));
+            ArgumentGuard.NotNull(state, nameof(state));
+
+            AssertHasData(data, state);
+
+            using IDisposable _ = state.Position.PushElement("data");
+            AssertHasSingleValue(data, false, state);
+
+            (IIdentifiable resource, ResourceType _) = ConvertResourceObject(data, requirements, state);
+
+            // Ensure that IResourceDefinition extensibility point sees the current operation, in case it injects IJsonApiRequest.
+            state.RefreshInjectables();
+
+            _resourceDefinitionAccessor.OnDeserialize(resource);
+            return resource;
+        }
+
+        protected virtual (IIdentifiable resource, ResourceType resourceType) ConvertResourceObject(SingleOrManyData<ResourceObject> data,
+            ResourceIdentityRequirements requirements, RequestAdapterState state)
+        {
+            return _resourceObjectAdapter.Convert(data.SingleValue, requirements, state);
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceDataInOperationsRequestAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceDataInOperationsRequestAdapter.cs
new file mode 100644
index 0000000000..b0e59b6afd
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceDataInOperationsRequestAdapter.cs
@@ -0,0 +1,28 @@
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <inheritdoc cref="IResourceDataInOperationsRequestAdapter" />
+    public sealed class ResourceDataInOperationsRequestAdapter : ResourceDataAdapter, IResourceDataInOperationsRequestAdapter
+    {
+        public ResourceDataInOperationsRequestAdapter(IResourceDefinitionAccessor resourceDefinitionAccessor, IResourceObjectAdapter resourceObjectAdapter)
+            : base(resourceDefinitionAccessor, resourceObjectAdapter)
+        {
+        }
+
+        protected override (IIdentifiable resource, ResourceType resourceType) ConvertResourceObject(SingleOrManyData<ResourceObject> data,
+            ResourceIdentityRequirements requirements, RequestAdapterState state)
+        {
+            // This override ensures that we enrich IJsonApiRequest before calling into IResourceDefinition, so it is ready for consumption there.
+
+            (IIdentifiable resource, ResourceType resourceType) = base.ConvertResourceObject(data, requirements, state);
+
+            state.WritableRequest.PrimaryResourceType = resourceType;
+            state.WritableRequest.PrimaryId = resource.StringId;
+
+            return (resource, resourceType);
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceIdentifierObjectAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceIdentifierObjectAdapter.cs
new file mode 100644
index 0000000000..fc5cbfc3e4
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceIdentifierObjectAdapter.cs
@@ -0,0 +1,26 @@
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <inheritdoc cref="IResourceIdentifierObjectAdapter" />
+    public sealed class ResourceIdentifierObjectAdapter : ResourceIdentityAdapter, IResourceIdentifierObjectAdapter
+    {
+        public ResourceIdentifierObjectAdapter(IResourceGraph resourceGraph, IResourceFactory resourceFactory)
+            : base(resourceGraph, resourceFactory)
+        {
+        }
+
+        /// <inheritdoc />
+        public IIdentifiable Convert(ResourceIdentifierObject resourceIdentifierObject, ResourceIdentityRequirements requirements, RequestAdapterState state)
+        {
+            ArgumentGuard.NotNull(resourceIdentifierObject, nameof(resourceIdentifierObject));
+            ArgumentGuard.NotNull(requirements, nameof(requirements));
+            ArgumentGuard.NotNull(state, nameof(state));
+
+            (IIdentifiable resource, _) = ConvertResourceIdentity(resourceIdentifierObject, requirements, state);
+            return resource;
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceIdentityAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceIdentityAdapter.cs
new file mode 100644
index 0000000000..5bb2a52d53
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceIdentityAdapter.cs
@@ -0,0 +1,222 @@
+using System;
+using System.Net;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// Base class for validating and converting objects that represent an identity.
+    /// </summary>
+    public abstract class ResourceIdentityAdapter
+    {
+        private readonly IResourceGraph _resourceGraph;
+        private readonly IResourceFactory _resourceFactory;
+
+        protected ResourceIdentityAdapter(IResourceGraph resourceGraph, IResourceFactory resourceFactory)
+        {
+            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
+            ArgumentGuard.NotNull(resourceFactory, nameof(resourceFactory));
+
+            _resourceGraph = resourceGraph;
+            _resourceFactory = resourceFactory;
+        }
+
+        protected (IIdentifiable resource, ResourceType resourceType) ConvertResourceIdentity(IResourceIdentity identity,
+            ResourceIdentityRequirements requirements, RequestAdapterState state)
+        {
+            ArgumentGuard.NotNull(identity, nameof(identity));
+            ArgumentGuard.NotNull(requirements, nameof(requirements));
+            ArgumentGuard.NotNull(state, nameof(state));
+
+            ResourceType resourceType = ResolveType(identity, requirements, state);
+            IIdentifiable resource = CreateResource(identity, requirements, resourceType.ClrType, state);
+
+            return (resource, resourceType);
+        }
+
+        private ResourceType ResolveType(IResourceIdentity identity, ResourceIdentityRequirements requirements, RequestAdapterState state)
+        {
+            AssertHasType(identity, state);
+
+            using IDisposable _ = state.Position.PushElement("type");
+            ResourceType resourceType = _resourceGraph.TryGetResourceType(identity.Type);
+
+            AssertIsKnownResourceType(resourceType, identity.Type, state);
+            AssertIsCompatibleResourceType(resourceType, requirements.ResourceType, requirements.RelationshipName, state);
+
+            return resourceType;
+        }
+
+        private static void AssertHasType(IResourceIdentity identity, RequestAdapterState state)
+        {
+            if (identity.Type == null)
+            {
+                throw new ModelConversionException(state.Position, "The 'type' element is required.", null);
+            }
+        }
+
+        private static void AssertIsKnownResourceType(ResourceType resourceType, string typeName, RequestAdapterState state)
+        {
+            if (resourceType == null)
+            {
+                throw new ModelConversionException(state.Position, "Unknown resource type found.", $"Resource type '{typeName}' does not exist.");
+            }
+        }
+
+        private static void AssertIsCompatibleResourceType(ResourceType actual, ResourceType expected, string relationshipName, RequestAdapterState state)
+        {
+            if (expected != null && !expected.ClrType.IsAssignableFrom(actual.ClrType))
+            {
+                string message = relationshipName != null
+                    ? $"Type '{actual.PublicName}' is incompatible with type '{expected.PublicName}' of relationship '{relationshipName}'."
+                    : $"Type '{actual.PublicName}' is incompatible with type '{expected.PublicName}'.";
+
+                throw new ModelConversionException(state.Position, "Incompatible resource type found.", message, HttpStatusCode.Conflict);
+            }
+        }
+
+        private IIdentifiable CreateResource(IResourceIdentity identity, ResourceIdentityRequirements requirements, Type resourceClrType,
+            RequestAdapterState state)
+        {
+            if (state.Request.Kind != EndpointKind.AtomicOperations)
+            {
+                AssertHasNoLid(identity, state);
+            }
+
+            AssertNoIdWithLid(identity, state);
+
+            if (requirements.IdConstraint == JsonElementConstraint.Required)
+            {
+                AssertHasIdOrLid(identity, requirements, state);
+            }
+            else if (requirements.IdConstraint == JsonElementConstraint.Forbidden)
+            {
+                AssertHasNoId(identity, state);
+            }
+
+            AssertSameIdValue(identity, requirements.IdValue, state);
+            AssertSameLidValue(identity, requirements.LidValue, state);
+
+            IIdentifiable resource = _resourceFactory.CreateInstance(resourceClrType);
+            AssignStringId(identity, resource, state);
+            resource.LocalId = identity.Lid;
+            return resource;
+        }
+
+        private static void AssertHasNoLid(IResourceIdentity identity, RequestAdapterState state)
+        {
+            if (identity.Lid != null)
+            {
+                using IDisposable _ = state.Position.PushElement("lid");
+                throw new ModelConversionException(state.Position, "The 'lid' element is not supported at this endpoint.", null);
+            }
+        }
+
+        private static void AssertNoIdWithLid(IResourceIdentity identity, RequestAdapterState state)
+        {
+            if (identity.Id != null && identity.Lid != null)
+            {
+                throw new ModelConversionException(state.Position, "The 'id' and 'lid' element are mutually exclusive.", null);
+            }
+        }
+
+        private static void AssertHasIdOrLid(IResourceIdentity identity, ResourceIdentityRequirements requirements, RequestAdapterState state)
+        {
+            string message = null;
+
+            if (requirements.IdValue != null && identity.Id == null)
+            {
+                message = "The 'id' element is required.";
+            }
+            else if (requirements.LidValue != null && identity.Lid == null)
+            {
+                message = "The 'lid' element is required.";
+            }
+            else if (identity.Id == null && identity.Lid == null)
+            {
+                message = state.Request.Kind == EndpointKind.AtomicOperations ? "The 'id' or 'lid' element is required." : "The 'id' element is required.";
+            }
+
+            if (message != null)
+            {
+                throw new ModelConversionException(state.Position, message, null);
+            }
+        }
+
+        private static void AssertHasNoId(IResourceIdentity identity, RequestAdapterState state)
+        {
+            if (identity.Id != null)
+            {
+                using IDisposable _ = state.Position.PushElement("id");
+                throw new ModelConversionException(state.Position, "The use of client-generated IDs is disabled.", null, HttpStatusCode.Forbidden);
+            }
+        }
+
+        private static void AssertSameIdValue(IResourceIdentity identity, string expected, RequestAdapterState state)
+        {
+            if (expected != null && identity.Id != expected)
+            {
+                using IDisposable _ = state.Position.PushElement("id");
+
+                throw new ModelConversionException(state.Position, "Conflicting 'id' values found.", $"Expected '{expected}' instead of '{identity.Id}'.",
+                    HttpStatusCode.Conflict);
+            }
+        }
+
+        private static void AssertSameLidValue(IResourceIdentity identity, string expected, RequestAdapterState state)
+        {
+            if (expected != null && identity.Lid != expected)
+            {
+                using IDisposable _ = state.Position.PushElement("lid");
+
+                throw new ModelConversionException(state.Position, "Conflicting 'lid' values found.", $"Expected '{expected}' instead of '{identity.Lid}'.",
+                    HttpStatusCode.Conflict);
+            }
+        }
+
+        private void AssignStringId(IResourceIdentity identity, IIdentifiable resource, RequestAdapterState state)
+        {
+            if (identity.Id != null)
+            {
+                try
+                {
+                    resource.StringId = identity.Id;
+                }
+                catch (FormatException exception)
+                {
+                    using IDisposable _ = state.Position.PushElement("id");
+                    throw new ModelConversionException(state.Position, "Incompatible 'id' value found.", exception.Message);
+                }
+            }
+        }
+
+        protected static void AssertIsKnownRelationship(RelationshipAttribute relationship, string relationshipName, ResourceType resourceType,
+            RequestAdapterState state)
+        {
+            if (relationship == null)
+            {
+                throw new ModelConversionException(state.Position, "Unknown relationship found.",
+                    $"Relationship '{relationshipName}' does not exist on resource type '{resourceType.PublicName}'.");
+            }
+        }
+
+        protected internal static void AssertToManyInAddOrRemoveRelationship(RelationshipAttribute relationship, RequestAdapterState state)
+        {
+            bool requireToManyRelationship = state.Request.WriteOperation is WriteOperationKind.AddToRelationship or WriteOperationKind.RemoveFromRelationship;
+
+            if (requireToManyRelationship && relationship is not HasManyAttribute)
+            {
+                string message = state.Request.Kind == EndpointKind.AtomicOperations
+                    ? "Only to-many relationships can be targeted through this operation."
+                    : "Only to-many relationships can be targeted through this endpoint.";
+
+                throw new ModelConversionException(state.Position, message, $"Relationship '{relationship.PublicName}' is not a to-many relationship.",
+                    HttpStatusCode.Forbidden);
+            }
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceIdentityRequirements.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceIdentityRequirements.cs
new file mode 100644
index 0000000000..601212ec93
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceIdentityRequirements.cs
@@ -0,0 +1,38 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <summary>
+    /// Defines requirements to validate an <see cref="IResourceIdentity" /> instance against.
+    /// </summary>
+    [PublicAPI]
+    public sealed class ResourceIdentityRequirements
+    {
+        /// <summary>
+        /// When not null, indicates that the "type" element must be compatible with the specified resource type.
+        /// </summary>
+        public ResourceType ResourceType { get; init; }
+
+        /// <summary>
+        /// When not null, indicates the presence or absence of the "id" element.
+        /// </summary>
+        public JsonElementConstraint? IdConstraint { get; init; }
+
+        /// <summary>
+        /// When not null, indicates what the value of the "id" element must be.
+        /// </summary>
+        public string IdValue { get; init; }
+
+        /// <summary>
+        /// When not null, indicates what the value of the "lid" element must be.
+        /// </summary>
+        public string LidValue { get; init; }
+
+        /// <summary>
+        /// When not null, indicates the name of the relationship to use in error messages.
+        /// </summary>
+        public string RelationshipName { get; init; }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceObjectAdapter.cs b/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceObjectAdapter.cs
new file mode 100644
index 0000000000..5c49a4e0e4
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/Adapters/ResourceObjectAdapter.cs
@@ -0,0 +1,159 @@
+using System;
+using System.Collections.Generic;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Request.Adapters
+{
+    /// <inheritdoc cref="IResourceObjectAdapter" />
+    public sealed class ResourceObjectAdapter : ResourceIdentityAdapter, IResourceObjectAdapter
+    {
+        private readonly IJsonApiOptions _options;
+        private readonly IRelationshipDataAdapter _relationshipDataAdapter;
+
+        public ResourceObjectAdapter(IResourceGraph resourceGraph, IResourceFactory resourceFactory, IJsonApiOptions options,
+            IRelationshipDataAdapter relationshipDataAdapter)
+            : base(resourceGraph, resourceFactory)
+        {
+            ArgumentGuard.NotNull(options, nameof(options));
+            ArgumentGuard.NotNull(relationshipDataAdapter, nameof(relationshipDataAdapter));
+
+            _options = options;
+            _relationshipDataAdapter = relationshipDataAdapter;
+        }
+
+        /// <inheritdoc />
+        public (IIdentifiable resource, ResourceType resourceType) Convert(ResourceObject resourceObject, ResourceIdentityRequirements requirements,
+            RequestAdapterState state)
+        {
+            ArgumentGuard.NotNull(resourceObject, nameof(resourceObject));
+            ArgumentGuard.NotNull(requirements, nameof(requirements));
+            ArgumentGuard.NotNull(state, nameof(state));
+
+            (IIdentifiable resource, ResourceType resourceType) = ConvertResourceIdentity(resourceObject, requirements, state);
+
+            ConvertAttributes(resourceObject.Attributes, resource, resourceType, state);
+            ConvertRelationships(resourceObject.Relationships, resource, resourceType, state);
+
+            return (resource, resourceType);
+        }
+
+        private void ConvertAttributes(IDictionary<string, object> resourceObjectAttributes, IIdentifiable resource, ResourceType resourceType,
+            RequestAdapterState state)
+        {
+            using IDisposable _ = state.Position.PushElement("attributes");
+
+            foreach ((string attributeName, object attributeValue) in resourceObjectAttributes.EmptyIfNull())
+            {
+                ConvertAttribute(resource, attributeName, attributeValue, resourceType, state);
+            }
+        }
+
+        private void ConvertAttribute(IIdentifiable resource, string attributeName, object attributeValue, ResourceType resourceType, RequestAdapterState state)
+        {
+            using IDisposable _ = state.Position.PushElement(attributeName);
+            AttrAttribute attr = resourceType.TryGetAttributeByPublicName(attributeName);
+
+            if (attr == null && _options.AllowUnknownFieldsInRequestBody)
+            {
+                return;
+            }
+
+            AssertIsKnownAttribute(attr, attributeName, resourceType, state);
+            AssertNoInvalidAttribute(attributeValue, state);
+            AssertNoBlockedCreate(attr, resourceType, state);
+            AssertNoBlockedChange(attr, resourceType, state);
+            AssertNotReadOnly(attr, resourceType, state);
+
+            attr!.SetValue(resource, attributeValue);
+            state.WritableTargetedFields.Attributes.Add(attr);
+        }
+
+        [AssertionMethod]
+        private static void AssertIsKnownAttribute(AttrAttribute attr, string attributeName, ResourceType resourceType, RequestAdapterState state)
+        {
+            if (attr == null)
+            {
+                throw new ModelConversionException(state.Position, "Unknown attribute found.",
+                    $"Attribute '{attributeName}' does not exist on resource type '{resourceType.PublicName}'.");
+            }
+        }
+
+        private static void AssertNoInvalidAttribute(object attributeValue, RequestAdapterState state)
+        {
+            if (attributeValue is JsonInvalidAttributeInfo info)
+            {
+                if (info == JsonInvalidAttributeInfo.Id)
+                {
+                    throw new ModelConversionException(state.Position, "Resource ID is read-only.", null);
+                }
+
+                string typeName = info.AttributeType.GetFriendlyTypeName();
+
+                throw new ModelConversionException(state.Position, "Incompatible attribute value found.",
+                    $"Failed to convert attribute '{info.AttributeName}' with value '{info.JsonValue}' of type '{info.JsonType}' to type '{typeName}'.");
+            }
+        }
+
+        private static void AssertNoBlockedCreate(AttrAttribute attr, ResourceType resourceType, RequestAdapterState state)
+        {
+            if (state.Request.WriteOperation == WriteOperationKind.CreateResource && !attr.Capabilities.HasFlag(AttrCapabilities.AllowCreate))
+            {
+                throw new ModelConversionException(state.Position, "Attribute value cannot be assigned when creating resource.",
+                    $"The attribute '{attr.PublicName}' on resource type '{resourceType.PublicName}' cannot be assigned to.");
+            }
+        }
+
+        private static void AssertNoBlockedChange(AttrAttribute attr, ResourceType resourceType, RequestAdapterState state)
+        {
+            if (state.Request.WriteOperation == WriteOperationKind.UpdateResource && !attr.Capabilities.HasFlag(AttrCapabilities.AllowChange))
+            {
+                throw new ModelConversionException(state.Position, "Attribute value cannot be assigned when updating resource.",
+                    $"The attribute '{attr.PublicName}' on resource type '{resourceType.PublicName}' cannot be assigned to.");
+            }
+        }
+
+        private static void AssertNotReadOnly(AttrAttribute attr, ResourceType resourceType, RequestAdapterState state)
+        {
+            if (attr.Property.SetMethod == null)
+            {
+                throw new ModelConversionException(state.Position, "Attribute is read-only.",
+                    $"Attribute '{attr.PublicName}' on resource type '{resourceType.PublicName}' is read-only.");
+            }
+        }
+
+        private void ConvertRelationships(IDictionary<string, RelationshipObject> resourceObjectRelationships, IIdentifiable resource,
+            ResourceType resourceType, RequestAdapterState state)
+        {
+            using IDisposable _ = state.Position.PushElement("relationships");
+
+            foreach ((string relationshipName, RelationshipObject relationshipObject) in resourceObjectRelationships.EmptyIfNull())
+            {
+                ConvertRelationship(relationshipName, relationshipObject.Data, resource, resourceType, state);
+            }
+        }
+
+        private void ConvertRelationship(string relationshipName, SingleOrManyData<ResourceIdentifierObject> relationshipData, IIdentifiable resource,
+            ResourceType resourceType, RequestAdapterState state)
+        {
+            using IDisposable _ = state.Position.PushElement(relationshipName);
+            RelationshipAttribute relationship = resourceType.TryGetRelationshipByPublicName(relationshipName);
+
+            if (relationship == null && _options.AllowUnknownFieldsInRequestBody)
+            {
+                return;
+            }
+
+            AssertIsKnownRelationship(relationship, relationshipName, resourceType, state);
+
+            object rightValue = _relationshipDataAdapter.Convert(relationshipData, relationship, true, state);
+
+            relationship!.SetValue(resource, rightValue);
+            state.WritableTargetedFields.Relationships.Add(relationship);
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/IJsonApiReader.cs b/src/JsonApiDotNetCore/Serialization/Request/IJsonApiReader.cs
new file mode 100644
index 0000000000..aab4712844
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/IJsonApiReader.cs
@@ -0,0 +1,19 @@
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using Microsoft.AspNetCore.Http;
+
+namespace JsonApiDotNetCore.Serialization.Request
+{
+    /// <summary>
+    /// Deserializes the incoming JSON:API request body and converts it to models, which are passed to controller actions by ASP.NET Core on `FromBody`
+    /// parameters.
+    /// </summary>
+    [PublicAPI]
+    public interface IJsonApiReader
+    {
+        /// <summary>
+        /// Reads an object from the request body.
+        /// </summary>
+        Task<object> ReadAsync(HttpRequest httpRequest);
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Request/JsonApiReader.cs b/src/JsonApiDotNetCore/Serialization/Request/JsonApiReader.cs
new file mode 100644
index 0000000000..96831014c3
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/JsonApiReader.cs
@@ -0,0 +1,108 @@
+using System;
+using System.Net;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Diagnostics;
+using JsonApiDotNetCore.Errors;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Serialization.Objects;
+using JsonApiDotNetCore.Serialization.Request.Adapters;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Extensions;
+using Microsoft.AspNetCore.WebUtilities;
+using Microsoft.Extensions.Logging;
+
+namespace JsonApiDotNetCore.Serialization.Request
+{
+    /// <inheritdoc />
+    public sealed class JsonApiReader : IJsonApiReader
+    {
+        private readonly IJsonApiOptions _options;
+        private readonly IDocumentAdapter _documentAdapter;
+        private readonly TraceLogWriter<JsonApiReader> _traceWriter;
+
+        public JsonApiReader(IJsonApiOptions options, IDocumentAdapter documentAdapter, ILoggerFactory loggerFactory)
+        {
+            ArgumentGuard.NotNull(options, nameof(options));
+            ArgumentGuard.NotNull(documentAdapter, nameof(documentAdapter));
+            ArgumentGuard.NotNull(loggerFactory, nameof(loggerFactory));
+
+            _options = options;
+            _documentAdapter = documentAdapter;
+            _traceWriter = new TraceLogWriter<JsonApiReader>(loggerFactory);
+        }
+
+        /// <inheritdoc />
+        public async Task<object> ReadAsync(HttpRequest httpRequest)
+        {
+            ArgumentGuard.NotNull(httpRequest, nameof(httpRequest));
+
+            string requestBody = await ReceiveRequestBodyAsync(httpRequest);
+
+            _traceWriter.LogMessage(() => $"Received {httpRequest.Method} request at '{httpRequest.GetEncodedUrl()}' with body: <<{requestBody}>>");
+
+            return GetModel(requestBody);
+        }
+
+        private static async Task<string> ReceiveRequestBodyAsync(HttpRequest httpRequest)
+        {
+            using IDisposable _ = CodeTimingSessionManager.Current.Measure("Receive request body");
+
+            using var reader = new HttpRequestStreamReader(httpRequest.Body, Encoding.UTF8);
+            return await reader.ReadToEndAsync();
+        }
+
+        private object GetModel(string requestBody)
+        {
+            AssertHasRequestBody(requestBody);
+
+            using IDisposable _ = CodeTimingSessionManager.Current.Measure("Read request body");
+
+            Document document = DeserializeDocument(requestBody);
+            return ConvertDocumentToModel(document, requestBody);
+        }
+
+        [AssertionMethod]
+        private static void AssertHasRequestBody(string requestBody)
+        {
+            if (string.IsNullOrEmpty(requestBody))
+            {
+                throw new InvalidRequestBodyException(null, "Missing request body.", null, null, HttpStatusCode.BadRequest);
+            }
+        }
+
+        private Document DeserializeDocument(string requestBody)
+        {
+            try
+            {
+                using IDisposable _ =
+                    CodeTimingSessionManager.Current.Measure("JsonSerializer.Deserialize", MeasurementSettings.ExcludeJsonSerializationInPercentages);
+
+                return JsonSerializer.Deserialize<Document>(requestBody, _options.SerializerReadOptions);
+            }
+            catch (JsonException exception)
+            {
+                // JsonException.Path looks great for setting error.source.pointer, but unfortunately it is wrong in most cases.
+                // This is due to the use of custom converters, which are unable to interact with internal position tracking.
+                // https://github.com/dotnet/runtime/issues/50205#issuecomment-808401245
+                throw new InvalidRequestBodyException(_options.IncludeRequestBodyInErrors ? requestBody : null, null, exception.Message, null, null, exception);
+            }
+        }
+
+        private object ConvertDocumentToModel(Document document, string requestBody)
+        {
+            try
+            {
+                return _documentAdapter.Convert(document);
+            }
+            catch (ModelConversionException exception)
+            {
+                throw new InvalidRequestBodyException(_options.IncludeRequestBodyInErrors ? requestBody : null, exception.GenericMessage,
+                    exception.SpecificMessage, exception.SourcePointer, exception.StatusCode, exception);
+            }
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/JsonInvalidAttributeInfo.cs b/src/JsonApiDotNetCore/Serialization/Request/JsonInvalidAttributeInfo.cs
similarity index 95%
rename from src/JsonApiDotNetCore/Serialization/JsonInvalidAttributeInfo.cs
rename to src/JsonApiDotNetCore/Serialization/Request/JsonInvalidAttributeInfo.cs
index 037eaf18af..5c448613a6 100644
--- a/src/JsonApiDotNetCore/Serialization/JsonInvalidAttributeInfo.cs
+++ b/src/JsonApiDotNetCore/Serialization/Request/JsonInvalidAttributeInfo.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Text.Json;
 
-namespace JsonApiDotNetCore.Serialization
+namespace JsonApiDotNetCore.Serialization.Request
 {
     /// <summary>
     /// A sentinel value that is temporarily stored in the attributes dictionary to postpone producing an error.
diff --git a/src/JsonApiDotNetCore/Serialization/Request/ModelConversionException.cs b/src/JsonApiDotNetCore/Serialization/Request/ModelConversionException.cs
new file mode 100644
index 0000000000..c9922e855b
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Request/ModelConversionException.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Net;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Serialization.Request.Adapters;
+
+namespace JsonApiDotNetCore.Serialization.Request
+{
+    /// <summary>
+    /// The error that is thrown when unable to convert a deserialized request body to an ASP.NET model.
+    /// </summary>
+    [PublicAPI]
+    public sealed class ModelConversionException : Exception
+    {
+        public string GenericMessage { get; }
+        public string SpecificMessage { get; }
+        public HttpStatusCode? StatusCode { get; }
+        public string SourcePointer { get; }
+
+        public ModelConversionException(RequestAdapterPosition position, string genericMessage, string specificMessage, HttpStatusCode? statusCode = null)
+            : base(genericMessage)
+        {
+            ArgumentGuard.NotNull(position, nameof(position));
+
+            GenericMessage = genericMessage;
+            SpecificMessage = specificMessage;
+            StatusCode = statusCode;
+            SourcePointer = position.ToSourcePointer();
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/RequestDeserializer.cs b/src/JsonApiDotNetCore/Serialization/RequestDeserializer.cs
deleted file mode 100644
index 3b466a7087..0000000000
--- a/src/JsonApiDotNetCore/Serialization/RequestDeserializer.cs
+++ /dev/null
@@ -1,524 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Net.Http;
-using Humanizer;
-using JetBrains.Annotations;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Middleware;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Resources.Internal;
-using JsonApiDotNetCore.Serialization.Objects;
-using Microsoft.AspNetCore.Http;
-
-namespace JsonApiDotNetCore.Serialization
-{
-    /// <summary>
-    /// Server deserializer implementation of the <see cref="BaseDeserializer" />.
-    /// </summary>
-    [PublicAPI]
-    public class RequestDeserializer : BaseDeserializer, IJsonApiDeserializer
-    {
-        private readonly ITargetedFields _targetedFields;
-        private readonly IHttpContextAccessor _httpContextAccessor;
-        private readonly IJsonApiRequest _request;
-        private readonly IJsonApiOptions _options;
-        private readonly IResourceDefinitionAccessor _resourceDefinitionAccessor;
-
-        public RequestDeserializer(IResourceGraph resourceGraph, IResourceFactory resourceFactory, ITargetedFields targetedFields,
-            IHttpContextAccessor httpContextAccessor, IJsonApiRequest request, IJsonApiOptions options, IResourceDefinitionAccessor resourceDefinitionAccessor)
-            : base(resourceGraph, resourceFactory)
-        {
-            ArgumentGuard.NotNull(targetedFields, nameof(targetedFields));
-            ArgumentGuard.NotNull(httpContextAccessor, nameof(httpContextAccessor));
-            ArgumentGuard.NotNull(request, nameof(request));
-            ArgumentGuard.NotNull(options, nameof(options));
-            ArgumentGuard.NotNull(resourceDefinitionAccessor, nameof(resourceDefinitionAccessor));
-
-            _targetedFields = targetedFields;
-            _httpContextAccessor = httpContextAccessor;
-            _request = request;
-            _options = options;
-            _resourceDefinitionAccessor = resourceDefinitionAccessor;
-        }
-
-        /// <inheritdoc />
-        public object Deserialize(string body)
-        {
-            ArgumentGuard.NotNullNorEmpty(body, nameof(body));
-
-            if (_request.Kind == EndpointKind.Relationship)
-            {
-                _targetedFields.Relationships.Add(_request.Relationship);
-            }
-
-            if (_request.Kind == EndpointKind.AtomicOperations)
-            {
-                return DeserializeOperationsDocument(body);
-            }
-
-            object instance = DeserializeData(body, _options.SerializerReadOptions);
-
-            if (instance is IIdentifiable resource && _request.Kind != EndpointKind.Relationship)
-            {
-                _resourceDefinitionAccessor.OnDeserialize(resource);
-            }
-
-            AssertResourceIdIsNotTargeted(_targetedFields);
-
-            return instance;
-        }
-
-        private object DeserializeOperationsDocument(string body)
-        {
-            Document document = DeserializeDocument(body, _options.SerializerReadOptions);
-
-            if ((document?.Operations).IsNullOrEmpty())
-            {
-                throw new JsonApiSerializationException("No operations found.", null);
-            }
-
-            if (document.Operations.Count > _options.MaximumOperationsPerRequest)
-            {
-                throw new JsonApiSerializationException("Request exceeds the maximum number of operations.",
-                    $"The number of operations in this request ({document.Operations.Count}) is higher than {_options.MaximumOperationsPerRequest}.");
-            }
-
-            var operations = new List<OperationContainer>();
-            AtomicOperationIndex = 0;
-
-            foreach (AtomicOperationObject operation in document.Operations)
-            {
-                OperationContainer container = DeserializeOperation(operation);
-                operations.Add(container);
-
-                AtomicOperationIndex++;
-            }
-
-            return operations;
-        }
-
-        private OperationContainer DeserializeOperation(AtomicOperationObject operation)
-        {
-            _targetedFields.Attributes.Clear();
-            _targetedFields.Relationships.Clear();
-
-            AssertHasNoHref(operation);
-
-            WriteOperationKind writeOperation = GetWriteOperationKind(operation);
-
-            switch (writeOperation)
-            {
-                case WriteOperationKind.CreateResource:
-                case WriteOperationKind.UpdateResource:
-                {
-                    return ParseForCreateOrUpdateResourceOperation(operation, writeOperation);
-                }
-                case WriteOperationKind.DeleteResource:
-                {
-                    return ParseForDeleteResourceOperation(operation, writeOperation);
-                }
-            }
-
-            bool requireToManyRelationship =
-                writeOperation == WriteOperationKind.AddToRelationship || writeOperation == WriteOperationKind.RemoveFromRelationship;
-
-            return ParseForRelationshipOperation(operation, writeOperation, requireToManyRelationship);
-        }
-
-        [AssertionMethod]
-        private void AssertHasNoHref(AtomicOperationObject operation)
-        {
-            if (operation.Href != null)
-            {
-                throw new JsonApiSerializationException("Usage of the 'href' element is not supported.", null, atomicOperationIndex: AtomicOperationIndex);
-            }
-        }
-
-        private WriteOperationKind GetWriteOperationKind(AtomicOperationObject operation)
-        {
-            switch (operation.Code)
-            {
-                case AtomicOperationCode.Add:
-                {
-                    if (operation.Ref is { Relationship: null })
-                    {
-                        throw new JsonApiSerializationException("The 'ref.relationship' element is required.", null,
-                            atomicOperationIndex: AtomicOperationIndex);
-                    }
-
-                    return operation.Ref == null ? WriteOperationKind.CreateResource : WriteOperationKind.AddToRelationship;
-                }
-                case AtomicOperationCode.Update:
-                {
-                    return operation.Ref?.Relationship != null ? WriteOperationKind.SetRelationship : WriteOperationKind.UpdateResource;
-                }
-                case AtomicOperationCode.Remove:
-                {
-                    if (operation.Ref == null)
-                    {
-                        throw new JsonApiSerializationException("The 'ref' element is required.", null, atomicOperationIndex: AtomicOperationIndex);
-                    }
-
-                    return operation.Ref.Relationship != null ? WriteOperationKind.RemoveFromRelationship : WriteOperationKind.DeleteResource;
-                }
-            }
-
-            throw new NotSupportedException($"Unknown operation code '{operation.Code}'.");
-        }
-
-        private OperationContainer ParseForCreateOrUpdateResourceOperation(AtomicOperationObject operation, WriteOperationKind writeOperation)
-        {
-            ResourceObject resourceObject = GetRequiredSingleDataForResourceOperation(operation);
-
-            AssertElementHasType(resourceObject, "data");
-            AssertElementHasIdOrLid(resourceObject, "data", writeOperation != WriteOperationKind.CreateResource);
-
-            ResourceContext primaryResourceContext = GetExistingResourceContext(resourceObject.Type);
-
-            AssertCompatibleId(resourceObject, primaryResourceContext.IdentityType);
-
-            if (operation.Ref != null)
-            {
-                // For resource update, 'ref' is optional. But when specified, it must match with 'data'.
-
-                AssertElementHasType(operation.Ref, "ref");
-                AssertElementHasIdOrLid(operation.Ref, "ref", true);
-
-                ResourceContext resourceContextInRef = GetExistingResourceContext(operation.Ref.Type);
-
-                if (!primaryResourceContext.Equals(resourceContextInRef))
-                {
-                    throw new JsonApiSerializationException("Resource type mismatch between 'ref.type' and 'data.type' element.",
-                        $"Expected resource of type '{resourceContextInRef.PublicName}' in 'data.type', instead of '{primaryResourceContext.PublicName}'.",
-                        atomicOperationIndex: AtomicOperationIndex);
-                }
-
-                AssertSameIdentityInRefData(operation, resourceObject);
-            }
-
-            var request = new JsonApiRequest
-            {
-                Kind = EndpointKind.AtomicOperations,
-                PrimaryResource = primaryResourceContext,
-                WriteOperation = writeOperation
-            };
-
-            _request.CopyFrom(request);
-
-            IIdentifiable primaryResource = ParseResourceObject(operation.Data.SingleValue);
-
-            _resourceDefinitionAccessor.OnDeserialize(primaryResource);
-
-            request.PrimaryId = primaryResource.StringId;
-            _request.CopyFrom(request);
-
-            var targetedFields = new TargetedFields
-            {
-                Attributes = _targetedFields.Attributes.ToHashSet(),
-                Relationships = _targetedFields.Relationships.ToHashSet()
-            };
-
-            AssertResourceIdIsNotTargeted(targetedFields);
-
-            return new OperationContainer(writeOperation, primaryResource, targetedFields, request);
-        }
-
-        private ResourceObject GetRequiredSingleDataForResourceOperation(AtomicOperationObject operation)
-        {
-            if (operation.Data.Value == null)
-            {
-                throw new JsonApiSerializationException("The 'data' element is required.", null, atomicOperationIndex: AtomicOperationIndex);
-            }
-
-            if (operation.Data.SingleValue == null)
-            {
-                throw new JsonApiSerializationException("Expected single data element for create/update resource operation.", null,
-                    atomicOperationIndex: AtomicOperationIndex);
-            }
-
-            return operation.Data.SingleValue;
-        }
-
-        [AssertionMethod]
-        private void AssertElementHasType(IResourceIdentity resourceIdentity, string elementPath)
-        {
-            if (resourceIdentity.Type == null)
-            {
-                throw new JsonApiSerializationException($"The '{elementPath}.type' element is required.", null, atomicOperationIndex: AtomicOperationIndex);
-            }
-        }
-
-        private void AssertElementHasIdOrLid(IResourceIdentity resourceIdentity, string elementPath, bool isRequired)
-        {
-            bool hasNone = resourceIdentity.Id == null && resourceIdentity.Lid == null;
-            bool hasBoth = resourceIdentity.Id != null && resourceIdentity.Lid != null;
-
-            if (isRequired ? hasNone || hasBoth : hasBoth)
-            {
-                throw new JsonApiSerializationException($"The '{elementPath}.id' or '{elementPath}.lid' element is required.", null,
-                    atomicOperationIndex: AtomicOperationIndex);
-            }
-        }
-
-        private void AssertCompatibleId(IResourceIdentity resourceIdentity, Type idType)
-        {
-            if (resourceIdentity.Id != null)
-            {
-                try
-                {
-                    RuntimeTypeConverter.ConvertType(resourceIdentity.Id, idType);
-                }
-                catch (FormatException exception)
-                {
-                    throw new JsonApiSerializationException(null, exception.Message, null, AtomicOperationIndex);
-                }
-            }
-        }
-
-        private void AssertSameIdentityInRefData(AtomicOperationObject operation, IResourceIdentity resourceIdentity)
-        {
-            if (operation.Ref.Id != null && resourceIdentity.Id != null && resourceIdentity.Id != operation.Ref.Id)
-            {
-                throw new JsonApiSerializationException("Resource ID mismatch between 'ref.id' and 'data.id' element.",
-                    $"Expected resource with ID '{operation.Ref.Id}' in 'data.id', instead of '{resourceIdentity.Id}'.",
-                    atomicOperationIndex: AtomicOperationIndex);
-            }
-
-            if (operation.Ref.Lid != null && resourceIdentity.Lid != null && resourceIdentity.Lid != operation.Ref.Lid)
-            {
-                throw new JsonApiSerializationException("Resource local ID mismatch between 'ref.lid' and 'data.lid' element.",
-                    $"Expected resource with local ID '{operation.Ref.Lid}' in 'data.lid', instead of '{resourceIdentity.Lid}'.",
-                    atomicOperationIndex: AtomicOperationIndex);
-            }
-
-            if (operation.Ref.Id != null && resourceIdentity.Lid != null)
-            {
-                throw new JsonApiSerializationException("Resource identity mismatch between 'ref.id' and 'data.lid' element.",
-                    $"Expected resource with ID '{operation.Ref.Id}' in 'data.id', instead of '{resourceIdentity.Lid}' in 'data.lid'.",
-                    atomicOperationIndex: AtomicOperationIndex);
-            }
-
-            if (operation.Ref.Lid != null && resourceIdentity.Id != null)
-            {
-                throw new JsonApiSerializationException("Resource identity mismatch between 'ref.lid' and 'data.id' element.",
-                    $"Expected resource with local ID '{operation.Ref.Lid}' in 'data.lid', instead of '{resourceIdentity.Id}' in 'data.id'.",
-                    atomicOperationIndex: AtomicOperationIndex);
-            }
-        }
-
-        private OperationContainer ParseForDeleteResourceOperation(AtomicOperationObject operation, WriteOperationKind writeOperation)
-        {
-            AssertElementHasType(operation.Ref, "ref");
-            AssertElementHasIdOrLid(operation.Ref, "ref", true);
-
-            ResourceContext primaryResourceContext = GetExistingResourceContext(operation.Ref.Type);
-
-            AssertCompatibleId(operation.Ref, primaryResourceContext.IdentityType);
-
-            IIdentifiable primaryResource = ResourceFactory.CreateInstance(primaryResourceContext.ResourceType);
-            primaryResource.StringId = operation.Ref.Id;
-            primaryResource.LocalId = operation.Ref.Lid;
-
-            var request = new JsonApiRequest
-            {
-                Kind = EndpointKind.AtomicOperations,
-                PrimaryId = primaryResource.StringId,
-                PrimaryResource = primaryResourceContext,
-                WriteOperation = writeOperation
-            };
-
-            return new OperationContainer(writeOperation, primaryResource, new TargetedFields(), request);
-        }
-
-        private OperationContainer ParseForRelationshipOperation(AtomicOperationObject operation, WriteOperationKind writeOperation, bool requireToMany)
-        {
-            AssertElementHasType(operation.Ref, "ref");
-            AssertElementHasIdOrLid(operation.Ref, "ref", true);
-
-            ResourceContext primaryResourceContext = GetExistingResourceContext(operation.Ref.Type);
-
-            AssertCompatibleId(operation.Ref, primaryResourceContext.IdentityType);
-
-            IIdentifiable primaryResource = ResourceFactory.CreateInstance(primaryResourceContext.ResourceType);
-            primaryResource.StringId = operation.Ref.Id;
-            primaryResource.LocalId = operation.Ref.Lid;
-
-            RelationshipAttribute relationship = GetExistingRelationship(operation.Ref, primaryResourceContext);
-
-            if (requireToMany && relationship is HasOneAttribute)
-            {
-                throw new JsonApiSerializationException($"Only to-many relationships can be targeted in '{operation.Code.ToString().Camelize()}' operations.",
-                    $"Relationship '{operation.Ref.Relationship}' must be a to-many relationship.", atomicOperationIndex: AtomicOperationIndex);
-            }
-
-            ResourceContext secondaryResourceContext = ResourceGraph.GetResourceContext(relationship.RightType);
-
-            var request = new JsonApiRequest
-            {
-                Kind = EndpointKind.AtomicOperations,
-                PrimaryId = primaryResource.StringId,
-                PrimaryResource = primaryResourceContext,
-                SecondaryResource = secondaryResourceContext,
-                Relationship = relationship,
-                IsCollection = relationship is HasManyAttribute,
-                WriteOperation = writeOperation
-            };
-
-            _request.CopyFrom(request);
-
-            _targetedFields.Relationships.Add(relationship);
-
-            ParseDataForRelationship(relationship, secondaryResourceContext, operation, primaryResource);
-
-            var targetedFields = new TargetedFields
-            {
-                Attributes = _targetedFields.Attributes.ToHashSet(),
-                Relationships = _targetedFields.Relationships.ToHashSet()
-            };
-
-            return new OperationContainer(writeOperation, primaryResource, targetedFields, request);
-        }
-
-        private RelationshipAttribute GetExistingRelationship(AtomicReference reference, ResourceContext resourceContext)
-        {
-            RelationshipAttribute relationship = resourceContext.TryGetRelationshipByPublicName(reference.Relationship);
-
-            if (relationship == null)
-            {
-                throw new JsonApiSerializationException("The referenced relationship does not exist.",
-                    $"Resource of type '{reference.Type}' does not contain a relationship named '{reference.Relationship}'.",
-                    atomicOperationIndex: AtomicOperationIndex);
-            }
-
-            return relationship;
-        }
-
-        private void ParseDataForRelationship(RelationshipAttribute relationship, ResourceContext secondaryResourceContext, AtomicOperationObject operation,
-            IIdentifiable primaryResource)
-        {
-            if (relationship is HasOneAttribute)
-            {
-                if (operation.Data.ManyValue != null)
-                {
-                    throw new JsonApiSerializationException("Expected single data element for to-one relationship.",
-                        $"Expected single data element for '{relationship.PublicName}' relationship.", atomicOperationIndex: AtomicOperationIndex);
-                }
-
-                if (operation.Data.SingleValue != null)
-                {
-                    ValidateSingleDataForRelationship(operation.Data.SingleValue, secondaryResourceContext, "data");
-
-                    IIdentifiable secondaryResource = ParseResourceObject(operation.Data.SingleValue);
-                    relationship.SetValue(primaryResource, secondaryResource);
-                }
-            }
-            else if (relationship is HasManyAttribute)
-            {
-                if (operation.Data.ManyValue == null)
-                {
-                    throw new JsonApiSerializationException("Expected data[] element for to-many relationship.",
-                        $"Expected data[] element for '{relationship.PublicName}' relationship.", atomicOperationIndex: AtomicOperationIndex);
-                }
-
-                var secondaryResources = new List<IIdentifiable>();
-
-                foreach (ResourceObject resourceObject in operation.Data.ManyValue)
-                {
-                    ValidateSingleDataForRelationship(resourceObject, secondaryResourceContext, "data[]");
-
-                    IIdentifiable secondaryResource = ParseResourceObject(resourceObject);
-                    secondaryResources.Add(secondaryResource);
-                }
-
-                IEnumerable rightResources = CollectionConverter.CopyToTypedCollection(secondaryResources, relationship.Property.PropertyType);
-                relationship.SetValue(primaryResource, rightResources);
-            }
-        }
-
-        private void ValidateSingleDataForRelationship(ResourceObject dataResourceObject, ResourceContext resourceContext, string elementPath)
-        {
-            AssertElementHasType(dataResourceObject, elementPath);
-            AssertElementHasIdOrLid(dataResourceObject, elementPath, true);
-
-            ResourceContext resourceContextInData = GetExistingResourceContext(dataResourceObject.Type);
-
-            AssertCompatibleType(resourceContextInData, resourceContext, elementPath);
-            AssertCompatibleId(dataResourceObject, resourceContextInData.IdentityType);
-        }
-
-        private void AssertCompatibleType(ResourceContext resourceContextInData, ResourceContext resourceContextInRef, string elementPath)
-        {
-            if (!resourceContextInData.ResourceType.IsAssignableFrom(resourceContextInRef.ResourceType))
-            {
-                throw new JsonApiSerializationException($"Resource type mismatch between 'ref.relationship' and '{elementPath}.type' element.",
-                    $"Expected resource of type '{resourceContextInRef.PublicName}' in '{elementPath}.type', instead of '{resourceContextInData.PublicName}'.",
-                    atomicOperationIndex: AtomicOperationIndex);
-            }
-        }
-
-        private void AssertResourceIdIsNotTargeted(ITargetedFields targetedFields)
-        {
-            if (!_request.IsReadOnly && targetedFields.Attributes.Any(attribute => attribute.Property.Name == nameof(Identifiable.Id)))
-            {
-                throw new JsonApiSerializationException("Resource ID is read-only.", null, atomicOperationIndex: AtomicOperationIndex);
-            }
-        }
-
-        /// <summary>
-        /// Additional processing required for server deserialization. Flags a processed attribute or relationship as updated using
-        /// <see cref="ITargetedFields" />.
-        /// </summary>
-        /// <param name="resource">
-        /// The resource that was constructed from the document's body.
-        /// </param>
-        /// <param name="field">
-        /// The metadata for the exposed field.
-        /// </param>
-        /// <param name="data">
-        /// Relationship data for <paramref name="resource" />. Is null when <paramref name="field" /> is not a <see cref="RelationshipAttribute" />.
-        /// </param>
-        protected override void AfterProcessField(IIdentifiable resource, ResourceFieldAttribute field, RelationshipObject data = null)
-        {
-            bool isCreatingResource = IsCreatingResource();
-            bool isUpdatingResource = IsUpdatingResource();
-
-            if (field is AttrAttribute attr)
-            {
-                if (isCreatingResource && !attr.Capabilities.HasFlag(AttrCapabilities.AllowCreate))
-                {
-                    throw new JsonApiSerializationException("Setting the initial value of the requested attribute is not allowed.",
-                        $"Setting the initial value of '{attr.PublicName}' is not allowed.", atomicOperationIndex: AtomicOperationIndex);
-                }
-
-                if (isUpdatingResource && !attr.Capabilities.HasFlag(AttrCapabilities.AllowChange))
-                {
-                    throw new JsonApiSerializationException("Changing the value of the requested attribute is not allowed.",
-                        $"Changing the value of '{attr.PublicName}' is not allowed.", atomicOperationIndex: AtomicOperationIndex);
-                }
-
-                _targetedFields.Attributes.Add(attr);
-            }
-            else if (field is RelationshipAttribute relationship)
-            {
-                _targetedFields.Relationships.Add(relationship);
-            }
-        }
-
-        private bool IsCreatingResource()
-        {
-            return _request.Kind == EndpointKind.AtomicOperations
-                ? _request.WriteOperation == WriteOperationKind.CreateResource
-                : _request.Kind == EndpointKind.Primary && _httpContextAccessor.HttpContext!.Request.Method == HttpMethod.Post.Method;
-        }
-
-        private bool IsUpdatingResource()
-        {
-            return _request.Kind == EndpointKind.AtomicOperations
-                ? _request.WriteOperation == WriteOperationKind.UpdateResource
-                : _request.Kind == EndpointKind.Primary && _httpContextAccessor.HttpContext!.Request.Method == HttpMethod.Patch.Method;
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/ETagGenerator.cs b/src/JsonApiDotNetCore/Serialization/Response/ETagGenerator.cs
similarity index 93%
rename from src/JsonApiDotNetCore/Serialization/ETagGenerator.cs
rename to src/JsonApiDotNetCore/Serialization/Response/ETagGenerator.cs
index bc1a7f3e49..f2a78adb65 100644
--- a/src/JsonApiDotNetCore/Serialization/ETagGenerator.cs
+++ b/src/JsonApiDotNetCore/Serialization/Response/ETagGenerator.cs
@@ -1,6 +1,6 @@
 using Microsoft.Net.Http.Headers;
 
-namespace JsonApiDotNetCore.Serialization
+namespace JsonApiDotNetCore.Serialization.Response
 {
     /// <inheritdoc />
     internal sealed class ETagGenerator : IETagGenerator
diff --git a/src/JsonApiDotNetCore/Serialization/EmptyResponseMeta.cs b/src/JsonApiDotNetCore/Serialization/Response/EmptyResponseMeta.cs
similarity index 83%
rename from src/JsonApiDotNetCore/Serialization/EmptyResponseMeta.cs
rename to src/JsonApiDotNetCore/Serialization/Response/EmptyResponseMeta.cs
index 592a752926..a06e4b76c3 100644
--- a/src/JsonApiDotNetCore/Serialization/EmptyResponseMeta.cs
+++ b/src/JsonApiDotNetCore/Serialization/Response/EmptyResponseMeta.cs
@@ -1,6 +1,6 @@
 using System.Collections.Generic;
 
-namespace JsonApiDotNetCore.Serialization
+namespace JsonApiDotNetCore.Serialization.Response
 {
     /// <inheritdoc />
     public sealed class EmptyResponseMeta : IResponseMeta
diff --git a/src/JsonApiDotNetCore/Serialization/FingerprintGenerator.cs b/src/JsonApiDotNetCore/Serialization/Response/FingerprintGenerator.cs
similarity index 97%
rename from src/JsonApiDotNetCore/Serialization/FingerprintGenerator.cs
rename to src/JsonApiDotNetCore/Serialization/Response/FingerprintGenerator.cs
index 3c1083dfbe..9835bf5de3 100644
--- a/src/JsonApiDotNetCore/Serialization/FingerprintGenerator.cs
+++ b/src/JsonApiDotNetCore/Serialization/Response/FingerprintGenerator.cs
@@ -3,7 +3,7 @@
 using System.Security.Cryptography;
 using System.Text;
 
-namespace JsonApiDotNetCore.Serialization
+namespace JsonApiDotNetCore.Serialization.Response
 {
     /// <inheritdoc />
     internal sealed class FingerprintGenerator : IFingerprintGenerator
diff --git a/src/JsonApiDotNetCore/Serialization/IETagGenerator.cs b/src/JsonApiDotNetCore/Serialization/Response/IETagGenerator.cs
similarity index 93%
rename from src/JsonApiDotNetCore/Serialization/IETagGenerator.cs
rename to src/JsonApiDotNetCore/Serialization/Response/IETagGenerator.cs
index 5aa3abf759..5fc5070129 100644
--- a/src/JsonApiDotNetCore/Serialization/IETagGenerator.cs
+++ b/src/JsonApiDotNetCore/Serialization/Response/IETagGenerator.cs
@@ -1,6 +1,6 @@
 using Microsoft.Net.Http.Headers;
 
-namespace JsonApiDotNetCore.Serialization
+namespace JsonApiDotNetCore.Serialization.Response
 {
     /// <summary>
     /// Provides generation of an ETag HTTP response header.
diff --git a/src/JsonApiDotNetCore/Serialization/IFingerprintGenerator.cs b/src/JsonApiDotNetCore/Serialization/Response/IFingerprintGenerator.cs
similarity index 89%
rename from src/JsonApiDotNetCore/Serialization/IFingerprintGenerator.cs
rename to src/JsonApiDotNetCore/Serialization/Response/IFingerprintGenerator.cs
index 51fafaf650..7b18e7db19 100644
--- a/src/JsonApiDotNetCore/Serialization/IFingerprintGenerator.cs
+++ b/src/JsonApiDotNetCore/Serialization/Response/IFingerprintGenerator.cs
@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using JetBrains.Annotations;
 
-namespace JsonApiDotNetCore.Serialization
+namespace JsonApiDotNetCore.Serialization.Response
 {
     /// <summary>
     /// Provides a method to generate a fingerprint for a collection of string values.
diff --git a/src/JsonApiDotNetCore/Serialization/Response/IJsonApiWriter.cs b/src/JsonApiDotNetCore/Serialization/Response/IJsonApiWriter.cs
new file mode 100644
index 0000000000..e8c0e6dab4
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Response/IJsonApiWriter.cs
@@ -0,0 +1,18 @@
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using Microsoft.AspNetCore.Http;
+
+namespace JsonApiDotNetCore.Serialization.Response
+{
+    /// <summary>
+    /// Serializes ASP.NET models into the outgoing JSON:API response body.
+    /// </summary>
+    [PublicAPI]
+    public interface IJsonApiWriter
+    {
+        /// <summary>
+        /// Writes an object to the response body.
+        /// </summary>
+        Task WriteAsync(object model, HttpContext httpContext);
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Building/ILinkBuilder.cs b/src/JsonApiDotNetCore/Serialization/Response/ILinkBuilder.cs
similarity index 83%
rename from src/JsonApiDotNetCore/Serialization/Building/ILinkBuilder.cs
rename to src/JsonApiDotNetCore/Serialization/Response/ILinkBuilder.cs
index 86462aee54..ce3e027410 100644
--- a/src/JsonApiDotNetCore/Serialization/Building/ILinkBuilder.cs
+++ b/src/JsonApiDotNetCore/Serialization/Response/ILinkBuilder.cs
@@ -1,8 +1,9 @@
+using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Resources;
 using JsonApiDotNetCore.Resources.Annotations;
 using JsonApiDotNetCore.Serialization.Objects;
 
-namespace JsonApiDotNetCore.Serialization.Building
+namespace JsonApiDotNetCore.Serialization.Response
 {
     /// <summary>
     /// Builds resource object links and relationship object links.
@@ -17,7 +18,7 @@ public interface ILinkBuilder
         /// <summary>
         /// Builds the links object for a returned resource (primary or included).
         /// </summary>
-        ResourceLinks GetResourceLinks(string resourceName, string id);
+        ResourceLinks GetResourceLinks(ResourceType resourceType, string id);
 
         /// <summary>
         /// Builds the links object for a relationship inside a returned resource.
diff --git a/src/JsonApiDotNetCore/Serialization/Building/IMetaBuilder.cs b/src/JsonApiDotNetCore/Serialization/Response/IMetaBuilder.cs
similarity index 92%
rename from src/JsonApiDotNetCore/Serialization/Building/IMetaBuilder.cs
rename to src/JsonApiDotNetCore/Serialization/Response/IMetaBuilder.cs
index 1e668feca5..c94b0150da 100644
--- a/src/JsonApiDotNetCore/Serialization/Building/IMetaBuilder.cs
+++ b/src/JsonApiDotNetCore/Serialization/Response/IMetaBuilder.cs
@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using JetBrains.Annotations;
 
-namespace JsonApiDotNetCore.Serialization.Building
+namespace JsonApiDotNetCore.Serialization.Response
 {
     /// <summary>
     /// Builds the top-level meta object.
diff --git a/src/JsonApiDotNetCore/Serialization/IResponseMeta.cs b/src/JsonApiDotNetCore/Serialization/Response/IResponseMeta.cs
similarity index 92%
rename from src/JsonApiDotNetCore/Serialization/IResponseMeta.cs
rename to src/JsonApiDotNetCore/Serialization/Response/IResponseMeta.cs
index 2561da2543..ca13ceaad2 100644
--- a/src/JsonApiDotNetCore/Serialization/IResponseMeta.cs
+++ b/src/JsonApiDotNetCore/Serialization/Response/IResponseMeta.cs
@@ -2,7 +2,7 @@
 using JsonApiDotNetCore.Resources;
 using JsonApiDotNetCore.Serialization.Objects;
 
-namespace JsonApiDotNetCore.Serialization
+namespace JsonApiDotNetCore.Serialization.Response
 {
     /// <summary>
     /// Provides a method to obtain global JSON:API meta, which is added at top-level to a response <see cref="Document" />. Use
diff --git a/src/JsonApiDotNetCore/Serialization/Response/IResponseModelAdapter.cs b/src/JsonApiDotNetCore/Serialization/Response/IResponseModelAdapter.cs
new file mode 100644
index 0000000000..960d541cd4
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Response/IResponseModelAdapter.cs
@@ -0,0 +1,47 @@
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Response
+{
+    /// <summary>
+    /// Converts the produced model from an ASP.NET controller action into a <see cref="Document" />, ready to be serialized as the response body.
+    /// </summary>
+    public interface IResponseModelAdapter
+    {
+        /// <summary>
+        /// Validates and converts the specified <paramref name="model" />. Supported model types:
+        /// <list type="bullet">
+        /// <item>
+        /// <description>
+        /// <code><![CDATA[IEnumerable<IIdentifiable>]]></code>
+        /// </description>
+        /// </item>
+        /// <item>
+        /// <description>
+        /// <code><![CDATA[IIdentifiable]]></code>
+        /// </description>
+        /// </item>
+        /// <item>
+        /// <description>
+        /// <code><![CDATA[null]]></code>
+        /// </description>
+        /// </item>
+        /// <item>
+        /// <description>
+        /// <code><![CDATA[IEnumerable<OperationContainer>]]></code>
+        /// </description>
+        /// </item>
+        /// <item>
+        /// <description>
+        /// <code><![CDATA[IEnumerable<ErrorObject>]]></code>
+        /// </description>
+        /// </item>
+        /// <item>
+        /// <description>
+        /// <code><![CDATA[ErrorObject]]></code>
+        /// </description>
+        /// </item>
+        /// </list>
+        /// </summary>
+        Document Convert(object model);
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Response/JsonApiWriter.cs b/src/JsonApiDotNetCore/Serialization/Response/JsonApiWriter.cs
new file mode 100644
index 0000000000..57d33276a1
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Response/JsonApiWriter.cs
@@ -0,0 +1,189 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Diagnostics;
+using JsonApiDotNetCore.Errors;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Serialization.Objects;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Extensions;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.WebUtilities;
+using Microsoft.Extensions.Logging;
+using Microsoft.Net.Http.Headers;
+
+namespace JsonApiDotNetCore.Serialization.Response
+{
+    /// <inheritdoc />
+    public sealed class JsonApiWriter : IJsonApiWriter
+    {
+        private readonly IJsonApiRequest _request;
+        private readonly IJsonApiOptions _options;
+        private readonly IResponseModelAdapter _responseModelAdapter;
+        private readonly IExceptionHandler _exceptionHandler;
+        private readonly IETagGenerator _eTagGenerator;
+        private readonly TraceLogWriter<JsonApiWriter> _traceWriter;
+
+        public JsonApiWriter(IJsonApiRequest request, IJsonApiOptions options, IResponseModelAdapter responseModelAdapter, IExceptionHandler exceptionHandler,
+            IETagGenerator eTagGenerator, ILoggerFactory loggerFactory)
+        {
+            ArgumentGuard.NotNull(request, nameof(request));
+            ArgumentGuard.NotNull(responseModelAdapter, nameof(responseModelAdapter));
+            ArgumentGuard.NotNull(exceptionHandler, nameof(exceptionHandler));
+            ArgumentGuard.NotNull(eTagGenerator, nameof(eTagGenerator));
+            ArgumentGuard.NotNull(options, nameof(options));
+            ArgumentGuard.NotNull(loggerFactory, nameof(loggerFactory));
+
+            _request = request;
+            _options = options;
+            _responseModelAdapter = responseModelAdapter;
+            _exceptionHandler = exceptionHandler;
+            _eTagGenerator = eTagGenerator;
+            _traceWriter = new TraceLogWriter<JsonApiWriter>(loggerFactory);
+        }
+
+        /// <inheritdoc />
+        public async Task WriteAsync(object model, HttpContext httpContext)
+        {
+            ArgumentGuard.NotNull(httpContext, nameof(httpContext));
+
+            if (model == null && !CanWriteBody((HttpStatusCode)httpContext.Response.StatusCode))
+            {
+                // Prevent exception from Kestrel server, caused by writing data:null json response.
+                return;
+            }
+
+            string responseBody = GetResponseBody(model, httpContext);
+
+            if (httpContext.Request.Method == HttpMethod.Head.Method)
+            {
+                httpContext.Response.GetTypedHeaders().ContentLength = Encoding.UTF8.GetByteCount(responseBody);
+                return;
+            }
+
+            _traceWriter.LogMessage(() =>
+                $"Sending {httpContext.Response.StatusCode} response for {httpContext.Request.Method} request at '{httpContext.Request.GetEncodedUrl()}' with body: <<{responseBody}>>");
+
+            await SendResponseBodyAsync(httpContext.Response, responseBody);
+        }
+
+        private static bool CanWriteBody(HttpStatusCode statusCode)
+        {
+            return statusCode is not HttpStatusCode.NoContent and not HttpStatusCode.ResetContent and not HttpStatusCode.NotModified;
+        }
+
+        private string GetResponseBody(object model, HttpContext httpContext)
+        {
+            using IDisposable _ = CodeTimingSessionManager.Current.Measure("Write response body");
+
+            try
+            {
+                if (model is ProblemDetails problemDetails)
+                {
+                    throw new UnsuccessfulActionResultException(problemDetails);
+                }
+
+                if (model == null && !IsSuccessStatusCode((HttpStatusCode)httpContext.Response.StatusCode))
+                {
+                    throw new UnsuccessfulActionResultException((HttpStatusCode)httpContext.Response.StatusCode);
+                }
+
+                string responseBody = RenderModel(model);
+
+                if (SetETagResponseHeader(httpContext.Request, httpContext.Response, responseBody))
+                {
+                    httpContext.Response.StatusCode = (int)HttpStatusCode.NotModified;
+                    return null;
+                }
+
+                return responseBody;
+            }
+#pragma warning disable AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException
+            catch (Exception exception)
+#pragma warning restore AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException
+            {
+                IReadOnlyList<ErrorObject> errors = _exceptionHandler.HandleException(exception);
+                httpContext.Response.StatusCode = (int)ErrorObject.GetResponseStatusCode(errors);
+
+                return RenderModel(errors);
+            }
+        }
+
+        private static bool IsSuccessStatusCode(HttpStatusCode statusCode)
+        {
+            return new HttpResponseMessage(statusCode).IsSuccessStatusCode;
+        }
+
+        private string RenderModel(object model)
+        {
+            Document document = _responseModelAdapter.Convert(model);
+            return SerializeDocument(document);
+        }
+
+        private string SerializeDocument(Document document)
+        {
+            using IDisposable _ =
+                CodeTimingSessionManager.Current.Measure("JsonSerializer.Serialize", MeasurementSettings.ExcludeJsonSerializationInPercentages);
+
+            return JsonSerializer.Serialize(document, _options.SerializerWriteOptions);
+        }
+
+        private bool SetETagResponseHeader(HttpRequest request, HttpResponse response, string responseContent)
+        {
+            bool isReadOnly = request.Method == HttpMethod.Get.Method || request.Method == HttpMethod.Head.Method;
+
+            if (isReadOnly && response.StatusCode == (int)HttpStatusCode.OK)
+            {
+                string url = request.GetEncodedUrl();
+                EntityTagHeaderValue responseETag = _eTagGenerator.Generate(url, responseContent);
+
+                if (responseETag != null)
+                {
+                    response.Headers.Add(HeaderNames.ETag, responseETag.ToString());
+
+                    return RequestContainsMatchingETag(request.Headers, responseETag);
+                }
+            }
+
+            return false;
+        }
+
+        private static bool RequestContainsMatchingETag(IHeaderDictionary requestHeaders, EntityTagHeaderValue responseETag)
+        {
+            if (requestHeaders.Keys.Contains(HeaderNames.IfNoneMatch) &&
+                EntityTagHeaderValue.TryParseList(requestHeaders[HeaderNames.IfNoneMatch], out IList<EntityTagHeaderValue> requestETags))
+            {
+                foreach (EntityTagHeaderValue requestETag in requestETags)
+                {
+                    if (responseETag.Equals(requestETag))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private async Task SendResponseBodyAsync(HttpResponse httpResponse, string responseBody)
+        {
+            if (!string.IsNullOrEmpty(responseBody))
+            {
+                httpResponse.ContentType =
+                    _request.Kind == EndpointKind.AtomicOperations ? HeaderConstants.AtomicOperationsMediaType : HeaderConstants.MediaType;
+
+                using IDisposable _ = CodeTimingSessionManager.Current.Measure("Send response body");
+
+                await using TextWriter writer = new HttpResponseStreamWriter(httpResponse.Body, Encoding.UTF8);
+                await writer.WriteAsync(responseBody);
+                await writer.FlushAsync();
+            }
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Building/LinkBuilder.cs b/src/JsonApiDotNetCore/Serialization/Response/LinkBuilder.cs
similarity index 79%
rename from src/JsonApiDotNetCore/Serialization/Building/LinkBuilder.cs
rename to src/JsonApiDotNetCore/Serialization/Response/LinkBuilder.cs
index ad82acff5b..4871bd7fdb 100644
--- a/src/JsonApiDotNetCore/Serialization/Building/LinkBuilder.cs
+++ b/src/JsonApiDotNetCore/Serialization/Response/LinkBuilder.cs
@@ -16,7 +16,7 @@
 using Microsoft.AspNetCore.Http.Extensions;
 using Microsoft.AspNetCore.Routing;
 
-namespace JsonApiDotNetCore.Serialization.Building
+namespace JsonApiDotNetCore.Serialization.Response
 {
     [PublicAPI]
     public class LinkBuilder : ILinkBuilder
@@ -31,25 +31,22 @@ public class LinkBuilder : ILinkBuilder
         private readonly IJsonApiOptions _options;
         private readonly IJsonApiRequest _request;
         private readonly IPaginationContext _paginationContext;
-        private readonly IResourceGraph _resourceGraph;
         private readonly IHttpContextAccessor _httpContextAccessor;
         private readonly LinkGenerator _linkGenerator;
         private readonly IControllerResourceMapping _controllerResourceMapping;
 
-        public LinkBuilder(IJsonApiOptions options, IJsonApiRequest request, IPaginationContext paginationContext, IResourceGraph resourceGraph,
-            IHttpContextAccessor httpContextAccessor, LinkGenerator linkGenerator, IControllerResourceMapping controllerResourceMapping)
+        public LinkBuilder(IJsonApiOptions options, IJsonApiRequest request, IPaginationContext paginationContext, IHttpContextAccessor httpContextAccessor,
+            LinkGenerator linkGenerator, IControllerResourceMapping controllerResourceMapping)
         {
             ArgumentGuard.NotNull(options, nameof(options));
             ArgumentGuard.NotNull(request, nameof(request));
             ArgumentGuard.NotNull(paginationContext, nameof(paginationContext));
-            ArgumentGuard.NotNull(resourceGraph, nameof(resourceGraph));
             ArgumentGuard.NotNull(linkGenerator, nameof(linkGenerator));
             ArgumentGuard.NotNull(controllerResourceMapping, nameof(controllerResourceMapping));
 
             _options = options;
             _request = request;
             _paginationContext = paginationContext;
-            _resourceGraph = resourceGraph;
             _httpContextAccessor = httpContextAccessor;
             _linkGenerator = linkGenerator;
             _controllerResourceMapping = controllerResourceMapping;
@@ -64,36 +61,35 @@ private static string NoAsyncSuffix(string actionName)
         public TopLevelLinks GetTopLevelLinks()
         {
             var links = new TopLevelLinks();
+            ResourceType resourceType = _request.SecondaryResourceType ?? _request.PrimaryResourceType;
 
-            ResourceContext requestContext = _request.SecondaryResource ?? _request.PrimaryResource;
-
-            if (ShouldIncludeTopLevelLink(LinkTypes.Self, requestContext))
+            if (ShouldIncludeTopLevelLink(LinkTypes.Self, resourceType))
             {
                 links.Self = GetLinkForTopLevelSelf();
             }
 
-            if (_request.Kind == EndpointKind.Relationship && ShouldIncludeTopLevelLink(LinkTypes.Related, requestContext))
+            if (_request.Kind == EndpointKind.Relationship && _request.Relationship != null && ShouldIncludeTopLevelLink(LinkTypes.Related, resourceType))
             {
                 links.Related = GetLinkForRelationshipRelated(_request.PrimaryId, _request.Relationship);
             }
 
-            if (_request.IsCollection && _paginationContext.PageSize != null && ShouldIncludeTopLevelLink(LinkTypes.Paging, requestContext))
+            if (_request.IsCollection && _paginationContext.PageSize != null && ShouldIncludeTopLevelLink(LinkTypes.Paging, resourceType))
             {
-                SetPaginationInTopLevelLinks(requestContext, links);
+                SetPaginationInTopLevelLinks(resourceType, links);
             }
 
             return links.HasValue() ? links : null;
         }
 
         /// <summary>
-        /// Checks if the top-level <paramref name="linkType" /> should be added by first checking configuration on the <see cref="ResourceContext" />, and if
-        /// not configured, by checking with the global configuration in <see cref="IJsonApiOptions" />.
+        /// Checks if the top-level <paramref name="linkType" /> should be added by first checking configuration on the <see cref="ResourceType" />, and if not
+        /// configured, by checking with the global configuration in <see cref="IJsonApiOptions" />.
         /// </summary>
-        private bool ShouldIncludeTopLevelLink(LinkTypes linkType, ResourceContext resourceContext)
+        private bool ShouldIncludeTopLevelLink(LinkTypes linkType, ResourceType resourceType)
         {
-            if (resourceContext.TopLevelLinks != LinkTypes.NotConfigured)
+            if (resourceType != null && resourceType.TopLevelLinks != LinkTypes.NotConfigured)
             {
-                return resourceContext.TopLevelLinks.HasFlag(linkType);
+                return resourceType.TopLevelLinks.HasFlag(linkType);
             }
 
             return _options.TopLevelLinks.HasFlag(linkType);
@@ -106,9 +102,9 @@ private string GetLinkForTopLevelSelf()
                 : _httpContextAccessor.HttpContext!.Request.GetEncodedUrl();
         }
 
-        private void SetPaginationInTopLevelLinks(ResourceContext requestContext, TopLevelLinks links)
+        private void SetPaginationInTopLevelLinks(ResourceType resourceType, TopLevelLinks links)
         {
-            string pageSizeValue = CalculatePageSizeValue(_paginationContext.PageSize, requestContext);
+            string pageSizeValue = CalculatePageSizeValue(_paginationContext.PageSize, resourceType);
 
             links.First = GetLinkForPagination(1, pageSizeValue);
 
@@ -131,17 +127,17 @@ private void SetPaginationInTopLevelLinks(ResourceContext requestContext, TopLev
             }
         }
 
-        private string CalculatePageSizeValue(PageSize topPageSize, ResourceContext requestContext)
+        private string CalculatePageSizeValue(PageSize topPageSize, ResourceType resourceType)
         {
             string pageSizeParameterValue = _httpContextAccessor.HttpContext!.Request.Query[PageSizeParameterName];
 
             PageSize newTopPageSize = Equals(topPageSize, _options.DefaultPageSize) ? null : topPageSize;
-            return ChangeTopPageSize(pageSizeParameterValue, newTopPageSize, requestContext);
+            return ChangeTopPageSize(pageSizeParameterValue, newTopPageSize, resourceType);
         }
 
-        private string ChangeTopPageSize(string pageSizeParameterValue, PageSize topPageSize, ResourceContext requestContext)
+        private string ChangeTopPageSize(string pageSizeParameterValue, PageSize topPageSize, ResourceType resourceType)
         {
-            IImmutableList<PaginationElementQueryStringValueExpression> elements = ParsePageSizeExpression(pageSizeParameterValue, requestContext);
+            IImmutableList<PaginationElementQueryStringValueExpression> elements = ParsePageSizeExpression(pageSizeParameterValue, resourceType);
             int elementInTopScopeIndex = elements.FindIndex(expression => expression.Scope == null);
 
             if (topPageSize != null)
@@ -164,16 +160,15 @@ private string ChangeTopPageSize(string pageSizeParameterValue, PageSize topPage
             return parameterValue == string.Empty ? null : parameterValue;
         }
 
-        private IImmutableList<PaginationElementQueryStringValueExpression> ParsePageSizeExpression(string pageSizeParameterValue,
-            ResourceContext requestResource)
+        private IImmutableList<PaginationElementQueryStringValueExpression> ParsePageSizeExpression(string pageSizeParameterValue, ResourceType resourceType)
         {
             if (pageSizeParameterValue == null)
             {
                 return ImmutableArray<PaginationElementQueryStringValueExpression>.Empty;
             }
 
-            var parser = new PaginationParser(_resourceGraph);
-            PaginationQueryStringValueExpression paginationExpression = parser.Parse(pageSizeParameterValue, requestResource);
+            var parser = new PaginationParser();
+            PaginationQueryStringValueExpression paginationExpression = parser.Parse(pageSizeParameterValue, resourceType);
 
             return paginationExpression.Elements;
         }
@@ -224,39 +219,38 @@ private static string DecodeSpecialCharacters(string uri)
         }
 
         /// <inheritdoc />
-        public ResourceLinks GetResourceLinks(string resourceName, string id)
+        public ResourceLinks GetResourceLinks(ResourceType resourceType, string id)
         {
-            ArgumentGuard.NotNullNorEmpty(resourceName, nameof(resourceName));
+            ArgumentGuard.NotNull(resourceType, nameof(resourceType));
             ArgumentGuard.NotNullNorEmpty(id, nameof(id));
 
             var links = new ResourceLinks();
-            ResourceContext resourceContext = _resourceGraph.GetResourceContext(resourceName);
 
-            if (_request.Kind != EndpointKind.Relationship && ShouldIncludeResourceLink(LinkTypes.Self, resourceContext))
+            if (ShouldIncludeResourceLink(LinkTypes.Self, resourceType))
             {
-                links.Self = GetLinkForResourceSelf(resourceContext, id);
+                links.Self = GetLinkForResourceSelf(resourceType, id);
             }
 
             return links.HasValue() ? links : null;
         }
 
         /// <summary>
-        /// Checks if the resource object level <paramref name="linkType" /> should be added by first checking configuration on the
-        /// <see cref="ResourceContext" />, and if not configured, by checking with the global configuration in <see cref="IJsonApiOptions" />.
+        /// Checks if the resource object level <paramref name="linkType" /> should be added by first checking configuration on the <see cref="ResourceType" />,
+        /// and if not configured, by checking with the global configuration in <see cref="IJsonApiOptions" />.
         /// </summary>
-        private bool ShouldIncludeResourceLink(LinkTypes linkType, ResourceContext resourceContext)
+        private bool ShouldIncludeResourceLink(LinkTypes linkType, ResourceType resourceType)
         {
-            if (resourceContext.ResourceLinks != LinkTypes.NotConfigured)
+            if (resourceType.ResourceLinks != LinkTypes.NotConfigured)
             {
-                return resourceContext.ResourceLinks.HasFlag(linkType);
+                return resourceType.ResourceLinks.HasFlag(linkType);
             }
 
             return _options.ResourceLinks.HasFlag(linkType);
         }
 
-        private string GetLinkForResourceSelf(ResourceContext resourceContext, string resourceId)
+        private string GetLinkForResourceSelf(ResourceType resourceType, string resourceId)
         {
-            string controllerName = _controllerResourceMapping.GetControllerNameForResourceType(resourceContext.ResourceType);
+            string controllerName = _controllerResourceMapping.TryGetControllerNameForResourceType(resourceType);
             IDictionary<string, object> routeValues = GetRouteValues(resourceId, null);
 
             return RenderLinkForAction(controllerName, GetPrimaryControllerActionName, routeValues);
@@ -269,14 +263,13 @@ public RelationshipLinks GetRelationshipLinks(RelationshipAttribute relationship
             ArgumentGuard.NotNull(leftResource, nameof(leftResource));
 
             var links = new RelationshipLinks();
-            ResourceContext leftResourceContext = _resourceGraph.GetResourceContext(leftResource.GetType());
 
-            if (ShouldIncludeRelationshipLink(LinkTypes.Self, relationship, leftResourceContext))
+            if (ShouldIncludeRelationshipLink(LinkTypes.Self, relationship))
             {
                 links.Self = GetLinkForRelationshipSelf(leftResource.StringId, relationship);
             }
 
-            if (ShouldIncludeRelationshipLink(LinkTypes.Related, relationship, leftResourceContext))
+            if (ShouldIncludeRelationshipLink(LinkTypes.Related, relationship))
             {
                 links.Related = GetLinkForRelationshipRelated(leftResource.StringId, relationship);
             }
@@ -286,7 +279,7 @@ public RelationshipLinks GetRelationshipLinks(RelationshipAttribute relationship
 
         private string GetLinkForRelationshipSelf(string leftId, RelationshipAttribute relationship)
         {
-            string controllerName = _controllerResourceMapping.GetControllerNameForResourceType(relationship.LeftType);
+            string controllerName = _controllerResourceMapping.TryGetControllerNameForResourceType(relationship.LeftType);
             IDictionary<string, object> routeValues = GetRouteValues(leftId, relationship.PublicName);
 
             return RenderLinkForAction(controllerName, GetRelationshipControllerActionName, routeValues);
@@ -294,7 +287,7 @@ private string GetLinkForRelationshipSelf(string leftId, RelationshipAttribute r
 
         private string GetLinkForRelationshipRelated(string leftId, RelationshipAttribute relationship)
         {
-            string controllerName = _controllerResourceMapping.GetControllerNameForResourceType(relationship.LeftType);
+            string controllerName = _controllerResourceMapping.TryGetControllerNameForResourceType(relationship.LeftType);
             IDictionary<string, object> routeValues = GetRouteValues(leftId, relationship.PublicName);
 
             return RenderLinkForAction(controllerName, GetSecondaryControllerActionName, routeValues);
@@ -325,16 +318,16 @@ protected virtual string RenderLinkForAction(string controllerName, string actio
         /// <paramref name="relationship" /> attribute, if not configured by checking <see cref="ResourceLinksAttribute.RelationshipLinks" /> on the resource
         /// type that contains this relationship, and if not configured by checking with the global configuration in <see cref="IJsonApiOptions" />.
         /// </summary>
-        private bool ShouldIncludeRelationshipLink(LinkTypes linkType, RelationshipAttribute relationship, ResourceContext leftResourceContext)
+        private bool ShouldIncludeRelationshipLink(LinkTypes linkType, RelationshipAttribute relationship)
         {
             if (relationship.Links != LinkTypes.NotConfigured)
             {
                 return relationship.Links.HasFlag(linkType);
             }
 
-            if (leftResourceContext.RelationshipLinks != LinkTypes.NotConfigured)
+            if (relationship.LeftType.RelationshipLinks != LinkTypes.NotConfigured)
             {
-                return leftResourceContext.RelationshipLinks.HasFlag(linkType);
+                return relationship.LeftType.RelationshipLinks.HasFlag(linkType);
             }
 
             return _options.RelationshipLinks.HasFlag(linkType);
diff --git a/src/JsonApiDotNetCore/Serialization/Building/MetaBuilder.cs b/src/JsonApiDotNetCore/Serialization/Response/MetaBuilder.cs
similarity index 97%
rename from src/JsonApiDotNetCore/Serialization/Building/MetaBuilder.cs
rename to src/JsonApiDotNetCore/Serialization/Response/MetaBuilder.cs
index dcddb2aa53..265154cca4 100644
--- a/src/JsonApiDotNetCore/Serialization/Building/MetaBuilder.cs
+++ b/src/JsonApiDotNetCore/Serialization/Response/MetaBuilder.cs
@@ -4,7 +4,7 @@
 using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Queries;
 
-namespace JsonApiDotNetCore.Serialization.Building
+namespace JsonApiDotNetCore.Serialization.Response
 {
     /// <inheritdoc />
     [PublicAPI]
diff --git a/src/JsonApiDotNetCore/Serialization/Response/ResourceObjectTreeNode.cs b/src/JsonApiDotNetCore/Serialization/Response/ResourceObjectTreeNode.cs
new file mode 100644
index 0000000000..5137f62716
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Response/ResourceObjectTreeNode.cs
@@ -0,0 +1,275 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Response
+{
+    /// <summary>
+    /// Represents a dependency tree of resource objects. It provides the values for 'data' and 'included' in the response body. The tree is built by
+    /// recursively walking the resource relationships from the inclusion chains. Note that a subsequent chain may add additional relationships to a resource
+    /// object that was produced by an earlier chain. Afterwards, this tree is used to fill relationship objects in the resource objects (depending on sparse
+    /// fieldsets) and to emit all entries in relationship declaration order.
+    /// </summary>
+    internal sealed class ResourceObjectTreeNode : IEquatable<ResourceObjectTreeNode>
+    {
+        // Placeholder root node for the tree, which is never emitted itself.
+        private static readonly ResourceType RootType = new("(root)", typeof(object), typeof(object));
+        private static readonly IIdentifiable RootResource = new EmptyResource();
+
+        // Direct children from root. These are emitted in 'data'.
+        private List<ResourceObjectTreeNode> _directChildren;
+
+        // Related resource objects per relationship. These are emitted in 'included'.
+        private Dictionary<RelationshipAttribute, HashSet<ResourceObjectTreeNode>> _childrenByRelationship;
+
+        private bool IsTreeRoot => RootType.Equals(Type);
+
+        // The resource this node was built for. We only store it for the LinkBuilder.
+        public IIdentifiable Resource { get; }
+
+        // The resource type. We use its relationships to maintain order.
+        public ResourceType Type { get; }
+
+        // The produced resource object from Resource. For each resource, at most one ResourceObject and one tree node must exist.
+        public ResourceObject ResourceObject { get; }
+
+        public ResourceObjectTreeNode(IIdentifiable resource, ResourceType type, ResourceObject resourceObject)
+        {
+            ArgumentGuard.NotNull(resource, nameof(resource));
+            ArgumentGuard.NotNull(type, nameof(type));
+            ArgumentGuard.NotNull(resourceObject, nameof(resourceObject));
+
+            Resource = resource;
+            Type = type;
+            ResourceObject = resourceObject;
+        }
+
+        public static ResourceObjectTreeNode CreateRoot()
+        {
+            return new(RootResource, RootType, new ResourceObject());
+        }
+
+        public void AttachDirectChild(ResourceObjectTreeNode treeNode)
+        {
+            ArgumentGuard.NotNull(treeNode, nameof(treeNode));
+
+            _directChildren ??= new List<ResourceObjectTreeNode>();
+            _directChildren.Add(treeNode);
+        }
+
+        public void EnsureHasRelationship(RelationshipAttribute relationship)
+        {
+            ArgumentGuard.NotNull(relationship, nameof(relationship));
+
+            _childrenByRelationship ??= new Dictionary<RelationshipAttribute, HashSet<ResourceObjectTreeNode>>();
+
+            if (!_childrenByRelationship.ContainsKey(relationship))
+            {
+                _childrenByRelationship[relationship] = new HashSet<ResourceObjectTreeNode>();
+            }
+        }
+
+        public void AttachRelationshipChild(RelationshipAttribute relationship, ResourceObjectTreeNode rightNode)
+        {
+            ArgumentGuard.NotNull(relationship, nameof(relationship));
+            ArgumentGuard.NotNull(rightNode, nameof(rightNode));
+
+            HashSet<ResourceObjectTreeNode> rightNodes = _childrenByRelationship[relationship];
+            rightNodes.Add(rightNode);
+        }
+
+        /// <summary>
+        /// Recursively walks the tree and returns the set of unique nodes. Uses relationship declaration order.
+        /// </summary>
+        public ISet<ResourceObjectTreeNode> GetUniqueNodes()
+        {
+            AssertIsTreeRoot();
+
+            var visited = new HashSet<ResourceObjectTreeNode>();
+
+            VisitSubtree(this, visited);
+
+            return visited;
+        }
+
+        private static void VisitSubtree(ResourceObjectTreeNode treeNode, ISet<ResourceObjectTreeNode> visited)
+        {
+            if (visited.Contains(treeNode))
+            {
+                return;
+            }
+
+            if (!treeNode.IsTreeRoot)
+            {
+                visited.Add(treeNode);
+            }
+
+            VisitDirectChildrenInSubtree(treeNode, visited);
+            VisitRelationshipChildrenInSubtree(treeNode, visited);
+        }
+
+        private static void VisitDirectChildrenInSubtree(ResourceObjectTreeNode treeNode, ISet<ResourceObjectTreeNode> visited)
+        {
+            if (treeNode._directChildren != null)
+            {
+                foreach (ResourceObjectTreeNode child in treeNode._directChildren)
+                {
+                    VisitSubtree(child, visited);
+                }
+            }
+        }
+
+        private static void VisitRelationshipChildrenInSubtree(ResourceObjectTreeNode treeNode, ISet<ResourceObjectTreeNode> visited)
+        {
+            if (treeNode._childrenByRelationship != null)
+            {
+                foreach (RelationshipAttribute relationship in treeNode.Type.Relationships)
+                {
+                    if (treeNode._childrenByRelationship.TryGetValue(relationship, out HashSet<ResourceObjectTreeNode> rightNodes))
+                    {
+                        VisitRelationshipChildInSubtree(rightNodes, visited);
+                    }
+                }
+            }
+        }
+
+        private static void VisitRelationshipChildInSubtree(HashSet<ResourceObjectTreeNode> rightNodes, ISet<ResourceObjectTreeNode> visited)
+        {
+            foreach (ResourceObjectTreeNode rightNode in rightNodes)
+            {
+                VisitSubtree(rightNode, visited);
+            }
+        }
+
+        public ISet<ResourceObjectTreeNode> GetRightNodesInRelationship(RelationshipAttribute relationship)
+        {
+            return _childrenByRelationship != null && _childrenByRelationship.TryGetValue(relationship, out HashSet<ResourceObjectTreeNode> rightNodes)
+                ? rightNodes
+                : null;
+        }
+
+        /// <summary>
+        /// Provides the value for 'data' in the response body. Uses relationship declaration order.
+        /// </summary>
+        public IList<ResourceObject> GetResponseData()
+        {
+            AssertIsTreeRoot();
+
+            return GetDirectChildren().Select(child => child.ResourceObject).ToArray();
+        }
+
+        /// <summary>
+        /// Provides the value for 'included' in the response body. Uses relationship declaration order.
+        /// </summary>
+        public IList<ResourceObject> GetResponseIncluded()
+        {
+            AssertIsTreeRoot();
+
+            var visited = new HashSet<ResourceObjectTreeNode>();
+
+            foreach (ResourceObjectTreeNode child in GetDirectChildren())
+            {
+                VisitRelationshipChildrenInSubtree(child, visited);
+            }
+
+            return visited.Select(node => node.ResourceObject).ToArray();
+        }
+
+        private IList<ResourceObjectTreeNode> GetDirectChildren()
+        {
+            // ReSharper disable once MergeConditionalExpression
+            // Justification: ReSharper reporting this is a bug, which is fixed in v2021.2.1. This condition cannot be merged.
+            return _directChildren == null ? Array.Empty<ResourceObjectTreeNode>() : _directChildren;
+        }
+
+        private void AssertIsTreeRoot()
+        {
+            if (!IsTreeRoot)
+            {
+                throw new InvalidOperationException("Internal error: this method should only be called from the root of the tree.");
+            }
+        }
+
+        public bool Equals(ResourceObjectTreeNode other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return ResourceObjectComparer.Instance.Equals(ResourceObject, other.ResourceObject);
+        }
+
+        public override bool Equals(object other)
+        {
+            return Equals(other as ResourceObjectTreeNode);
+        }
+
+        public override int GetHashCode()
+        {
+            return ResourceObject.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            var builder = new StringBuilder();
+            builder.Append(IsTreeRoot ? Type.PublicName : $"{ResourceObject.Type}:{ResourceObject.Id}");
+
+            if (_directChildren != null)
+            {
+                builder.Append($", children: {_directChildren.Count}");
+            }
+            else if (_childrenByRelationship != null)
+            {
+                builder.Append($", children: {string.Join(',', _childrenByRelationship.Select(pair => $"{pair.Key.PublicName} ({pair.Value.Count})"))}");
+            }
+
+            return builder.ToString();
+        }
+
+        private sealed class EmptyResource : IIdentifiable
+        {
+            public string StringId { get; set; }
+            public string LocalId { get; set; }
+        }
+
+        private sealed class ResourceObjectComparer : IEqualityComparer<ResourceObject>
+        {
+            public static readonly ResourceObjectComparer Instance = new();
+
+            private ResourceObjectComparer()
+            {
+            }
+
+            public bool Equals(ResourceObject x, ResourceObject y)
+            {
+                if (ReferenceEquals(x, y))
+                {
+                    return true;
+                }
+
+                if (x is null || y is null || x.GetType() != y.GetType())
+                {
+                    return false;
+                }
+
+                return x.Type == y.Type && x.Id == y.Id && x.Lid == y.Lid;
+            }
+
+            public int GetHashCode(ResourceObject obj)
+            {
+                return HashCode.Combine(obj.Type, obj.Id, obj.Lid);
+            }
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/Response/ResponseModelAdapter.cs b/src/JsonApiDotNetCore/Serialization/Response/ResponseModelAdapter.cs
new file mode 100644
index 0000000000..10f25f2c20
--- /dev/null
+++ b/src/JsonApiDotNetCore/Serialization/Response/ResponseModelAdapter.cs
@@ -0,0 +1,362 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text.Json.Serialization;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.AtomicOperations;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Queries.Expressions;
+using JsonApiDotNetCore.Queries.Internal;
+using JsonApiDotNetCore.QueryStrings;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Resources.Internal;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization.Response
+{
+    /// <inheritdoc />
+    [PublicAPI]
+    public class ResponseModelAdapter : IResponseModelAdapter
+    {
+        private static readonly CollectionConverter CollectionConverter = new();
+
+        private readonly IJsonApiRequest _request;
+        private readonly IJsonApiOptions _options;
+        private readonly ILinkBuilder _linkBuilder;
+        private readonly IMetaBuilder _metaBuilder;
+        private readonly IResourceDefinitionAccessor _resourceDefinitionAccessor;
+        private readonly IEvaluatedIncludeCache _evaluatedIncludeCache;
+        private readonly IRequestQueryStringAccessor _requestQueryStringAccessor;
+        private readonly ISparseFieldSetCache _sparseFieldSetCache;
+
+        // Ensures that at most one ResourceObject (and one tree node) is produced per resource instance.
+        private readonly Dictionary<IIdentifiable, ResourceObjectTreeNode> _resourceToTreeNodeCache = new(IdentifiableComparer.Instance);
+
+        public ResponseModelAdapter(IJsonApiRequest request, IJsonApiOptions options, ILinkBuilder linkBuilder, IMetaBuilder metaBuilder,
+            IResourceDefinitionAccessor resourceDefinitionAccessor, IEvaluatedIncludeCache evaluatedIncludeCache, ISparseFieldSetCache sparseFieldSetCache,
+            IRequestQueryStringAccessor requestQueryStringAccessor)
+        {
+            ArgumentGuard.NotNull(request, nameof(request));
+            ArgumentGuard.NotNull(options, nameof(options));
+            ArgumentGuard.NotNull(linkBuilder, nameof(linkBuilder));
+            ArgumentGuard.NotNull(metaBuilder, nameof(metaBuilder));
+            ArgumentGuard.NotNull(resourceDefinitionAccessor, nameof(resourceDefinitionAccessor));
+            ArgumentGuard.NotNull(evaluatedIncludeCache, nameof(evaluatedIncludeCache));
+            ArgumentGuard.NotNull(sparseFieldSetCache, nameof(sparseFieldSetCache));
+            ArgumentGuard.NotNull(requestQueryStringAccessor, nameof(requestQueryStringAccessor));
+
+            _request = request;
+            _options = options;
+            _linkBuilder = linkBuilder;
+            _metaBuilder = metaBuilder;
+            _resourceDefinitionAccessor = resourceDefinitionAccessor;
+            _evaluatedIncludeCache = evaluatedIncludeCache;
+            _sparseFieldSetCache = sparseFieldSetCache;
+            _requestQueryStringAccessor = requestQueryStringAccessor;
+        }
+
+        /// <inheritdoc />
+        public Document Convert(object model)
+        {
+            _sparseFieldSetCache.Reset();
+            _resourceToTreeNodeCache.Clear();
+
+            var document = new Document();
+
+            IncludeExpression include = _evaluatedIncludeCache.Get();
+            IImmutableSet<IncludeElementExpression> includeElements = include?.Elements ?? ImmutableHashSet<IncludeElementExpression>.Empty;
+
+            var rootNode = ResourceObjectTreeNode.CreateRoot();
+            ResourceType resourceType = _request.SecondaryResourceType ?? _request.PrimaryResourceType;
+
+            if (model is IEnumerable<IIdentifiable> resources)
+            {
+                foreach (IIdentifiable resource in resources)
+                {
+                    TraverseResource(resource, resourceType, _request.Kind, includeElements, rootNode, null);
+                }
+
+                PopulateRelationshipsInTree(rootNode, _request.Kind);
+
+                IEnumerable<ResourceObject> resourceObjects = rootNode.GetResponseData();
+                document.Data = new SingleOrManyData<ResourceObject>(resourceObjects);
+            }
+            else if (model is IIdentifiable resource)
+            {
+                TraverseResource(resource, resourceType, _request.Kind, includeElements, rootNode, null);
+                PopulateRelationshipsInTree(rootNode, _request.Kind);
+
+                ResourceObject resourceObject = rootNode.GetResponseData().Single();
+                document.Data = new SingleOrManyData<ResourceObject>(resourceObject);
+            }
+            else if (model == null)
+            {
+                document.Data = new SingleOrManyData<ResourceObject>(null);
+            }
+            else if (model is IEnumerable<OperationContainer> operations)
+            {
+                using var _ = new RevertRequestStateOnDispose(_request, null);
+                document.Results = operations.Select(operation => ConvertOperation(operation, includeElements)).ToList();
+            }
+            else if (model is IEnumerable<ErrorObject> errorObjects)
+            {
+                document.Errors = errorObjects.ToArray();
+            }
+            else if (model is ErrorObject errorObject)
+            {
+                document.Errors = errorObject.AsArray();
+            }
+            else
+            {
+                throw new InvalidOperationException("Data being returned must be resources, operations, errors or null.");
+            }
+
+            document.JsonApi = GetApiObject();
+            document.Links = _linkBuilder.GetTopLevelLinks();
+            document.Meta = _metaBuilder.Build();
+            document.Included = GetIncluded(rootNode);
+
+            return document;
+        }
+
+        protected virtual AtomicResultObject ConvertOperation(OperationContainer operation, IImmutableSet<IncludeElementExpression> includeElements)
+        {
+            ResourceObject resourceObject = null;
+
+            if (operation != null)
+            {
+                _request.CopyFrom(operation.Request);
+
+                ResourceType resourceType = operation.Request.SecondaryResourceType ?? operation.Request.PrimaryResourceType;
+                var rootNode = ResourceObjectTreeNode.CreateRoot();
+
+                TraverseResource(operation.Resource, resourceType, operation.Request.Kind, includeElements, rootNode, null);
+                PopulateRelationshipsInTree(rootNode, operation.Request.Kind);
+
+                resourceObject = rootNode.GetResponseData().Single();
+
+                _sparseFieldSetCache.Reset();
+                _resourceToTreeNodeCache.Clear();
+            }
+
+            return new AtomicResultObject
+            {
+                Data = resourceObject == null ? default : new SingleOrManyData<ResourceObject>(resourceObject)
+            };
+        }
+
+        private void TraverseResource(IIdentifiable resource, ResourceType type, EndpointKind kind, IImmutableSet<IncludeElementExpression> includeElements,
+            ResourceObjectTreeNode parentTreeNode, RelationshipAttribute parentRelationship)
+        {
+            ResourceObjectTreeNode treeNode = GetOrCreateTreeNode(resource, type, kind);
+
+            if (parentRelationship != null)
+            {
+                parentTreeNode.AttachRelationshipChild(parentRelationship, treeNode);
+            }
+            else
+            {
+                parentTreeNode.AttachDirectChild(treeNode);
+            }
+
+            if (kind != EndpointKind.Relationship)
+            {
+                TraverseRelationships(resource, treeNode, includeElements, kind);
+            }
+        }
+
+        private ResourceObjectTreeNode GetOrCreateTreeNode(IIdentifiable resource, ResourceType type, EndpointKind kind)
+        {
+            if (!_resourceToTreeNodeCache.TryGetValue(resource, out ResourceObjectTreeNode treeNode))
+            {
+                ResourceObject resourceObject = ConvertResource(resource, type, kind);
+                treeNode = new ResourceObjectTreeNode(resource, type, resourceObject);
+
+                _resourceToTreeNodeCache.Add(resource, treeNode);
+            }
+
+            return treeNode;
+        }
+
+        protected virtual ResourceObject ConvertResource(IIdentifiable resource, ResourceType type, EndpointKind kind)
+        {
+            bool isRelationship = kind == EndpointKind.Relationship;
+
+            if (!isRelationship)
+            {
+                _resourceDefinitionAccessor.OnSerialize(resource);
+            }
+
+            var resourceObject = new ResourceObject
+            {
+                Type = type.PublicName,
+                Id = resource.StringId
+            };
+
+            if (!isRelationship)
+            {
+                IImmutableSet<ResourceFieldAttribute> fieldSet = _sparseFieldSetCache.GetSparseFieldSetForSerializer(type);
+
+                resourceObject.Attributes = ConvertAttributes(resource, type, fieldSet);
+                resourceObject.Links = _linkBuilder.GetResourceLinks(type, resource.StringId);
+                resourceObject.Meta = _resourceDefinitionAccessor.GetMeta(type, resource);
+            }
+
+            return resourceObject;
+        }
+
+        protected virtual IDictionary<string, object> ConvertAttributes(IIdentifiable resource, ResourceType resourceType,
+            IImmutableSet<ResourceFieldAttribute> fieldSet)
+        {
+            var attrMap = new Dictionary<string, object>(resourceType.Attributes.Count);
+
+            foreach (AttrAttribute attr in resourceType.Attributes)
+            {
+                if (!fieldSet.Contains(attr) || attr.Property.Name == nameof(Identifiable.Id))
+                {
+                    continue;
+                }
+
+                object value = attr.GetValue(resource);
+
+                if (_options.SerializerOptions.DefaultIgnoreCondition == JsonIgnoreCondition.WhenWritingNull && value == null)
+                {
+                    continue;
+                }
+
+                if (_options.SerializerOptions.DefaultIgnoreCondition == JsonIgnoreCondition.WhenWritingDefault &&
+                    Equals(value, RuntimeTypeConverter.GetDefaultValue(attr.Property.PropertyType)))
+                {
+                    continue;
+                }
+
+                attrMap.Add(attr.PublicName, value);
+            }
+
+            return attrMap.Any() ? attrMap : null;
+        }
+
+        private void TraverseRelationships(IIdentifiable leftResource, ResourceObjectTreeNode leftTreeNode,
+            IImmutableSet<IncludeElementExpression> includeElements, EndpointKind kind)
+        {
+            foreach (IncludeElementExpression includeElement in includeElements)
+            {
+                TraverseRelationship(includeElement.Relationship, leftResource, leftTreeNode, includeElement, kind);
+            }
+        }
+
+        private void TraverseRelationship(RelationshipAttribute relationship, IIdentifiable leftResource, ResourceObjectTreeNode leftTreeNode,
+            IncludeElementExpression includeElement, EndpointKind kind)
+        {
+            object rightValue = relationship.GetValue(leftResource);
+            ICollection<IIdentifiable> rightResources = CollectionConverter.ExtractResources(rightValue);
+
+            leftTreeNode.EnsureHasRelationship(relationship);
+
+            foreach (IIdentifiable rightResource in rightResources)
+            {
+                TraverseResource(rightResource, relationship.RightType, kind, includeElement.Children, leftTreeNode, relationship);
+            }
+        }
+
+        private void PopulateRelationshipsInTree(ResourceObjectTreeNode rootNode, EndpointKind kind)
+        {
+            if (kind != EndpointKind.Relationship)
+            {
+                foreach (ResourceObjectTreeNode treeNode in rootNode.GetUniqueNodes())
+                {
+                    PopulateRelationshipsInResourceObject(treeNode);
+                }
+            }
+        }
+
+        private void PopulateRelationshipsInResourceObject(ResourceObjectTreeNode treeNode)
+        {
+            IImmutableSet<ResourceFieldAttribute> fieldSet = _sparseFieldSetCache.GetSparseFieldSetForSerializer(treeNode.Type);
+
+            foreach (RelationshipAttribute relationship in treeNode.Type.Relationships)
+            {
+                if (fieldSet.Contains(relationship))
+                {
+                    PopulateRelationshipInResourceObject(treeNode, relationship);
+                }
+            }
+        }
+
+        private void PopulateRelationshipInResourceObject(ResourceObjectTreeNode treeNode, RelationshipAttribute relationship)
+        {
+            SingleOrManyData<ResourceIdentifierObject> data = GetRelationshipData(treeNode, relationship);
+            RelationshipLinks links = _linkBuilder.GetRelationshipLinks(relationship, treeNode.Resource);
+
+            if (links != null || data.IsAssigned)
+            {
+                var relationshipObject = new RelationshipObject
+                {
+                    Links = links,
+                    Data = data
+                };
+
+                treeNode.ResourceObject.Relationships ??= new Dictionary<string, RelationshipObject>();
+                treeNode.ResourceObject.Relationships.Add(relationship.PublicName, relationshipObject);
+            }
+        }
+
+        private static SingleOrManyData<ResourceIdentifierObject> GetRelationshipData(ResourceObjectTreeNode treeNode, RelationshipAttribute relationship)
+        {
+            ISet<ResourceObjectTreeNode> rightNodes = treeNode.GetRightNodesInRelationship(relationship);
+
+            if (rightNodes != null)
+            {
+                IEnumerable<ResourceIdentifierObject> resourceIdentifierObjects = rightNodes.Select(rightNode => new ResourceIdentifierObject
+                {
+                    Type = rightNode.Type.PublicName,
+                    Id = rightNode.ResourceObject.Id
+                });
+
+                return relationship is HasOneAttribute
+                    ? new SingleOrManyData<ResourceIdentifierObject>(resourceIdentifierObjects.SingleOrDefault())
+                    : new SingleOrManyData<ResourceIdentifierObject>(resourceIdentifierObjects);
+            }
+
+            return default;
+        }
+
+        protected virtual JsonApiObject GetApiObject()
+        {
+            if (!_options.IncludeJsonApiVersion)
+            {
+                return null;
+            }
+
+            var jsonApiObject = new JsonApiObject
+            {
+                Version = "1.1"
+            };
+
+            if (_request.Kind == EndpointKind.AtomicOperations)
+            {
+                jsonApiObject.Ext = new List<string>
+                {
+                    "https://jsonapi.org/ext/atomic"
+                };
+            }
+
+            return jsonApiObject;
+        }
+
+        private IList<ResourceObject> GetIncluded(ResourceObjectTreeNode rootNode)
+        {
+            IList<ResourceObject> resourceObjects = rootNode.GetResponseIncluded();
+
+            if (resourceObjects.Any())
+            {
+                return resourceObjects;
+            }
+
+            return _requestQueryStringAccessor.Query.ContainsKey("include") ? Array.Empty<ResourceObject>() : null;
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Serialization/ResponseSerializer.cs b/src/JsonApiDotNetCore/Serialization/ResponseSerializer.cs
deleted file mode 100644
index 348e1d7a2d..0000000000
--- a/src/JsonApiDotNetCore/Serialization/ResponseSerializer.cs
+++ /dev/null
@@ -1,179 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using JetBrains.Annotations;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Middleware;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization.Building;
-using JsonApiDotNetCore.Serialization.Objects;
-
-namespace JsonApiDotNetCore.Serialization
-{
-    /// <summary>
-    /// Server serializer implementation of <see cref="BaseSerializer" /> for resources of a specific type.
-    /// </summary>
-    /// <remarks>
-    /// Because in JsonApiDotNetCore every JSON:API request is associated with exactly one resource (the primary resource, see
-    /// <see cref="IJsonApiRequest.PrimaryResource" />), the serializer can leverage this information using generics. See
-    /// <see cref="ResponseSerializerFactory" /> for how this is instantiated.
-    /// </remarks>
-    /// <typeparam name="TResource">
-    /// Type of the resource associated with the scope of the request for which this serializer is used.
-    /// </typeparam>
-    [PublicAPI]
-    public class ResponseSerializer<TResource> : BaseSerializer, IJsonApiSerializer
-        where TResource : class, IIdentifiable
-    {
-        private readonly IMetaBuilder _metaBuilder;
-        private readonly ILinkBuilder _linkBuilder;
-        private readonly IIncludedResourceObjectBuilder _includedBuilder;
-        private readonly IFieldsToSerialize _fieldsToSerialize;
-        private readonly IResourceDefinitionAccessor _resourceDefinitionAccessor;
-        private readonly IJsonApiOptions _options;
-        private readonly Type _primaryResourceType;
-
-        /// <inheritdoc />
-        public string ContentType { get; } = HeaderConstants.MediaType;
-
-        public ResponseSerializer(IMetaBuilder metaBuilder, ILinkBuilder linkBuilder, IIncludedResourceObjectBuilder includedBuilder,
-            IFieldsToSerialize fieldsToSerialize, IResourceObjectBuilder resourceObjectBuilder, IResourceDefinitionAccessor resourceDefinitionAccessor,
-            IJsonApiOptions options)
-            : base(resourceObjectBuilder)
-        {
-            ArgumentGuard.NotNull(metaBuilder, nameof(metaBuilder));
-            ArgumentGuard.NotNull(linkBuilder, nameof(linkBuilder));
-            ArgumentGuard.NotNull(includedBuilder, nameof(includedBuilder));
-            ArgumentGuard.NotNull(fieldsToSerialize, nameof(fieldsToSerialize));
-            ArgumentGuard.NotNull(resourceDefinitionAccessor, nameof(resourceDefinitionAccessor));
-            ArgumentGuard.NotNull(options, nameof(options));
-
-            _metaBuilder = metaBuilder;
-            _linkBuilder = linkBuilder;
-            _includedBuilder = includedBuilder;
-            _fieldsToSerialize = fieldsToSerialize;
-            _resourceDefinitionAccessor = resourceDefinitionAccessor;
-            _options = options;
-            _primaryResourceType = typeof(TResource);
-        }
-
-        /// <inheritdoc />
-        public string Serialize(object content)
-        {
-            if (content == null || content is IIdentifiable)
-            {
-                return SerializeSingle((IIdentifiable)content);
-            }
-
-            if (content is IEnumerable<IIdentifiable> collectionOfIdentifiable)
-            {
-                return SerializeMany(collectionOfIdentifiable.ToArray());
-            }
-
-            if (content is Document errorDocument)
-            {
-                return SerializeErrorDocument(errorDocument);
-            }
-
-            throw new InvalidOperationException("Data being returned must be errors or resources.");
-        }
-
-        private string SerializeErrorDocument(Document document)
-        {
-            SetApiVersion(document);
-
-            return SerializeObject(document, _options.SerializerWriteOptions);
-        }
-
-        /// <summary>
-        /// Converts a single resource into a serialized <see cref="Document" />.
-        /// </summary>
-        /// <remarks>
-        /// This method is internal instead of private for easier testability.
-        /// </remarks>
-        internal string SerializeSingle(IIdentifiable resource)
-        {
-            if (resource != null && _fieldsToSerialize.ShouldSerialize)
-            {
-                _resourceDefinitionAccessor.OnSerialize(resource);
-            }
-
-            IReadOnlyCollection<AttrAttribute> attributes = _fieldsToSerialize.GetAttributes(_primaryResourceType);
-            IReadOnlyCollection<RelationshipAttribute> relationships = _fieldsToSerialize.GetRelationships(_primaryResourceType);
-
-            Document document = Build(resource, attributes, relationships);
-            ResourceObject resourceObject = document.Data.SingleValue;
-
-            if (resourceObject != null)
-            {
-                resourceObject.Links = _linkBuilder.GetResourceLinks(resourceObject.Type, resourceObject.Id);
-            }
-
-            AddTopLevelObjects(document);
-
-            return SerializeObject(document, _options.SerializerWriteOptions);
-        }
-
-        /// <summary>
-        /// Converts a collection of resources into a serialized <see cref="Document" />.
-        /// </summary>
-        /// <remarks>
-        /// This method is internal instead of private for easier testability.
-        /// </remarks>
-        internal string SerializeMany(IReadOnlyCollection<IIdentifiable> resources)
-        {
-            if (_fieldsToSerialize.ShouldSerialize)
-            {
-                foreach (IIdentifiable resource in resources)
-                {
-                    _resourceDefinitionAccessor.OnSerialize(resource);
-                }
-            }
-
-            IReadOnlyCollection<AttrAttribute> attributes = _fieldsToSerialize.GetAttributes(_primaryResourceType);
-            IReadOnlyCollection<RelationshipAttribute> relationships = _fieldsToSerialize.GetRelationships(_primaryResourceType);
-
-            Document document = Build(resources, attributes, relationships);
-
-            foreach (ResourceObject resourceObject in document.Data.ManyValue)
-            {
-                ResourceLinks links = _linkBuilder.GetResourceLinks(resourceObject.Type, resourceObject.Id);
-
-                if (links == null)
-                {
-                    break;
-                }
-
-                resourceObject.Links = links;
-            }
-
-            AddTopLevelObjects(document);
-
-            return SerializeObject(document, _options.SerializerWriteOptions);
-        }
-
-        /// <summary>
-        /// 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)
-            {
-                document.JsonApi = new JsonApiObject
-                {
-                    Version = "1.1"
-                };
-            }
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Serialization/ResponseSerializerFactory.cs b/src/JsonApiDotNetCore/Serialization/ResponseSerializerFactory.cs
deleted file mode 100644
index 5ddc248a4d..0000000000
--- a/src/JsonApiDotNetCore/Serialization/ResponseSerializerFactory.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-using System;
-using JetBrains.Annotations;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Middleware;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace JsonApiDotNetCore.Serialization
-{
-    /// <summary>
-    /// A factory class to abstract away the initialization of the serializer from the ASP.NET Core formatter pipeline.
-    /// </summary>
-    [PublicAPI]
-    public class ResponseSerializerFactory : IJsonApiSerializerFactory
-    {
-        private readonly IServiceProvider _provider;
-        private readonly IJsonApiRequest _request;
-
-        public ResponseSerializerFactory(IJsonApiRequest request, IRequestScopedServiceProvider provider)
-        {
-            ArgumentGuard.NotNull(request, nameof(request));
-            ArgumentGuard.NotNull(provider, nameof(provider));
-
-            _request = request;
-            _provider = provider;
-        }
-
-        /// <summary>
-        /// Initializes the server serializer using the <see cref="ResourceContext" /> associated with the current request.
-        /// </summary>
-        public IJsonApiSerializer GetSerializer()
-        {
-            if (_request.Kind == EndpointKind.AtomicOperations)
-            {
-                return (IJsonApiSerializer)_provider.GetRequiredService(typeof(AtomicOperationsResponseSerializer));
-            }
-
-            Type targetType = GetDocumentType();
-
-            Type serializerType = typeof(ResponseSerializer<>).MakeGenericType(targetType);
-            object serializer = _provider.GetRequiredService(serializerType);
-
-            return (IJsonApiSerializer)serializer;
-        }
-
-        private Type GetDocumentType()
-        {
-            ResourceContext resourceContext = _request.SecondaryResource ?? _request.PrimaryResource;
-            return resourceContext.ResourceType;
-        }
-    }
-}
diff --git a/src/JsonApiDotNetCore/Services/JsonApiResourceService.cs b/src/JsonApiDotNetCore/Services/JsonApiResourceService.cs
index 9b659a4cdf..feb508cf56 100644
--- a/src/JsonApiDotNetCore/Services/JsonApiResourceService.cs
+++ b/src/JsonApiDotNetCore/Services/JsonApiResourceService.cs
@@ -66,7 +66,7 @@ public virtual async Task<IReadOnlyCollection<TResource>> GetAsync(CancellationT
 
             if (_options.IncludeTotalResourceCount)
             {
-                FilterExpression topFilter = _queryLayerComposer.GetTopFilterFromConstraints(_request.PrimaryResource);
+                FilterExpression topFilter = _queryLayerComposer.GetTopFilterFromConstraints(_request.PrimaryResourceType);
                 _paginationContext.TotalResourceCount = await _repositoryAccessor.CountAsync<TResource>(topFilter, cancellationToken);
 
                 if (_paginationContext.TotalResourceCount == 0)
@@ -75,7 +75,7 @@ public virtual async Task<IReadOnlyCollection<TResource>> GetAsync(CancellationT
                 }
             }
 
-            QueryLayer queryLayer = _queryLayerComposer.ComposeFromConstraints(_request.PrimaryResource);
+            QueryLayer queryLayer = _queryLayerComposer.ComposeFromConstraints(_request.PrimaryResourceType);
             IReadOnlyCollection<TResource> resources = await _repositoryAccessor.GetAsync<TResource>(queryLayer, cancellationToken);
 
             if (queryLayer.Pagination?.PageSize != null && queryLayer.Pagination.PageSize.Value == resources.Count)
@@ -112,8 +112,10 @@ public virtual async Task<object> GetSecondaryAsync(TId id, string relationshipN
 
             AssertHasRelationship(_request.Relationship, relationshipName);
 
-            QueryLayer secondaryLayer = _queryLayerComposer.ComposeFromConstraints(_request.SecondaryResource);
-            QueryLayer primaryLayer = _queryLayerComposer.WrapLayerForSecondaryEndpoint(secondaryLayer, _request.PrimaryResource, id, _request.Relationship);
+            QueryLayer secondaryLayer = _queryLayerComposer.ComposeFromConstraints(_request.SecondaryResourceType);
+
+            QueryLayer primaryLayer =
+                _queryLayerComposer.WrapLayerForSecondaryEndpoint(secondaryLayer, _request.PrimaryResourceType, id, _request.Relationship);
 
             IReadOnlyCollection<TResource> primaryResources = await _repositoryAccessor.GetAsync<TResource>(primaryLayer, cancellationToken);
 
@@ -145,8 +147,10 @@ public virtual async Task<object> GetRelationshipAsync(TId id, string relationsh
 
             AssertHasRelationship(_request.Relationship, relationshipName);
 
-            QueryLayer secondaryLayer = _queryLayerComposer.ComposeSecondaryLayerForRelationship(_request.SecondaryResource);
-            QueryLayer primaryLayer = _queryLayerComposer.WrapLayerForSecondaryEndpoint(secondaryLayer, _request.PrimaryResource, id, _request.Relationship);
+            QueryLayer secondaryLayer = _queryLayerComposer.ComposeSecondaryLayerForRelationship(_request.SecondaryResourceType);
+
+            QueryLayer primaryLayer =
+                _queryLayerComposer.WrapLayerForSecondaryEndpoint(secondaryLayer, _request.PrimaryResourceType, id, _request.Relationship);
 
             IReadOnlyCollection<TResource> primaryResources = await _repositoryAccessor.GetAsync<TResource>(primaryLayer, cancellationToken);
 
@@ -190,7 +194,7 @@ public virtual async Task<TResource> CreateAsync(TResource resource, Cancellatio
 
                     if (existingResource != null)
                     {
-                        throw new ResourceAlreadyExistsException(resourceFromRequest.StringId, _request.PrimaryResource.PublicName);
+                        throw new ResourceAlreadyExistsException(resourceFromRequest.StringId, _request.PrimaryResourceType.PublicName);
                     }
                 }
 
@@ -236,8 +240,8 @@ protected async Task AssertResourcesToAssignInRelationshipsExistAsync(TResource
         private async IAsyncEnumerable<MissingResourceInRelationship> GetMissingRightResourcesAsync(QueryLayer existingRightResourceIdsQueryLayer,
             RelationshipAttribute relationship, ICollection<IIdentifiable> rightResourceIds, [EnumeratorCancellation] CancellationToken cancellationToken)
         {
-            IReadOnlyCollection<IIdentifiable> existingResources = await _repositoryAccessor.GetAsync(
-                existingRightResourceIdsQueryLayer.ResourceContext.ResourceType, existingRightResourceIdsQueryLayer, cancellationToken);
+            IReadOnlyCollection<IIdentifiable> existingResources = await _repositoryAccessor.GetAsync(existingRightResourceIdsQueryLayer.ResourceType,
+                existingRightResourceIdsQueryLayer, cancellationToken);
 
             string[] existingResourceIds = existingResources.Select(resource => resource.StringId).ToArray();
 
@@ -245,7 +249,7 @@ private async IAsyncEnumerable<MissingResourceInRelationship> GetMissingRightRes
             {
                 if (!existingResourceIds.Contains(rightResourceId.StringId))
                 {
-                    yield return new MissingResourceInRelationship(relationship.PublicName, existingRightResourceIdsQueryLayer.ResourceContext.PublicName,
+                    yield return new MissingResourceInRelationship(relationship.PublicName, existingRightResourceIdsQueryLayer.ResourceType.PublicName,
                         rightResourceId.StringId);
                 }
             }
@@ -456,7 +460,7 @@ protected async Task<TResource> GetPrimaryResourceByIdAsync(TId id, TopFieldSele
 
         private async Task<TResource> TryGetPrimaryResourceByIdAsync(TId id, TopFieldSelection fieldSelection, CancellationToken cancellationToken)
         {
-            QueryLayer primaryLayer = _queryLayerComposer.ComposeForGetById(id, _request.PrimaryResource, fieldSelection);
+            QueryLayer primaryLayer = _queryLayerComposer.ComposeForGetById(id, _request.PrimaryResourceType, fieldSelection);
 
             IReadOnlyCollection<TResource> primaryResources = await _repositoryAccessor.GetAsync<TResource>(primaryLayer, cancellationToken);
             return primaryResources.SingleOrDefault();
@@ -464,7 +468,7 @@ private async Task<TResource> TryGetPrimaryResourceByIdAsync(TId id, TopFieldSel
 
         protected async Task<TResource> GetPrimaryResourceForUpdateAsync(TId id, CancellationToken cancellationToken)
         {
-            QueryLayer queryLayer = _queryLayerComposer.ComposeForUpdate(id, _request.PrimaryResource);
+            QueryLayer queryLayer = _queryLayerComposer.ComposeForUpdate(id, _request.PrimaryResourceType);
             var resource = await _repositoryAccessor.GetForUpdateAsync<TResource>(queryLayer, cancellationToken);
 
             AssertPrimaryResourceExists(resource);
@@ -476,7 +480,7 @@ private void AssertPrimaryResourceExists(TResource resource)
         {
             if (resource == null)
             {
-                throw new ResourceNotFoundException(_request.PrimaryId, _request.PrimaryResource.PublicName);
+                throw new ResourceNotFoundException(_request.PrimaryId, _request.PrimaryResourceType.PublicName);
             }
         }
 
@@ -485,7 +489,7 @@ private void AssertHasRelationship(RelationshipAttribute relationship, string na
         {
             if (relationship == null)
             {
-                throw new RelationshipNotFoundException(name, _request.PrimaryResource.PublicName);
+                throw new RelationshipNotFoundException(name, _request.PrimaryResourceType.PublicName);
             }
         }
     }
diff --git a/src/JsonApiDotNetCore/TypeExtensions.cs b/src/JsonApiDotNetCore/TypeExtensions.cs
index 15713ac5fa..50514f3128 100644
--- a/src/JsonApiDotNetCore/TypeExtensions.cs
+++ b/src/JsonApiDotNetCore/TypeExtensions.cs
@@ -39,7 +39,7 @@ public static string GetFriendlyTypeName(this Type type)
                 string genericArguments = type.GetGenericArguments().Select(GetFriendlyTypeName)
                     .Aggregate((firstType, secondType) => $"{firstType}, {secondType}");
 
-                return $"{type.Name[..type.Name.IndexOf("`", StringComparison.Ordinal)]}" + $"<{genericArguments}>";
+                return $"{type.Name[..type.Name.IndexOf("`", StringComparison.Ordinal)]}<{genericArguments}>";
             }
 
             return type.Name;
diff --git a/test/DiscoveryTests/ServiceDiscoveryFacadeTests.cs b/test/DiscoveryTests/ServiceDiscoveryFacadeTests.cs
index a5a2f9fd77..1599ae57c2 100644
--- a/test/DiscoveryTests/ServiceDiscoveryFacadeTests.cs
+++ b/test/DiscoveryTests/ServiceDiscoveryFacadeTests.cs
@@ -56,11 +56,11 @@ public void Can_add_resources_from_assembly_to_graph()
             // Assert
             IResourceGraph resourceGraph = _resourceGraphBuilder.Build();
 
-            ResourceContext personContext = resourceGraph.TryGetResourceContext(typeof(Person));
-            personContext.Should().NotBeNull();
+            ResourceType personType = resourceGraph.TryGetResourceType(typeof(Person));
+            personType.Should().NotBeNull();
 
-            ResourceContext todoItemContext = resourceGraph.TryGetResourceContext(typeof(TodoItem));
-            todoItemContext.Should().NotBeNull();
+            ResourceType todoItemType = resourceGraph.TryGetResourceType(typeof(TodoItem));
+            todoItemType.Should().NotBeNull();
         }
 
         [Fact]
@@ -76,8 +76,8 @@ public void Can_add_resource_from_current_assembly_to_graph()
             // Assert
             IResourceGraph resourceGraph = _resourceGraphBuilder.Build();
 
-            ResourceContext testContext = resourceGraph.TryGetResourceContext(typeof(TestResource));
-            testContext.Should().NotBeNull();
+            ResourceType testResourceType = resourceGraph.TryGetResourceType(typeof(TestResource));
+            testResourceType.Should().NotBeNull();
         }
 
         [Fact]
diff --git a/test/DiscoveryTests/TestResourceRepository.cs b/test/DiscoveryTests/TestResourceRepository.cs
index 096da8abd9..a42d1603f3 100644
--- a/test/DiscoveryTests/TestResourceRepository.cs
+++ b/test/DiscoveryTests/TestResourceRepository.cs
@@ -11,10 +11,10 @@ namespace DiscoveryTests
     [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
     public sealed class TestResourceRepository : EntityFrameworkCoreRepository<TestResource>
     {
-        public TestResourceRepository(ITargetedFields targetedFields, IDbContextResolver contextResolver, IResourceGraph resourceGraph,
+        public TestResourceRepository(ITargetedFields targetedFields, IDbContextResolver dbContextResolver, IResourceGraph resourceGraph,
             IResourceFactory resourceFactory, IEnumerable<IQueryConstraintProvider> constraintProviders, ILoggerFactory loggerFactory,
             IResourceDefinitionAccessor resourceDefinitionAccessor)
-            : base(targetedFields, contextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
+            : base(targetedFields, dbContextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
         {
         }
     }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/Archiving/TelevisionBroadcastDefinition.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/Archiving/TelevisionBroadcastDefinition.cs
index 862612d978..f6b7148e3e 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/Archiving/TelevisionBroadcastDefinition.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/Archiving/TelevisionBroadcastDefinition.cs
@@ -43,7 +43,7 @@ public override FilterExpression OnApplyFilter(FilterExpression existingFilter)
 
                 if (IsReturningCollectionOfTelevisionBroadcasts() && !HasFilterOnArchivedAt(existingFilter))
                 {
-                    AttrAttribute archivedAtAttribute = ResourceContext.GetAttributeByPropertyName(nameof(TelevisionBroadcast.ArchivedAt));
+                    AttrAttribute archivedAtAttribute = ResourceType.GetAttributeByPropertyName(nameof(TelevisionBroadcast.ArchivedAt));
                     var archivedAtChain = new ResourceFieldChainExpression(archivedAtAttribute);
 
                     FilterExpression isUnarchived = new ComparisonExpression(ComparisonOperator.Equals, archivedAtChain, new NullConstantExpression());
@@ -64,7 +64,7 @@ private bool IsRequestingCollectionOfTelevisionBroadcasts()
         {
             if (_request.IsCollection)
             {
-                if (ResourceContext.Equals(_request.PrimaryResource) || ResourceContext.Equals(_request.SecondaryResource))
+                if (ResourceType.Equals(_request.PrimaryResourceType) || ResourceType.Equals(_request.SecondaryResourceType))
                 {
                     return true;
                 }
@@ -90,7 +90,7 @@ private bool IsIncludingCollectionOfTelevisionBroadcasts()
 
             foreach (IncludeElementExpression includeElement in includeElements)
             {
-                if (includeElement.Relationship is HasManyAttribute && includeElement.Relationship.RightType == ResourceContext.ResourceType)
+                if (includeElement.Relationship is HasManyAttribute && includeElement.Relationship.RightType.Equals(ResourceType))
                 {
                     return true;
                 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Controllers/CreateMusicTrackOperationsController.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Controllers/CreateMusicTrackOperationsController.cs
index 5806456a9c..c0b8319fac 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Controllers/CreateMusicTrackOperationsController.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Controllers/CreateMusicTrackOperationsController.cs
@@ -38,7 +38,7 @@ private static void AssertOnlyCreatingMusicTracks(IEnumerable<OperationContainer
 
             foreach (OperationContainer operation in operations)
             {
-                if (operation.Kind != WriteOperationKind.CreateResource || operation.Resource.GetType() != typeof(MusicTrack))
+                if (operation.Request.WriteOperation != WriteOperationKind.CreateResource || operation.Resource.GetType() != typeof(MusicTrack))
                 {
                     throw new JsonApiException(new ErrorObject(HttpStatusCode.UnprocessableEntity)
                     {
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceTests.cs
index 93dd55627e..ad9ab8197d 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceTests.cs
@@ -6,8 +6,10 @@
 using System.Threading.Tasks;
 using FluentAssertions;
 using FluentAssertions.Extensions;
+using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Serialization.Objects;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
 using TestBuildingBlocks;
 using Xunit;
 
@@ -28,6 +30,9 @@ public AtomicCreateResourceTests(IntegrationTestContext<TestableStartup<Operatio
             testContext.UseController<LyricsController>();
             testContext.UseController<MusicTracksController>();
             testContext.UseController<PlaylistsController>();
+
+            var options = (JsonApiOptions)testContext.Factory.Services.GetRequiredService<IJsonApiOptions>();
+            options.AllowUnknownFieldsInRequestBody = false;
         }
 
         [Fact]
@@ -211,10 +216,57 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             });
         }
 
+        [Fact]
+        public async Task Cannot_create_resource_with_unknown_attribute()
+        {
+            // Arrange
+            string newName = _fakers.Playlist.Generate().Name;
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "add",
+                        data = new
+                        {
+                            type = "playlists",
+                            attributes = new
+                            {
+                                doesNotExist = "ignored",
+                                name = newName
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Unknown attribute found.");
+            error.Detail.Should().Be("Attribute 'doesNotExist' does not exist on resource type 'playlists'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/attributes/doesNotExist");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
         [Fact]
         public async Task Can_create_resource_with_unknown_attribute()
         {
             // Arrange
+            var options = (JsonApiOptions)_testContext.Factory.Services.GetRequiredService<IJsonApiOptions>();
+            options.AllowUnknownFieldsInRequestBody = true;
+
             string newName = _fakers.Playlist.Generate().Name;
 
             var requestBody = new
@@ -261,10 +313,61 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             });
         }
 
+        [Fact]
+        public async Task Cannot_create_resource_with_unknown_relationship()
+        {
+            // Arrange
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "add",
+                        data = new
+                        {
+                            type = "lyrics",
+                            relationships = new
+                            {
+                                doesNotExist = new
+                                {
+                                    data = new
+                                    {
+                                        type = Unknown.ResourceType,
+                                        id = Unknown.StringId.Int32
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Unknown relationship found.");
+            error.Detail.Should().Be("Relationship 'doesNotExist' does not exist on resource type 'lyrics'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/doesNotExist");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
         [Fact]
         public async Task Can_create_resource_with_unknown_relationship()
         {
             // Arrange
+            var options = (JsonApiOptions)_testContext.Factory.Services.GetRequiredService<IJsonApiOptions>();
+            options.AllowUnknownFieldsInRequestBody = true;
+
             var requestBody = new
             {
                 atomic__operations = new[]
@@ -354,9 +457,10 @@ public async Task Cannot_create_resource_with_client_generated_ID()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.Forbidden);
-            error.Title.Should().Be("Specifying the resource ID in operations that create a resource is not allowed.");
+            error.Title.Should().Be("Failed to deserialize request body: The use of client-generated IDs is disabled.");
             error.Detail.Should().BeNull();
             error.Source.Pointer.Should().Be("/atomic:operations[0]/data/id");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -387,9 +491,10 @@ public async Task Cannot_create_resource_for_href_element()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Usage of the 'href' element is not supported.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'href' element is not supported.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/href");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -423,9 +528,10 @@ public async Task Cannot_create_resource_for_ref_element()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.relationship' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'relationship' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -458,12 +564,49 @@ public async Task Cannot_create_resource_for_missing_data()
             error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
             error.Detail.Should().BeNull();
             error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
-        public async Task Cannot_create_resource_for_missing_type()
+        public async Task Cannot_create_resource_for_null_data()
+        {
+            // Arrange
+            var requestBody = new
+            {
+                atomic__operations = new object[]
+                {
+                    new
+                    {
+                        op = "add",
+                        data = (object)null
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an object in 'data' element, instead of 'null'.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_create_resource_for_array_data()
         {
             // Arrange
+            string newArtistName = _fakers.Performer.Generate().ArtistName;
+
             var requestBody = new
             {
                 atomic__operations = new[]
@@ -471,10 +614,15 @@ public async Task Cannot_create_resource_for_missing_type()
                     new
                     {
                         op = "add",
-                        data = new
+                        data = new[]
                         {
-                            attributes = new
+                            new
                             {
+                                type = "performers",
+                                attributes = new
+                                {
+                                    artistName = newArtistName
+                                }
                             }
                         }
                     }
@@ -493,13 +641,14 @@ public async Task Cannot_create_resource_for_missing_type()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data.type' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: Expected an object in 'data' element, instead of an array.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
-        public async Task Cannot_create_resource_for_unknown_type()
+        public async Task Cannot_create_resource_for_missing_type()
         {
             // Arrange
             var requestBody = new
@@ -511,7 +660,9 @@ public async Task Cannot_create_resource_for_unknown_type()
                         op = "add",
                         data = new
                         {
-                            type = Unknown.ResourceType
+                            attributes = new
+                            {
+                            }
                         }
                     }
                 }
@@ -529,17 +680,16 @@ public async Task Cannot_create_resource_for_unknown_type()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
-            error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
-        public async Task Cannot_create_resource_for_array()
+        public async Task Cannot_create_resource_for_unknown_type()
         {
             // Arrange
-            string newArtistName = _fakers.Performer.Generate().ArtistName;
-
             var requestBody = new
             {
                 atomic__operations = new[]
@@ -547,16 +697,9 @@ public async Task Cannot_create_resource_for_array()
                     new
                     {
                         op = "add",
-                        data = new[]
+                        data = new
                         {
-                            new
-                            {
-                                type = "performers",
-                                attributes = new
-                                {
-                                    artistName = newArtistName
-                                }
-                            }
+                            type = Unknown.ResourceType
                         }
                     }
                 }
@@ -574,9 +717,10 @@ public async Task Cannot_create_resource_for_array()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected single data element for create/update resource operation.");
-            error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
+            error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -614,9 +758,10 @@ public async Task Cannot_create_resource_attribute_with_blocked_capability()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Setting the initial value of the requested attribute is not allowed.");
-            error.Detail.Should().Be("Setting the initial value of 'createdAt' is not allowed.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: Attribute value cannot be assigned when creating resource.");
+            error.Detail.Should().Be("The attribute 'createdAt' on resource type 'lyrics' cannot be assigned to.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/attributes/createdAt");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -658,8 +803,9 @@ public async Task Cannot_create_resource_with_readonly_attribute()
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
             error.Title.Should().Be("Failed to deserialize request body: Attribute is read-only.");
-            error.Detail.Should().Be("Attribute 'isArchived' is read-only.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Detail.Should().Be("Attribute 'isArchived' on resource type 'playlists' is read-only.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/attributes/isArchived");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -697,9 +843,10 @@ public async Task Cannot_create_resource_with_incompatible_attribute_value()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body.");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible attribute value found.");
             error.Detail.Should().Be("Failed to convert attribute 'bornAt' with value '12345' of type 'Number' to type 'DateTimeOffset'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/attributes/bornAt");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceWithClientGeneratedIdTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceWithClientGeneratedIdTests.cs
index eb3780a140..1574e20095 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceWithClientGeneratedIdTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceWithClientGeneratedIdTests.cs
@@ -186,6 +186,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.Title.Should().Be("Another resource with the specified ID already exists.");
             error.Detail.Should().Be($"Another resource of type 'textLanguages' with ID '{languageToCreate.StringId}' already exists.");
             error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -225,9 +226,10 @@ public async Task Cannot_create_resource_for_incompatible_ID()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body.");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible 'id' value found.");
             error.Detail.Should().Be($"Failed to convert '{guid}' of type 'String' to type 'Int32'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/id");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -263,9 +265,10 @@ public async Task Cannot_create_resource_for_ID_and_local_ID()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data.id' or 'data.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' and 'lid' element are mutually exclusive.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
     }
 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceWithToManyRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceWithToManyRelationshipTests.cs
index d35107a8b8..c3952cf1c6 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceWithToManyRelationshipTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceWithToManyRelationshipTests.cs
@@ -232,9 +232,10 @@ public async Task Cannot_create_for_missing_relationship_type()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'type' element.");
-            error.Detail.Should().Be("Expected 'type' element in 'performers' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/performers/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -282,9 +283,10 @@ public async Task Cannot_create_for_unknown_relationship_type()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
             error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/performers/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -331,9 +333,10 @@ public async Task Cannot_create_for_missing_relationship_ID()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'id' or 'lid' element.");
-            error.Detail.Should().Be("Expected 'id' or 'lid' element in 'performers' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' or 'lid' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/performers/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -445,15 +448,16 @@ public async Task Cannot_create_on_relationship_type_mismatch()
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Conflict);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Relationship contains incompatible resource type.");
-            error.Detail.Should().Be("Relationship 'performers' contains incompatible resource type 'playlists'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.StatusCode.Should().Be(HttpStatusCode.Conflict);
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'playlists' is incompatible with type 'performers' of relationship 'performers'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/performers/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -533,7 +537,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
         }
 
         [Fact]
-        public async Task Cannot_create_with_null_data_in_OneToMany_relationship()
+        public async Task Cannot_create_with_missing_data_in_OneToMany_relationship()
         {
             // Arrange
             var requestBody = new
@@ -550,7 +554,6 @@ public async Task Cannot_create_with_null_data_in_OneToMany_relationship()
                             {
                                 performers = new
                                 {
-                                    data = (object)null
                                 }
                             }
                         }
@@ -570,9 +573,10 @@ public async Task Cannot_create_with_null_data_in_OneToMany_relationship()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected data[] element for to-many relationship.");
-            error.Detail.Should().Be("Expected data[] element for 'performers' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/performers");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -613,9 +617,56 @@ public async Task Cannot_create_with_null_data_in_ManyToMany_relationship()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected data[] element for to-many relationship.");
-            error.Detail.Should().Be("Expected data[] element for 'tracks' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of 'null'.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/tracks/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_create_with_object_data_in_ManyToMany_relationship()
+        {
+            // Arrange
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "add",
+                        data = new
+                        {
+                            type = "playlists",
+                            relationships = new
+                            {
+                                tracks = new
+                                {
+                                    data = new
+                                    {
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of an object.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/tracks/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
     }
 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceWithToOneRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceWithToOneRelationshipTests.cs
index 9153bb404d..51c9dc27c9 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceWithToOneRelationshipTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceWithToOneRelationshipTests.cs
@@ -256,6 +256,100 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             });
         }
 
+        [Fact]
+        public async Task Cannot_create_for_missing_data_in_relationship()
+        {
+            // Arrange
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "add",
+                        data = new
+                        {
+                            type = "musicTracks",
+                            relationships = new
+                            {
+                                lyric = new
+                                {
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/lyric");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_create_for_array_data_in_relationship()
+        {
+            // Arrange
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "add",
+                        data = new
+                        {
+                            type = "musicTracks",
+                            relationships = new
+                            {
+                                lyric = new
+                                {
+                                    data = new[]
+                                    {
+                                        new
+                                        {
+                                            type = "lyrics",
+                                            id = Unknown.StringId.For<Lyric, long>()
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an object or 'null' in 'data' element, instead of an array.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/lyric/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
         [Fact]
         public async Task Cannot_create_for_missing_relationship_type()
         {
@@ -297,9 +391,10 @@ public async Task Cannot_create_for_missing_relationship_type()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'type' element.");
-            error.Detail.Should().Be("Expected 'type' element in 'lyric' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/lyric/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -344,9 +439,10 @@ public async Task Cannot_create_for_unknown_relationship_type()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
             error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/lyric/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -390,9 +486,10 @@ public async Task Cannot_create_for_missing_relationship_ID()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'id' or 'lid' element.");
-            error.Detail.Should().Be("Expected 'id' or 'lid' element in 'lyric' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' or 'lid' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/lyric/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -442,6 +539,7 @@ public async Task Cannot_create_with_unknown_relationship_ID()
             error.Title.Should().Be("A related resource does not exist.");
             error.Detail.Should().Be($"Related resource of type 'lyrics' with ID '{lyricId}' in relationship 'lyric' does not exist.");
             error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -480,15 +578,16 @@ public async Task Cannot_create_on_relationship_type_mismatch()
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Conflict);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Relationship contains incompatible resource type.");
-            error.Detail.Should().Be("Relationship 'lyric' contains incompatible resource type 'playlists'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.StatusCode.Should().Be(HttpStatusCode.Conflict);
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'playlists' is incompatible with type 'lyrics' of relationship 'lyric'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/lyric/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -568,55 +667,5 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 trackInDatabase.OwnedBy.Id.Should().Be(existingCompany.Id);
             });
         }
-
-        [Fact]
-        public async Task Cannot_create_with_data_array_in_relationship()
-        {
-            // Arrange
-            var requestBody = new
-            {
-                atomic__operations = new[]
-                {
-                    new
-                    {
-                        op = "add",
-                        data = new
-                        {
-                            type = "musicTracks",
-                            relationships = new
-                            {
-                                lyric = new
-                                {
-                                    data = new[]
-                                    {
-                                        new
-                                        {
-                                            type = "lyrics",
-                                            id = Unknown.StringId.For<Lyric, long>()
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            };
-
-            const string route = "/operations";
-
-            // Act
-            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
-
-            // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
-
-            responseDocument.Errors.Should().HaveCount(1);
-
-            ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected single data element for to-one relationship.");
-            error.Detail.Should().Be("Expected single data element for 'lyric' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
-        }
     }
 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Deleting/AtomicDeleteResourceTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Deleting/AtomicDeleteResourceTests.cs
index ff0f20a15b..5eef754388 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Deleting/AtomicDeleteResourceTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Deleting/AtomicDeleteResourceTests.cs
@@ -356,9 +356,10 @@ public async Task Cannot_delete_resource_for_href_element()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Usage of the 'href' element is not supported.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'href' element is not supported.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/href");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -391,6 +392,7 @@ public async Task Cannot_delete_resource_for_missing_ref_element()
             error.Title.Should().Be("Failed to deserialize request body: The 'ref' element is required.");
             error.Detail.Should().BeNull();
             error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -424,9 +426,10 @@ public async Task Cannot_delete_resource_for_missing_type()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.type' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -461,9 +464,10 @@ public async Task Cannot_delete_resource_for_unknown_type()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
             error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -497,9 +501,10 @@ public async Task Cannot_delete_resource_for_missing_ID()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.id' or 'ref.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' or 'lid' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -539,6 +544,7 @@ public async Task Cannot_delete_resource_for_unknown_ID()
             error.Title.Should().Be("The requested resource does not exist.");
             error.Detail.Should().Be($"Resource of type 'performers' with ID '{performerId}' does not exist.");
             error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -575,9 +581,10 @@ public async Task Cannot_delete_resource_for_incompatible_ID()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body.");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible 'id' value found.");
             error.Detail.Should().Be($"Failed to convert '{guid}' of type 'String' to type 'Int64'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref/id");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -613,9 +620,10 @@ public async Task Cannot_delete_resource_for_ID_and_local_ID()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.id' or 'ref.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' and 'lid' element are mutually exclusive.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
     }
 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/LocalIds/AtomicLocalIdTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/LocalIds/AtomicLocalIdTests.cs
index 036cb640af..a683635358 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/LocalIds/AtomicLocalIdTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/LocalIds/AtomicLocalIdTests.cs
@@ -2098,7 +2098,7 @@ public async Task Cannot_consume_local_ID_of_different_type_in_same_operation()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
-            error.Title.Should().Be("Type mismatch in local ID usage.");
+            error.Title.Should().Be("Incompatible type in Local ID usage.");
             error.Detail.Should().Be("Local ID 'track-1' belongs to resource type 'musicTracks' instead of 'recordCompanies'.");
             error.Source.Pointer.Should().Be("/atomic:operations[1]");
         }
@@ -2155,7 +2155,7 @@ public async Task Cannot_consume_local_ID_of_different_type_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
-            error.Title.Should().Be("Type mismatch in local ID usage.");
+            error.Title.Should().Be("Incompatible type in Local ID usage.");
             error.Detail.Should().Be("Local ID 'company-1' belongs to resource type 'recordCompanies' instead of 'musicTracks'.");
             error.Source.Pointer.Should().Be("/atomic:operations[2]");
         }
@@ -2215,7 +2215,7 @@ public async Task Cannot_consume_local_ID_of_different_type_in_data_element()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
-            error.Title.Should().Be("Type mismatch in local ID usage.");
+            error.Title.Should().Be("Incompatible type in Local ID usage.");
             error.Detail.Should().Be("Local ID 'performer-1' belongs to resource type 'performers' instead of 'playlists'.");
             error.Source.Pointer.Should().Be("/atomic:operations[2]");
         }
@@ -2289,7 +2289,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
-            error.Title.Should().Be("Type mismatch in local ID usage.");
+            error.Title.Should().Be("Incompatible type in Local ID usage.");
             error.Detail.Should().Be("Local ID 'company-1' belongs to resource type 'recordCompanies' instead of 'performers'.");
             error.Source.Pointer.Should().Be("/atomic:operations[2]");
         }
@@ -2362,7 +2362,7 @@ public async Task Cannot_consume_local_ID_of_different_type_in_relationship_data
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
-            error.Title.Should().Be("Type mismatch in local ID usage.");
+            error.Title.Should().Be("Incompatible type in Local ID usage.");
             error.Detail.Should().Be("Local ID 'playlist-1' belongs to resource type 'playlists' instead of 'recordCompanies'.");
             error.Source.Pointer.Should().Be("/atomic:operations[2]");
         }
@@ -2432,7 +2432,7 @@ public async Task Cannot_consume_local_ID_of_different_type_in_relationship_data
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
-            error.Title.Should().Be("Type mismatch in local ID usage.");
+            error.Title.Should().Be("Incompatible type in Local ID usage.");
             error.Detail.Should().Be("Local ID 'performer-1' belongs to resource type 'performers' instead of 'musicTracks'.");
             error.Source.Pointer.Should().Be("/atomic:operations[2]");
         }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Meta/AtomicResponseMeta.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Meta/AtomicResponseMeta.cs
index c6fede0077..a1f67e0bb2 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Meta/AtomicResponseMeta.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Meta/AtomicResponseMeta.cs
@@ -1,5 +1,5 @@
 using System.Collections.Generic;
-using JsonApiDotNetCore.Serialization;
+using JsonApiDotNetCore.Serialization.Response;
 
 namespace JsonApiDotNetCoreTests.IntegrationTests.AtomicOperations.Meta
 {
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Meta/AtomicResponseMetaTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Meta/AtomicResponseMetaTests.cs
index f775ea6c79..e1469b3454 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Meta/AtomicResponseMetaTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Meta/AtomicResponseMetaTests.cs
@@ -5,8 +5,8 @@
 using System.Threading.Tasks;
 using FluentAssertions;
 using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Serialization;
 using JsonApiDotNetCore.Serialization.Objects;
+using JsonApiDotNetCore.Serialization.Response;
 using Microsoft.Extensions.DependencyInjection;
 using TestBuildingBlocks;
 using Xunit;
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Mixed/AtomicLoggingTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Mixed/AtomicLoggingTests.cs
new file mode 100644
index 0000000000..eb3bae022b
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Mixed/AtomicLoggingTests.cs
@@ -0,0 +1,186 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using FluentAssertions;
+using JsonApiDotNetCore.AtomicOperations;
+using JsonApiDotNetCore.Serialization.Objects;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using TestBuildingBlocks;
+using Xunit;
+
+namespace JsonApiDotNetCoreTests.IntegrationTests.AtomicOperations.Mixed
+{
+    public sealed class AtomicLoggingTests : IClassFixture<IntegrationTestContext<TestableStartup<OperationsDbContext>, OperationsDbContext>>
+    {
+        private readonly IntegrationTestContext<TestableStartup<OperationsDbContext>, OperationsDbContext> _testContext;
+
+        public AtomicLoggingTests(IntegrationTestContext<TestableStartup<OperationsDbContext>, OperationsDbContext> testContext)
+        {
+            _testContext = testContext;
+
+            testContext.UseController<OperationsController>();
+
+            var loggerFactory = new FakeLoggerFactory(LogLevel.Information);
+
+            testContext.ConfigureLogging(options =>
+            {
+                options.ClearProviders();
+                options.AddProvider(loggerFactory);
+                options.SetMinimumLevel(LogLevel.Information);
+            });
+
+            testContext.ConfigureServicesBeforeStartup(services =>
+            {
+                services.AddSingleton(loggerFactory);
+            });
+
+            testContext.ConfigureServicesAfterStartup(services =>
+            {
+                services.AddSingleton<IOperationsTransactionFactory, ThrowingOperationsTransactionFactory>();
+            });
+        }
+
+        [Fact]
+        public async Task Logs_at_error_level_on_unhandled_exception()
+        {
+            // Arrange
+            var loggerFactory = _testContext.Factory.Services.GetRequiredService<FakeLoggerFactory>();
+            loggerFactory.Logger.Clear();
+
+            var transactionFactory = (ThrowingOperationsTransactionFactory)_testContext.Factory.Services.GetRequiredService<IOperationsTransactionFactory>();
+            transactionFactory.ThrowOnOperationStart = true;
+
+            var requestBody = new
+            {
+                atomic__operations = new object[]
+                {
+                    new
+                    {
+                        op = "add",
+                        data = new
+                        {
+                            type = "performers",
+                            attributes = new
+                            {
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.InternalServerError);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.InternalServerError);
+            error.Title.Should().Be("An unhandled error occurred while processing an operation in this request.");
+            error.Detail.Should().Be("Simulated failure.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+
+            loggerFactory.Logger.Messages.Should().NotBeEmpty();
+
+            loggerFactory.Logger.Messages.Should().ContainSingle(message => message.LogLevel == LogLevel.Error &&
+                message.Text.Contains("Simulated failure.", StringComparison.Ordinal));
+        }
+
+        [Fact]
+        public async Task Logs_at_info_level_on_invalid_request_body()
+        {
+            // Arrange
+            var loggerFactory = _testContext.Factory.Services.GetRequiredService<FakeLoggerFactory>();
+            loggerFactory.Logger.Clear();
+
+            var transactionFactory = (ThrowingOperationsTransactionFactory)_testContext.Factory.Services.GetRequiredService<IOperationsTransactionFactory>();
+            transactionFactory.ThrowOnOperationStart = false;
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "update"
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            loggerFactory.Logger.Messages.Should().NotBeEmpty();
+
+            loggerFactory.Logger.Messages.Should().ContainSingle(message => message.LogLevel == LogLevel.Information &&
+                message.Text.Contains("Failed to deserialize request body", StringComparison.Ordinal));
+        }
+
+        private sealed class ThrowingOperationsTransactionFactory : IOperationsTransactionFactory
+        {
+            public bool ThrowOnOperationStart { get; set; }
+
+            public Task<IOperationsTransaction> BeginTransactionAsync(CancellationToken cancellationToken)
+            {
+                IOperationsTransaction transaction = new ThrowingOperationsTransaction(this);
+                return Task.FromResult(transaction);
+            }
+
+            private sealed class ThrowingOperationsTransaction : IOperationsTransaction
+            {
+                private readonly ThrowingOperationsTransactionFactory _owner;
+
+                public string TransactionId => "some";
+
+                public ThrowingOperationsTransaction(ThrowingOperationsTransactionFactory owner)
+                {
+                    _owner = owner;
+                }
+
+                public ValueTask DisposeAsync()
+                {
+                    return ValueTask.CompletedTask;
+                }
+
+                public Task BeforeProcessOperationAsync(CancellationToken cancellationToken)
+                {
+                    return ThrowIfEnabled();
+                }
+
+                public Task AfterProcessOperationAsync(CancellationToken cancellationToken)
+                {
+                    return ThrowIfEnabled();
+                }
+
+                public Task CommitAsync(CancellationToken cancellationToken)
+                {
+                    return ThrowIfEnabled();
+                }
+
+                private Task ThrowIfEnabled()
+                {
+                    if (_owner.ThrowOnOperationStart)
+                    {
+                        throw new Exception("Simulated failure.");
+                    }
+
+                    return Task.CompletedTask;
+                }
+            }
+        }
+    }
+}
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Mixed/AtomicRequestBodyTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Mixed/AtomicRequestBodyTests.cs
index 8b2a56a092..0b61701084 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Mixed/AtomicRequestBodyTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Mixed/AtomicRequestBodyTests.cs
@@ -1,11 +1,9 @@
 using System;
-using System.Collections.Generic;
 using System.Net;
 using System.Net.Http;
 using System.Threading.Tasks;
 using FluentAssertions;
 using JsonApiDotNetCore.Serialization.Objects;
-using Microsoft.EntityFrameworkCore;
 using TestBuildingBlocks;
 using Xunit;
 
@@ -38,18 +36,10 @@ public async Task Cannot_process_for_missing_request_body()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
-            error.Title.Should().Be("Missing request body.");
+            error.Title.Should().Be("Failed to deserialize request body: Missing request body.");
             error.Detail.Should().BeNull();
             error.Source.Should().BeNull();
-
-            await _testContext.RunOnDatabaseAsync(async dbContext =>
-            {
-                List<Performer> performersInDatabase = await dbContext.Performers.ToListAsync();
-                performersInDatabase.Should().BeEmpty();
-
-                List<MusicTrack> tracksInDatabase = await dbContext.MusicTracks.ToListAsync();
-                tracksInDatabase.Should().BeEmpty();
-            });
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -75,6 +65,36 @@ public async Task Cannot_process_for_broken_JSON_request_body()
             error.Source.Should().BeNull();
         }
 
+        [Fact]
+        public async Task Cannot_process_for_missing_operations_array()
+        {
+            // Arrange
+            const string route = "/operations";
+
+            var requestBody = new
+            {
+                meta = new
+                {
+                    key = "value"
+                }
+            };
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: No operations found.");
+            error.Detail.Should().BeNull();
+            error.Source.Should().BeNull();
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
         [Fact]
         public async Task Cannot_process_empty_operations_array()
         {
@@ -99,15 +119,7 @@ public async Task Cannot_process_empty_operations_array()
             error.Title.Should().Be("Failed to deserialize request body: No operations found.");
             error.Detail.Should().BeNull();
             error.Source.Should().BeNull();
-
-            await _testContext.RunOnDatabaseAsync(async dbContext =>
-            {
-                List<Performer> performersInDatabase = await dbContext.Performers.ToListAsync();
-                performersInDatabase.Should().BeEmpty();
-
-                List<MusicTrack> tracksInDatabase = await dbContext.MusicTracks.ToListAsync();
-                tracksInDatabase.Should().BeEmpty();
-            });
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -147,15 +159,6 @@ public async Task Cannot_process_for_unknown_operation_code()
             error.Title.Should().Be("Failed to deserialize request body.");
             error.Detail.Should().StartWith("The JSON value could not be converted to ");
             error.Source.Should().BeNull();
-
-            await _testContext.RunOnDatabaseAsync(async dbContext =>
-            {
-                List<Performer> performersInDatabase = await dbContext.Performers.ToListAsync();
-                performersInDatabase.Should().BeEmpty();
-
-                List<MusicTrack> tracksInDatabase = await dbContext.MusicTracks.ToListAsync();
-                tracksInDatabase.Should().BeEmpty();
-            });
         }
     }
 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Mixed/AtomicSerializationTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Mixed/AtomicSerializationTests.cs
index bc9b637617..f034fb9411 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Mixed/AtomicSerializationTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Mixed/AtomicSerializationTests.cs
@@ -4,7 +4,6 @@
 using System.Threading.Tasks;
 using FluentAssertions;
 using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Resources;
 using Microsoft.Extensions.DependencyInjection;
 using TestBuildingBlocks;
 using Xunit;
@@ -13,8 +12,6 @@ namespace JsonApiDotNetCoreTests.IntegrationTests.AtomicOperations.Mixed
 {
     public sealed class AtomicSerializationTests : IClassFixture<IntegrationTestContext<TestableStartup<OperationsDbContext>, OperationsDbContext>>
     {
-        private const string JsonDateTimeOffsetFormatSpecifier = "yyyy-MM-ddTHH:mm:ss.FFFFFFFK";
-
         private readonly IntegrationTestContext<TestableStartup<OperationsDbContext>, OperationsDbContext> _testContext;
         private readonly OperationsFakers _fakers = new();
 
@@ -25,11 +22,11 @@ public AtomicSerializationTests(IntegrationTestContext<TestableStartup<Operation
             testContext.UseController<OperationsController>();
 
             // These routes need to be registered in ASP.NET for rendering links to resource/relationship endpoints.
-            testContext.UseController<PerformersController>();
+            testContext.UseController<TextLanguagesController>();
 
             testContext.ConfigureServicesAfterStartup(services =>
             {
-                services.AddScoped(typeof(IResourceChangeTracker<>), typeof(NeverSameResourceChangeTracker<>));
+                services.AddResourceDefinition<ImplicitlyChangingTextLanguageDefinition>();
             });
 
             var options = (JsonApiOptions)testContext.Factory.Services.GetRequiredService<IJsonApiOptions>();
@@ -39,32 +36,46 @@ public AtomicSerializationTests(IntegrationTestContext<TestableStartup<Operation
         }
 
         [Fact]
-        public async Task Includes_version_with_ext_on_operations_endpoint()
+        public async Task Hides_data_for_void_operation()
         {
             // Arrange
-            Performer newPerformer = _fakers.Performer.Generate();
-            newPerformer.Id = Unknown.TypedId.Int32;
+            Performer existingPerformer = _fakers.Performer.Generate();
+
+            TextLanguage newLanguage = _fakers.TextLanguage.Generate();
+            newLanguage.Id = Guid.NewGuid();
 
             await _testContext.RunOnDatabaseAsync(async dbContext =>
             {
-                await dbContext.ClearTableAsync<Performer>();
+                dbContext.Performers.Add(existingPerformer);
+                await dbContext.SaveChangesAsync();
             });
 
             var requestBody = new
             {
-                atomic__operations = new[]
+                atomic__operations = new object[]
                 {
                     new
                     {
-                        op = "add",
+                        op = "update",
                         data = new
                         {
                             type = "performers",
-                            id = newPerformer.StringId,
+                            id = existingPerformer.StringId,
                             attributes = new
                             {
-                                artistName = newPerformer.ArtistName,
-                                bornAt = newPerformer.BornAt
+                            }
+                        }
+                    },
+                    new
+                    {
+                        op = "add",
+                        data = new
+                        {
+                            type = "textLanguages",
+                            id = newLanguage.StringId,
+                            attributes = new
+                            {
+                                isoCode = newLanguage.IsoCode
                             }
                         }
                     }
@@ -86,17 +97,30 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
       ""https://jsonapi.org/ext/atomic""
     ]
   },
+  ""links"": {
+    ""self"": ""http://localhost/operations""
+  },
   ""atomic:results"": [
+    {
+      ""data"": null
+    },
     {
       ""data"": {
-        ""type"": ""performers"",
-        ""id"": """ + newPerformer.StringId + @""",
+        ""type"": ""textLanguages"",
+        ""id"": """ + newLanguage.StringId + @""",
         ""attributes"": {
-          ""artistName"": """ + newPerformer.ArtistName + @""",
-          ""bornAt"": """ + newPerformer.BornAt.ToString(JsonDateTimeOffsetFormatSpecifier) + @"""
+          ""isoCode"": """ + newLanguage.IsoCode + @" (changed)""
+        },
+        ""relationships"": {
+          ""lyrics"": {
+            ""links"": {
+              ""self"": ""http://localhost/textLanguages/" + newLanguage.StringId + @"/relationships/lyrics"",
+              ""related"": ""http://localhost/textLanguages/" + newLanguage.StringId + @"/lyrics""
+            }
+          }
         },
         ""links"": {
-          ""self"": ""http://localhost/performers/" + newPerformer.StringId + @"""
+          ""self"": ""http://localhost/textLanguages/" + newLanguage.StringId + @"""
         }
       }
     }
@@ -143,6 +167,9 @@ public async Task Includes_version_with_ext_on_error_in_operations_endpoint()
       ""https://jsonapi.org/ext/atomic""
     ]
   },
+  ""links"": {
+    ""self"": ""http://localhost/operations""
+  },
   ""errors"": [
     {
       ""id"": """ + errorId + @""",
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Mixed/MaximumOperationsPerRequestTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Mixed/MaximumOperationsPerRequestTests.cs
index d72a79f9b8..199f91f6ae 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Mixed/MaximumOperationsPerRequestTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Mixed/MaximumOperationsPerRequestTests.cs
@@ -72,9 +72,10 @@ public async Task Cannot_process_more_operations_than_maximum()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request exceeds the maximum number of operations.");
-            error.Detail.Should().Be("The number of operations in this request (3) is higher than 2.");
-            error.Source.Should().BeNull();
+            error.Title.Should().Be("Failed to deserialize request body: Too many operations in request.");
+            error.Detail.Should().Be("The number of operations in this request (3) is higher than the maximum of 2.");
+            error.Source.Pointer.Should().Be("/atomic:operations");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Transactions/LyricRepository.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Transactions/LyricRepository.cs
index 60dfb891b0..fd9dd6afa3 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Transactions/LyricRepository.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Transactions/LyricRepository.cs
@@ -15,10 +15,10 @@ public sealed class LyricRepository : EntityFrameworkCoreRepository<Lyric, long>
 
         public override string TransactionId => _extraDbContext.Database.CurrentTransaction.TransactionId.ToString();
 
-        public LyricRepository(ExtraDbContext extraDbContext, ITargetedFields targetedFields, IDbContextResolver contextResolver, IResourceGraph resourceGraph,
-            IResourceFactory resourceFactory, IEnumerable<IQueryConstraintProvider> constraintProviders, ILoggerFactory loggerFactory,
-            IResourceDefinitionAccessor resourceDefinitionAccessor)
-            : base(targetedFields, contextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
+        public LyricRepository(ExtraDbContext extraDbContext, ITargetedFields targetedFields, IDbContextResolver dbContextResolver,
+            IResourceGraph resourceGraph, IResourceFactory resourceFactory, IEnumerable<IQueryConstraintProvider> constraintProviders,
+            ILoggerFactory loggerFactory, IResourceDefinitionAccessor resourceDefinitionAccessor)
+            : base(targetedFields, dbContextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
         {
             _extraDbContext = extraDbContext;
 
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Transactions/MusicTrackRepository.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Transactions/MusicTrackRepository.cs
index b379f6614b..b6268ee068 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Transactions/MusicTrackRepository.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Transactions/MusicTrackRepository.cs
@@ -14,10 +14,10 @@ public sealed class MusicTrackRepository : EntityFrameworkCoreRepository<MusicTr
     {
         public override string TransactionId => null;
 
-        public MusicTrackRepository(ITargetedFields targetedFields, IDbContextResolver contextResolver, IResourceGraph resourceGraph,
+        public MusicTrackRepository(ITargetedFields targetedFields, IDbContextResolver dbContextResolver, IResourceGraph resourceGraph,
             IResourceFactory resourceFactory, IEnumerable<IQueryConstraintProvider> constraintProviders, ILoggerFactory loggerFactory,
             IResourceDefinitionAccessor resourceDefinitionAccessor)
-            : base(targetedFields, contextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
+            : base(targetedFields, dbContextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
         {
         }
     }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Relationships/AtomicAddToToManyRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Relationships/AtomicAddToToManyRelationshipTests.cs
index ada44f47e7..c234c09182 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Relationships/AtomicAddToToManyRelationshipTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Relationships/AtomicAddToToManyRelationshipTests.cs
@@ -64,14 +64,16 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Forbidden);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Only to-many relationships can be targeted in 'add' operations.");
-            error.Detail.Should().Be("Relationship 'ownedBy' must be a to-many relationship.");
+            error.StatusCode.Should().Be(HttpStatusCode.Forbidden);
+            error.Title.Should().Be("Failed to deserialize request body: Only to-many relationships can be targeted through this operation.");
+            error.Detail.Should().Be("Relationship 'ownedBy' is not a to-many relationship.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref/relationship");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -262,9 +264,10 @@ public async Task Cannot_add_for_href_element()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Usage of the 'href' element is not supported.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'href' element is not supported.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/href");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -299,9 +302,10 @@ public async Task Cannot_add_for_missing_type_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.type' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -337,9 +341,10 @@ public async Task Cannot_add_for_unknown_type_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
             error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -374,9 +379,10 @@ public async Task Cannot_add_for_missing_ID_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.id' or 'ref.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' or 'lid' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -433,6 +439,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.Title.Should().Be("The requested resource does not exist.");
             error.Detail.Should().Be($"Resource of type 'recordCompanies' with ID '{companyId}' does not exist.");
             error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -469,9 +476,10 @@ public async Task Cannot_add_for_ID_and_local_ID_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.id' or 'ref.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' and 'lid' element are mutually exclusive.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -506,9 +514,10 @@ public async Task Cannot_add_for_missing_relationship_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.relationship' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'relationship' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -544,9 +553,57 @@ public async Task Cannot_add_for_unknown_relationship_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The referenced relationship does not exist.");
-            error.Detail.Should().Be($"Resource of type 'performers' does not contain a relationship named '{Unknown.Relationship}'.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown relationship found.");
+            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' does not exist on resource type 'performers'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref/relationship");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_add_for_missing_data()
+        {
+            // Arrange
+            MusicTrack existingTrack = _fakers.MusicTrack.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.MusicTracks.Add(existingTrack);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "add",
+                        @ref = new
+                        {
+                            type = "musicTracks",
+                            id = existingTrack.StringId,
+                            relationship = "performers"
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
             error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -591,9 +648,60 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected data[] element for to-many relationship.");
-            error.Detail.Should().Be("Expected data[] element for 'performers' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of 'null'.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_add_for_object_data()
+        {
+            // Arrange
+            MusicTrack existingTrack = _fakers.MusicTrack.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.MusicTracks.Add(existingTrack);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "add",
+                        @ref = new
+                        {
+                            type = "musicTracks",
+                            id = existingTrack.StringId,
+                            relationship = "performers"
+                        },
+                        data = new
+                        {
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of an object.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -636,9 +744,10 @@ public async Task Cannot_add_for_missing_type_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data[].type' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -682,9 +791,10 @@ public async Task Cannot_add_for_unknown_type_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
             error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -727,9 +837,10 @@ public async Task Cannot_add_for_missing_ID_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data[].id' or 'data[].lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' or 'lid' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -774,9 +885,10 @@ public async Task Cannot_add_for_ID_and_local_ID_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data[].id' or 'data[].lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' and 'lid' element are mutually exclusive.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -893,15 +1005,16 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Conflict);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Resource type mismatch between 'ref.relationship' and 'data[].type' element.");
-            error.Detail.Should().Be("Expected resource of type 'performers' in 'data[].type', instead of 'playlists'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.StatusCode.Should().Be(HttpStatusCode.Conflict);
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'playlists' is incompatible with type 'performers' of relationship 'performers'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Relationships/AtomicRemoveFromToManyRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Relationships/AtomicRemoveFromToManyRelationshipTests.cs
index ffaff765c3..95840ff95d 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Relationships/AtomicRemoveFromToManyRelationshipTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Relationships/AtomicRemoveFromToManyRelationshipTests.cs
@@ -65,14 +65,16 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Forbidden);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Only to-many relationships can be targeted in 'remove' operations.");
-            error.Detail.Should().Be("Relationship 'ownedBy' must be a to-many relationship.");
+            error.StatusCode.Should().Be(HttpStatusCode.Forbidden);
+            error.Title.Should().Be("Failed to deserialize request body: Only to-many relationships can be targeted through this operation.");
+            error.Detail.Should().Be("Relationship 'ownedBy' is not a to-many relationship.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref/relationship");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -262,9 +264,10 @@ public async Task Cannot_remove_for_href_element()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Usage of the 'href' element is not supported.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'href' element is not supported.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/href");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -299,9 +302,10 @@ public async Task Cannot_remove_for_missing_type_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.type' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -337,9 +341,10 @@ public async Task Cannot_remove_for_unknown_type_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
             error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -374,9 +379,10 @@ public async Task Cannot_remove_for_missing_ID_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.id' or 'ref.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' or 'lid' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -433,6 +439,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.Title.Should().Be("The requested resource does not exist.");
             error.Detail.Should().Be($"Resource of type 'recordCompanies' with ID '{companyId}' does not exist.");
             error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -469,9 +476,10 @@ public async Task Cannot_remove_for_ID_and_local_ID_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.id' or 'ref.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' and 'lid' element are mutually exclusive.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -507,9 +515,57 @@ public async Task Cannot_remove_for_unknown_relationship_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The referenced relationship does not exist.");
-            error.Detail.Should().Be($"Resource of type 'performers' does not contain a relationship named '{Unknown.Relationship}'.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown relationship found.");
+            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' does not exist on resource type 'performers'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref/relationship");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_remove_for_missing_data()
+        {
+            // Arrange
+            MusicTrack existingTrack = _fakers.MusicTrack.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.MusicTracks.Add(existingTrack);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "remove",
+                        @ref = new
+                        {
+                            type = "musicTracks",
+                            id = existingTrack.StringId,
+                            relationship = "performers"
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
             error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -554,9 +610,60 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected data[] element for to-many relationship.");
-            error.Detail.Should().Be("Expected data[] element for 'performers' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of 'null'.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_remove_for_object_data()
+        {
+            // Arrange
+            MusicTrack existingTrack = _fakers.MusicTrack.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.MusicTracks.Add(existingTrack);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "remove",
+                        @ref = new
+                        {
+                            type = "musicTracks",
+                            id = existingTrack.StringId,
+                            relationship = "performers"
+                        },
+                        data = new
+                        {
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of an object.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -599,9 +706,10 @@ public async Task Cannot_remove_for_missing_type_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data[].type' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -645,9 +753,10 @@ public async Task Cannot_remove_for_unknown_type_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
             error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -690,9 +799,10 @@ public async Task Cannot_remove_for_missing_ID_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data[].id' or 'data[].lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' or 'lid' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -737,9 +847,10 @@ public async Task Cannot_remove_for_ID_and_local_ID_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data[].id' or 'data[].lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' and 'lid' element are mutually exclusive.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -856,15 +967,16 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Conflict);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Resource type mismatch between 'ref.relationship' and 'data[].type' element.");
-            error.Detail.Should().Be("Expected resource of type 'performers' in 'data[].type', instead of 'playlists'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.StatusCode.Should().Be(HttpStatusCode.Conflict);
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'playlists' is incompatible with type 'performers' of relationship 'performers'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Relationships/AtomicReplaceToManyRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Relationships/AtomicReplaceToManyRelationshipTests.cs
index c1426db8a9..c7b6972438 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Relationships/AtomicReplaceToManyRelationshipTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Relationships/AtomicReplaceToManyRelationshipTests.cs
@@ -299,9 +299,10 @@ public async Task Cannot_replace_for_href_element()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Usage of the 'href' element is not supported.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'href' element is not supported.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/href");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -336,9 +337,10 @@ public async Task Cannot_replace_for_missing_type_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.type' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -374,9 +376,10 @@ public async Task Cannot_replace_for_unknown_type_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
             error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -411,9 +414,10 @@ public async Task Cannot_replace_for_missing_ID_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.id' or 'ref.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' or 'lid' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -470,6 +474,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.Title.Should().Be("The requested resource does not exist.");
             error.Detail.Should().Be($"Resource of type 'recordCompanies' with ID '{companyId}' does not exist.");
             error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -523,9 +528,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body.");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible 'id' value found.");
             error.Detail.Should().Be($"Failed to convert '{guid}' of type 'String' to type 'Int16'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref/id");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -562,9 +568,10 @@ public async Task Cannot_replace_for_ID_and_local_ID_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.id' or 'ref.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' and 'lid' element are mutually exclusive.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -600,9 +607,57 @@ public async Task Cannot_replace_for_unknown_relationship_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The referenced relationship does not exist.");
-            error.Detail.Should().Be($"Resource of type 'performers' does not contain a relationship named '{Unknown.Relationship}'.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown relationship found.");
+            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' does not exist on resource type 'performers'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref/relationship");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_replace_for_missing_data()
+        {
+            // Arrange
+            MusicTrack existingTrack = _fakers.MusicTrack.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.MusicTracks.Add(existingTrack);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "update",
+                        @ref = new
+                        {
+                            type = "musicTracks",
+                            id = existingTrack.StringId,
+                            relationship = "performers"
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
             error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -647,9 +702,60 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected data[] element for to-many relationship.");
-            error.Detail.Should().Be("Expected data[] element for 'performers' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of 'null'.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_replace_for_object_data()
+        {
+            // Arrange
+            MusicTrack existingTrack = _fakers.MusicTrack.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.MusicTracks.Add(existingTrack);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "update",
+                        @ref = new
+                        {
+                            type = "musicTracks",
+                            id = existingTrack.StringId,
+                            relationship = "performers"
+                        },
+                        data = new
+                        {
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of an object.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -692,9 +798,10 @@ public async Task Cannot_replace_for_missing_type_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data[].type' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -738,9 +845,10 @@ public async Task Cannot_replace_for_unknown_type_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
             error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -783,9 +891,10 @@ public async Task Cannot_replace_for_missing_ID_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data[].id' or 'data[].lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' or 'lid' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -830,9 +939,10 @@ public async Task Cannot_replace_for_ID_and_local_ID_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data[].id' or 'data[].lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' and 'lid' element are mutually exclusive.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -955,9 +1065,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body.");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible 'id' value found.");
             error.Detail.Should().Be("Failed to convert 'invalid-guid' of type 'String' to type 'Guid'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data[0]/id");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -1003,15 +1114,16 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Conflict);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Resource type mismatch between 'ref.relationship' and 'data[].type' element.");
-            error.Detail.Should().Be("Expected resource of type 'performers' in 'data[].type', instead of 'playlists'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.StatusCode.Should().Be(HttpStatusCode.Conflict);
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'playlists' is incompatible with type 'performers' of relationship 'performers'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
     }
 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Relationships/AtomicUpdateToOneRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Relationships/AtomicUpdateToOneRelationshipTests.cs
index 85c153a7f1..30640ad32a 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Relationships/AtomicUpdateToOneRelationshipTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Relationships/AtomicUpdateToOneRelationshipTests.cs
@@ -546,9 +546,10 @@ public async Task Cannot_create_for_href_element()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Usage of the 'href' element is not supported.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'href' element is not supported.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/href");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -583,9 +584,10 @@ public async Task Cannot_create_for_missing_type_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.type' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -621,9 +623,10 @@ public async Task Cannot_create_for_unknown_type_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
             error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -658,9 +661,10 @@ public async Task Cannot_create_for_missing_ID_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.id' or 'ref.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' or 'lid' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -714,6 +718,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.Title.Should().Be("The requested resource does not exist.");
             error.Detail.Should().Be($"Resource of type 'musicTracks' with ID '{trackId}' does not exist.");
             error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -762,9 +767,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body.");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible 'id' value found.");
             error.Detail.Should().Be("Failed to convert 'invalid-guid' of type 'String' to type 'Guid'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref/id");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -801,9 +807,10 @@ public async Task Cannot_create_for_ID_and_local_ID_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.id' or 'ref.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' and 'lid' element are mutually exclusive.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -839,13 +846,61 @@ public async Task Cannot_create_for_unknown_relationship_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The referenced relationship does not exist.");
-            error.Detail.Should().Be($"Resource of type 'performers' does not contain a relationship named '{Unknown.Relationship}'.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown relationship found.");
+            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' does not exist on resource type 'performers'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref/relationship");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_create_for_missing_data()
+        {
+            // Arrange
+            MusicTrack existingTrack = _fakers.MusicTrack.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.MusicTracks.Add(existingTrack);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "update",
+                        @ref = new
+                        {
+                            type = "musicTracks",
+                            id = existingTrack.StringId,
+                            relationship = "lyric"
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
             error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
-        public async Task Cannot_create_for_array_in_data()
+        public async Task Cannot_create_for_array_data()
         {
             // Arrange
             MusicTrack existingTrack = _fakers.MusicTrack.Generate();
@@ -893,9 +948,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected single data element for to-one relationship.");
-            error.Detail.Should().Be("Expected single data element for 'lyric' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: Expected an object or 'null' in 'data' element, instead of an array.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -935,9 +991,10 @@ public async Task Cannot_create_for_missing_type_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data.type' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -978,9 +1035,10 @@ public async Task Cannot_create_for_unknown_type_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
             error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -1020,9 +1078,10 @@ public async Task Cannot_create_for_missing_ID_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data.id' or 'data.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' or 'lid' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -1064,9 +1123,10 @@ public async Task Cannot_create_for_ID_and_local_ID_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data.id' or 'data.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' and 'lid' element are mutually exclusive.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -1120,6 +1180,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.Title.Should().Be("A related resource does not exist.");
             error.Detail.Should().Be($"Related resource of type 'lyrics' with ID '{lyricId}' in relationship 'lyric' does not exist.");
             error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -1168,9 +1229,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body.");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible 'id' value found.");
             error.Detail.Should().Be("Failed to convert 'invalid-guid' of type 'String' to type 'Guid'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/id");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -1213,15 +1275,16 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Conflict);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Resource type mismatch between 'ref.relationship' and 'data.type' element.");
-            error.Detail.Should().Be("Expected resource of type 'lyrics' in 'data.type', instead of 'playlists'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.StatusCode.Should().Be(HttpStatusCode.Conflict);
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'playlists' is incompatible with type 'lyrics' of relationship 'lyric'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
     }
 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Resources/AtomicReplaceToManyRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Resources/AtomicReplaceToManyRelationshipTests.cs
index 3ee9307112..3e8e8f9740 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Resources/AtomicReplaceToManyRelationshipTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Resources/AtomicReplaceToManyRelationshipTests.cs
@@ -292,7 +292,59 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
         }
 
         [Fact]
-        public async Task Cannot_replace_for_null_relationship_data()
+        public async Task Cannot_replace_for_missing_data_in_relationship()
+        {
+            // Arrange
+            MusicTrack existingTrack = _fakers.MusicTrack.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.MusicTracks.Add(existingTrack);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "update",
+                        data = new
+                        {
+                            type = "musicTracks",
+                            id = existingTrack.StringId,
+                            relationships = new
+                            {
+                                performers = new
+                                {
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/performers");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_replace_for_null_data_in_relationship()
         {
             // Arrange
             MusicTrack existingTrack = _fakers.MusicTrack.Generate();
@@ -338,9 +390,65 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected data[] element for to-many relationship.");
-            error.Detail.Should().Be("Expected data[] element for 'performers' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of 'null'.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/performers/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_replace_for_object_data_in_relationship()
+        {
+            // Arrange
+            MusicTrack existingTrack = _fakers.MusicTrack.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.MusicTracks.Add(existingTrack);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "update",
+                        data = new
+                        {
+                            type = "musicTracks",
+                            id = existingTrack.StringId,
+                            relationships = new
+                            {
+                                performers = new
+                                {
+                                    data = new
+                                    {
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of an object.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/performers/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -388,9 +496,10 @@ public async Task Cannot_replace_for_missing_type_in_relationship_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'type' element.");
-            error.Detail.Should().Be("Expected 'type' element in 'tracks' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/tracks/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -439,9 +548,10 @@ public async Task Cannot_replace_for_unknown_type_in_relationship_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
             error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/performers/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -489,9 +599,10 @@ public async Task Cannot_replace_for_missing_ID_in_relationship_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'id' or 'lid' element.");
-            error.Detail.Should().Be("Expected 'id' or 'lid' element in 'performers' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' or 'lid' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/performers/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -541,9 +652,10 @@ public async Task Cannot_replace_for_ID_and_local_ID_relationship_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'id' or 'lid' element.");
-            error.Detail.Should().Be("Expected 'id' or 'lid' element in 'performers' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' and 'lid' element are mutually exclusive.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/performers/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -670,15 +782,16 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Conflict);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Relationship contains incompatible resource type.");
-            error.Detail.Should().Be("Relationship 'performers' contains incompatible resource type 'playlists'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.StatusCode.Should().Be(HttpStatusCode.Conflict);
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'playlists' is incompatible with type 'performers' of relationship 'performers'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/performers/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
     }
 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Resources/AtomicUpdateResourceTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Resources/AtomicUpdateResourceTests.cs
index 1a6b73e239..f3892baa47 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Resources/AtomicUpdateResourceTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Resources/AtomicUpdateResourceTests.cs
@@ -9,6 +9,7 @@
 using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Serialization.Objects;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
 using TestBuildingBlocks;
 using Xunit;
 
@@ -32,6 +33,9 @@ public AtomicUpdateResourceTests(IntegrationTestContext<TestableStartup<Operatio
             {
                 services.AddResourceDefinition<ImplicitlyChangingTextLanguageDefinition>();
             });
+
+            var options = (JsonApiOptions)testContext.Factory.Services.GetRequiredService<IJsonApiOptions>();
+            options.AllowUnknownFieldsInRequestBody = false;
         }
 
         [Fact]
@@ -157,10 +161,65 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             });
         }
 
+        [Fact]
+        public async Task Cannot_update_resource_with_unknown_attribute()
+        {
+            // Arrange
+            MusicTrack existingTrack = _fakers.MusicTrack.Generate();
+            string newTitle = _fakers.MusicTrack.Generate().Title;
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.MusicTracks.Add(existingTrack);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "update",
+                        data = new
+                        {
+                            type = "musicTracks",
+                            id = existingTrack.StringId,
+                            attributes = new
+                            {
+                                title = newTitle,
+                                doesNotExist = "Ignored"
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Unknown attribute found.");
+            error.Detail.Should().Be("Attribute 'doesNotExist' does not exist on resource type 'musicTracks'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/attributes/doesNotExist");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
         [Fact]
         public async Task Can_update_resource_with_unknown_attribute()
         {
             // Arrange
+            var options = (JsonApiOptions)_testContext.Factory.Services.GetRequiredService<IJsonApiOptions>();
+            options.AllowUnknownFieldsInRequestBody = true;
+
             MusicTrack existingTrack = _fakers.MusicTrack.Generate();
             string newTitle = _fakers.MusicTrack.Generate().Title;
 
@@ -209,10 +268,70 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             });
         }
 
+        [Fact]
+        public async Task Cannot_update_resource_with_unknown_relationship()
+        {
+            // Arrange
+            MusicTrack existingTrack = _fakers.MusicTrack.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.MusicTracks.Add(existingTrack);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "update",
+                        data = new
+                        {
+                            type = "musicTracks",
+                            id = existingTrack.StringId,
+                            relationships = new
+                            {
+                                doesNotExist = new
+                                {
+                                    data = new
+                                    {
+                                        type = Unknown.ResourceType,
+                                        id = Unknown.StringId.Int32
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Unknown relationship found.");
+            error.Detail.Should().Be("Relationship 'doesNotExist' does not exist on resource type 'musicTracks'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/doesNotExist");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
         [Fact]
         public async Task Can_update_resource_with_unknown_relationship()
         {
             // Arrange
+            var options = (JsonApiOptions)_testContext.Factory.Services.GetRequiredService<IJsonApiOptions>();
+            options.AllowUnknownFieldsInRequestBody = true;
+
             MusicTrack existingTrack = _fakers.MusicTrack.Generate();
 
             await _testContext.RunOnDatabaseAsync(async dbContext =>
@@ -510,9 +629,10 @@ public async Task Cannot_update_resource_for_href_element()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Usage of the 'href' element is not supported.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'href' element is not supported.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/href");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -614,9 +734,10 @@ public async Task Cannot_update_resource_for_missing_type_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.type' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -661,9 +782,10 @@ public async Task Cannot_update_resource_for_missing_ID_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.id' or 'ref.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' or 'lid' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -710,9 +832,10 @@ public async Task Cannot_update_resource_for_ID_and_local_ID_in_ref()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'ref.id' or 'ref.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' and 'lid' element are mutually exclusive.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -745,10 +868,11 @@ public async Task Cannot_update_resource_for_missing_data()
             error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
             error.Detail.Should().BeNull();
             error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
-        public async Task Cannot_update_resource_for_missing_type_in_data()
+        public async Task Cannot_update_resource_for_null_data()
         {
             // Arrange
             var requestBody = new
@@ -758,14 +882,58 @@ public async Task Cannot_update_resource_for_missing_type_in_data()
                     new
                     {
                         op = "update",
-                        data = new
+                        data = (object)null
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an object in 'data' element, instead of 'null'.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_update_resource_for_array_data()
+        {
+            // Arrange
+            Performer existingPerformer = _fakers.Performer.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.Performers.Add(existingPerformer);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "update",
+                        data = new[]
                         {
-                            id = Unknown.StringId.Int32,
-                            attributes = new
-                            {
-                            },
-                            relationships = new
+                            new
                             {
+                                type = "performers",
+                                id = existingPerformer.StringId,
+                                attributes = new
+                                {
+                                    artistName = existingPerformer.ArtistName
+                                }
                             }
                         }
                     }
@@ -784,13 +952,14 @@ public async Task Cannot_update_resource_for_missing_type_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data.type' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: Expected an object in 'data' element, instead of an array.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
-        public async Task Cannot_update_resource_for_missing_ID_in_data()
+        public async Task Cannot_update_resource_for_missing_type_in_data()
         {
             // Arrange
             var requestBody = new
@@ -802,7 +971,7 @@ public async Task Cannot_update_resource_for_missing_ID_in_data()
                         op = "update",
                         data = new
                         {
-                            type = "performers",
+                            id = Unknown.StringId.Int32,
                             attributes = new
                             {
                             },
@@ -826,13 +995,14 @@ public async Task Cannot_update_resource_for_missing_ID_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data.id' or 'data.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
-        public async Task Cannot_update_resource_for_ID_and_local_ID_in_data()
+        public async Task Cannot_update_resource_for_missing_ID_in_data()
         {
             // Arrange
             var requestBody = new
@@ -845,8 +1015,6 @@ public async Task Cannot_update_resource_for_ID_and_local_ID_in_data()
                         data = new
                         {
                             type = "performers",
-                            id = Unknown.StringId.For<Performer, int>(),
-                            lid = "local-1",
                             attributes = new
                             {
                             },
@@ -870,23 +1038,16 @@ public async Task Cannot_update_resource_for_ID_and_local_ID_in_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: The 'data.id' or 'data.lid' element is required.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' or 'lid' element is required.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
-        public async Task Cannot_update_resource_for_array_in_data()
+        public async Task Cannot_update_resource_for_ID_and_local_ID_in_data()
         {
             // Arrange
-            Performer existingPerformer = _fakers.Performer.Generate();
-
-            await _testContext.RunOnDatabaseAsync(async dbContext =>
-            {
-                dbContext.Performers.Add(existingPerformer);
-                await dbContext.SaveChangesAsync();
-            });
-
             var requestBody = new
             {
                 atomic__operations = new[]
@@ -894,16 +1055,16 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                     new
                     {
                         op = "update",
-                        data = new[]
+                        data = new
                         {
-                            new
+                            type = "performers",
+                            id = Unknown.StringId.For<Performer, int>(),
+                            lid = "local-1",
+                            attributes = new
+                            {
+                            },
+                            relationships = new
                             {
-                                type = "performers",
-                                id = existingPerformer.StringId,
-                                attributes = new
-                                {
-                                    artistName = existingPerformer.ArtistName
-                                }
                             }
                         }
                     }
@@ -922,9 +1083,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected single data element for create/update resource operation.");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' and 'lid' element are mutually exclusive.");
             error.Detail.Should().BeNull();
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -964,15 +1126,16 @@ public async Task Cannot_update_on_resource_type_mismatch_between_ref_and_data()
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Conflict);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Resource type mismatch between 'ref.type' and 'data.type' element.");
-            error.Detail.Should().Be("Expected resource of type 'performers' in 'data.type', instead of 'playlists'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.StatusCode.Should().Be(HttpStatusCode.Conflict);
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'playlists' is incompatible with type 'performers'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -1015,15 +1178,16 @@ public async Task Cannot_update_on_resource_ID_mismatch_between_ref_and_data()
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Conflict);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Resource ID mismatch between 'ref.id' and 'data.id' element.");
-            error.Detail.Should().Be($"Expected resource with ID '{performerId1}' in 'data.id', instead of '{performerId2}'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.StatusCode.Should().Be(HttpStatusCode.Conflict);
+            error.Title.Should().Be("Failed to deserialize request body: Conflicting 'id' values found.");
+            error.Detail.Should().Be($"Expected '{performerId1}' instead of '{performerId2}'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/id");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -1063,15 +1227,16 @@ public async Task Cannot_update_on_resource_local_ID_mismatch_between_ref_and_da
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Conflict);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Resource local ID mismatch between 'ref.lid' and 'data.lid' element.");
-            error.Detail.Should().Be("Expected resource with local ID 'local-1' in 'data.lid', instead of 'local-2'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.StatusCode.Should().Be(HttpStatusCode.Conflict);
+            error.Title.Should().Be("Failed to deserialize request body: Conflicting 'lid' values found.");
+            error.Detail.Should().Be("Expected 'local-1' instead of 'local-2'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/lid");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -1119,9 +1284,10 @@ public async Task Cannot_update_on_mixture_of_ID_and_local_ID_between_ref_and_da
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Resource identity mismatch between 'ref.id' and 'data.lid' element.");
-            error.Detail.Should().Be($"Expected resource with ID '{performerId}' in 'data.id', instead of 'local-1' in 'data.lid'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -1169,9 +1335,10 @@ public async Task Cannot_update_on_mixture_of_local_ID_and_ID_between_ref_and_da
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Resource identity mismatch between 'ref.lid' and 'data.id' element.");
-            error.Detail.Should().Be($"Expected resource with local ID 'local-1' in 'data.lid', instead of '{performerId}' in 'data.id'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: The 'lid' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -1212,9 +1379,10 @@ public async Task Cannot_update_resource_for_unknown_type()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
             error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -1304,9 +1472,10 @@ public async Task Cannot_update_resource_for_incompatible_ID()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body.");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible 'id' value found.");
             error.Detail.Should().Be($"Failed to convert '{guid}' of type 'String' to type 'Int32'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/ref/id");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -1353,9 +1522,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Changing the value of the requested attribute is not allowed.");
-            error.Detail.Should().Be("Changing the value of 'createdAt' is not allowed.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: Attribute value cannot be assigned when updating resource.");
+            error.Detail.Should().Be("The attribute 'createdAt' on resource type 'lyrics' cannot be assigned to.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/attributes/createdAt");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -1403,8 +1573,9 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
             error.Title.Should().Be("Failed to deserialize request body: Attribute is read-only.");
-            error.Detail.Should().Be("Attribute 'isArchived' is read-only.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Detail.Should().Be("Attribute 'isArchived' on resource type 'playlists' is read-only.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/attributes/isArchived");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -1451,9 +1622,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body.");
-            error.Detail.Should().Be("Resource ID is read-only.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: Resource ID is read-only.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/attributes/id");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -1500,9 +1672,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body.");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible attribute value found.");
             error.Detail.Should().Be("Failed to convert attribute 'bornAt' with value '123.45' of type 'Number' to type 'DateTimeOffset'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/attributes/bornAt");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Resources/AtomicUpdateToOneRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Resources/AtomicUpdateToOneRelationshipTests.cs
index 9487a69551..1ec00d4b48 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Resources/AtomicUpdateToOneRelationshipTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Resources/AtomicUpdateToOneRelationshipTests.cs
@@ -564,7 +564,59 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
         }
 
         [Fact]
-        public async Task Cannot_create_for_array_in_relationship_data()
+        public async Task Cannot_create_for_missing_data_in_relationship()
+        {
+            // Arrange
+            MusicTrack existingTrack = _fakers.MusicTrack.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.MusicTracks.Add(existingTrack);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                atomic__operations = new[]
+                {
+                    new
+                    {
+                        op = "update",
+                        data = new
+                        {
+                            type = "musicTracks",
+                            id = existingTrack.StringId,
+                            relationships = new
+                            {
+                                lyric = new
+                                {
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/lyric");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_create_for_array_data_in_relationship()
         {
             // Arrange
             MusicTrack existingTrack = _fakers.MusicTrack.Generate();
@@ -617,9 +669,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected single data element for to-one relationship.");
-            error.Detail.Should().Be("Expected single data element for 'lyric' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: Expected an object or 'null' in 'data' element, instead of an array.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/lyric/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -664,9 +717,10 @@ public async Task Cannot_create_for_missing_type_in_relationship_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'type' element.");
-            error.Detail.Should().Be("Expected 'type' element in 'track' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/track/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -712,9 +766,10 @@ public async Task Cannot_create_for_unknown_type_in_relationship_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
             error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/lyric/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -759,9 +814,10 @@ public async Task Cannot_create_for_missing_ID_in_relationship_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'id' or 'lid' element.");
-            error.Detail.Should().Be("Expected 'id' or 'lid' element in 'lyric' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' or 'lid' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/lyric/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -808,9 +864,10 @@ public async Task Cannot_create_for_ID_and_local_ID_in_relationship_data()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'id' or 'lid' element.");
-            error.Detail.Should().Be("Expected 'id' or 'lid' element in 'lyric' relationship.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' and 'lid' element are mutually exclusive.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/lyric/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -869,6 +926,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.Title.Should().Be("A related resource does not exist.");
             error.Detail.Should().Be($"Related resource of type 'lyrics' with ID '{lyricId}' in relationship 'lyric' does not exist.");
             error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -916,15 +974,16 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Conflict);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Relationship contains incompatible resource type.");
-            error.Detail.Should().Be("Relationship 'lyric' contains incompatible resource type 'playlists'.");
-            error.Source.Pointer.Should().Be("/atomic:operations[0]");
+            error.StatusCode.Should().Be(HttpStatusCode.Conflict);
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'playlists' is incompatible with type 'lyrics' of relationship 'lyric'.");
+            error.Source.Pointer.Should().Be("/atomic:operations[0]/data/relationships/lyric/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
     }
 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/CompositeKeys/Car.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/CompositeKeys/Car.cs
index e50286f5a0..74ebc3a865 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/CompositeKeys/Car.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/CompositeKeys/Car.cs
@@ -12,18 +12,22 @@ public sealed class Car : Identifiable<string>
         [NotMapped]
         public override string Id
         {
-            get => $"{RegionId}:{LicensePlate}";
+            get => RegionId == default && LicensePlate == default ? null : $"{RegionId}:{LicensePlate}";
             set
             {
+                if (value == null)
+                {
+                    RegionId = default;
+                    LicensePlate = default;
+                    return;
+                }
+
                 string[] elements = value.Split(':');
 
-                if (elements.Length == 2)
+                if (elements.Length == 2 && int.TryParse(elements[0], out int regionId))
                 {
-                    if (int.TryParse(elements[0], out int regionId))
-                    {
-                        RegionId = regionId;
-                        LicensePlate = elements[1];
-                    }
+                    RegionId = regionId;
+                    LicensePlate = elements[1];
                 }
                 else
                 {
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/CompositeKeys/CarCompositeKeyAwareRepository.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/CompositeKeys/CarCompositeKeyAwareRepository.cs
index f76e0baa66..035d18a1c9 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/CompositeKeys/CarCompositeKeyAwareRepository.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/CompositeKeys/CarCompositeKeyAwareRepository.cs
@@ -16,10 +16,10 @@ public class CarCompositeKeyAwareRepository<TResource, TId> : EntityFrameworkCor
     {
         private readonly CarExpressionRewriter _writer;
 
-        public CarCompositeKeyAwareRepository(ITargetedFields targetedFields, IDbContextResolver contextResolver, IResourceGraph resourceGraph,
+        public CarCompositeKeyAwareRepository(ITargetedFields targetedFields, IDbContextResolver dbContextResolver, IResourceGraph resourceGraph,
             IResourceFactory resourceFactory, IEnumerable<IQueryConstraintProvider> constraintProviders, ILoggerFactory loggerFactory,
             IResourceDefinitionAccessor resourceDefinitionAccessor)
-            : base(targetedFields, contextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
+            : base(targetedFields, dbContextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
         {
             _writer = new CarExpressionRewriter(resourceGraph);
         }
@@ -57,10 +57,10 @@ private void RecursiveRewriteFilterInLayer(QueryLayer queryLayer)
     public class CarCompositeKeyAwareRepository<TResource> : CarCompositeKeyAwareRepository<TResource, int>, IResourceRepository<TResource>
         where TResource : class, IIdentifiable<int>
     {
-        public CarCompositeKeyAwareRepository(ITargetedFields targetedFields, IDbContextResolver contextResolver, IResourceGraph resourceGraph,
+        public CarCompositeKeyAwareRepository(ITargetedFields targetedFields, IDbContextResolver dbContextResolver, IResourceGraph resourceGraph,
             IResourceFactory resourceFactory, IEnumerable<IQueryConstraintProvider> constraintProviders, ILoggerFactory loggerFactory,
             IResourceDefinitionAccessor resourceDefinitionAccessor)
-            : base(targetedFields, contextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
+            : base(targetedFields, dbContextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
         {
         }
     }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/CompositeKeys/CarExpressionRewriter.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/CompositeKeys/CarExpressionRewriter.cs
index cce9320cce..c5ec910a98 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/CompositeKeys/CarExpressionRewriter.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/CompositeKeys/CarExpressionRewriter.cs
@@ -25,10 +25,10 @@ internal sealed class CarExpressionRewriter : QueryExpressionRewriter<object>
 
         public CarExpressionRewriter(IResourceGraph resourceGraph)
         {
-            ResourceContext carResourceContext = resourceGraph.GetResourceContext<Car>();
+            ResourceType carType = resourceGraph.GetResourceType<Car>();
 
-            _regionIdAttribute = carResourceContext.GetAttributeByPropertyName(nameof(Car.RegionId));
-            _licensePlateAttribute = carResourceContext.GetAttributeByPropertyName(nameof(Car.LicensePlate));
+            _regionIdAttribute = carType.GetAttributeByPropertyName(nameof(Car.RegionId));
+            _licensePlateAttribute = carType.GetAttributeByPropertyName(nameof(Car.LicensePlate));
         }
 
         public override QueryExpression VisitComparison(ComparisonExpression expression, object argument)
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ControllerActionResults/ActionResultTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ControllerActionResults/ActionResultTests.cs
index 51bb1c6f5c..5168931a82 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ControllerActionResults/ActionResultTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ControllerActionResults/ActionResultTests.cs
@@ -100,7 +100,7 @@ public async Task Cannot_convert_ActionResult_with_string_parameter_to_error_col
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.InternalServerError);
             error.Title.Should().Be("An unhandled error occurred while processing this request.");
-            error.Detail.Should().Be("Data being returned must be errors or resources.");
+            error.Detail.Should().Be("Data being returned must be resources, operations, errors or null.");
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/EagerLoading/BuildingRepository.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/EagerLoading/BuildingRepository.cs
index 4c49bdc209..4c32d6d3a6 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/EagerLoading/BuildingRepository.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/EagerLoading/BuildingRepository.cs
@@ -13,10 +13,10 @@ namespace JsonApiDotNetCoreTests.IntegrationTests.EagerLoading
     [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
     public sealed class BuildingRepository : EntityFrameworkCoreRepository<Building>
     {
-        public BuildingRepository(ITargetedFields targetedFields, IDbContextResolver contextResolver, IResourceGraph resourceGraph,
+        public BuildingRepository(ITargetedFields targetedFields, IDbContextResolver dbContextResolver, IResourceGraph resourceGraph,
             IResourceFactory resourceFactory, IEnumerable<IQueryConstraintProvider> constraintProviders, ILoggerFactory loggerFactory,
             IResourceDefinitionAccessor resourceDefinitionAccessor)
-            : base(targetedFields, contextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
+            : base(targetedFields, dbContextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
         {
         }
 
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ExceptionHandling/AlternateExceptionHandler.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ExceptionHandling/AlternateExceptionHandler.cs
index d6af489f76..0ccbcf7947 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ExceptionHandling/AlternateExceptionHandler.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ExceptionHandling/AlternateExceptionHandler.cs
@@ -24,7 +24,7 @@ protected override LogLevel GetLogLevel(Exception exception)
             return base.GetLogLevel(exception);
         }
 
-        protected override Document CreateErrorDocument(Exception exception)
+        protected override IReadOnlyList<ErrorObject> CreateErrorResponse(Exception exception)
         {
             if (exception is ConsumerArticleIsNoLongerAvailableException articleException)
             {
@@ -34,7 +34,7 @@ protected override Document CreateErrorDocument(Exception exception)
                 };
             }
 
-            return base.CreateErrorDocument(exception);
+            return base.CreateErrorResponse(exception);
         }
     }
 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ExceptionHandling/ExceptionHandlerTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ExceptionHandling/ExceptionHandlerTests.cs
index ff8a61471f..a7dcd3329a 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ExceptionHandling/ExceptionHandlerTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ExceptionHandling/ExceptionHandlerTests.cs
@@ -80,11 +80,44 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.Detail.Should().Be("Article with code 'X123' is no longer available.");
             ((JsonElement)error.Meta["support"]).GetString().Should().Be("Please contact us for info about similar articles at company@email.com.");
 
+            responseDocument.Meta.Should().BeNull();
+
             loggerFactory.Logger.Messages.Should().HaveCount(1);
             loggerFactory.Logger.Messages.Single().LogLevel.Should().Be(LogLevel.Warning);
             loggerFactory.Logger.Messages.Single().Text.Should().Contain("Article with code 'X123' is no longer available.");
         }
 
+        [Fact]
+        public async Task Logs_and_produces_error_response_on_deserialization_failure()
+        {
+            // Arrange
+            var loggerFactory = _testContext.Factory.Services.GetRequiredService<FakeLoggerFactory>();
+            loggerFactory.Logger.Clear();
+
+            const string requestBody = @"{ ""data"": { ""type"": """" } }";
+
+            const string route = "/consumerArticles";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
+            error.Detail.Should().Be("Resource type '' does not exist.");
+            error.Meta["requestBody"].ToString().Should().Be(requestBody);
+
+            IEnumerable<string> stackTraceLines = ((JsonElement)error.Meta["stackTrace"]).EnumerateArray().Select(token => token.GetString());
+            stackTraceLines.Should().NotBeEmpty();
+
+            loggerFactory.Logger.Messages.Should().BeEmpty();
+        }
+
         [Fact]
         public async Task Logs_and_produces_error_response_on_serialization_failure()
         {
@@ -116,7 +149,9 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.Detail.Should().Be("Exception has been thrown by the target of an invocation.");
 
             IEnumerable<string> stackTraceLines = ((JsonElement)error.Meta["stackTrace"]).EnumerateArray().Select(token => token.GetString());
-            stackTraceLines.Should().ContainMatch("* System.InvalidOperationException: Article status could not be determined.*");
+            stackTraceLines.Should().ContainMatch("*ThrowingArticle*");
+
+            responseDocument.Meta.Should().BeNull();
 
             loggerFactory.Logger.Messages.Should().HaveCount(1);
             loggerFactory.Logger.Messages.Single().LogLevel.Should().Be(LogLevel.Error);
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/IdObfuscation/ObfuscatedIdentifiable.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/IdObfuscation/ObfuscatedIdentifiable.cs
index 99a89e6b8c..ab86709eba 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/IdObfuscation/ObfuscatedIdentifiable.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/IdObfuscation/ObfuscatedIdentifiable.cs
@@ -8,12 +8,12 @@ public abstract class ObfuscatedIdentifiable : Identifiable
 
         protected override string GetStringId(int value)
         {
-            return Codec.Encode(value);
+            return value == default ? null : Codec.Encode(value);
         }
 
         protected override int GetTypedId(string value)
         {
-            return Codec.Decode(value);
+            return value == null ? default : Codec.Decode(value);
         }
     }
 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/Meta/ResponseMetaTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/Meta/ResponseMetaTests.cs
index 0c698644da..ed5e3da83f 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/Meta/ResponseMetaTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/Meta/ResponseMetaTests.cs
@@ -3,7 +3,7 @@
 using System.Threading.Tasks;
 using FluentAssertions;
 using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Serialization;
+using JsonApiDotNetCore.Serialization.Response;
 using Microsoft.Extensions.DependencyInjection;
 using TestBuildingBlocks;
 using Xunit;
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/Meta/SupportResponseMeta.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/Meta/SupportResponseMeta.cs
index dccf338f22..1f7eee1262 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/Meta/SupportResponseMeta.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/Meta/SupportResponseMeta.cs
@@ -1,5 +1,5 @@
 using System.Collections.Generic;
-using JsonApiDotNetCore.Serialization;
+using JsonApiDotNetCore.Serialization.Response;
 
 namespace JsonApiDotNetCoreTests.IntegrationTests.Meta
 {
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/NonJsonApiControllers/NonJsonApiController.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/NonJsonApiControllers/NonJsonApiController.cs
index fa783d5095..3f108548ac 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/NonJsonApiControllers/NonJsonApiController.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/NonJsonApiControllers/NonJsonApiController.cs
@@ -28,21 +28,21 @@ public async Task<IActionResult> PostAsync()
                 return BadRequest("Please send your name.");
             }
 
-            string result = "Hello, " + name;
+            string result = $"Hello, {name}";
             return Ok(result);
         }
 
         [HttpPut]
         public IActionResult Put([FromBody] string name)
         {
-            string result = "Hi, " + name;
+            string result = $"Hi, {name}";
             return Ok(result);
         }
 
         [HttpPatch]
         public IActionResult Patch(string name)
         {
-            string result = "Good day, " + name;
+            string result = $"Good day, {name}";
             return Ok(result);
         }
 
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Filtering/FilterDepthTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Filtering/FilterDepthTests.cs
index 4d13fd69c1..807f104a15 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Filtering/FilterDepthTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Filtering/FilterDepthTests.cs
@@ -415,7 +415,11 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             responseDocument.Data.ManyValue.Should().HaveCount(1);
 
             responseDocument.Included.Should().HaveCount(2);
+
+            responseDocument.Included[0].Type.Should().Be("webAccounts");
             responseDocument.Included[0].Id.Should().Be(blog.Owner.StringId);
+
+            responseDocument.Included[1].Type.Should().Be("blogPosts");
             responseDocument.Included[1].Id.Should().Be(blog.Owner.Posts[1].StringId);
         }
 
@@ -530,8 +534,14 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             responseDocument.Data.ManyValue[0].Id.Should().Be(blogs[1].StringId);
 
             responseDocument.Included.Should().HaveCount(3);
+
+            responseDocument.Included[0].Type.Should().Be("webAccounts");
             responseDocument.Included[0].Id.Should().Be(blogs[1].Owner.StringId);
+
+            responseDocument.Included[1].Type.Should().Be("blogPosts");
             responseDocument.Included[1].Id.Should().Be(blogs[1].Owner.Posts[1].StringId);
+
+            responseDocument.Included[2].Type.Should().Be("comments");
             responseDocument.Included[2].Id.Should().Be(blogs[1].Owner.Posts[1].Comments.ElementAt(1).StringId);
         }
     }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Filtering/FilterTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Filtering/FilterTests.cs
index 8aa640c530..cc6a6cc372 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Filtering/FilterTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Filtering/FilterTests.cs
@@ -43,7 +43,7 @@ public async Task Cannot_filter_in_unknown_scope()
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
             error.Title.Should().Be("The specified filter is invalid.");
-            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' does not exist on resource 'webAccounts'.");
+            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' does not exist on resource type 'webAccounts'.");
             error.Source.Parameter.Should().Be($"filter[{Unknown.Relationship}]");
         }
 
@@ -64,7 +64,7 @@ public async Task Cannot_filter_in_unknown_nested_scope()
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
             error.Title.Should().Be("The specified filter is invalid.");
-            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' in 'posts.{Unknown.Relationship}' does not exist on resource 'blogPosts'.");
+            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' in 'posts.{Unknown.Relationship}' does not exist on resource type 'blogPosts'.");
             error.Source.Parameter.Should().Be($"filter[posts.{Unknown.Relationship}]");
         }
 
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Includes/IncludeTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Includes/IncludeTests.cs
index 7236e285eb..d6efa22782 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Includes/IncludeTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Includes/IncludeTests.cs
@@ -447,37 +447,176 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             responseDocument.Data.SingleValue.Should().NotBeNull();
             responseDocument.Data.SingleValue.Id.Should().Be(blog.StringId);
-            responseDocument.Data.SingleValue.Attributes["title"].Should().Be(blog.Title);
+            responseDocument.Data.SingleValue.Relationships["posts"].Data.ManyValue[0].Type.Should().Be("blogPosts");
+            responseDocument.Data.SingleValue.Relationships["posts"].Data.ManyValue[0].Id.Should().Be(blog.Posts[0].StringId);
 
             responseDocument.Included.Should().HaveCount(7);
 
             responseDocument.Included[0].Type.Should().Be("blogPosts");
             responseDocument.Included[0].Id.Should().Be(blog.Posts[0].StringId);
-            responseDocument.Included[0].Attributes["caption"].Should().Be(blog.Posts[0].Caption);
+            responseDocument.Included[0].Relationships["author"].Data.SingleValue.Type.Should().Be("webAccounts");
+            responseDocument.Included[0].Relationships["author"].Data.SingleValue.Id.Should().Be(blog.Posts[0].Author.StringId);
+            responseDocument.Included[0].Relationships["comments"].Data.ManyValue[0].Type.Should().Be("comments");
+            responseDocument.Included[0].Relationships["comments"].Data.ManyValue[0].Id.Should().Be(blog.Posts[0].Comments.ElementAt(0).StringId);
 
             responseDocument.Included[1].Type.Should().Be("webAccounts");
             responseDocument.Included[1].Id.Should().Be(blog.Posts[0].Author.StringId);
-            responseDocument.Included[1].Attributes["userName"].Should().Be(blog.Posts[0].Author.UserName);
+            responseDocument.Included[1].Relationships["preferences"].Data.SingleValue.Type.Should().Be("accountPreferences");
+            responseDocument.Included[1].Relationships["preferences"].Data.SingleValue.Id.Should().Be(blog.Posts[0].Author.Preferences.StringId);
+            responseDocument.Included[1].Relationships["posts"].Data.Value.Should().BeNull();
 
             responseDocument.Included[2].Type.Should().Be("accountPreferences");
             responseDocument.Included[2].Id.Should().Be(blog.Posts[0].Author.Preferences.StringId);
-            responseDocument.Included[2].Attributes["useDarkTheme"].Should().Be(blog.Posts[0].Author.Preferences.UseDarkTheme);
 
             responseDocument.Included[3].Type.Should().Be("comments");
             responseDocument.Included[3].Id.Should().Be(blog.Posts[0].Comments.ElementAt(0).StringId);
-            responseDocument.Included[3].Attributes["text"].Should().Be(blog.Posts[0].Comments.ElementAt(0).Text);
+            responseDocument.Included[3].Relationships["author"].Data.SingleValue.Type.Should().Be("webAccounts");
+            responseDocument.Included[3].Relationships["author"].Data.SingleValue.Id.Should().Be(blog.Posts[0].Comments.ElementAt(0).Author.StringId);
 
             responseDocument.Included[4].Type.Should().Be("webAccounts");
             responseDocument.Included[4].Id.Should().Be(blog.Posts[0].Comments.ElementAt(0).Author.StringId);
-            responseDocument.Included[4].Attributes["userName"].Should().Be(blog.Posts[0].Comments.ElementAt(0).Author.UserName);
+            responseDocument.Included[4].Relationships["posts"].Data.ManyValue[0].Type.Should().Be("blogPosts");
+            responseDocument.Included[4].Relationships["posts"].Data.ManyValue[0].Id.Should().Be(blog.Posts[0].Comments.ElementAt(0).Author.Posts[0].StringId);
+            responseDocument.Included[4].Relationships["preferences"].Data.Value.Should().BeNull();
 
             responseDocument.Included[5].Type.Should().Be("blogPosts");
             responseDocument.Included[5].Id.Should().Be(blog.Posts[0].Comments.ElementAt(0).Author.Posts[0].StringId);
-            responseDocument.Included[5].Attributes["caption"].Should().Be(blog.Posts[0].Comments.ElementAt(0).Author.Posts[0].Caption);
+            responseDocument.Included[5].Relationships["author"].Data.Value.Should().BeNull();
+            responseDocument.Included[5].Relationships["comments"].Data.Value.Should().BeNull();
 
             responseDocument.Included[6].Type.Should().Be("comments");
             responseDocument.Included[6].Id.Should().Be(blog.Posts[0].Comments.ElementAt(1).StringId);
-            responseDocument.Included[6].Attributes["text"].Should().Be(blog.Posts[0].Comments.ElementAt(1).Text);
+            responseDocument.Included[5].Relationships["author"].Data.Value.Should().BeNull();
+        }
+
+        [Fact]
+        public async Task Can_include_chain_of_relationships_with_reused_resources()
+        {
+            WebAccount author = _fakers.WebAccount.Generate();
+            author.Preferences = _fakers.AccountPreferences.Generate();
+            author.LoginAttempts = _fakers.LoginAttempt.Generate(1);
+
+            WebAccount reviewer = _fakers.WebAccount.Generate();
+            reviewer.Preferences = _fakers.AccountPreferences.Generate();
+            reviewer.LoginAttempts = _fakers.LoginAttempt.Generate(1);
+
+            BlogPost post1 = _fakers.BlogPost.Generate();
+            post1.Author = author;
+            post1.Reviewer = reviewer;
+
+            WebAccount person = _fakers.WebAccount.Generate();
+            person.Preferences = _fakers.AccountPreferences.Generate();
+            person.LoginAttempts = _fakers.LoginAttempt.Generate(1);
+
+            BlogPost post2 = _fakers.BlogPost.Generate();
+            post2.Author = person;
+            post2.Reviewer = person;
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                await dbContext.ClearTableAsync<BlogPost>();
+                dbContext.Posts.AddRange(post1, post2);
+                await dbContext.SaveChangesAsync();
+            });
+
+            const string route = "/blogPosts?include=reviewer.loginAttempts,author.preferences";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecuteGetAsync<Document>(route);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
+
+            responseDocument.Data.ManyValue.Should().HaveCount(2);
+
+            responseDocument.Data.ManyValue[0].Type.Should().Be("blogPosts");
+            responseDocument.Data.ManyValue[0].Id.Should().Be(post1.StringId);
+            responseDocument.Data.ManyValue[0].Relationships["author"].Data.SingleValue.Type.Should().Be("webAccounts");
+            responseDocument.Data.ManyValue[0].Relationships["author"].Data.SingleValue.Id.Should().Be(author.StringId);
+            responseDocument.Data.ManyValue[0].Relationships["reviewer"].Data.SingleValue.Type.Should().Be("webAccounts");
+            responseDocument.Data.ManyValue[0].Relationships["reviewer"].Data.SingleValue.Id.Should().Be(reviewer.StringId);
+
+            responseDocument.Data.ManyValue[1].Type.Should().Be("blogPosts");
+            responseDocument.Data.ManyValue[1].Id.Should().Be(post2.StringId);
+            responseDocument.Data.ManyValue[1].Relationships["author"].Data.SingleValue.Type.Should().Be("webAccounts");
+            responseDocument.Data.ManyValue[1].Relationships["author"].Data.SingleValue.Id.Should().Be(person.StringId);
+            responseDocument.Data.ManyValue[1].Relationships["reviewer"].Data.SingleValue.Type.Should().Be("webAccounts");
+            responseDocument.Data.ManyValue[1].Relationships["reviewer"].Data.SingleValue.Id.Should().Be(person.StringId);
+
+            responseDocument.Included.Should().HaveCount(7);
+
+            responseDocument.Included[0].Type.Should().Be("webAccounts");
+            responseDocument.Included[0].Id.Should().Be(author.StringId);
+            responseDocument.Included[0].Relationships["preferences"].Data.SingleValue.Type.Should().Be("accountPreferences");
+            responseDocument.Included[0].Relationships["preferences"].Data.SingleValue.Id.Should().Be(author.Preferences.StringId);
+            responseDocument.Included[0].Relationships["loginAttempts"].Data.Value.Should().BeNull();
+
+            responseDocument.Included[1].Type.Should().Be("accountPreferences");
+            responseDocument.Included[1].Id.Should().Be(author.Preferences.StringId);
+
+            responseDocument.Included[2].Type.Should().Be("webAccounts");
+            responseDocument.Included[2].Id.Should().Be(reviewer.StringId);
+            responseDocument.Included[2].Relationships["preferences"].Data.Value.Should().BeNull();
+            responseDocument.Included[2].Relationships["loginAttempts"].Data.ManyValue[0].Type.Should().Be("loginAttempts");
+            responseDocument.Included[2].Relationships["loginAttempts"].Data.ManyValue[0].Id.Should().Be(reviewer.LoginAttempts[0].StringId);
+
+            responseDocument.Included[3].Type.Should().Be("loginAttempts");
+            responseDocument.Included[3].Id.Should().Be(reviewer.LoginAttempts[0].StringId);
+
+            responseDocument.Included[4].Type.Should().Be("webAccounts");
+            responseDocument.Included[4].Id.Should().Be(person.StringId);
+            responseDocument.Included[4].Relationships["preferences"].Data.SingleValue.Type.Should().Be("accountPreferences");
+            responseDocument.Included[4].Relationships["preferences"].Data.SingleValue.Id.Should().Be(person.Preferences.StringId);
+            responseDocument.Included[4].Relationships["loginAttempts"].Data.ManyValue[0].Type.Should().Be("loginAttempts");
+            responseDocument.Included[4].Relationships["loginAttempts"].Data.ManyValue[0].Id.Should().Be(person.LoginAttempts[0].StringId);
+
+            responseDocument.Included[5].Type.Should().Be("accountPreferences");
+            responseDocument.Included[5].Id.Should().Be(person.Preferences.StringId);
+
+            responseDocument.Included[6].Type.Should().Be("loginAttempts");
+            responseDocument.Included[6].Id.Should().Be(person.LoginAttempts[0].StringId);
+        }
+
+        [Fact]
+        public async Task Can_include_chain_with_cyclic_dependency()
+        {
+            List<BlogPost> posts = _fakers.BlogPost.Generate(1);
+
+            Blog blog = _fakers.Blog.Generate();
+            blog.Posts = posts;
+            blog.Posts[0].Author = _fakers.WebAccount.Generate();
+            blog.Posts[0].Author.Posts = posts;
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.Blogs.Add(blog);
+                await dbContext.SaveChangesAsync();
+            });
+
+            string route = $"/blogs/{blog.StringId}?include=posts.author.posts.author.posts.author";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecuteGetAsync<Document>(route);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
+
+            responseDocument.Data.SingleValue.Type.Should().Be("blogs");
+            responseDocument.Data.SingleValue.Id.Should().Be(blog.StringId);
+            responseDocument.Data.SingleValue.Relationships["posts"].Data.ManyValue[0].Type.Should().Be("blogPosts");
+            responseDocument.Data.SingleValue.Relationships["posts"].Data.ManyValue[0].Id.Should().Be(blog.Posts[0].StringId);
+
+            responseDocument.Included.Should().HaveCount(2);
+
+            responseDocument.Included[0].Type.Should().Be("blogPosts");
+            responseDocument.Included[0].Id.Should().Be(blog.Posts[0].StringId);
+            responseDocument.Included[0].Relationships["author"].Data.SingleValue.Type.Should().Be("webAccounts");
+            responseDocument.Included[0].Relationships["author"].Data.SingleValue.Id.Should().Be(blog.Posts[0].Author.StringId);
+
+            responseDocument.Included[1].Type.Should().Be("webAccounts");
+            responseDocument.Included[1].Id.Should().Be(blog.Posts[0].Author.StringId);
+            responseDocument.Included[1].Relationships["posts"].Data.ManyValue[0].Type.Should().Be("blogPosts");
+            responseDocument.Included[1].Relationships["posts"].Data.ManyValue[0].Id.Should().Be(blog.Posts[0].StringId);
         }
 
         [Fact]
@@ -564,7 +703,7 @@ public async Task Cannot_include_unknown_relationship()
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
             error.Title.Should().Be("The specified include is invalid.");
-            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' does not exist on resource 'webAccounts'.");
+            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' does not exist on resource type 'webAccounts'.");
             error.Source.Parameter.Should().Be("include");
         }
 
@@ -585,7 +724,7 @@ public async Task Cannot_include_unknown_nested_relationship()
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
             error.Title.Should().Be("The specified include is invalid.");
-            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' in 'posts.{Unknown.Relationship}' does not exist on resource 'blogPosts'.");
+            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' in 'posts.{Unknown.Relationship}' does not exist on resource type 'blogPosts'.");
             error.Source.Parameter.Should().Be("include");
         }
 
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/LoginAttempt.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/LoginAttempt.cs
new file mode 100644
index 0000000000..d86783f387
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/LoginAttempt.cs
@@ -0,0 +1,17 @@
+using System;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreTests.IntegrationTests.QueryStrings
+{
+    [UsedImplicitly(ImplicitUseTargetFlags.Members)]
+    public sealed class LoginAttempt : Identifiable
+    {
+        [Attr]
+        public DateTimeOffset TriedAt { get; set; }
+
+        [Attr]
+        public bool IsSucceeded { get; set; }
+    }
+}
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Pagination/PaginationWithTotalCountTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Pagination/PaginationWithTotalCountTests.cs
index 8d87adfc7d..5c5eb11f6d 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Pagination/PaginationWithTotalCountTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Pagination/PaginationWithTotalCountTests.cs
@@ -368,8 +368,14 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             responseDocument.Data.ManyValue[0].Id.Should().Be(blogs[1].StringId);
 
             responseDocument.Included.Should().HaveCount(3);
+
+            responseDocument.Included[0].Type.Should().Be("webAccounts");
             responseDocument.Included[0].Id.Should().Be(blogs[1].Owner.StringId);
+
+            responseDocument.Included[1].Type.Should().Be("blogPosts");
             responseDocument.Included[1].Id.Should().Be(blogs[1].Owner.Posts[1].StringId);
+
+            responseDocument.Included[2].Type.Should().Be("comments");
             responseDocument.Included[2].Id.Should().Be(blogs[1].Owner.Posts[1].Comments.ElementAt(1).StringId);
 
             string linkPrefix = $"{HostPrefix}/blogs?include=owner.posts.comments";
@@ -399,7 +405,7 @@ public async Task Cannot_paginate_in_unknown_scope()
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
             error.Title.Should().Be("The specified paging is invalid.");
-            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' does not exist on resource 'webAccounts'.");
+            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' does not exist on resource type 'webAccounts'.");
             error.Source.Parameter.Should().Be("page[number]");
         }
 
@@ -420,7 +426,7 @@ public async Task Cannot_paginate_in_unknown_nested_scope()
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
             error.Title.Should().Be("The specified paging is invalid.");
-            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' in 'posts.{Unknown.Relationship}' does not exist on resource 'blogPosts'.");
+            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' in 'posts.{Unknown.Relationship}' does not exist on resource type 'blogPosts'.");
             error.Source.Parameter.Should().Be("page[size]");
         }
 
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/QueryStringDbContext.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/QueryStringDbContext.cs
index b09dfbc278..af11134b1c 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/QueryStringDbContext.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/QueryStringDbContext.cs
@@ -14,6 +14,7 @@ public sealed class QueryStringDbContext : DbContext
         public DbSet<Comment> Comments { get; set; }
         public DbSet<WebAccount> Accounts { get; set; }
         public DbSet<AccountPreferences> AccountPreferences { get; set; }
+        public DbSet<LoginAttempt> LoginAttempts { get; set; }
         public DbSet<Calendar> Calendars { get; set; }
         public DbSet<Appointment> Appointments { get; set; }
 
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/QueryStringFakers.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/QueryStringFakers.cs
index 702ba9c7f5..54bf83fb01 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/QueryStringFakers.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/QueryStringFakers.cs
@@ -43,6 +43,12 @@ internal sealed class QueryStringFakers : FakerContainer
                 .RuleFor(webAccount => webAccount.DateOfBirth, faker => faker.Person.DateOfBirth)
                 .RuleFor(webAccount => webAccount.EmailAddress, faker => faker.Internet.Email()));
 
+        private readonly Lazy<Faker<LoginAttempt>> _lazyLoginAttemptFaker = new(() =>
+            new Faker<LoginAttempt>()
+                .UseSeed(GetFakerSeed())
+                .RuleFor(loginAttempt => loginAttempt.TriedAt, faker => faker.Date.PastOffset())
+                .RuleFor(loginAttempt => loginAttempt.IsSucceeded, faker => faker.Random.Bool()));
+
         private readonly Lazy<Faker<AccountPreferences>> _lazyAccountPreferencesFaker = new(() =>
             new Faker<AccountPreferences>()
                 .UseSeed(GetFakerSeed())
@@ -67,6 +73,7 @@ internal sealed class QueryStringFakers : FakerContainer
         public Faker<Label> Label => _lazyLabelFaker.Value;
         public Faker<Comment> Comment => _lazyCommentFaker.Value;
         public Faker<WebAccount> WebAccount => _lazyWebAccountFaker.Value;
+        public Faker<LoginAttempt> LoginAttempt => _lazyLoginAttemptFaker.Value;
         public Faker<AccountPreferences> AccountPreferences => _lazyAccountPreferencesFaker.Value;
         public Faker<Calendar> Calendar => _lazyCalendarFaker.Value;
         public Faker<Appointment> Appointment => _lazyAppointmentFaker.Value;
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Sorting/SortTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Sorting/SortTests.cs
index 43ceb3fdf9..c719961d58 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Sorting/SortTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Sorting/SortTests.cs
@@ -433,10 +433,20 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             responseDocument.Data.ManyValue[1].Id.Should().Be(blogs[0].StringId);
 
             responseDocument.Included.Should().HaveCount(5);
+
+            responseDocument.Included[0].Type.Should().Be("webAccounts");
             responseDocument.Included[0].Id.Should().Be(blogs[1].Owner.StringId);
+
+            responseDocument.Included[1].Type.Should().Be("blogPosts");
             responseDocument.Included[1].Id.Should().Be(blogs[1].Owner.Posts[1].StringId);
+
+            responseDocument.Included[2].Type.Should().Be("comments");
             responseDocument.Included[2].Id.Should().Be(blogs[1].Owner.Posts[1].Comments.ElementAt(1).StringId);
+
+            responseDocument.Included[3].Type.Should().Be("comments");
             responseDocument.Included[3].Id.Should().Be(blogs[1].Owner.Posts[1].Comments.ElementAt(0).StringId);
+
+            responseDocument.Included[4].Type.Should().Be("blogPosts");
             responseDocument.Included[4].Id.Should().Be(blogs[1].Owner.Posts[0].StringId);
         }
 
@@ -457,7 +467,7 @@ public async Task Cannot_sort_in_unknown_scope()
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
             error.Title.Should().Be("The specified sort is invalid.");
-            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' does not exist on resource 'webAccounts'.");
+            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' does not exist on resource type 'webAccounts'.");
             error.Source.Parameter.Should().Be($"sort[{Unknown.Relationship}]");
         }
 
@@ -478,7 +488,7 @@ public async Task Cannot_sort_in_unknown_nested_scope()
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
             error.Title.Should().Be("The specified sort is invalid.");
-            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' in 'posts.{Unknown.Relationship}' does not exist on resource 'blogPosts'.");
+            error.Detail.Should().Be($"Relationship '{Unknown.Relationship}' in 'posts.{Unknown.Relationship}' does not exist on resource type 'blogPosts'.");
             error.Source.Parameter.Should().Be($"sort[posts.{Unknown.Relationship}]");
         }
 
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/SparseFieldSets/ResultCapturingRepository.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/SparseFieldSets/ResultCapturingRepository.cs
index 0bf6da70f0..d2c9a3e780 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/SparseFieldSets/ResultCapturingRepository.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/SparseFieldSets/ResultCapturingRepository.cs
@@ -19,10 +19,10 @@ public sealed class ResultCapturingRepository<TResource> : EntityFrameworkCoreRe
     {
         private readonly ResourceCaptureStore _captureStore;
 
-        public ResultCapturingRepository(ITargetedFields targetedFields, IDbContextResolver contextResolver, IResourceGraph resourceGraph,
+        public ResultCapturingRepository(ITargetedFields targetedFields, IDbContextResolver dbContextResolver, IResourceGraph resourceGraph,
             IResourceFactory resourceFactory, IEnumerable<IQueryConstraintProvider> constraintProviders, ILoggerFactory loggerFactory,
             IResourceDefinitionAccessor resourceDefinitionAccessor, ResourceCaptureStore captureStore)
-            : base(targetedFields, contextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
+            : base(targetedFields, dbContextResolver, resourceGraph, resourceFactory, constraintProviders, loggerFactory, resourceDefinitionAccessor)
         {
             _captureStore = captureStore;
         }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/SparseFieldSets/SparseFieldSetTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/SparseFieldSets/SparseFieldSetTests.cs
index a8681a1403..c393d8197b 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/SparseFieldSets/SparseFieldSetTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/SparseFieldSets/SparseFieldSetTests.cs
@@ -445,6 +445,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
 
             responseDocument.Data.SingleValue.Should().NotBeNull();
+            responseDocument.Data.SingleValue.Type.Should().Be("blogs");
             responseDocument.Data.SingleValue.Id.Should().Be(blog.StringId);
             responseDocument.Data.SingleValue.Attributes.Should().HaveCount(1);
             responseDocument.Data.SingleValue.Attributes["title"].Should().Be(blog.Title);
@@ -452,12 +453,14 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             responseDocument.Included.Should().HaveCount(2);
 
+            responseDocument.Included[0].Type.Should().Be("webAccounts");
             responseDocument.Included[0].Id.Should().Be(blog.Owner.StringId);
             responseDocument.Included[0].Attributes.Should().HaveCount(2);
             responseDocument.Included[0].Attributes["userName"].Should().Be(blog.Owner.UserName);
             responseDocument.Included[0].Attributes["displayName"].Should().Be(blog.Owner.DisplayName);
             responseDocument.Included[0].Relationships.Should().BeNull();
 
+            responseDocument.Included[1].Type.Should().Be("blogPosts");
             responseDocument.Included[1].Id.Should().Be(blog.Owner.Posts[0].StringId);
             responseDocument.Included[1].Attributes.Should().HaveCount(1);
             responseDocument.Included[1].Attributes["caption"].Should().Be(blog.Owner.Posts[0].Caption);
@@ -503,6 +506,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
 
             responseDocument.Data.SingleValue.Should().NotBeNull();
+            responseDocument.Data.SingleValue.Type.Should().Be("blogs");
             responseDocument.Data.SingleValue.Id.Should().Be(blog.StringId);
             responseDocument.Data.SingleValue.Attributes.Should().HaveCount(1);
             responseDocument.Data.SingleValue.Attributes["title"].Should().Be(blog.Title);
@@ -513,6 +517,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             responseDocument.Included.Should().HaveCount(2);
 
+            responseDocument.Included[0].Type.Should().Be("webAccounts");
             responseDocument.Included[0].Id.Should().Be(blog.Owner.StringId);
             responseDocument.Included[0].Attributes["userName"].Should().Be(blog.Owner.UserName);
             responseDocument.Included[0].Attributes["displayName"].Should().Be(blog.Owner.DisplayName);
@@ -522,6 +527,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             responseDocument.Included[0].Relationships["posts"].Links.Self.Should().NotBeNull();
             responseDocument.Included[0].Relationships["posts"].Links.Related.Should().NotBeNull();
 
+            responseDocument.Included[1].Type.Should().Be("blogPosts");
             responseDocument.Included[1].Id.Should().Be(blog.Owner.Posts[0].StringId);
             responseDocument.Included[1].Attributes["caption"].Should().Be(blog.Owner.Posts[0].Caption);
             responseDocument.Included[1].Attributes["url"].Should().Be(blog.Owner.Posts[0].Url);
@@ -721,5 +727,34 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             postCaptured.Caption.Should().Be(post.Caption);
             postCaptured.Url.Should().Be(postCaptured.Url);
         }
+
+        [Fact]
+        public async Task Returns_related_resources_on_broken_resource_linkage()
+        {
+            // Arrange
+            WebAccount account = _fakers.WebAccount.Generate();
+            account.Posts = _fakers.BlogPost.Generate(2);
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.Accounts.Add(account);
+                await dbContext.SaveChangesAsync();
+            });
+
+            string route = $"/webAccounts/{account.StringId}?include=posts&fields[webAccounts]=displayName";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecuteGetAsync<Document>(route);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
+
+            responseDocument.Data.SingleValue.Should().NotBeNull();
+            responseDocument.Data.SingleValue.Id.Should().Be(account.StringId);
+            responseDocument.Data.SingleValue.Relationships.Should().BeNull();
+
+            responseDocument.Included.Should().HaveCount(2);
+            responseDocument.Included.Should().OnlyContain(resourceObject => resourceObject.Type == "blogPosts");
+        }
     }
 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/WebAccount.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/WebAccount.cs
index 09a3e5f2a7..ee47154be3 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/WebAccount.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/WebAccount.cs
@@ -29,5 +29,8 @@ public sealed class WebAccount : Identifiable
 
         [HasOne]
         public AccountPreferences Preferences { get; set; }
+
+        [HasMany]
+        public IList<LoginAttempt> LoginAttempts { get; set; }
     }
 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Creating/CreateResourceTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Creating/CreateResourceTests.cs
index 9a148f48b1..25eff993b6 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Creating/CreateResourceTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Creating/CreateResourceTests.cs
@@ -33,6 +33,7 @@ public CreateResourceTests(IntegrationTestContext<TestableStartup<ReadWriteDbCon
             var options = (JsonApiOptions)testContext.Factory.Services.GetRequiredService<IJsonApiOptions>();
             options.UseRelativeLinks = false;
             options.AllowClientGeneratedIds = false;
+            options.AllowUnknownFieldsInRequestBody = false;
         }
 
         [Fact]
@@ -252,10 +253,50 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             });
         }
 
+        [Fact]
+        public async Task Cannot_create_resource_with_unknown_attribute()
+        {
+            // Arrange
+            WorkItem newWorkItem = _fakers.WorkItem.Generate();
+
+            var requestBody = new
+            {
+                data = new
+                {
+                    type = "workItems",
+                    attributes = new
+                    {
+                        doesNotExist = "ignored",
+                        description = newWorkItem.Description
+                    }
+                }
+            };
+
+            const string route = "/workItems";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Unknown attribute found.");
+            error.Detail.Should().Be("Attribute 'doesNotExist' does not exist on resource type 'workItems'.");
+            error.Source.Pointer.Should().Be("/data/attributes/doesNotExist");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
         [Fact]
         public async Task Can_create_resource_with_unknown_attribute()
         {
             // Arrange
+            var options = (JsonApiOptions)_testContext.Factory.Services.GetRequiredService<IJsonApiOptions>();
+            options.AllowUnknownFieldsInRequestBody = true;
+
             WorkItem newWorkItem = _fakers.WorkItem.Generate();
 
             var requestBody = new
@@ -294,10 +335,54 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             });
         }
 
+        [Fact]
+        public async Task Cannot_create_resource_with_unknown_relationship()
+        {
+            // Arrange
+            var requestBody = new
+            {
+                data = new
+                {
+                    type = "workItems",
+                    relationships = new
+                    {
+                        doesNotExist = new
+                        {
+                            data = new
+                            {
+                                type = Unknown.ResourceType,
+                                id = Unknown.StringId.Int32
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/workItems";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Unknown relationship found.");
+            error.Detail.Should().Be("Relationship 'doesNotExist' does not exist on resource type 'workItems'.");
+            error.Source.Pointer.Should().Be("/data/relationships/doesNotExist");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
         [Fact]
         public async Task Can_create_resource_with_unknown_relationship()
         {
             // Arrange
+            var options = (JsonApiOptions)_testContext.Factory.Services.GetRequiredService<IJsonApiOptions>();
+            options.AllowUnknownFieldsInRequestBody = true;
+
             var requestBody = new
             {
                 data = new
@@ -352,7 +437,7 @@ public async Task Cannot_create_resource_with_client_generated_ID()
                     id = "0A0B0C",
                     attributes = new
                     {
-                        name = "Black"
+                        displayName = "Black"
                     }
                 }
             };
@@ -369,9 +454,10 @@ public async Task Cannot_create_resource_with_client_generated_ID()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.Forbidden);
-            error.Title.Should().Be("Specifying the resource ID in POST requests is not allowed.");
+            error.Title.Should().Be("Failed to deserialize request body: The use of client-generated IDs is disabled.");
             error.Detail.Should().BeNull();
             error.Source.Pointer.Should().Be("/data/id");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -392,8 +478,100 @@ public async Task Cannot_create_resource_for_missing_request_body()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
-            error.Title.Should().Be("Missing request body.");
+            error.Title.Should().Be("Failed to deserialize request body: Missing request body.");
             error.Detail.Should().BeNull();
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
+        }
+
+        [Fact]
+        public async Task Cannot_create_resource_for_missing_data()
+        {
+            // Arrange
+            var requestBody = new
+            {
+                meta = new
+                {
+                    key = "value"
+                }
+            };
+
+            const string route = "/workItems";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Should().BeNull();
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_create_resource_for_null_data()
+        {
+            // Arrange
+            var requestBody = new
+            {
+                data = (object)null
+            };
+
+            const string route = "/workItems";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an object in 'data' element, instead of 'null'.");
+            error.Source.Pointer.Should().Be("/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_create_resource_for_array_data()
+        {
+            // Arrange
+            var requestBody = new
+            {
+                data = new[]
+                {
+                    new
+                    {
+                        type = "workItems"
+                    }
+                }
+            };
+
+            const string route = "/workItems";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an object in 'data' element, instead of an array.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -422,8 +600,10 @@ public async Task Cannot_create_resource_for_missing_type()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'type' element.");
-            error.Detail.Should().StartWith("Expected 'type' element in 'data' element. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -453,8 +633,10 @@ public async Task Cannot_create_resource_for_unknown_type()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
-            error.Detail.Should().StartWith($"Resource type '{Unknown.ResourceType}' does not exist. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
+            error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
+            error.Source.Pointer.Should().Be("/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -508,8 +690,10 @@ public async Task Cannot_create_on_resource_type_mismatch_between_url_and_body()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.Conflict);
-            error.Title.Should().Be("Resource type mismatch between request body and endpoint URL.");
-            error.Detail.Should().Be("Expected resource of type 'workItems' in POST request body at endpoint '/workItems', instead of 'rgbColors'.");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'rgbColors' is incompatible with type 'workItems'.");
+            error.Source.Pointer.Should().Be("/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -540,8 +724,10 @@ public async Task Cannot_create_resource_attribute_with_blocked_capability()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Setting the initial value of the requested attribute is not allowed.");
-            error.Detail.Should().StartWith("Setting the initial value of 'isImportant' is not allowed. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Attribute value cannot be assigned when creating resource.");
+            error.Detail.Should().Be("The attribute 'isImportant' on resource type 'workItems' cannot be assigned to.");
+            error.Source.Pointer.Should().Be("/data/attributes/isImportant");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -573,7 +759,9 @@ public async Task Cannot_create_resource_with_readonly_attribute()
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
             error.Title.Should().Be("Failed to deserialize request body: Attribute is read-only.");
-            error.Detail.Should().StartWith("Attribute 'isDeprecated' is read-only. - Request body: <<");
+            error.Detail.Should().Be("Attribute 'isDeprecated' on resource type 'workItemGroups' is read-only.");
+            error.Source.Pointer.Should().Be("/data/attributes/isDeprecated");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -595,7 +783,9 @@ public async Task Cannot_create_resource_for_broken_JSON_request_body()
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
             error.Title.Should().Be("Failed to deserialize request body.");
-            error.Detail.Should().Match("'{' is invalid after a property name. * - Request body: <<*");
+            error.Detail.Should().StartWith("'{' is invalid after a property name.");
+            error.Source.Should().BeNull();
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -626,10 +816,10 @@ public async Task Cannot_create_resource_with_incompatible_attribute_value()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body.");
-
-            error.Detail.Should().StartWith("Failed to convert attribute 'dueAt' with value 'not-a-valid-time' " +
-                "of type 'String' to type 'Nullable<DateTimeOffset>'. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible attribute value found.");
+            error.Detail.Should().Be("Failed to convert attribute 'dueAt' with value 'not-a-valid-time' of type 'String' to type 'Nullable<DateTimeOffset>'.");
+            error.Source.Pointer.Should().Be("/data/attributes/dueAt");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Creating/CreateResourceWithClientGeneratedIdTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Creating/CreateResourceWithClientGeneratedIdTests.cs
index e8dc30f79f..181152a06d 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Creating/CreateResourceWithClientGeneratedIdTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Creating/CreateResourceWithClientGeneratedIdTests.cs
@@ -248,6 +248,8 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.StatusCode.Should().Be(HttpStatusCode.Conflict);
             error.Title.Should().Be("Another resource with the specified ID already exists.");
             error.Detail.Should().Be($"Another resource of type 'rgbColors' with ID '{existingColor.StringId}' already exists.");
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
     }
 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Creating/CreateResourceWithToManyRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Creating/CreateResourceWithToManyRelationshipTests.cs
index e9eae47336..037ef0cb92 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Creating/CreateResourceWithToManyRelationshipTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Creating/CreateResourceWithToManyRelationshipTests.cs
@@ -357,8 +357,10 @@ public async Task Cannot_create_for_missing_relationship_type()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'type' element.");
-            error.Detail.Should().StartWith("Expected 'type' element in 'subscribers' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/subscribers/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -399,8 +401,10 @@ public async Task Cannot_create_for_unknown_relationship_type()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
-            error.Detail.Should().StartWith($"Resource type '{Unknown.ResourceType}' does not exist. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
+            error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
+            error.Source.Pointer.Should().Be("/data/relationships/subscribers/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -440,8 +444,10 @@ public async Task Cannot_create_for_missing_relationship_ID()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'id' element.");
-            error.Detail.Should().StartWith("Expected 'id' element in 'subscribers' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/subscribers/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -531,14 +537,16 @@ public async Task Cannot_create_on_relationship_type_mismatch()
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Conflict);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Relationship contains incompatible resource type.");
-            error.Detail.Should().StartWith("Relationship 'subscribers' contains incompatible resource type 'rgbColors'. - Request body: <<");
+            error.StatusCode.Should().Be(HttpStatusCode.Conflict);
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'rgbColors' is incompatible with type 'userAccounts' of relationship 'subscribers'.");
+            error.Source.Pointer.Should().Be("/data/relationships/subscribers/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -608,7 +616,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
         }
 
         [Fact]
-        public async Task Cannot_create_with_null_data_in_OneToMany_relationship()
+        public async Task Cannot_create_with_missing_data_in_OneToMany_relationship()
         {
             // Arrange
             var requestBody = new
@@ -620,7 +628,6 @@ public async Task Cannot_create_with_null_data_in_OneToMany_relationship()
                     {
                         subscribers = new
                         {
-                            data = (object)null
                         }
                     }
                 }
@@ -638,8 +645,10 @@ public async Task Cannot_create_with_null_data_in_OneToMany_relationship()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected data[] element for to-many relationship.");
-            error.Detail.Should().StartWith("Expected data[] element for 'subscribers' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/subscribers");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -673,8 +682,49 @@ public async Task Cannot_create_with_null_data_in_ManyToMany_relationship()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected data[] element for to-many relationship.");
-            error.Detail.Should().StartWith("Expected data[] element for 'tags' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of 'null'.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/tags/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_create_with_object_data_in_ManyToMany_relationship()
+        {
+            // Arrange
+            var requestBody = new
+            {
+                data = new
+                {
+                    type = "workItems",
+                    relationships = new
+                    {
+                        tags = new
+                        {
+                            data = new
+                            {
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/workItems";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of an object.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/tags/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -718,8 +768,10 @@ public async Task Cannot_create_resource_with_local_ID()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body.");
-            error.Detail.Should().StartWith("Local IDs cannot be used at this endpoint. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'lid' element is not supported at this endpoint.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/lid");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
     }
 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Creating/CreateResourceWithToOneRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Creating/CreateResourceWithToOneRelationshipTests.cs
index acd6f6136e..fd7472958c 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Creating/CreateResourceWithToOneRelationshipTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Creating/CreateResourceWithToOneRelationshipTests.cs
@@ -283,6 +283,102 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             });
         }
 
+        [Fact]
+        public async Task Cannot_create_with_missing_data_in_relationship()
+        {
+            // Arrange
+            UserAccount existingUserAccount = _fakers.UserAccount.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.UserAccounts.Add(existingUserAccount);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                data = new
+                {
+                    type = "workItems",
+                    relationships = new
+                    {
+                        assignee = new
+                        {
+                        }
+                    }
+                }
+            };
+
+            const string route = "/workItems";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/assignee");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_create_with_array_data_in_relationship()
+        {
+            // Arrange
+            UserAccount existingUserAccount = _fakers.UserAccount.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.UserAccounts.Add(existingUserAccount);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                data = new
+                {
+                    type = "workItems",
+                    relationships = new
+                    {
+                        assignee = new
+                        {
+                            data = new[]
+                            {
+                                new
+                                {
+                                    type = "userAccounts",
+                                    id = existingUserAccount.StringId
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/workItems";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an object or 'null' in 'data' element, instead of an array.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/assignee/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
         [Fact]
         public async Task Cannot_create_for_missing_relationship_type()
         {
@@ -317,8 +413,10 @@ public async Task Cannot_create_for_missing_relationship_type()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'type' element.");
-            error.Detail.Should().StartWith("Expected 'type' element in 'assignee' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/assignee/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -356,8 +454,10 @@ public async Task Cannot_create_for_unknown_relationship_type()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
-            error.Detail.Should().StartWith($"Resource type '{Unknown.ResourceType}' does not exist. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
+            error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
+            error.Source.Pointer.Should().Be("/data/relationships/assignee/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -394,8 +494,10 @@ public async Task Cannot_create_for_missing_relationship_ID()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'id' element.");
-            error.Detail.Should().StartWith("Expected 'id' element in 'assignee' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/assignee/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -437,6 +539,8 @@ public async Task Cannot_create_with_unknown_relationship_ID()
             error.StatusCode.Should().Be(HttpStatusCode.NotFound);
             error.Title.Should().Be("A related resource does not exist.");
             error.Detail.Should().Be($"Related resource of type 'userAccounts' with ID '{userAccountId}' in relationship 'assignee' does not exist.");
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -468,14 +572,16 @@ public async Task Cannot_create_on_relationship_type_mismatch()
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Conflict);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Relationship contains incompatible resource type.");
-            error.Detail.Should().StartWith("Relationship 'assignee' contains incompatible resource type 'rgbColors'. - Request body: <<");
+            error.StatusCode.Should().Be(HttpStatusCode.Conflict);
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'rgbColors' is incompatible with type 'userAccounts' of relationship 'assignee'.");
+            error.Source.Pointer.Should().Be("/data/relationships/assignee/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -549,56 +655,6 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             });
         }
 
-        [Fact]
-        public async Task Cannot_create_with_data_array_in_relationship()
-        {
-            // Arrange
-            UserAccount existingUserAccount = _fakers.UserAccount.Generate();
-
-            await _testContext.RunOnDatabaseAsync(async dbContext =>
-            {
-                dbContext.UserAccounts.Add(existingUserAccount);
-                await dbContext.SaveChangesAsync();
-            });
-
-            var requestBody = new
-            {
-                data = new
-                {
-                    type = "workItems",
-                    relationships = new
-                    {
-                        assignee = new
-                        {
-                            data = new[]
-                            {
-                                new
-                                {
-                                    type = "userAccounts",
-                                    id = existingUserAccount.StringId
-                                }
-                            }
-                        }
-                    }
-                }
-            };
-
-            const string route = "/workItems";
-
-            // Act
-            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
-
-            // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
-
-            responseDocument.Errors.Should().HaveCount(1);
-
-            ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected single data element for to-one relationship.");
-            error.Detail.Should().StartWith("Expected single data element for 'assignee' relationship. - Request body: <<");
-        }
-
         [Fact]
         public async Task Cannot_create_resource_with_local_ID()
         {
@@ -637,8 +693,10 @@ public async Task Cannot_create_resource_with_local_ID()
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body.");
-            error.Detail.Should().StartWith("Local IDs cannot be used at this endpoint. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'lid' element is not supported at this endpoint.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/lid");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
     }
 }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Deleting/DeleteResourceTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Deleting/DeleteResourceTests.cs
index e9d7116889..4db422d5e8 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Deleting/DeleteResourceTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Deleting/DeleteResourceTests.cs
@@ -75,6 +75,8 @@ public async Task Cannot_delete_unknown_resource()
             error.StatusCode.Should().Be(HttpStatusCode.NotFound);
             error.Title.Should().Be("The requested resource does not exist.");
             error.Detail.Should().Be($"Resource of type 'workItems' with ID '{workItemId}' does not exist.");
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/AddToToManyRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/AddToToManyRelationshipTests.cs
index d66a425101..d827b58e4a 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/AddToToManyRelationshipTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/AddToToManyRelationshipTests.cs
@@ -58,8 +58,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.Forbidden);
-            error.Title.Should().Be("Only to-many relationships can be updated through this endpoint.");
-            error.Detail.Should().Be("Relationship 'assignee' must be a to-many relationship.");
+            error.Title.Should().Be("Failed to deserialize request body: Only to-many relationships can be targeted through this endpoint.");
+            error.Detail.Should().Be("Relationship 'assignee' is not a to-many relationship.");
+            error.Source.Should().BeNull();
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -202,8 +204,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
-            error.Title.Should().Be("Missing request body.");
+            error.Title.Should().Be("Failed to deserialize request body: Missing request body.");
             error.Detail.Should().BeNull();
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -241,8 +245,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'type' element.");
-            error.Detail.Should().StartWith("Expected 'type' element in 'data' element. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -281,8 +287,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
-            error.Detail.Should().StartWith($"Resource type '{Unknown.ResourceType}' does not exist. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
+            error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
+            error.Source.Pointer.Should().Be("/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -320,8 +328,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'id' element.");
-            error.Detail.Should().StartWith("Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -506,6 +516,8 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.StatusCode.Should().Be(HttpStatusCode.NotFound);
             error.Title.Should().Be("The requested resource does not exist.");
             error.Detail.Should().Be($"Resource of type 'workItems' with ID '{workItemId}' does not exist.");
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -546,6 +558,8 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.StatusCode.Should().Be(HttpStatusCode.NotFound);
             error.Title.Should().Be("The requested relationship does not exist.");
             error.Detail.Should().Be($"Resource of type 'workItems' does not contain a relationship named '{Unknown.Relationship}'.");
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -585,10 +599,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.Conflict);
-            error.Title.Should().Be("Resource type mismatch between request body and endpoint URL.");
-
-            error.Detail.Should().Be("Expected resource of type 'workTags' in POST request body at endpoint " +
-                $"'/workItems/{existingWorkItem.StringId}/relationships/tags', instead of 'userAccounts'.");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'userAccounts' is incompatible with type 'workTags' of relationship 'tags'.");
+            error.Source.Pointer.Should().Be("/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -676,7 +690,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
         }
 
         [Fact]
-        public async Task Cannot_add_with_null_data_in_OneToMany_relationship()
+        public async Task Cannot_add_with_missing_data_in_OneToMany_relationship()
         {
             // Arrange
             WorkItem existingWorkItem = _fakers.WorkItem.Generate();
@@ -689,7 +703,6 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             var requestBody = new
             {
-                data = (object)null
             };
 
             string route = $"/workItems/{existingWorkItem.StringId}/relationships/subscribers";
@@ -704,8 +717,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected data[] element for to-many relationship.");
-            error.Detail.Should().StartWith("Expected data[] element for 'subscribers' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Should().BeNull();
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -737,8 +752,47 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected data[] element for to-many relationship.");
-            error.Detail.Should().StartWith("Expected data[] element for 'tags' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of 'null'.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_add_with_object_data_in_ManyToMany_relationship()
+        {
+            // Arrange
+            WorkItem existingWorkItem = _fakers.WorkItem.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.WorkItems.Add(existingWorkItem);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                data = new
+                {
+                }
+            };
+
+            string route = $"/workItems/{existingWorkItem.StringId}/relationships/tags";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of an object.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/RemoveFromToManyRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/RemoveFromToManyRelationshipTests.cs
index ed1f9755ab..0d97f78a2f 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/RemoveFromToManyRelationshipTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/RemoveFromToManyRelationshipTests.cs
@@ -73,8 +73,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.Forbidden);
-            error.Title.Should().Be("Only to-many relationships can be updated through this endpoint.");
-            error.Detail.Should().Be("Relationship 'assignee' must be a to-many relationship.");
+            error.Title.Should().Be("Failed to deserialize request body: Only to-many relationships can be targeted through this endpoint.");
+            error.Detail.Should().Be("Relationship 'assignee' is not a to-many relationship.");
+            error.Source.Should().BeNull();
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -318,8 +320,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
-            error.Title.Should().Be("Missing request body.");
+            error.Title.Should().Be("Failed to deserialize request body: Missing request body.");
             error.Detail.Should().BeNull();
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -358,8 +362,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'type' element.");
-            error.Detail.Should().StartWith("Expected 'type' element in 'data' element. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -398,8 +404,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
-            error.Detail.Should().StartWith($"Resource type '{Unknown.ResourceType}' does not exist. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
+            error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
+            error.Source.Pointer.Should().Be("/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -437,8 +445,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'id' element.");
-            error.Detail.Should().StartWith("Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -623,6 +633,8 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.StatusCode.Should().Be(HttpStatusCode.NotFound);
             error.Title.Should().Be("The requested resource does not exist.");
             error.Detail.Should().Be($"Resource of type 'workItems' with ID '{workItemId}' does not exist.");
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -663,6 +675,8 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.StatusCode.Should().Be(HttpStatusCode.NotFound);
             error.Title.Should().Be("The requested relationship does not exist.");
             error.Detail.Should().Be($"Resource of type 'workItems' does not contain a relationship named '{Unknown.Relationship}'.");
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -702,10 +716,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.Conflict);
-            error.Title.Should().Be("Resource type mismatch between request body and endpoint URL.");
-
-            error.Detail.Should().Be("Expected resource of type 'workTags' in DELETE request body at endpoint " +
-                $"'/workItems/{existingWorkItem.StringId}/relationships/tags', instead of 'userAccounts'.");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'userAccounts' is incompatible with type 'workTags' of relationship 'tags'.");
+            error.Source.Pointer.Should().Be("/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -795,7 +809,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
         }
 
         [Fact]
-        public async Task Cannot_remove_with_null_data_in_OneToMany_relationship()
+        public async Task Cannot_remove_with_missing_data_in_OneToMany_relationship()
         {
             // Arrange
             WorkItem existingWorkItem = _fakers.WorkItem.Generate();
@@ -808,7 +822,6 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             var requestBody = new
             {
-                data = (object)null
             };
 
             string route = $"/workItems/{existingWorkItem.StringId}/relationships/subscribers";
@@ -823,8 +836,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected data[] element for to-many relationship.");
-            error.Detail.Should().StartWith("Expected data[] element for 'subscribers' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Should().BeNull();
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -856,8 +871,47 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected data[] element for to-many relationship.");
-            error.Detail.Should().StartWith("Expected data[] element for 'tags' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of 'null'.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_remove_with_object_data_in_ManyToMany_relationship()
+        {
+            // Arrange
+            WorkItem existingWorkItem = _fakers.WorkItem.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.WorkItems.Add(existingWorkItem);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                data = new
+                {
+                }
+            };
+
+            string route = $"/workItems/{existingWorkItem.StringId}/relationships/tags";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecuteDeleteAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of an object.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/ReplaceToManyRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/ReplaceToManyRelationshipTests.cs
index 3b439c1cec..ab4e3fc2bb 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/ReplaceToManyRelationshipTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/ReplaceToManyRelationshipTests.cs
@@ -234,8 +234,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
-            error.Title.Should().Be("Missing request body.");
+            error.Title.Should().Be("Failed to deserialize request body: Missing request body.");
             error.Detail.Should().BeNull();
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -273,8 +275,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'type' element.");
-            error.Detail.Should().StartWith("Expected 'type' element in 'data' element. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -313,8 +317,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
-            error.Detail.Should().StartWith($"Resource type '{Unknown.ResourceType}' does not exist. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
+            error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
+            error.Source.Pointer.Should().Be("/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -352,8 +358,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'id' element.");
-            error.Detail.Should().StartWith("Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -402,11 +410,13 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error1.StatusCode.Should().Be(HttpStatusCode.NotFound);
             error1.Title.Should().Be("A related resource does not exist.");
             error1.Detail.Should().Be($"Related resource of type 'userAccounts' with ID '{userAccountId1}' in relationship 'subscribers' does not exist.");
+            error1.Source.Should().BeNull();
 
             ErrorObject error2 = responseDocument.Errors[1];
             error2.StatusCode.Should().Be(HttpStatusCode.NotFound);
             error2.Title.Should().Be("A related resource does not exist.");
             error2.Detail.Should().Be($"Related resource of type 'userAccounts' with ID '{userAccountId2}' in relationship 'subscribers' does not exist.");
+            error2.Source.Should().BeNull();
         }
 
         [Fact]
@@ -455,11 +465,13 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error1.StatusCode.Should().Be(HttpStatusCode.NotFound);
             error1.Title.Should().Be("A related resource does not exist.");
             error1.Detail.Should().Be($"Related resource of type 'workTags' with ID '{tagId1}' in relationship 'tags' does not exist.");
+            error1.Source.Should().BeNull();
 
             ErrorObject error2 = responseDocument.Errors[1];
             error2.StatusCode.Should().Be(HttpStatusCode.NotFound);
             error2.Title.Should().Be("A related resource does not exist.");
             error2.Detail.Should().Be($"Related resource of type 'workTags' with ID '{tagId2}' in relationship 'tags' does not exist.");
+            error2.Source.Should().BeNull();
         }
 
         [Fact]
@@ -531,6 +543,8 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.StatusCode.Should().Be(HttpStatusCode.NotFound);
             error.Title.Should().Be("The requested resource does not exist.");
             error.Detail.Should().Be($"Resource of type 'workItems' with ID '{workItemId}' does not exist.");
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -571,6 +585,8 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.StatusCode.Should().Be(HttpStatusCode.NotFound);
             error.Title.Should().Be("The requested relationship does not exist.");
             error.Detail.Should().Be($"Resource of type 'workItems' does not contain a relationship named '{Unknown.Relationship}'.");
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -610,10 +626,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.Conflict);
-            error.Title.Should().Be("Resource type mismatch between request body and endpoint URL.");
-
-            error.Detail.Should().Be("Expected resource of type 'workTags' in PATCH request body at endpoint " +
-                $"'/workItems/{existingWorkItem.StringId}/relationships/tags', instead of 'userAccounts'.");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'userAccounts' is incompatible with type 'workTags' of relationship 'tags'.");
+            error.Source.Pointer.Should().Be("/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -668,7 +684,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
         }
 
         [Fact]
-        public async Task Cannot_replace_with_null_data_in_OneToMany_relationship()
+        public async Task Cannot_replace_with_missing_data_in_OneToMany_relationship()
         {
             // Arrange
             WorkItem existingWorkItem = _fakers.WorkItem.Generate();
@@ -681,7 +697,6 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             var requestBody = new
             {
-                data = (object)null
             };
 
             string route = $"/workItems/{existingWorkItem.StringId}/relationships/subscribers";
@@ -696,8 +711,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected data[] element for to-many relationship.");
-            error.Detail.Should().StartWith("Expected data[] element for 'subscribers' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Should().BeNull();
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -729,8 +746,47 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected data[] element for to-many relationship.");
-            error.Detail.Should().StartWith("Expected data[] element for 'tags' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of 'null'.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_replace_with_object_data_in_ManyToMany_relationship()
+        {
+            // Arrange
+            WorkItem existingWorkItem = _fakers.WorkItem.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.WorkItems.Add(existingWorkItem);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                data = new
+                {
+                }
+            };
+
+            string route = $"/workItems/{existingWorkItem.StringId}/relationships/tags";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePatchAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of an object.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/UpdateToOneRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/UpdateToOneRelationshipTests.cs
index afe4fc3c97..a7cd13c53c 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/UpdateToOneRelationshipTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/UpdateToOneRelationshipTests.cs
@@ -267,8 +267,88 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
-            error.Title.Should().Be("Missing request body.");
+            error.Title.Should().Be("Failed to deserialize request body: Missing request body.");
             error.Detail.Should().BeNull();
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
+        }
+
+        [Fact]
+        public async Task Cannot_create_for_missing_data()
+        {
+            // Arrange
+            WorkItem existingWorkItem = _fakers.WorkItem.Generate();
+            UserAccount existingUserAccount = _fakers.UserAccount.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.AddInRange(existingWorkItem, existingUserAccount);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+            };
+
+            string route = $"/workItems/{existingWorkItem.StringId}/relationships/assignee";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePatchAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Should().BeNull();
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_create_for_array_data()
+        {
+            // Arrange
+            WorkItem existingWorkItem = _fakers.WorkItem.Generate();
+            UserAccount existingUserAccount = _fakers.UserAccount.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.AddInRange(existingWorkItem, existingUserAccount);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                data = new[]
+                {
+                    new
+                    {
+                        type = "userAccounts",
+                        id = existingUserAccount.StringId
+                    }
+                }
+            };
+
+            string route = $"/workItems/{existingWorkItem.StringId}/relationships/assignee";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePatchAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an object or 'null' in 'data' element, instead of an array.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -303,8 +383,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'type' element.");
-            error.Detail.Should().StartWith("Expected 'type' element in 'data' element. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -340,8 +422,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
-            error.Detail.Should().StartWith($"Resource type '{Unknown.ResourceType}' does not exist. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
+            error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
+            error.Source.Pointer.Should().Be("/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -376,8 +460,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'id' element.");
-            error.Detail.Should().StartWith("Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -417,6 +503,8 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.StatusCode.Should().Be(HttpStatusCode.NotFound);
             error.Title.Should().Be("A related resource does not exist.");
             error.Detail.Should().Be($"Related resource of type 'userAccounts' with ID '{userAccountId}' in relationship 'assignee' does not exist.");
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -489,6 +577,8 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.StatusCode.Should().Be(HttpStatusCode.NotFound);
             error.Title.Should().Be("The requested resource does not exist.");
             error.Detail.Should().Be($"Resource of type 'workItems' with ID '{workItemId}' does not exist.");
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -526,6 +616,8 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.StatusCode.Should().Be(HttpStatusCode.NotFound);
             error.Title.Should().Be("The requested relationship does not exist.");
             error.Detail.Should().Be($"Resource of type 'workItems' does not contain a relationship named '{Unknown.Relationship}'.");
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -562,51 +654,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.Conflict);
-            error.Title.Should().Be("Resource type mismatch between request body and endpoint URL.");
-
-            error.Detail.Should().Be("Expected resource of type 'userAccounts' in PATCH request body at endpoint " +
-                $"'/workItems/{existingWorkItem.StringId}/relationships/assignee', instead of 'rgbColors'.");
-        }
-
-        [Fact]
-        public async Task Cannot_create_with_data_array_in_relationship()
-        {
-            // Arrange
-            WorkItem existingWorkItem = _fakers.WorkItem.Generate();
-            UserAccount existingUserAccount = _fakers.UserAccount.Generate();
-
-            await _testContext.RunOnDatabaseAsync(async dbContext =>
-            {
-                dbContext.AddInRange(existingWorkItem, existingUserAccount);
-                await dbContext.SaveChangesAsync();
-            });
-
-            var requestBody = new
-            {
-                data = new[]
-                {
-                    new
-                    {
-                        type = "userAccounts",
-                        id = existingUserAccount.StringId
-                    }
-                }
-            };
-
-            string route = $"/workItems/{existingWorkItem.StringId}/relationships/assignee";
-
-            // Act
-            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePatchAsync<Document>(route, requestBody);
-
-            // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
-
-            responseDocument.Errors.Should().HaveCount(1);
-
-            ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected single data element for to-one relationship.");
-            error.Detail.Should().StartWith("Expected single data element for 'assignee' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'rgbColors' is incompatible with type 'userAccounts' of relationship 'assignee'.");
+            error.Source.Pointer.Should().Be("/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Resources/ReplaceToManyRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Resources/ReplaceToManyRelationshipTests.cs
index b225589c4e..da348514cf 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Resources/ReplaceToManyRelationshipTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Resources/ReplaceToManyRelationshipTests.cs
@@ -441,8 +441,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'type' element.");
-            error.Detail.Should().StartWith("Expected 'type' element in 'subscribers' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/subscribers/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -492,8 +494,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
-            error.Detail.Should().StartWith($"Resource type '{Unknown.ResourceType}' does not exist. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
+            error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
+            error.Source.Pointer.Should().Be("/data/relationships/subscribers/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -542,8 +546,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'id' element.");
-            error.Detail.Should().StartWith("Expected 'id' element in 'subscribers' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/subscribers/data[0]");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -680,14 +686,16 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePatchAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Conflict);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Relationship contains incompatible resource type.");
-            error.Detail.Should().StartWith("Relationship 'subscribers' contains incompatible resource type 'rgbColors'. - Request body: <<");
+            error.StatusCode.Should().Be(HttpStatusCode.Conflict);
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'rgbColors' is incompatible with type 'userAccounts' of relationship 'subscribers'.");
+            error.Source.Pointer.Should().Be("/data/relationships/subscribers/data[0]/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -753,7 +761,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
         }
 
         [Fact]
-        public async Task Cannot_replace_with_null_data_in_OneToMany_relationship()
+        public async Task Cannot_replace_with_missing_data_in_OneToMany_relationship()
         {
             // Arrange
             WorkItem existingWorkItem = _fakers.WorkItem.Generate();
@@ -774,7 +782,6 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                     {
                         subscribers = new
                         {
-                            data = (object)null
                         }
                     }
                 }
@@ -792,8 +799,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected data[] element for to-many relationship.");
-            error.Detail.Should().StartWith("Expected data[] element for 'subscribers' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/subscribers");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -836,8 +845,58 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected data[] element for to-many relationship.");
-            error.Detail.Should().StartWith("Expected data[] element for 'tags' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of 'null'.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/tags/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_replace_with_object_data_in_ManyToMany_relationship()
+        {
+            // Arrange
+            WorkItem existingWorkItem = _fakers.WorkItem.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.WorkItems.Add(existingWorkItem);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                data = new
+                {
+                    type = "workItems",
+                    id = existingWorkItem.StringId,
+                    relationships = new
+                    {
+                        tags = new
+                        {
+                            data = new
+                            {
+                            }
+                        }
+                    }
+                }
+            };
+
+            string route = $"/workItems/{existingWorkItem.StringId}";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePatchAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an array in 'data' element, instead of an object.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/tags/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Resources/UpdateResourceTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Resources/UpdateResourceTests.cs
index a3bf1986f2..8f2fa5efab 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Resources/UpdateResourceTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Resources/UpdateResourceTests.cs
@@ -10,6 +10,7 @@
 using JsonApiDotNetCore.Resources;
 using JsonApiDotNetCore.Serialization.Objects;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
 using TestBuildingBlocks;
 using Xunit;
 
@@ -34,6 +35,9 @@ public UpdateResourceTests(IntegrationTestContext<TestableStartup<ReadWriteDbCon
                 services.AddResourceDefinition<ImplicitlyChangingWorkItemDefinition>();
                 services.AddResourceDefinition<ImplicitlyChangingWorkItemGroupDefinition>();
             });
+
+            var options = (JsonApiOptions)testContext.Factory.Services.GetRequiredService<IJsonApiOptions>();
+            options.AllowUnknownFieldsInRequestBody = false;
         }
 
         [Fact]
@@ -82,10 +86,58 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             });
         }
 
+        [Fact]
+        public async Task Cannot_update_resource_with_unknown_attribute()
+        {
+            // Arrange
+            UserAccount existingUserAccount = _fakers.UserAccount.Generate();
+            string newFirstName = _fakers.UserAccount.Generate().FirstName;
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.UserAccounts.Add(existingUserAccount);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                data = new
+                {
+                    type = "userAccounts",
+                    id = existingUserAccount.StringId,
+                    attributes = new
+                    {
+                        firstName = newFirstName,
+                        doesNotExist = "Ignored"
+                    }
+                }
+            };
+
+            string route = $"/userAccounts/{existingUserAccount.StringId}";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePatchAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Unknown attribute found.");
+            error.Detail.Should().Be("Attribute 'doesNotExist' does not exist on resource type 'userAccounts'.");
+            error.Source.Pointer.Should().Be("/data/attributes/doesNotExist");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
         [Fact]
         public async Task Can_update_resource_with_unknown_attribute()
         {
             // Arrange
+            var options = (JsonApiOptions)_testContext.Factory.Services.GetRequiredService<IJsonApiOptions>();
+            options.AllowUnknownFieldsInRequestBody = true;
+
             UserAccount existingUserAccount = _fakers.UserAccount.Generate();
             string newFirstName = _fakers.UserAccount.Generate().FirstName;
 
@@ -128,10 +180,63 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             });
         }
 
+        [Fact]
+        public async Task Cannot_update_resource_with_unknown_relationship()
+        {
+            // Arrange
+            UserAccount existingUserAccount = _fakers.UserAccount.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.UserAccounts.Add(existingUserAccount);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                data = new
+                {
+                    type = "userAccounts",
+                    id = existingUserAccount.StringId,
+                    relationships = new
+                    {
+                        doesNotExist = new
+                        {
+                            data = new
+                            {
+                                type = Unknown.ResourceType,
+                                id = Unknown.StringId.Int32
+                            }
+                        }
+                    }
+                }
+            };
+
+            string route = $"/userAccounts/{existingUserAccount.StringId}";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePatchAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Unknown relationship found.");
+            error.Detail.Should().Be("Relationship 'doesNotExist' does not exist on resource type 'userAccounts'.");
+            error.Source.Pointer.Should().Be("/data/relationships/doesNotExist");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
         [Fact]
         public async Task Can_update_resource_with_unknown_relationship()
         {
             // Arrange
+            var options = (JsonApiOptions)_testContext.Factory.Services.GetRequiredService<IJsonApiOptions>();
+            options.AllowUnknownFieldsInRequestBody = true;
+
             UserAccount existingUserAccount = _fakers.UserAccount.Generate();
 
             await _testContext.RunOnDatabaseAsync(async dbContext =>
@@ -551,8 +656,125 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
-            error.Title.Should().Be("Missing request body.");
+            error.Title.Should().Be("Failed to deserialize request body: Missing request body.");
+            error.Detail.Should().BeNull();
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
+        }
+
+        [Fact]
+        public async Task Cannot_update_resource_for_missing_data()
+        {
+            // Arrange
+            WorkItem existingWorkItem = _fakers.WorkItem.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.WorkItems.Add(existingWorkItem);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                meta = new
+                {
+                    key = "value"
+                }
+            };
+
+            string route = $"/workItems/{existingWorkItem.StringId}";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePatchAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Should().BeNull();
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_update_resource_for_null_data()
+        {
+            // Arrange
+            WorkItem existingWorkItem = _fakers.WorkItem.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.WorkItems.Add(existingWorkItem);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                data = (object)null
+            };
+
+            string route = $"/workItems/{existingWorkItem.StringId}";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePatchAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an object in 'data' element, instead of 'null'.");
             error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_update_resource_for_array_data()
+        {
+            // Arrange
+            WorkItem existingWorkItem = _fakers.WorkItem.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.WorkItems.Add(existingWorkItem);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                data = new[]
+                {
+                    new
+                    {
+                        type = "workItems",
+                        id = existingWorkItem.StringId
+                    }
+                }
+            };
+
+            string route = $"/workItems/{existingWorkItem.StringId}";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePatchAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: Expected an object in 'data' element, instead of an array.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -587,8 +809,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'type' element.");
-            error.Detail.Should().StartWith("Expected 'type' element in 'data' element. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -624,8 +848,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
-            error.Detail.Should().StartWith($"Resource type '{Unknown.ResourceType}' does not exist. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
+            error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
+            error.Source.Pointer.Should().Be("/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -660,8 +886,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'id' element.");
-            error.Detail.Should().StartWith("Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -725,6 +953,8 @@ public async Task Cannot_update_resource_on_unknown_resource_ID_in_url()
             error.StatusCode.Should().Be(HttpStatusCode.NotFound);
             error.Title.Should().Be("The requested resource does not exist.");
             error.Detail.Should().Be($"Resource of type 'workItems' with ID '{workItemId}' does not exist.");
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
@@ -760,10 +990,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.Conflict);
-            error.Title.Should().Be("Resource type mismatch between request body and endpoint URL.");
-
-            error.Detail.Should().Be("Expected resource of type 'workItems' in PATCH request body at endpoint " +
-                $"'/workItems/{existingWorkItem.StringId}', instead of 'rgbColors'.");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'rgbColors' is incompatible with type 'workItems'.");
+            error.Source.Pointer.Should().Be("/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -799,10 +1029,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.Conflict);
-            error.Title.Should().Be("Resource ID mismatch between request body and endpoint URL.");
-
-            error.Detail.Should().Be($"Expected resource ID '{existingWorkItems[1].StringId}' in PATCH request body at endpoint " +
-                $"'/workItems/{existingWorkItems[1].StringId}', instead of '{existingWorkItems[0].StringId}'.");
+            error.Title.Should().Be("Failed to deserialize request body: Conflicting 'id' values found.");
+            error.Detail.Should().Be($"Expected '{existingWorkItems[1].StringId}' instead of '{existingWorkItems[0].StringId}'.");
+            error.Source.Pointer.Should().Be("/data/id");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -842,19 +1072,21 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Changing the value of the requested attribute is not allowed.");
-            error.Detail.Should().StartWith("Changing the value of 'isImportant' is not allowed. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Attribute value cannot be assigned when updating resource.");
+            error.Detail.Should().Be("The attribute 'isImportant' on resource type 'workItems' cannot be assigned to.");
+            error.Source.Pointer.Should().Be("/data/attributes/isImportant");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
         public async Task Cannot_update_resource_with_readonly_attribute()
         {
             // Arrange
-            WorkItem existingWorkItem = _fakers.WorkItem.Generate();
+            WorkItemGroup existingWorkItemGroup = _fakers.WorkItemGroup.Generate();
 
             await _testContext.RunOnDatabaseAsync(async dbContext =>
             {
-                dbContext.WorkItems.Add(existingWorkItem);
+                dbContext.Groups.Add(existingWorkItemGroup);
                 await dbContext.SaveChangesAsync();
             });
 
@@ -863,7 +1095,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 data = new
                 {
                     type = "workItemGroups",
-                    id = existingWorkItem.StringId,
+                    id = existingWorkItemGroup.StringId,
                     attributes = new
                     {
                         isDeprecated = true
@@ -871,7 +1103,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 }
             };
 
-            string route = $"/workItemGroups/{existingWorkItem.StringId}";
+            string route = $"/workItemGroups/{existingWorkItemGroup.StringId}";
 
             // Act
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePatchAsync<Document>(route, requestBody);
@@ -884,7 +1116,9 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
             error.Title.Should().Be("Failed to deserialize request body: Attribute is read-only.");
-            error.Detail.Should().StartWith("Attribute 'isDeprecated' is read-only. - Request body: <<");
+            error.Detail.Should().Be("Attribute 'isDeprecated' on resource type 'workItemGroups' is read-only.");
+            error.Source.Pointer.Should().Be("/data/attributes/isDeprecated");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -914,7 +1148,9 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
             error.Title.Should().Be("Failed to deserialize request body.");
-            error.Detail.Should().Match("Expected end of string, but instead reached end of data. * - Request body: <<*");
+            error.Detail.Should().StartWith("Expected end of string, but instead reached end of data.");
+            error.Source.Should().BeNull();
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -954,8 +1190,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body.");
-            error.Detail.Should().StartWith("Resource ID is read-only. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Resource ID is read-only.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/attributes/id");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -995,7 +1233,9 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
             error.Title.Should().Be("Failed to deserialize request body.");
-            error.Detail.Should().StartWith($"Failed to convert ID '{existingWorkItem.Id}' of type 'Number' to type 'String'. - Request body: <<");
+            error.Detail.Should().Be($"Failed to convert ID '{existingWorkItem.Id}' of type 'Number' to type 'String'.");
+            error.Source.Should().BeNull();
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
@@ -1039,10 +1279,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body.");
-
-            error.Detail.Should().Match("Failed to convert attribute 'dueAt' with value '*start*end*' " +
-                "of type 'Object' to type 'Nullable<DateTimeOffset>'. - Request body: <<*");
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible attribute value found.");
+            error.Detail.Should().Match("Failed to convert attribute 'dueAt' with value '*start*end*' of type 'Object' to type 'Nullable<DateTimeOffset>'.");
+            error.Source.Pointer.Should().Be("/data/attributes/dueAt");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Resources/UpdateToOneRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Resources/UpdateToOneRelationshipTests.cs
index 3eac83cc04..7ee8e988bd 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Resources/UpdateToOneRelationshipTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Resources/UpdateToOneRelationshipTests.cs
@@ -437,14 +437,15 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
         }
 
         [Fact]
-        public async Task Cannot_create_for_missing_relationship_type()
+        public async Task Cannot_create_with_missing_data_in_relationship()
         {
             // Arrange
             WorkItem existingWorkItem = _fakers.WorkItem.Generate();
+            UserAccount existingUserAccount = _fakers.UserAccount.Generate();
 
             await _testContext.RunOnDatabaseAsync(async dbContext =>
             {
-                dbContext.WorkItems.Add(existingWorkItem);
+                dbContext.AddInRange(existingWorkItem, existingUserAccount);
                 await dbContext.SaveChangesAsync();
             });
 
@@ -458,9 +459,59 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                     {
                         assignee = new
                         {
-                            data = new
+                        }
+                    }
+                }
+            };
+
+            string route = $"/workItems/{existingWorkItem.StringId}";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePatchAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+
+            responseDocument.Errors.Should().HaveCount(1);
+
+            ErrorObject error = responseDocument.Errors[0];
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: The 'data' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/assignee");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
+        }
+
+        [Fact]
+        public async Task Cannot_create_with_array_data_in_relationship()
+        {
+            // Arrange
+            WorkItem existingWorkItem = _fakers.WorkItem.Generate();
+            UserAccount existingUserAccount = _fakers.UserAccount.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.AddInRange(existingWorkItem, existingUserAccount);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var requestBody = new
+            {
+                data = new
+                {
+                    type = "workItems",
+                    id = existingWorkItem.StringId,
+                    relationships = new
+                    {
+                        assignee = new
+                        {
+                            data = new[]
                             {
-                                id = Unknown.StringId.For<UserAccount, long>()
+                                new
+                                {
+                                    type = "userAccounts",
+                                    id = existingUserAccount.StringId
+                                }
                             }
                         }
                     }
@@ -479,12 +530,14 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'type' element.");
-            error.Detail.Should().StartWith("Expected 'type' element in 'assignee' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Expected an object or 'null' in 'data' element, instead of an array.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/assignee/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
-        public async Task Cannot_create_for_unknown_relationship_type()
+        public async Task Cannot_create_for_missing_relationship_type()
         {
             // Arrange
             WorkItem existingWorkItem = _fakers.WorkItem.Generate();
@@ -507,7 +560,6 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                         {
                             data = new
                             {
-                                type = Unknown.ResourceType,
                                 id = Unknown.StringId.For<UserAccount, long>()
                             }
                         }
@@ -527,12 +579,14 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body includes unknown resource type.");
-            error.Detail.Should().StartWith($"Resource type '{Unknown.ResourceType}' does not exist. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: The 'type' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/assignee/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
-        public async Task Cannot_create_for_missing_relationship_ID()
+        public async Task Cannot_create_for_unknown_relationship_type()
         {
             // Arrange
             WorkItem existingWorkItem = _fakers.WorkItem.Generate();
@@ -555,7 +609,8 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                         {
                             data = new
                             {
-                                type = "userAccounts"
+                                type = Unknown.ResourceType,
+                                id = Unknown.StringId.For<UserAccount, long>()
                             }
                         }
                     }
@@ -574,12 +629,14 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             ErrorObject error = responseDocument.Errors[0];
             error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Request body must include 'id' element.");
-            error.Detail.Should().StartWith("Expected 'id' element in 'assignee' relationship. - Request body: <<");
+            error.Title.Should().Be("Failed to deserialize request body: Unknown resource type found.");
+            error.Detail.Should().Be($"Resource type '{Unknown.ResourceType}' does not exist.");
+            error.Source.Pointer.Should().Be("/data/relationships/assignee/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
-        public async Task Cannot_create_with_unknown_relationship_ID()
+        public async Task Cannot_create_for_missing_relationship_ID()
         {
             // Arrange
             WorkItem existingWorkItem = _fakers.WorkItem.Generate();
@@ -590,8 +647,6 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 await dbContext.SaveChangesAsync();
             });
 
-            string userAccountId = Unknown.StringId.For<UserAccount, long>();
-
             var requestBody = new
             {
                 data = new
@@ -604,8 +659,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                         {
                             data = new
                             {
-                                type = "userAccounts",
-                                id = userAccountId
+                                type = "userAccounts"
                             }
                         }
                     }
@@ -618,18 +672,20 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePatchAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.NotFound);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.NotFound);
-            error.Title.Should().Be("A related resource does not exist.");
-            error.Detail.Should().Be($"Related resource of type 'userAccounts' with ID '{userAccountId}' in relationship 'assignee' does not exist.");
+            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
+            error.Title.Should().Be("Failed to deserialize request body: The 'id' element is required.");
+            error.Detail.Should().BeNull();
+            error.Source.Pointer.Should().Be("/data/relationships/assignee/data");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
-        public async Task Cannot_create_on_relationship_type_mismatch()
+        public async Task Cannot_create_with_unknown_relationship_ID()
         {
             // Arrange
             WorkItem existingWorkItem = _fakers.WorkItem.Generate();
@@ -640,6 +696,8 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 await dbContext.SaveChangesAsync();
             });
 
+            string userAccountId = Unknown.StringId.For<UserAccount, long>();
+
             var requestBody = new
             {
                 data = new
@@ -652,8 +710,8 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                         {
                             data = new
                             {
-                                type = "rgbColors",
-                                id = "0A0B0C"
+                                type = "userAccounts",
+                                id = userAccountId
                             }
                         }
                     }
@@ -666,26 +724,27 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePatchAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.NotFound);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Relationship contains incompatible resource type.");
-            error.Detail.Should().StartWith("Relationship 'assignee' contains incompatible resource type 'rgbColors'. - Request body: <<");
+            error.StatusCode.Should().Be(HttpStatusCode.NotFound);
+            error.Title.Should().Be("A related resource does not exist.");
+            error.Detail.Should().Be($"Related resource of type 'userAccounts' with ID '{userAccountId}' in relationship 'assignee' does not exist.");
+            error.Source.Should().BeNull();
+            error.Meta.Should().NotContainKey("requestBody");
         }
 
         [Fact]
-        public async Task Cannot_create_with_data_array_in_relationship()
+        public async Task Cannot_create_on_relationship_type_mismatch()
         {
             // Arrange
             WorkItem existingWorkItem = _fakers.WorkItem.Generate();
-            UserAccount existingUserAccount = _fakers.UserAccount.Generate();
 
             await _testContext.RunOnDatabaseAsync(async dbContext =>
             {
-                dbContext.AddInRange(existingWorkItem, existingUserAccount);
+                dbContext.WorkItems.Add(existingWorkItem);
                 await dbContext.SaveChangesAsync();
             });
 
@@ -699,13 +758,10 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                     {
                         assignee = new
                         {
-                            data = new[]
+                            data = new
                             {
-                                new
-                                {
-                                    type = "userAccounts",
-                                    id = existingUserAccount.StringId
-                                }
+                                type = "rgbColors",
+                                id = "0A0B0C"
                             }
                         }
                     }
@@ -718,14 +774,16 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePatchAsync<Document>(route, requestBody);
 
             // Assert
-            httpResponse.Should().HaveStatusCode(HttpStatusCode.UnprocessableEntity);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Conflict);
 
             responseDocument.Errors.Should().HaveCount(1);
 
             ErrorObject error = responseDocument.Errors[0];
-            error.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
-            error.Title.Should().Be("Failed to deserialize request body: Expected single data element for to-one relationship.");
-            error.Detail.Should().StartWith("Expected single data element for 'assignee' relationship. - Request body: <<");
+            error.StatusCode.Should().Be(HttpStatusCode.Conflict);
+            error.Title.Should().Be("Failed to deserialize request body: Incompatible resource type found.");
+            error.Detail.Should().Be("Type 'rgbColors' is incompatible with type 'userAccounts' of relationship 'assignee'.");
+            error.Source.Pointer.Should().Be("/data/relationships/assignee/data/type");
+            error.Meta["requestBody"].ToString().Should().NotBeNullOrEmpty();
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/RequiredRelationships/DefaultBehaviorTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/RequiredRelationships/DefaultBehaviorTests.cs
index 20448ea5db..0fe047f5b5 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/RequiredRelationships/DefaultBehaviorTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/RequiredRelationships/DefaultBehaviorTests.cs
@@ -43,7 +43,7 @@ public async Task Cannot_create_dependent_side_of_required_ManyToOne_relationshi
                     type = "orders",
                     attributes = new
                     {
-                        order = order.Amount
+                        amount = order.Amount
                     }
                 }
             };
@@ -212,7 +212,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
             error.Title.Should().Be("Failed to clear a required relationship.");
 
-            error.Detail.Should().Be($"The relationship 'customer' of resource type 'orders' with ID '{existingOrder.StringId}' " +
+            error.Detail.Should().Be($"The relationship 'customer' on resource type 'orders' with ID '{existingOrder.StringId}' " +
                 "cannot be cleared because it is a required relationship.");
         }
 
@@ -249,7 +249,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
             error.Title.Should().Be("Failed to clear a required relationship.");
 
-            error.Detail.Should().Be($"The relationship 'customer' of resource type 'orders' with ID '{existingOrder.StringId}' " +
+            error.Detail.Should().Be($"The relationship 'customer' on resource type 'orders' with ID '{existingOrder.StringId}' " +
                 "cannot be cleared because it is a required relationship.");
         }
 
@@ -297,7 +297,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
             error.Title.Should().Be("Failed to clear a required relationship.");
 
-            error.Detail.Should().Be($"The relationship 'orders' of resource type 'customers' with ID '{existingOrder.StringId}' " +
+            error.Detail.Should().Be($"The relationship 'orders' on resource type 'customers' with ID '{existingOrder.StringId}' " +
                 "cannot be cleared because it is a required relationship.");
         }
 
@@ -334,7 +334,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
             error.Title.Should().Be("Failed to clear a required relationship.");
 
-            error.Detail.Should().Be($"The relationship 'orders' of resource type 'customers' with ID '{existingOrder.StringId}' " +
+            error.Detail.Should().Be($"The relationship 'orders' on resource type 'customers' with ID '{existingOrder.StringId}' " +
                 "cannot be cleared because it is a required relationship.");
         }
 
@@ -378,7 +378,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.StatusCode.Should().Be(HttpStatusCode.BadRequest);
             error.Title.Should().Be("Failed to clear a required relationship.");
 
-            error.Detail.Should().Be($"The relationship 'orders' of resource type 'customers' with ID '{existingOrder.StringId}' " +
+            error.Detail.Should().Be($"The relationship 'orders' on resource type 'customers' with ID '{existingOrder.StringId}' " +
                 "cannot be cleared because it is a required relationship.");
         }
 
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceDefinitions/Reading/MoonDefinition.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceDefinitions/Reading/MoonDefinition.cs
index a40696a23a..13709920ca 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceDefinitions/Reading/MoonDefinition.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceDefinitions/Reading/MoonDefinition.cs
@@ -25,7 +25,7 @@ public MoonDefinition(IResourceGraph resourceGraph, IClientSettingsProvider clie
             _hitCounter = hitCounter;
         }
 
-        public override IImmutableList<IncludeElementExpression> OnApplyIncludes(IImmutableList<IncludeElementExpression> existingIncludes)
+        public override IImmutableSet<IncludeElementExpression> OnApplyIncludes(IImmutableSet<IncludeElementExpression> existingIncludes)
         {
             _hitCounter.TrackInvocation<Moon>(ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyIncludes);
 
@@ -35,7 +35,7 @@ public override IImmutableList<IncludeElementExpression> OnApplyIncludes(IImmuta
                 return existingIncludes;
             }
 
-            RelationshipAttribute orbitsAroundRelationship = ResourceContext.GetRelationshipByPropertyName(nameof(Moon.OrbitsAround));
+            RelationshipAttribute orbitsAroundRelationship = ResourceType.GetRelationshipByPropertyName(nameof(Moon.OrbitsAround));
 
             return existingIncludes.Add(new IncludeElementExpression(orbitsAroundRelationship));
         }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceDefinitions/Reading/PlanetDefinition.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceDefinitions/Reading/PlanetDefinition.cs
index b2313bee98..820074667c 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceDefinitions/Reading/PlanetDefinition.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceDefinitions/Reading/PlanetDefinition.cs
@@ -27,7 +27,7 @@ public PlanetDefinition(IResourceGraph resourceGraph, IClientSettingsProvider cl
             _hitCounter = hitCounter;
         }
 
-        public override IImmutableList<IncludeElementExpression> OnApplyIncludes(IImmutableList<IncludeElementExpression> existingIncludes)
+        public override IImmutableSet<IncludeElementExpression> OnApplyIncludes(IImmutableSet<IncludeElementExpression> existingIncludes)
         {
             _hitCounter.TrackInvocation<Planet>(ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyIncludes);
 
@@ -49,7 +49,7 @@ public override FilterExpression OnApplyFilter(FilterExpression existingFilter)
 
             if (_clientSettingsProvider.ArePlanetsWithPrivateNameHidden)
             {
-                AttrAttribute privateNameAttribute = ResourceContext.GetAttributeByPropertyName(nameof(Planet.PrivateName));
+                AttrAttribute privateNameAttribute = ResourceType.GetAttributeByPropertyName(nameof(Planet.PrivateName));
 
                 FilterExpression hasNoPrivateName = new ComparisonExpression(ComparisonOperator.Equals, new ResourceFieldChainExpression(privateNameAttribute),
                     new NullConstantExpression());
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceDefinitions/Reading/ResourceDefinitionReadTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceDefinitions/Reading/ResourceDefinitionReadTests.cs
index 675d562f5f..aa837c689b 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceDefinitions/Reading/ResourceDefinitionReadTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceDefinitions/Reading/ResourceDefinitionReadTests.cs
@@ -124,7 +124,56 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             hitCounter.HitExtensibilityPoints.Should().BeEquivalentTo(new[]
             {
-                (typeof(Moon), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyIncludes)
+                (typeof(Moon), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyIncludes),
+                (typeof(Planet), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyIncludes)
+            }, options => options.WithStrictOrdering());
+        }
+
+        [Fact]
+        public async Task Include_from_included_resource_definition_is_added()
+        {
+            // Arrange
+            var hitCounter = _testContext.Factory.Services.GetRequiredService<ResourceDefinitionHitCounter>();
+
+            var settingsProvider = (TestClientSettingsProvider)_testContext.Factory.Services.GetRequiredService<IClientSettingsProvider>();
+            settingsProvider.AutoIncludeOrbitingPlanetForMoons();
+
+            Planet planet = _fakers.Planet.Generate();
+            planet.Moons = _fakers.Moon.Generate(1).ToHashSet();
+            planet.Moons.ElementAt(0).OrbitsAround = _fakers.Planet.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.Planets.Add(planet);
+                await dbContext.SaveChangesAsync();
+            });
+
+            string route = $"/planets/{planet.StringId}?include=moons";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecuteGetAsync<Document>(route);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
+
+            responseDocument.Data.SingleValue.Should().NotBeNull();
+
+            responseDocument.Included.Should().HaveCount(2);
+
+            responseDocument.Included[0].Type.Should().Be("moons");
+            responseDocument.Included[0].Id.Should().Be(planet.Moons.ElementAt(0).StringId);
+            responseDocument.Included[0].Attributes["name"].Should().Be(planet.Moons.ElementAt(0).Name);
+
+            responseDocument.Included[1].Type.Should().Be("planets");
+            responseDocument.Included[1].Id.Should().Be(planet.Moons.ElementAt(0).OrbitsAround.StringId);
+            responseDocument.Included[1].Attributes["publicName"].Should().Be(planet.Moons.ElementAt(0).OrbitsAround.PublicName);
+
+            hitCounter.HitExtensibilityPoints.Should().BeEquivalentTo(new[]
+            {
+                (typeof(Planet), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyFilter),
+                (typeof(Planet), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyIncludes),
+                (typeof(Moon), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyIncludes),
+                (typeof(Planet), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyIncludes)
             }, options => options.WithStrictOrdering());
         }
 
@@ -261,7 +310,6 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyPagination),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySort),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet),
-                (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet)
             }, options => options.WithStrictOrdering());
         }
@@ -308,7 +356,6 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyPagination),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySort),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet),
-                (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet)
             }, options => options.WithStrictOrdering());
         }
@@ -343,7 +390,6 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyPagination),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySort),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet),
-                (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet)
             }, options => options.WithStrictOrdering());
         }
@@ -381,7 +427,6 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyPagination),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySort),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet),
-                (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet)
             }, options => options.WithStrictOrdering());
         }
@@ -420,7 +465,6 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyPagination),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySort),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet),
-                (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet)
             }, options => options.WithStrictOrdering());
         }
@@ -458,7 +502,6 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyPagination),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySort),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet),
-                (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet)
             }, options => options.WithStrictOrdering());
         }
@@ -496,7 +539,6 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyPagination),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySort),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet),
-                (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet),
                 (typeof(Star), ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplySparseFieldSet)
             }, options => options.WithStrictOrdering());
         }
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/Serialization/SerializationTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/Serialization/SerializationTests.cs
index f73e03004d..42817f2798 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/Serialization/SerializationTests.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/Serialization/SerializationTests.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Net;
@@ -65,6 +64,8 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             // Assert
             httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
 
+            httpResponse.Content.Headers.ContentLength.Should().BeGreaterThan(0);
+
             responseDocument.Should().BeEmpty();
         }
 
@@ -80,6 +81,8 @@ public async Task Returns_no_body_for_failed_HEAD_request()
             // Assert
             httpResponse.Should().HaveStatusCode(HttpStatusCode.NotFound);
 
+            httpResponse.Content.Headers.ContentLength.Should().BeGreaterThan(0);
+
             responseDocument.Should().BeEmpty();
         }
 
@@ -87,13 +90,13 @@ public async Task Returns_no_body_for_failed_HEAD_request()
         public async Task Can_get_primary_resources_with_include()
         {
             // Arrange
-            List<Meeting> meetings = _fakers.Meeting.Generate(1);
-            meetings[0].Attendees = _fakers.MeetingAttendee.Generate(1);
+            Meeting meeting = _fakers.Meeting.Generate();
+            meeting.Attendees = _fakers.MeetingAttendee.Generate(1);
 
             await _testContext.RunOnDatabaseAsync(async dbContext =>
             {
                 await dbContext.ClearTableAsync<Meeting>();
-                dbContext.Meetings.AddRange(meetings);
+                dbContext.Meetings.Add(meeting);
                 await dbContext.SaveChangesAsync();
             });
 
@@ -113,52 +116,52 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
   ""data"": [
     {
       ""type"": ""meetings"",
-      ""id"": """ + meetings[0].StringId + @""",
+      ""id"": """ + meeting.StringId + @""",
       ""attributes"": {
-        ""title"": """ + meetings[0].Title + @""",
-        ""startTime"": """ + meetings[0].StartTime.ToString(JsonDateTimeOffsetFormatSpecifier) + @""",
-        ""duration"": """ + meetings[0].Duration + @""",
+        ""title"": """ + meeting.Title + @""",
+        ""startTime"": """ + meeting.StartTime.ToString(JsonDateTimeOffsetFormatSpecifier) + @""",
+        ""duration"": """ + meeting.Duration + @""",
         ""location"": {
-          ""lat"": " + meetings[0].Location.Latitude.ToString(CultureInfo.InvariantCulture) + @",
-          ""lng"": " + meetings[0].Location.Longitude.ToString(CultureInfo.InvariantCulture) + @"
+          ""lat"": " + meeting.Location.Latitude.ToString(CultureInfo.InvariantCulture) + @",
+          ""lng"": " + meeting.Location.Longitude.ToString(CultureInfo.InvariantCulture) + @"
         }
       },
       ""relationships"": {
         ""attendees"": {
           ""links"": {
-            ""self"": ""http://localhost/meetings/" + meetings[0].StringId + @"/relationships/attendees"",
-            ""related"": ""http://localhost/meetings/" + meetings[0].StringId + @"/attendees""
+            ""self"": ""http://localhost/meetings/" + meeting.StringId + @"/relationships/attendees"",
+            ""related"": ""http://localhost/meetings/" + meeting.StringId + @"/attendees""
           },
           ""data"": [
             {
               ""type"": ""meetingAttendees"",
-              ""id"": """ + meetings[0].Attendees[0].StringId + @"""
+              ""id"": """ + meeting.Attendees[0].StringId + @"""
             }
           ]
         }
       },
       ""links"": {
-        ""self"": ""http://localhost/meetings/" + meetings[0].StringId + @"""
+        ""self"": ""http://localhost/meetings/" + meeting.StringId + @"""
       }
     }
   ],
   ""included"": [
     {
       ""type"": ""meetingAttendees"",
-      ""id"": """ + meetings[0].Attendees[0].StringId + @""",
+      ""id"": """ + meeting.Attendees[0].StringId + @""",
       ""attributes"": {
-        ""displayName"": """ + meetings[0].Attendees[0].DisplayName + @"""
+        ""displayName"": """ + meeting.Attendees[0].DisplayName + @"""
       },
       ""relationships"": {
         ""meeting"": {
           ""links"": {
-            ""self"": ""http://localhost/meetingAttendees/" + meetings[0].Attendees[0].StringId + @"/relationships/meeting"",
-            ""related"": ""http://localhost/meetingAttendees/" + meetings[0].Attendees[0].StringId + @"/meeting""
+            ""self"": ""http://localhost/meetingAttendees/" + meeting.Attendees[0].StringId + @"/relationships/meeting"",
+            ""related"": ""http://localhost/meetingAttendees/" + meeting.Attendees[0].StringId + @"/meeting""
           }
         }
       },
       ""links"": {
-        ""self"": ""http://localhost/meetingAttendees/" + meetings[0].Attendees[0].StringId + @"""
+        ""self"": ""http://localhost/meetingAttendees/" + meeting.Attendees[0].StringId + @"""
       }
     }
   ]
@@ -166,15 +169,62 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
         }
 
         [Fact]
-        public async Task Can_get_primary_resources_with_empty_include()
+        public async Task Can_get_primary_resource_with_empty_ToOne_include()
         {
             // Arrange
-            List<Meeting> meetings = _fakers.Meeting.Generate(1);
+            MeetingAttendee attendee = _fakers.MeetingAttendee.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.Attendees.Add(attendee);
+                await dbContext.SaveChangesAsync();
+            });
+
+            string route = $"/meetingAttendees/{attendee.StringId}?include=meeting";
+
+            // Act
+            (HttpResponseMessage httpResponse, string responseDocument) = await _testContext.ExecuteGetAsync<string>(route);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
+
+            responseDocument.Should().BeJson(@"{
+  ""links"": {
+    ""self"": ""http://localhost/meetingAttendees/" + attendee.StringId + @"?include=meeting""
+  },
+  ""data"": {
+    ""type"": ""meetingAttendees"",
+    ""id"": """ + attendee.StringId + @""",
+    ""attributes"": {
+      ""displayName"": """ + attendee.DisplayName + @"""
+    },
+    ""relationships"": {
+      ""meeting"": {
+        ""links"": {
+          ""self"": ""http://localhost/meetingAttendees/" + attendee.StringId + @"/relationships/meeting"",
+          ""related"": ""http://localhost/meetingAttendees/" + attendee.StringId + @"/meeting""
+        },
+        ""data"": null
+      }
+    },
+    ""links"": {
+      ""self"": ""http://localhost/meetingAttendees/" + attendee.StringId + @"""
+    }
+  },
+  ""included"": []
+}");
+        }
+
+        [Fact]
+        public async Task Can_get_primary_resources_with_empty_ToMany_include()
+        {
+            // Arrange
+            Meeting meeting = _fakers.Meeting.Generate();
 
             await _testContext.RunOnDatabaseAsync(async dbContext =>
             {
                 await dbContext.ClearTableAsync<Meeting>();
-                dbContext.Meetings.AddRange(meetings);
+                dbContext.Meetings.Add(meeting);
                 await dbContext.SaveChangesAsync();
             });
 
@@ -194,27 +244,27 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
   ""data"": [
     {
       ""type"": ""meetings"",
-      ""id"": """ + meetings[0].StringId + @""",
+      ""id"": """ + meeting.StringId + @""",
       ""attributes"": {
-        ""title"": """ + meetings[0].Title + @""",
-        ""startTime"": """ + meetings[0].StartTime.ToString(JsonDateTimeOffsetFormatSpecifier) + @""",
-        ""duration"": """ + meetings[0].Duration + @""",
+        ""title"": """ + meeting.Title + @""",
+        ""startTime"": """ + meeting.StartTime.ToString(JsonDateTimeOffsetFormatSpecifier) + @""",
+        ""duration"": """ + meeting.Duration + @""",
         ""location"": {
-          ""lat"": " + meetings[0].Location.Latitude.ToString(CultureInfo.InvariantCulture) + @",
-          ""lng"": " + meetings[0].Location.Longitude.ToString(CultureInfo.InvariantCulture) + @"
+          ""lat"": " + meeting.Location.Latitude.ToString(CultureInfo.InvariantCulture) + @",
+          ""lng"": " + meeting.Location.Longitude.ToString(CultureInfo.InvariantCulture) + @"
         }
       },
       ""relationships"": {
         ""attendees"": {
           ""links"": {
-            ""self"": ""http://localhost/meetings/" + meetings[0].StringId + @"/relationships/attendees"",
-            ""related"": ""http://localhost/meetings/" + meetings[0].StringId + @"/attendees""
+            ""self"": ""http://localhost/meetings/" + meeting.StringId + @"/relationships/attendees"",
+            ""related"": ""http://localhost/meetings/" + meeting.StringId + @"/attendees""
           },
           ""data"": []
         }
       },
       ""links"": {
-        ""self"": ""http://localhost/meetings/" + meetings[0].StringId + @"""
+        ""self"": ""http://localhost/meetings/" + meeting.StringId + @"""
       }
     }
   ],
@@ -290,6 +340,9 @@ public async Task Cannot_get_unknown_primary_resource_by_ID()
             string errorId = JsonApiStringConverter.ExtractErrorId(responseDocument);
 
             responseDocument.Should().BeJson(@"{
+  ""links"": {
+    ""self"": ""http://localhost/meetings/ffffffff-ffff-ffff-ffff-ffffffffffff""
+  },
   ""errors"": [
     {
       ""id"": """ + errorId + @""",
@@ -761,6 +814,9 @@ public async Task Includes_version_on_error_in_resource_endpoint()
   ""jsonapi"": {
     ""version"": ""1.1""
   },
+  ""links"": {
+    ""self"": ""http://localhost/meetingAttendees/ffffffff-ffff-ffff-ffff-ffffffffffff""
+  },
   ""errors"": [
     {
       ""id"": """ + errorId + @""",
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/SoftDeletion/SoftDeletionAwareResourceService.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/SoftDeletion/SoftDeletionAwareResourceService.cs
index 68ac5a6942..6c5cd0aa98 100644
--- a/test/JsonApiDotNetCoreTests/IntegrationTests/SoftDeletion/SoftDeletionAwareResourceService.cs
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/SoftDeletion/SoftDeletionAwareResourceService.cs
@@ -41,7 +41,7 @@ public SoftDeletionAwareResourceService(ISystemClock systemClock, ITargetedField
 
         public override async Task<TResource> CreateAsync(TResource resource, CancellationToken cancellationToken)
         {
-            if (_targetedFields.Relationships.Any(relationship => IsSoftDeletable(relationship.RightType)))
+            if (_targetedFields.Relationships.Any(relationship => IsSoftDeletable(relationship.RightType.ClrType)))
             {
                 await AssertResourcesToAssignInRelationshipsExistAsync(resource, cancellationToken);
             }
@@ -51,7 +51,7 @@ public override async Task<TResource> CreateAsync(TResource resource, Cancellati
 
         public override async Task<TResource> UpdateAsync(TId id, TResource resource, CancellationToken cancellationToken)
         {
-            if (_targetedFields.Relationships.Any(relationship => IsSoftDeletable(relationship.RightType)))
+            if (_targetedFields.Relationships.Any(relationship => IsSoftDeletable(relationship.RightType.ClrType)))
             {
                 await AssertResourcesToAssignInRelationshipsExistAsync(resource, cancellationToken);
             }
@@ -61,7 +61,7 @@ public override async Task<TResource> UpdateAsync(TId id, TResource resource, Ca
 
         public override async Task SetRelationshipAsync(TId leftId, string relationshipName, object rightValue, CancellationToken cancellationToken)
         {
-            if (IsSoftDeletable(_request.Relationship.RightType))
+            if (IsSoftDeletable(_request.Relationship.RightType.ClrType))
             {
                 await AssertRightResourcesExistAsync(rightValue, cancellationToken);
             }
@@ -77,7 +77,7 @@ public override async Task AddToToManyRelationshipAsync(TId leftId, string relat
                 _ = await GetPrimaryResourceByIdAsync(leftId, TopFieldSelection.OnlyIdAttribute, cancellationToken);
             }
 
-            if (IsSoftDeletable(_request.Relationship.RightType))
+            if (IsSoftDeletable(_request.Relationship.RightType.ClrType))
             {
                 await AssertRightResourcesExistAsync(rightResourceIds, cancellationToken);
             }
@@ -107,9 +107,9 @@ private async Task SoftDeleteAsync(TId id, CancellationToken cancellationToken)
             await _repositoryAccessor.UpdateAsync(resourceFromDatabase, resourceFromDatabase, cancellationToken);
         }
 
-        private static bool IsSoftDeletable(Type resourceType)
+        private static bool IsSoftDeletable(Type resourceClrType)
         {
-            return typeof(ISoftDeletable).IsAssignableFrom(resourceType);
+            return typeof(ISoftDeletable).IsAssignableFrom(resourceClrType);
         }
     }
 
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/Links/LinkInclusionTests.cs b/test/JsonApiDotNetCoreTests/UnitTests/Links/LinkInclusionTests.cs
index deceb19902..84546eefd0 100644
--- a/test/JsonApiDotNetCoreTests/UnitTests/Links/LinkInclusionTests.cs
+++ b/test/JsonApiDotNetCoreTests/UnitTests/Links/LinkInclusionTests.cs
@@ -1,13 +1,12 @@
 using System;
 using FluentAssertions;
-using JsonApiDotNetCore;
 using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Middleware;
 using JsonApiDotNetCore.Queries;
 using JsonApiDotNetCore.Resources;
 using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization.Building;
 using JsonApiDotNetCore.Serialization.Objects;
+using JsonApiDotNetCore.Serialization.Response;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Routing;
 using Xunit;
@@ -53,11 +52,10 @@ public sealed class LinkInclusionTests
         [InlineData(LinkTypes.All, LinkTypes.Related, LinkTypes.All)]
         [InlineData(LinkTypes.All, LinkTypes.Paging, LinkTypes.All)]
         [InlineData(LinkTypes.All, LinkTypes.All, LinkTypes.All)]
-        public void Applies_cascading_settings_for_top_level_links(LinkTypes linksInResourceContext, LinkTypes linksInOptions, LinkTypes expected)
+        public void Applies_cascading_settings_for_top_level_links(LinkTypes linksInResourceType, LinkTypes linksInOptions, LinkTypes expected)
         {
             // Arrange
-            var exampleResourceContext = new ResourceContext(nameof(ExampleResource), typeof(ExampleResource), typeof(int), Array.Empty<AttrAttribute>(),
-                Array.Empty<RelationshipAttribute>(), Array.Empty<EagerLoadAttribute>(), linksInResourceContext);
+            var exampleResourceType = new ResourceType(nameof(ExampleResource), typeof(ExampleResource), typeof(int), topLevelLinks: linksInResourceType);
 
             var options = new JsonApiOptions
             {
@@ -66,7 +64,7 @@ public void Applies_cascading_settings_for_top_level_links(LinkTypes linksInReso
 
             var request = new JsonApiRequest
             {
-                PrimaryResource = exampleResourceContext,
+                PrimaryResourceType = exampleResourceType,
                 PrimaryId = "1",
                 IsCollection = true,
                 Kind = EndpointKind.Relationship,
@@ -80,13 +78,10 @@ public void Applies_cascading_settings_for_top_level_links(LinkTypes linksInReso
                 TotalResourceCount = 10
             };
 
-            var resourceGraph = new ResourceGraph(exampleResourceContext.AsHashSet());
             var httpContextAccessor = new FakeHttpContextAccessor();
             var linkGenerator = new FakeLinkGenerator();
             var controllerResourceMapping = new FakeControllerResourceMapping();
-
-            var linkBuilder = new LinkBuilder(options, request, paginationContext, resourceGraph, httpContextAccessor, linkGenerator,
-                controllerResourceMapping);
+            var linkBuilder = new LinkBuilder(options, request, paginationContext, httpContextAccessor, linkGenerator, controllerResourceMapping);
 
             // Act
             TopLevelLinks topLevelLinks = linkBuilder.GetTopLevelLinks();
@@ -150,11 +145,10 @@ public void Applies_cascading_settings_for_top_level_links(LinkTypes linksInReso
         [InlineData(LinkTypes.All, LinkTypes.None, LinkTypes.Self)]
         [InlineData(LinkTypes.All, LinkTypes.Self, LinkTypes.Self)]
         [InlineData(LinkTypes.All, LinkTypes.All, LinkTypes.Self)]
-        public void Applies_cascading_settings_for_resource_links(LinkTypes linksInResourceContext, LinkTypes linksInOptions, LinkTypes expected)
+        public void Applies_cascading_settings_for_resource_links(LinkTypes linksInResourceType, LinkTypes linksInOptions, LinkTypes expected)
         {
             // Arrange
-            var exampleResourceContext = new ResourceContext(nameof(ExampleResource), typeof(ExampleResource), typeof(int), Array.Empty<AttrAttribute>(),
-                Array.Empty<RelationshipAttribute>(), Array.Empty<EagerLoadAttribute>(), resourceLinks: linksInResourceContext);
+            var exampleResourceType = new ResourceType(nameof(ExampleResource), typeof(ExampleResource), typeof(int), resourceLinks: linksInResourceType);
 
             var options = new JsonApiOptions
             {
@@ -163,16 +157,13 @@ public void Applies_cascading_settings_for_resource_links(LinkTypes linksInResou
 
             var request = new JsonApiRequest();
             var paginationContext = new PaginationContext();
-            var resourceGraph = new ResourceGraph(exampleResourceContext.AsHashSet());
             var httpContextAccessor = new FakeHttpContextAccessor();
             var linkGenerator = new FakeLinkGenerator();
             var controllerResourceMapping = new FakeControllerResourceMapping();
-
-            var linkBuilder = new LinkBuilder(options, request, paginationContext, resourceGraph, httpContextAccessor, linkGenerator,
-                controllerResourceMapping);
+            var linkBuilder = new LinkBuilder(options, request, paginationContext, httpContextAccessor, linkGenerator, controllerResourceMapping);
 
             // Act
-            ResourceLinks resourceLinks = linkBuilder.GetResourceLinks(nameof(ExampleResource), "id");
+            ResourceLinks resourceLinks = linkBuilder.GetResourceLinks(exampleResourceType, "id");
 
             // Assert
             if (expected == LinkTypes.Self)
@@ -311,12 +302,11 @@ public void Applies_cascading_settings_for_resource_links(LinkTypes linksInResou
         [InlineData(LinkTypes.All, LinkTypes.All, LinkTypes.Self, LinkTypes.All)]
         [InlineData(LinkTypes.All, LinkTypes.All, LinkTypes.Related, LinkTypes.All)]
         [InlineData(LinkTypes.All, LinkTypes.All, LinkTypes.All, LinkTypes.All)]
-        public void Applies_cascading_settings_for_relationship_links(LinkTypes linksInRelationshipAttribute, LinkTypes linksInResourceContext,
+        public void Applies_cascading_settings_for_relationship_links(LinkTypes linksInRelationshipAttribute, LinkTypes linksInResourceType,
             LinkTypes linksInOptions, LinkTypes expected)
         {
             // Arrange
-            var exampleResourceContext = new ResourceContext(nameof(ExampleResource), typeof(ExampleResource), typeof(int), Array.Empty<AttrAttribute>(),
-                Array.Empty<RelationshipAttribute>(), Array.Empty<EagerLoadAttribute>(), relationshipLinks: linksInResourceContext);
+            var exampleResourceType = new ResourceType(nameof(ExampleResource), typeof(ExampleResource), typeof(int), relationshipLinks: linksInResourceType);
 
             var options = new JsonApiOptions
             {
@@ -325,17 +315,15 @@ public void Applies_cascading_settings_for_relationship_links(LinkTypes linksInR
 
             var request = new JsonApiRequest();
             var paginationContext = new PaginationContext();
-            var resourceGraph = new ResourceGraph(exampleResourceContext.AsHashSet());
             var httpContextAccessor = new FakeHttpContextAccessor();
             var linkGenerator = new FakeLinkGenerator();
             var controllerResourceMapping = new FakeControllerResourceMapping();
-
-            var linkBuilder = new LinkBuilder(options, request, paginationContext, resourceGraph, httpContextAccessor, linkGenerator,
-                controllerResourceMapping);
+            var linkBuilder = new LinkBuilder(options, request, paginationContext, httpContextAccessor, linkGenerator, controllerResourceMapping);
 
             var relationship = new HasOneAttribute
             {
-                Links = linksInRelationshipAttribute
+                Links = linksInRelationshipAttribute,
+                LeftType = exampleResourceType
             };
 
             // Act
@@ -386,12 +374,12 @@ private sealed class FakeHttpContextAccessor : IHttpContextAccessor
 
         private sealed class FakeControllerResourceMapping : IControllerResourceMapping
         {
-            public Type GetResourceTypeForController(Type controllerType)
+            public ResourceType TryGetResourceTypeForController(Type controllerType)
             {
                 throw new NotImplementedException();
             }
 
-            public string GetControllerNameForResourceType(Type resourceType)
+            public string TryGetControllerNameForResourceType(ResourceType resourceType)
             {
                 return null;
             }
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/BaseParseTests.cs b/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/BaseParseTests.cs
index 9d55b6fe3c..193a5c1ea9 100644
--- a/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/BaseParseTests.cs
+++ b/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/BaseParseTests.cs
@@ -25,6 +25,7 @@ protected BaseParseTests()
                 .Add<Comment>()
                 .Add<WebAccount>()
                 .Add<AccountPreferences>()
+                .Add<LoginAttempt>()
                 .Build();
 
             // @formatter:wrap_chained_method_calls restore
@@ -32,7 +33,7 @@ protected BaseParseTests()
 
             Request = new JsonApiRequest
             {
-                PrimaryResource = ResourceGraph.GetResourceContext<Blog>(),
+                PrimaryResourceType = ResourceGraph.GetResourceType<Blog>(),
                 IsCollection = true
             };
         }
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/FilterParseTests.cs b/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/FilterParseTests.cs
index b628a06167..966c6ef1ae 100644
--- a/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/FilterParseTests.cs
+++ b/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/FilterParseTests.cs
@@ -58,14 +58,15 @@ public void Reader_Is_Enabled(JsonApiQueryStringParameters parametersDisabled, b
 
         [Theory]
         [InlineData("filter[", "equals(caption,'some')", "Field name expected.")]
-        [InlineData("filter[caption]", "equals(url,'some')", "Relationship 'caption' does not exist on resource 'blogs'.")]
-        [InlineData("filter[posts.caption]", "equals(firstName,'some')", "Relationship 'caption' in 'posts.caption' does not exist on resource 'blogPosts'.")]
+        [InlineData("filter[caption]", "equals(url,'some')", "Relationship 'caption' does not exist on resource type 'blogs'.")]
+        [InlineData("filter[posts.caption]", "equals(firstName,'some')",
+            "Relationship 'caption' in 'posts.caption' does not exist on resource type 'blogPosts'.")]
         [InlineData("filter[posts.author]", "equals(firstName,'some')",
-            "Relationship 'author' in 'posts.author' must be a to-many relationship on resource 'blogPosts'.")]
+            "Relationship 'author' in 'posts.author' must be a to-many relationship on resource type 'blogPosts'.")]
         [InlineData("filter[posts.comments.author]", "equals(firstName,'some')",
-            "Relationship 'author' in 'posts.comments.author' must be a to-many relationship on resource 'comments'.")]
-        [InlineData("filter[posts]", "equals(author,'some')", "Attribute 'author' does not exist on resource 'blogPosts'.")]
-        [InlineData("filter[posts]", "lessThan(author,null)", "Attribute 'author' does not exist on resource 'blogPosts'.")]
+            "Relationship 'author' in 'posts.comments.author' must be a to-many relationship on resource type 'comments'.")]
+        [InlineData("filter[posts]", "equals(author,'some')", "Attribute 'author' does not exist on resource type 'blogPosts'.")]
+        [InlineData("filter[posts]", "lessThan(author,null)", "Attribute 'author' does not exist on resource type 'blogPosts'.")]
         [InlineData("filter", " ", "Unexpected whitespace.")]
         [InlineData("filter", "contains(owner.displayName, )", "Unexpected whitespace.")]
         [InlineData("filter", "some", "Filter function expected.")]
@@ -76,19 +77,19 @@ public void Reader_Is_Enabled(JsonApiQueryStringParameters parametersDisabled, b
         [InlineData("filter", "equals(count(posts),", "Count function, value between quotes, null or field name expected.")]
         [InlineData("filter", "equals(title,')", "' expected.")]
         [InlineData("filter", "equals(title,null", ") expected.")]
-        [InlineData("filter", "equals(null", "Field 'null' does not exist on resource 'blogs'.")]
+        [InlineData("filter", "equals(null", "Field 'null' does not exist on resource type 'blogs'.")]
         [InlineData("filter", "equals(title,(", "Count function, value between quotes, null or field name expected.")]
-        [InlineData("filter", "equals(has(posts),'true')", "Field 'has' does not exist on resource 'blogs'.")]
+        [InlineData("filter", "equals(has(posts),'true')", "Field 'has' does not exist on resource type 'blogs'.")]
         [InlineData("filter", "has(posts,", "Filter function expected.")]
         [InlineData("filter", "contains)", "( expected.")]
         [InlineData("filter", "contains(title,'a','b')", ") expected.")]
         [InlineData("filter", "contains(title,null)", "Value between quotes expected.")]
-        [InlineData("filter[posts]", "contains(author,null)", "Attribute 'author' does not exist on resource 'blogPosts'.")]
-        [InlineData("filter", "any(null,'a','b')", "Attribute 'null' does not exist on resource 'blogs'.")]
+        [InlineData("filter[posts]", "contains(author,null)", "Attribute 'author' does not exist on resource type 'blogPosts'.")]
+        [InlineData("filter", "any(null,'a','b')", "Attribute 'null' does not exist on resource type 'blogs'.")]
         [InlineData("filter", "any('a','b','c')", "Field name expected.")]
         [InlineData("filter", "any(title,'b','c',)", "Value between quotes expected.")]
         [InlineData("filter", "any(title,'b')", ", expected.")]
-        [InlineData("filter[posts]", "any(author,'a','b')", "Attribute 'author' does not exist on resource 'blogPosts'.")]
+        [InlineData("filter[posts]", "any(author,'a','b')", "Attribute 'author' does not exist on resource type 'blogPosts'.")]
         [InlineData("filter", "and(", "Filter function expected.")]
         [InlineData("filter", "or(equals(title,'some'),equals(title,'other')", ") expected.")]
         [InlineData("filter", "or(equals(title,'some'),equals(title,'other')))", "End of expression expected.")]
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/IncludeParseTests.cs b/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/IncludeParseTests.cs
index 30af87ab5c..afa922ebcc 100644
--- a/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/IncludeParseTests.cs
+++ b/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/IncludeParseTests.cs
@@ -56,9 +56,9 @@ public void Reader_Is_Enabled(JsonApiQueryStringParameters parametersDisabled, b
         [InlineData("includes", ",", "Relationship name expected.")]
         [InlineData("includes", "posts,", "Relationship name expected.")]
         [InlineData("includes", "posts[", ", expected.")]
-        [InlineData("includes", "title", "Relationship 'title' does not exist on resource 'blogs'.")]
+        [InlineData("includes", "title", "Relationship 'title' does not exist on resource type 'blogs'.")]
         [InlineData("includes", "posts.comments.publishTime,",
-            "Relationship 'publishTime' in 'posts.comments.publishTime' does not exist on resource 'comments'.")]
+            "Relationship 'publishTime' in 'posts.comments.publishTime' does not exist on resource type 'comments'.")]
         public void Reader_Read_Fails(string parameterName, string parameterValue, string errorMessage)
         {
             // Act
@@ -82,7 +82,7 @@ public void Reader_Read_Fails(string parameterName, string parameterValue, strin
         [InlineData("includes", "posts.author", "posts.author")]
         [InlineData("includes", "posts.comments", "posts.comments")]
         [InlineData("includes", "posts,posts.comments", "posts.comments")]
-        [InlineData("includes", "posts,posts.comments,posts.labels", "posts.comments,posts.labels")]
+        [InlineData("includes", "posts,posts.labels,posts.comments", "posts.comments,posts.labels")]
         public void Reader_Read_Succeeds(string parameterName, string parameterValue, string valueExpected)
         {
             // Act
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/LegacyFilterParseTests.cs b/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/LegacyFilterParseTests.cs
index 1c447a297a..0210db3140 100644
--- a/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/LegacyFilterParseTests.cs
+++ b/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/LegacyFilterParseTests.cs
@@ -22,7 +22,7 @@ public LegacyFilterParseTests()
         {
             Options.EnableLegacyFilterNotation = true;
 
-            Request.PrimaryResource = ResourceGraph.GetResourceContext<BlogPost>();
+            Request.PrimaryResourceType = ResourceGraph.GetResourceType<BlogPost>();
 
             var resourceFactory = new ResourceFactory(new ServiceContainer());
             _reader = new FilterQueryStringParameterReader(Request, ResourceGraph, resourceFactory, Options);
@@ -32,15 +32,16 @@ public LegacyFilterParseTests()
         [InlineData("filter", "some", "Expected field name between brackets in filter parameter name.")]
         [InlineData("filter[", "some", "Expected field name between brackets in filter parameter name.")]
         [InlineData("filter[]", "some", "Expected field name between brackets in filter parameter name.")]
-        [InlineData("filter[.]", "some", "Relationship '' in '.' does not exist on resource 'blogPosts'.")]
-        [InlineData("filter[some]", "other", "Field 'some' does not exist on resource 'blogPosts'.")]
-        [InlineData("filter[author]", "some", "Attribute 'author' does not exist on resource 'blogPosts'.")]
-        [InlineData("filter[author.posts]", "some", "Field 'posts' in 'author.posts' must be an attribute or a to-one relationship on resource 'webAccounts'.")]
-        [InlineData("filter[unknown.id]", "some", "Relationship 'unknown' in 'unknown.id' does not exist on resource 'blogPosts'.")]
-        [InlineData("filter", "expr:equals(some,'other')", "Field 'some' does not exist on resource 'blogPosts'.")]
-        [InlineData("filter", "expr:equals(author,'Joe')", "Attribute 'author' does not exist on resource 'blogPosts'.")]
-        [InlineData("filter", "expr:has(author)", "Relationship 'author' must be a to-many relationship on resource 'blogPosts'.")]
-        [InlineData("filter", "expr:equals(count(author),'1')", "Relationship 'author' must be a to-many relationship on resource 'blogPosts'.")]
+        [InlineData("filter[.]", "some", "Relationship '' in '.' does not exist on resource type 'blogPosts'.")]
+        [InlineData("filter[some]", "other", "Field 'some' does not exist on resource type 'blogPosts'.")]
+        [InlineData("filter[author]", "some", "Attribute 'author' does not exist on resource type 'blogPosts'.")]
+        [InlineData("filter[author.posts]", "some",
+            "Field 'posts' in 'author.posts' must be an attribute or a to-one relationship on resource type 'webAccounts'.")]
+        [InlineData("filter[unknown.id]", "some", "Relationship 'unknown' in 'unknown.id' does not exist on resource type 'blogPosts'.")]
+        [InlineData("filter", "expr:equals(some,'other')", "Field 'some' does not exist on resource type 'blogPosts'.")]
+        [InlineData("filter", "expr:equals(author,'Joe')", "Attribute 'author' does not exist on resource type 'blogPosts'.")]
+        [InlineData("filter", "expr:has(author)", "Relationship 'author' must be a to-many relationship on resource type 'blogPosts'.")]
+        [InlineData("filter", "expr:equals(count(author),'1')", "Relationship 'author' must be a to-many relationship on resource type 'blogPosts'.")]
         public void Reader_Read_Fails(string parameterName, string parameterValue, string errorMessage)
         {
             // Act
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/PaginationParseTests.cs b/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/PaginationParseTests.cs
index 71afbca69f..924569618d 100644
--- a/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/PaginationParseTests.cs
+++ b/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/PaginationParseTests.cs
@@ -66,10 +66,10 @@ public void Reader_Is_Enabled(JsonApiQueryStringParameters parametersDisabled, b
         [InlineData("1(", ", expected.")]
         [InlineData("posts:-abc", "Digits expected.")]
         [InlineData("posts:-1", "Page number cannot be negative or zero.")]
-        [InlineData("posts.id", "Relationship 'id' in 'posts.id' does not exist on resource 'blogPosts'.")]
-        [InlineData("posts.comments.id", "Relationship 'id' in 'posts.comments.id' does not exist on resource 'comments'.")]
-        [InlineData("posts.author", "Relationship 'author' in 'posts.author' must be a to-many relationship on resource 'blogPosts'.")]
-        [InlineData("something", "Relationship 'something' does not exist on resource 'blogs'.")]
+        [InlineData("posts.id", "Relationship 'id' in 'posts.id' does not exist on resource type 'blogPosts'.")]
+        [InlineData("posts.comments.id", "Relationship 'id' in 'posts.comments.id' does not exist on resource type 'comments'.")]
+        [InlineData("posts.author", "Relationship 'author' in 'posts.author' must be a to-many relationship on resource type 'blogPosts'.")]
+        [InlineData("something", "Relationship 'something' does not exist on resource type 'blogs'.")]
         public void Reader_Read_Page_Number_Fails(string parameterValue, string errorMessage)
         {
             // Act
@@ -99,10 +99,10 @@ public void Reader_Read_Page_Number_Fails(string parameterValue, string errorMes
         [InlineData("1(", ", expected.")]
         [InlineData("posts:-abc", "Digits expected.")]
         [InlineData("posts:-1", "Page size cannot be negative.")]
-        [InlineData("posts.id", "Relationship 'id' in 'posts.id' does not exist on resource 'blogPosts'.")]
-        [InlineData("posts.comments.id", "Relationship 'id' in 'posts.comments.id' does not exist on resource 'comments'.")]
-        [InlineData("posts.author", "Relationship 'author' in 'posts.author' must be a to-many relationship on resource 'blogPosts'.")]
-        [InlineData("something", "Relationship 'something' does not exist on resource 'blogs'.")]
+        [InlineData("posts.id", "Relationship 'id' in 'posts.id' does not exist on resource type 'blogPosts'.")]
+        [InlineData("posts.comments.id", "Relationship 'id' in 'posts.comments.id' does not exist on resource type 'comments'.")]
+        [InlineData("posts.author", "Relationship 'author' in 'posts.author' must be a to-many relationship on resource type 'blogPosts'.")]
+        [InlineData("something", "Relationship 'something' does not exist on resource type 'blogs'.")]
         public void Reader_Read_Page_Size_Fails(string parameterValue, string errorMessage)
         {
             // Act
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/SortParseTests.cs b/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/SortParseTests.cs
index b5776bfbbf..4c4d29acbb 100644
--- a/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/SortParseTests.cs
+++ b/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/SortParseTests.cs
@@ -54,22 +54,23 @@ public void Reader_Is_Enabled(JsonApiQueryStringParameters parametersDisabled, b
 
         [Theory]
         [InlineData("sort[", "id", "Field name expected.")]
-        [InlineData("sort[abc.def]", "id", "Relationship 'abc' in 'abc.def' does not exist on resource 'blogs'.")]
-        [InlineData("sort[posts.author]", "id", "Relationship 'author' in 'posts.author' must be a to-many relationship on resource 'blogPosts'.")]
+        [InlineData("sort[abc.def]", "id", "Relationship 'abc' in 'abc.def' does not exist on resource type 'blogs'.")]
+        [InlineData("sort[posts.author]", "id", "Relationship 'author' in 'posts.author' must be a to-many relationship on resource type 'blogPosts'.")]
         [InlineData("sort", "", "-, count function or field name expected.")]
         [InlineData("sort", " ", "Unexpected whitespace.")]
         [InlineData("sort", "-", "Count function or field name expected.")]
-        [InlineData("sort", "abc", "Attribute 'abc' does not exist on resource 'blogs'.")]
-        [InlineData("sort[posts]", "author", "Attribute 'author' does not exist on resource 'blogPosts'.")]
-        [InlineData("sort[posts]", "author.livingAddress", "Attribute 'livingAddress' in 'author.livingAddress' does not exist on resource 'webAccounts'.")]
+        [InlineData("sort", "abc", "Attribute 'abc' does not exist on resource type 'blogs'.")]
+        [InlineData("sort[posts]", "author", "Attribute 'author' does not exist on resource type 'blogPosts'.")]
+        [InlineData("sort[posts]", "author.livingAddress",
+            "Attribute 'livingAddress' in 'author.livingAddress' does not exist on resource type 'webAccounts'.")]
         [InlineData("sort", "-count", "( expected.")]
         [InlineData("sort", "count", "( expected.")]
         [InlineData("sort", "count(posts", ") expected.")]
         [InlineData("sort", "count(", "Field name expected.")]
         [InlineData("sort", "count(-abc)", "Field name expected.")]
-        [InlineData("sort", "count(abc)", "Relationship 'abc' does not exist on resource 'blogs'.")]
-        [InlineData("sort", "count(id)", "Relationship 'id' does not exist on resource 'blogs'.")]
-        [InlineData("sort[posts]", "count(author)", "Relationship 'author' must be a to-many relationship on resource 'blogPosts'.")]
+        [InlineData("sort", "count(abc)", "Relationship 'abc' does not exist on resource type 'blogs'.")]
+        [InlineData("sort", "count(id)", "Relationship 'id' does not exist on resource type 'blogs'.")]
+        [InlineData("sort[posts]", "count(author)", "Relationship 'author' must be a to-many relationship on resource type 'blogPosts'.")]
         [InlineData("sort[posts]", "caption,", "-, count function or field name expected.")]
         [InlineData("sort[posts]", "caption:", ", expected.")]
         [InlineData("sort[posts]", "caption,-", "Count function or field name expected.")]
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/SparseFieldSetParseTests.cs b/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/SparseFieldSetParseTests.cs
index fb017cfd9b..8142160429 100644
--- a/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/SparseFieldSetParseTests.cs
+++ b/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/SparseFieldSetParseTests.cs
@@ -61,11 +61,11 @@ public void Reader_Is_Enabled(JsonApiQueryStringParameters parametersDisabled, b
         [InlineData("fields[owner]", "", "Resource type 'owner' does not exist.")]
         [InlineData("fields[owner.posts]", "id", "Resource type 'owner.posts' does not exist.")]
         [InlineData("fields[blogPosts]", " ", "Unexpected whitespace.")]
-        [InlineData("fields[blogPosts]", "some", "Field 'some' does not exist on resource 'blogPosts'.")]
-        [InlineData("fields[blogPosts]", "id,owner.name", "Field 'owner.name' does not exist on resource 'blogPosts'.")]
+        [InlineData("fields[blogPosts]", "some", "Field 'some' does not exist on resource type 'blogPosts'.")]
+        [InlineData("fields[blogPosts]", "id,owner.name", "Field 'owner.name' does not exist on resource type 'blogPosts'.")]
         [InlineData("fields[blogPosts]", "id(", ", expected.")]
         [InlineData("fields[blogPosts]", "id,", "Field name expected.")]
-        [InlineData("fields[blogPosts]", "author.id,", "Field 'author.id' does not exist on resource 'blogPosts'.")]
+        [InlineData("fields[blogPosts]", "author.id,", "Field 'author.id' does not exist on resource type 'blogPosts'.")]
         public void Reader_Read_Fails(string parameterName, string parameterValue, string errorMessage)
         {
             // Act
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/Serialization/InputConversionTests.cs b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/InputConversionTests.cs
new file mode 100644
index 0000000000..5bca89bad2
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/InputConversionTests.cs
@@ -0,0 +1,352 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Design;
+using FluentAssertions;
+using FluentAssertions.Extensions;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Serialization.JsonConverters;
+using JsonApiDotNetCore.Serialization.Objects;
+using JsonApiDotNetCore.Serialization.Request.Adapters;
+using Microsoft.Extensions.Logging.Abstractions;
+using Xunit;
+
+namespace JsonApiDotNetCoreTests.UnitTests.Serialization
+{
+    public sealed class InputConversionTests
+    {
+        [Fact]
+        public void Converts_various_data_types_with_values()
+        {
+            // Arrange
+            DocumentAdapter documentAdapter = CreateDocumentAdapter<ResourceWithVariousDataTypes>(resourceGraph => new JsonApiRequest
+            {
+                Kind = EndpointKind.Primary,
+                PrimaryResourceType = resourceGraph.GetResourceType<ResourceWithVariousDataTypes>(),
+                WriteOperation = WriteOperationKind.CreateResource
+            });
+
+            const bool booleanValue = true;
+            const bool nullableBooleanValue = false;
+            const char charValue = 'A';
+            const char nullableCharValue = '?';
+            const ulong unsignedLongValue = ulong.MaxValue;
+            const ulong nullableUnsignedLongValue = 9_000_000_000UL;
+            const decimal decimalValue = 19.95m;
+            const decimal nullableDecimalValue = 12.50m;
+            const float floatValue = (float)1 / 3;
+            const float nullableFloatValue = (float)3 / 5;
+            const string stringValue = "text";
+            var guidValue = Guid.NewGuid();
+            var nullableGuidValue = Guid.NewGuid();
+            DateTime dateTimeValue = 12.July(1982);
+            DateTime nullableDateTimeValue = 18.October(2028);
+            DateTimeOffset dateTimeOffsetValue = 3.March(1999).WithOffset(7.Hours());
+            DateTimeOffset nullableDateTimeOffsetValue = 28.February(2009).WithOffset(-2.Hours());
+            TimeSpan timeSpanValue = 4.Hours().And(58.Minutes());
+            TimeSpan nullableTimeSpanValue = 35.Seconds().And(44.Milliseconds());
+            const DayOfWeek enumValue = DayOfWeek.Wednesday;
+            const DayOfWeek nullableEnumValue = DayOfWeek.Sunday;
+
+            var complexObject = new ComplexObject
+            {
+                Value = "Single"
+            };
+
+            var complexObjectList = new List<ComplexObject>
+            {
+                new()
+                {
+                    Value = "One"
+                },
+                new()
+                {
+                    Value = "Two"
+                }
+            };
+
+            var document = new Document
+            {
+                Data = new SingleOrManyData<ResourceObject>(new ResourceObject
+                {
+                    Type = "resourceWithVariousDataTypes",
+                    Attributes = new Dictionary<string, object>
+                    {
+                        ["boolean"] = booleanValue,
+                        ["nullableBoolean"] = nullableBooleanValue,
+                        ["char"] = charValue,
+                        ["nullableChar"] = nullableCharValue,
+                        ["unsignedLong"] = unsignedLongValue,
+                        ["nullableUnsignedLong"] = nullableUnsignedLongValue,
+                        ["decimal"] = decimalValue,
+                        ["nullableDecimal"] = nullableDecimalValue,
+                        ["float"] = floatValue,
+                        ["nullableFloat"] = nullableFloatValue,
+                        ["string"] = stringValue,
+                        ["guid"] = guidValue,
+                        ["nullableGuid"] = nullableGuidValue,
+                        ["dateTime"] = dateTimeValue,
+                        ["nullableDateTime"] = nullableDateTimeValue,
+                        ["dateTimeOffset"] = dateTimeOffsetValue,
+                        ["nullableDateTimeOffset"] = nullableDateTimeOffsetValue,
+                        ["timeSpan"] = timeSpanValue,
+                        ["nullableTimeSpan"] = nullableTimeSpanValue,
+                        ["enum"] = enumValue,
+                        ["nullableEnum"] = nullableEnumValue,
+                        ["complexObject"] = complexObject,
+                        ["complexObjectList"] = complexObjectList
+                    }
+                })
+            };
+
+            // Act
+            var model = (ResourceWithVariousDataTypes)documentAdapter.Convert(document);
+
+            // Assert
+            model.Should().NotBeNull();
+
+            model.Boolean.Should().Be(booleanValue);
+            model.NullableBoolean.Should().Be(nullableBooleanValue);
+            model.Char.Should().Be(charValue);
+            model.NullableChar.Should().Be(nullableCharValue);
+            model.UnsignedLong.Should().Be(unsignedLongValue);
+            model.NullableUnsignedLong.Should().Be(nullableUnsignedLongValue);
+            model.Decimal.Should().Be(decimalValue);
+            model.NullableDecimal.Should().Be(nullableDecimalValue);
+            model.Float.Should().Be(floatValue);
+            model.NullableFloat.Should().Be(nullableFloatValue);
+            model.String.Should().Be(stringValue);
+            model.Guid.Should().Be(guidValue);
+            model.NullableGuid.Should().Be(nullableGuidValue);
+            model.DateTime.Should().Be(dateTimeValue);
+            model.NullableDateTime.Should().Be(nullableDateTimeValue);
+            model.DateTimeOffset.Should().Be(dateTimeOffsetValue);
+            model.NullableDateTimeOffset.Should().Be(nullableDateTimeOffsetValue);
+            model.TimeSpan.Should().Be(timeSpanValue);
+            model.NullableTimeSpan.Should().Be(nullableTimeSpanValue);
+            model.Enum.Should().Be(enumValue);
+            model.NullableEnum.Should().Be(nullableEnumValue);
+
+            model.ComplexObject.Should().NotBeNull();
+            model.ComplexObject.Value.Should().Be(complexObject.Value);
+
+            model.ComplexObjectList.Should().HaveCount(2);
+            model.ComplexObjectList[0].Value.Should().Be(complexObjectList[0].Value);
+            model.ComplexObjectList[1].Value.Should().Be(complexObjectList[1].Value);
+        }
+
+        [Fact]
+        public void Converts_various_data_types_with_defaults()
+        {
+            // Arrange
+            DocumentAdapter documentAdapter = CreateDocumentAdapter<ResourceWithVariousDataTypes>(resourceGraph => new JsonApiRequest
+            {
+                Kind = EndpointKind.Primary,
+                PrimaryResourceType = resourceGraph.GetResourceType<ResourceWithVariousDataTypes>(),
+                WriteOperation = WriteOperationKind.CreateResource
+            });
+
+            const bool booleanValue = default;
+            const bool nullableBooleanValue = default;
+            const char charValue = default;
+            const char nullableCharValue = default;
+            const ulong unsignedLongValue = default;
+            const ulong nullableUnsignedLongValue = default;
+            const decimal decimalValue = default;
+            const decimal nullableDecimalValue = default;
+            const float floatValue = default;
+            const float nullableFloatValue = default;
+            const string stringValue = default;
+            Guid guidValue = default;
+            Guid nullableGuidValue = default;
+            DateTime dateTimeValue = default;
+            DateTime nullableDateTimeValue = default;
+            DateTimeOffset dateTimeOffsetValue = default;
+            DateTimeOffset nullableDateTimeOffsetValue = default;
+            TimeSpan timeSpanValue = default;
+            TimeSpan nullableTimeSpanValue = default;
+            const DayOfWeek enumValue = default;
+            const DayOfWeek nullableEnumValue = default;
+
+            var document = new Document
+            {
+                Data = new SingleOrManyData<ResourceObject>(new ResourceObject
+                {
+                    Type = "resourceWithVariousDataTypes",
+                    Attributes = new Dictionary<string, object>
+                    {
+                        ["boolean"] = booleanValue,
+                        ["nullableBoolean"] = nullableBooleanValue,
+                        ["char"] = charValue,
+                        ["nullableChar"] = nullableCharValue,
+                        ["unsignedLong"] = unsignedLongValue,
+                        ["nullableUnsignedLong"] = nullableUnsignedLongValue,
+                        ["decimal"] = decimalValue,
+                        ["nullableDecimal"] = nullableDecimalValue,
+                        ["float"] = floatValue,
+                        ["nullableFloat"] = nullableFloatValue,
+                        ["string"] = stringValue,
+                        ["guid"] = guidValue,
+                        ["nullableGuid"] = nullableGuidValue,
+                        ["dateTime"] = dateTimeValue,
+                        ["nullableDateTime"] = nullableDateTimeValue,
+                        ["dateTimeOffset"] = dateTimeOffsetValue,
+                        ["nullableDateTimeOffset"] = nullableDateTimeOffsetValue,
+                        ["timeSpan"] = timeSpanValue,
+                        ["nullableTimeSpan"] = nullableTimeSpanValue,
+                        ["enum"] = enumValue,
+                        ["nullableEnum"] = nullableEnumValue,
+                        ["complexObject"] = null,
+                        ["complexObjectList"] = null
+                    }
+                })
+            };
+
+            // Act
+            var model = (ResourceWithVariousDataTypes)documentAdapter.Convert(document);
+
+            // Assert
+            model.Should().NotBeNull();
+
+            model.Boolean.Should().Be(booleanValue);
+            model.NullableBoolean.Should().Be(nullableBooleanValue);
+            model.Char.Should().Be(charValue);
+            model.NullableChar.Should().Be(nullableCharValue);
+            model.UnsignedLong.Should().Be(unsignedLongValue);
+            model.NullableUnsignedLong.Should().Be(nullableUnsignedLongValue);
+            model.Decimal.Should().Be(decimalValue);
+            model.NullableDecimal.Should().Be(nullableDecimalValue);
+            model.Float.Should().Be(floatValue);
+            model.NullableFloat.Should().Be(nullableFloatValue);
+            model.String.Should().Be(stringValue);
+            model.Guid.Should().Be(guidValue);
+            model.NullableGuid.Should().Be(nullableGuidValue);
+            model.DateTime.Should().Be(dateTimeValue);
+            model.NullableDateTime.Should().Be(nullableDateTimeValue);
+            model.DateTimeOffset.Should().Be(dateTimeOffsetValue);
+            model.NullableDateTimeOffset.Should().Be(nullableDateTimeOffsetValue);
+            model.TimeSpan.Should().Be(timeSpanValue);
+            model.NullableTimeSpan.Should().Be(nullableTimeSpanValue);
+            model.Enum.Should().Be(enumValue);
+            model.NullableEnum.Should().Be(nullableEnumValue);
+            model.ComplexObject.Should().BeNull();
+            model.ComplexObjectList.Should().BeNull();
+        }
+
+        private static DocumentAdapter CreateDocumentAdapter<TResource>(Func<IResourceGraph, JsonApiRequest> createRequest)
+            where TResource : Identifiable
+        {
+            var options = new JsonApiOptions();
+            IResourceGraph resourceGraph = new ResourceGraphBuilder(options, NullLoggerFactory.Instance).Add<TResource>().Build();
+            options.SerializerOptions.Converters.Add(new ResourceObjectConverter(resourceGraph));
+
+            var serviceContainer = new ServiceContainer();
+            var resourceFactory = new ResourceFactory(serviceContainer);
+            var resourceDefinitionAccessor = new ResourceDefinitionAccessor(resourceGraph, serviceContainer);
+
+            serviceContainer.AddService(typeof(IResourceDefinitionAccessor), resourceDefinitionAccessor);
+            serviceContainer.AddService(typeof(IResourceDefinition<TResource>), new JsonApiResourceDefinition<TResource>(resourceGraph));
+
+            JsonApiRequest request = createRequest(resourceGraph);
+            var targetedFields = new TargetedFields();
+
+            var resourceIdentifierObjectAdapter = new ResourceIdentifierObjectAdapter(resourceGraph, resourceFactory);
+            var relationshipDataAdapter = new RelationshipDataAdapter(resourceIdentifierObjectAdapter);
+            var resourceObjectAdapter = new ResourceObjectAdapter(resourceGraph, resourceFactory, options, relationshipDataAdapter);
+            var resourceDataAdapter = new ResourceDataAdapter(resourceDefinitionAccessor, resourceObjectAdapter);
+
+            var atomicReferenceAdapter = new AtomicReferenceAdapter(resourceGraph, resourceFactory);
+            var atomicOperationResourceDataAdapter = new ResourceDataInOperationsRequestAdapter(resourceDefinitionAccessor, resourceObjectAdapter);
+
+            var atomicOperationObjectAdapter = new AtomicOperationObjectAdapter(options, atomicReferenceAdapter,
+                atomicOperationResourceDataAdapter, relationshipDataAdapter);
+
+            var resourceDocumentAdapter = new DocumentInResourceOrRelationshipRequestAdapter(options, resourceDataAdapter, relationshipDataAdapter);
+            var operationsDocumentAdapter = new DocumentInOperationsRequestAdapter(options, atomicOperationObjectAdapter);
+
+            return new DocumentAdapter(request, targetedFields, resourceDocumentAdapter, operationsDocumentAdapter);
+        }
+
+        [UsedImplicitly(ImplicitUseTargetFlags.Members)]
+        public sealed class ResourceWithVariousDataTypes : Identifiable
+        {
+            [Attr]
+            public bool Boolean { get; set; }
+
+            [Attr]
+            public bool? NullableBoolean { get; set; }
+
+            [Attr]
+            public char Char { get; set; }
+
+            [Attr]
+            public char? NullableChar { get; set; }
+
+            [Attr]
+            public ulong UnsignedLong { get; set; }
+
+            [Attr]
+            public ulong? NullableUnsignedLong { get; set; }
+
+            [Attr]
+            public decimal Decimal { get; set; }
+
+            [Attr]
+            public decimal? NullableDecimal { get; set; }
+
+            [Attr]
+            public float Float { get; set; }
+
+            [Attr]
+            public float? NullableFloat { get; set; }
+
+            [Attr]
+            public string String { get; set; }
+
+            [Attr]
+            public Guid Guid { get; set; }
+
+            [Attr]
+            public Guid? NullableGuid { get; set; }
+
+            [Attr]
+            public DateTime DateTime { get; set; }
+
+            [Attr]
+            public DateTime? NullableDateTime { get; set; }
+
+            [Attr]
+            public DateTimeOffset DateTimeOffset { get; set; }
+
+            [Attr]
+            public DateTimeOffset? NullableDateTimeOffset { get; set; }
+
+            [Attr]
+            public TimeSpan TimeSpan { get; set; }
+
+            [Attr]
+            public TimeSpan? NullableTimeSpan { get; set; }
+
+            [Attr]
+            public DayOfWeek Enum { get; set; }
+
+            [Attr]
+            public DayOfWeek? NullableEnum { get; set; }
+
+            [Attr]
+            public ComplexObject ComplexObject { get; set; }
+
+            [Attr]
+            public IList<ComplexObject> ComplexObjectList { get; set; }
+        }
+
+        [UsedImplicitly(ImplicitUseTargetFlags.Members)]
+        public sealed class ComplexObject
+        {
+            public string Value { get; set; }
+        }
+    }
+}
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/Models/Article.cs b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/Models/Article.cs
new file mode 100644
index 0000000000..ce79fe44f7
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/Models/Article.cs
@@ -0,0 +1,19 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreTests.UnitTests.Serialization.Response.Models
+{
+    [UsedImplicitly(ImplicitUseTargetFlags.Members)]
+    public sealed class Article : Identifiable
+    {
+        [Attr]
+        public string Title { get; set; }
+
+        [HasOne]
+        public Person Reviewer { get; set; }
+
+        [HasOne]
+        public Person Author { get; set; }
+    }
+}
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/Models/Blog.cs b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/Models/Blog.cs
new file mode 100644
index 0000000000..8438fc2c0a
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/Models/Blog.cs
@@ -0,0 +1,19 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreTests.UnitTests.Serialization.Response.Models
+{
+    [UsedImplicitly(ImplicitUseTargetFlags.Members)]
+    public sealed class Blog : Identifiable
+    {
+        [Attr]
+        public string Title { get; set; }
+
+        [HasOne]
+        public Person Reviewer { get; set; }
+
+        [HasOne]
+        public Person Author { get; set; }
+    }
+}
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/Models/Food.cs b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/Models/Food.cs
new file mode 100644
index 0000000000..5acc9d6bb8
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/Models/Food.cs
@@ -0,0 +1,13 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreTests.UnitTests.Serialization.Response.Models
+{
+    [UsedImplicitly(ImplicitUseTargetFlags.Members)]
+    public sealed class Food : Identifiable
+    {
+        [Attr]
+        public string Dish { get; set; }
+    }
+}
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/Models/Person.cs b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/Models/Person.cs
new file mode 100644
index 0000000000..0c5972b291
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/Models/Person.cs
@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreTests.UnitTests.Serialization.Response.Models
+{
+    [UsedImplicitly(ImplicitUseTargetFlags.Members)]
+    public sealed class Person : Identifiable
+    {
+        [Attr]
+        public string Name { get; set; }
+
+        [HasMany]
+        public ISet<Blog> Blogs { get; set; }
+
+        [HasOne]
+        public Food FavoriteFood { get; set; }
+
+        [HasOne]
+        public Song FavoriteSong { get; set; }
+    }
+}
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/Models/Song.cs b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/Models/Song.cs
new file mode 100644
index 0000000000..6bda0ab81b
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/Models/Song.cs
@@ -0,0 +1,13 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreTests.UnitTests.Serialization.Response.Models
+{
+    [UsedImplicitly(ImplicitUseTargetFlags.Members)]
+    public sealed class Song : Identifiable
+    {
+        [Attr]
+        public string Title { get; set; }
+    }
+}
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/ResponseModelAdapterTests.cs b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/ResponseModelAdapterTests.cs
new file mode 100644
index 0000000000..c19a40fc79
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/ResponseModelAdapterTests.cs
@@ -0,0 +1,718 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using FluentAssertions;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Queries;
+using JsonApiDotNetCore.Queries.Expressions;
+using JsonApiDotNetCore.Queries.Internal;
+using JsonApiDotNetCore.Queries.Internal.Parsing;
+using JsonApiDotNetCore.QueryStrings;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Serialization.Objects;
+using JsonApiDotNetCore.Serialization.Response;
+using JsonApiDotNetCoreTests.UnitTests.Serialization.Response.Models;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging.Abstractions;
+using TestBuildingBlocks;
+using Xunit;
+
+namespace JsonApiDotNetCoreTests.UnitTests.Serialization.Response
+{
+    public sealed class ResponseModelAdapterTests
+    {
+        [Fact]
+        public void Resources_in_deeply_nested_circular_chain_are_written_in_relationship_declaration_order()
+        {
+            // Arrange
+            var fakers = new ResponseSerializationFakers();
+
+            Article article = fakers.Article.Generate();
+            article.Author = fakers.Person.Generate();
+            article.Author.Blogs = fakers.Blog.Generate(2).ToHashSet();
+            article.Author.Blogs.ElementAt(0).Reviewer = article.Author;
+            article.Author.Blogs.ElementAt(1).Reviewer = fakers.Person.Generate();
+            article.Author.FavoriteFood = fakers.Food.Generate();
+            article.Author.Blogs.ElementAt(1).Reviewer.FavoriteFood = fakers.Food.Generate();
+
+            IJsonApiOptions options = new JsonApiOptions();
+            ResponseModelAdapter responseModelAdapter = CreateAdapter(options, article.StringId, "author.blogs.reviewer.favoriteFood");
+
+            // Act
+            Document document = responseModelAdapter.Convert(article);
+
+            // Assert
+            string text = JsonSerializer.Serialize(document, new JsonSerializerOptions(options.SerializerWriteOptions));
+
+            text.Should().BeJson(@"{
+  ""data"": {
+    ""type"": ""articles"",
+    ""id"": ""1"",
+    ""attributes"": {
+      ""title"": ""The SAS microchip is down, quantify the 1080p microchip so we can quantify the SAS microchip!""
+    },
+    ""relationships"": {
+      ""author"": {
+        ""data"": {
+          ""type"": ""people"",
+          ""id"": ""2""
+        }
+      }
+    }
+  },
+  ""included"": [
+    {
+      ""type"": ""people"",
+      ""id"": ""2"",
+      ""attributes"": {
+        ""name"": ""Ernestine Runte""
+      },
+      ""relationships"": {
+        ""blogs"": {
+          ""data"": [
+            {
+              ""type"": ""blogs"",
+              ""id"": ""3""
+            },
+            {
+              ""type"": ""blogs"",
+              ""id"": ""4""
+            }
+          ]
+        },
+        ""favoriteFood"": {
+          ""data"": {
+            ""type"": ""foods"",
+            ""id"": ""6""
+          }
+        }
+      }
+    },
+    {
+      ""type"": ""blogs"",
+      ""id"": ""3"",
+      ""attributes"": {
+        ""title"": ""The SAS microchip is down, quantify the 1080p microchip so we can quantify the SAS microchip!""
+      },
+      ""relationships"": {
+        ""reviewer"": {
+          ""data"": {
+            ""type"": ""people"",
+            ""id"": ""2""
+          }
+        }
+      }
+    },
+    {
+      ""type"": ""blogs"",
+      ""id"": ""4"",
+      ""attributes"": {
+        ""title"": ""I'll connect the mobile ADP card, that should card the ADP card!""
+      },
+      ""relationships"": {
+        ""reviewer"": {
+          ""data"": {
+            ""type"": ""people"",
+            ""id"": ""5""
+          }
+        }
+      }
+    },
+    {
+      ""type"": ""people"",
+      ""id"": ""5"",
+      ""attributes"": {
+        ""name"": ""Doug Shields""
+      },
+      ""relationships"": {
+        ""favoriteFood"": {
+          ""data"": {
+            ""type"": ""foods"",
+            ""id"": ""7""
+          }
+        }
+      }
+    },
+    {
+      ""type"": ""foods"",
+      ""id"": ""7"",
+      ""attributes"": {
+        ""dish"": ""Nostrum totam harum totam voluptatibus.""
+      }
+    },
+    {
+      ""type"": ""foods"",
+      ""id"": ""6"",
+      ""attributes"": {
+        ""dish"": ""Illum assumenda iste quia natus et dignissimos reiciendis.""
+      }
+    }
+  ]
+}");
+        }
+
+        [Fact]
+        public void Resources_in_deeply_nested_circular_chains_are_written_in_relationship_declaration_order_without_duplicates()
+        {
+            // Arrange
+            var fakers = new ResponseSerializationFakers();
+
+            Article article1 = fakers.Article.Generate();
+            article1.Author = fakers.Person.Generate();
+            article1.Author.Blogs = fakers.Blog.Generate(2).ToHashSet();
+            article1.Author.Blogs.ElementAt(0).Reviewer = article1.Author;
+            article1.Author.Blogs.ElementAt(1).Reviewer = fakers.Person.Generate();
+            article1.Author.FavoriteFood = fakers.Food.Generate();
+            article1.Author.Blogs.ElementAt(1).Reviewer.FavoriteFood = fakers.Food.Generate();
+
+            Article article2 = fakers.Article.Generate();
+            article2.Author = article1.Author;
+
+            IJsonApiOptions options = new JsonApiOptions();
+            ResponseModelAdapter responseModelAdapter = CreateAdapter(options, article1.StringId, "author.blogs.reviewer.favoriteFood");
+
+            // Act
+            Document document = responseModelAdapter.Convert(new[]
+            {
+                article1,
+                article2
+            });
+
+            // Assert
+            string text = JsonSerializer.Serialize(document, new JsonSerializerOptions(options.SerializerWriteOptions));
+
+            text.Should().BeJson(@"{
+  ""data"": [
+    {
+      ""type"": ""articles"",
+      ""id"": ""1"",
+      ""attributes"": {
+        ""title"": ""The SAS microchip is down, quantify the 1080p microchip so we can quantify the SAS microchip!""
+      },
+      ""relationships"": {
+        ""author"": {
+          ""data"": {
+            ""type"": ""people"",
+            ""id"": ""2""
+          }
+        }
+      }
+    },
+    {
+      ""type"": ""articles"",
+      ""id"": ""8"",
+      ""attributes"": {
+        ""title"": ""I'll connect the mobile ADP card, that should card the ADP card!""
+      },
+      ""relationships"": {
+        ""author"": {
+          ""data"": {
+            ""type"": ""people"",
+            ""id"": ""2""
+          }
+        }
+      }
+    }
+  ],
+  ""included"": [
+    {
+      ""type"": ""people"",
+      ""id"": ""2"",
+      ""attributes"": {
+        ""name"": ""Ernestine Runte""
+      },
+      ""relationships"": {
+        ""blogs"": {
+          ""data"": [
+            {
+              ""type"": ""blogs"",
+              ""id"": ""3""
+            },
+            {
+              ""type"": ""blogs"",
+              ""id"": ""4""
+            }
+          ]
+        },
+        ""favoriteFood"": {
+          ""data"": {
+            ""type"": ""foods"",
+            ""id"": ""6""
+          }
+        }
+      }
+    },
+    {
+      ""type"": ""blogs"",
+      ""id"": ""3"",
+      ""attributes"": {
+        ""title"": ""The SAS microchip is down, quantify the 1080p microchip so we can quantify the SAS microchip!""
+      },
+      ""relationships"": {
+        ""reviewer"": {
+          ""data"": {
+            ""type"": ""people"",
+            ""id"": ""2""
+          }
+        }
+      }
+    },
+    {
+      ""type"": ""blogs"",
+      ""id"": ""4"",
+      ""attributes"": {
+        ""title"": ""I'll connect the mobile ADP card, that should card the ADP card!""
+      },
+      ""relationships"": {
+        ""reviewer"": {
+          ""data"": {
+            ""type"": ""people"",
+            ""id"": ""5""
+          }
+        }
+      }
+    },
+    {
+      ""type"": ""people"",
+      ""id"": ""5"",
+      ""attributes"": {
+        ""name"": ""Doug Shields""
+      },
+      ""relationships"": {
+        ""favoriteFood"": {
+          ""data"": {
+            ""type"": ""foods"",
+            ""id"": ""7""
+          }
+        }
+      }
+    },
+    {
+      ""type"": ""foods"",
+      ""id"": ""7"",
+      ""attributes"": {
+        ""dish"": ""Nostrum totam harum totam voluptatibus.""
+      }
+    },
+    {
+      ""type"": ""foods"",
+      ""id"": ""6"",
+      ""attributes"": {
+        ""dish"": ""Illum assumenda iste quia natus et dignissimos reiciendis.""
+      }
+    }
+  ]
+}");
+        }
+
+        [Fact]
+        public void Resources_in_overlapping_deeply_nested_circular_chains_are_written_in_relationship_declaration_order()
+        {
+            // Arrange
+            var fakers = new ResponseSerializationFakers();
+
+            Article article = fakers.Article.Generate();
+            article.Author = fakers.Person.Generate();
+            article.Author.Blogs = fakers.Blog.Generate(2).ToHashSet();
+            article.Author.Blogs.ElementAt(0).Reviewer = article.Author;
+            article.Author.Blogs.ElementAt(1).Reviewer = fakers.Person.Generate();
+            article.Author.FavoriteFood = fakers.Food.Generate();
+            article.Author.Blogs.ElementAt(1).Reviewer.FavoriteFood = fakers.Food.Generate();
+
+            article.Reviewer = fakers.Person.Generate();
+            article.Reviewer.Blogs = fakers.Blog.Generate(1).ToHashSet();
+            article.Reviewer.Blogs.Add(article.Author.Blogs.ElementAt(0));
+            article.Reviewer.Blogs.ElementAt(0).Author = article.Reviewer;
+
+            article.Reviewer.Blogs.ElementAt(1).Author = article.Author.Blogs.ElementAt(1).Reviewer;
+            article.Author.Blogs.ElementAt(1).Reviewer.FavoriteSong = fakers.Song.Generate();
+            article.Reviewer.FavoriteSong = fakers.Song.Generate();
+
+            IJsonApiOptions options = new JsonApiOptions();
+
+            ResponseModelAdapter responseModelAdapter =
+                CreateAdapter(options, article.StringId, "author.blogs.reviewer.favoriteFood,reviewer.blogs.author.favoriteSong");
+
+            // Act
+            Document document = responseModelAdapter.Convert(article);
+
+            // Assert
+            string text = JsonSerializer.Serialize(document, new JsonSerializerOptions(options.SerializerWriteOptions));
+
+            text.Should().BeJson(@"{
+  ""data"": {
+    ""type"": ""articles"",
+    ""id"": ""1"",
+    ""attributes"": {
+      ""title"": ""The SAS microchip is down, quantify the 1080p microchip so we can quantify the SAS microchip!""
+    },
+    ""relationships"": {
+      ""reviewer"": {
+        ""data"": {
+          ""type"": ""people"",
+          ""id"": ""8""
+        }
+      },
+      ""author"": {
+        ""data"": {
+          ""type"": ""people"",
+          ""id"": ""2""
+        }
+      }
+    }
+  },
+  ""included"": [
+    {
+      ""type"": ""people"",
+      ""id"": ""8"",
+      ""attributes"": {
+        ""name"": ""Nettie Howell""
+      },
+      ""relationships"": {
+        ""blogs"": {
+          ""data"": [
+            {
+              ""type"": ""blogs"",
+              ""id"": ""9""
+            },
+            {
+              ""type"": ""blogs"",
+              ""id"": ""3""
+            }
+          ]
+        },
+        ""favoriteSong"": {
+          ""data"": {
+            ""type"": ""songs"",
+            ""id"": ""11""
+          }
+        }
+      }
+    },
+    {
+      ""type"": ""blogs"",
+      ""id"": ""9"",
+      ""attributes"": {
+        ""title"": ""The RSS bus is down, parse the mobile bus so we can parse the RSS bus!""
+      },
+      ""relationships"": {
+        ""author"": {
+          ""data"": {
+            ""type"": ""people"",
+            ""id"": ""8""
+          }
+        }
+      }
+    },
+    {
+      ""type"": ""blogs"",
+      ""id"": ""3"",
+      ""attributes"": {
+        ""title"": ""The SAS microchip is down, quantify the 1080p microchip so we can quantify the SAS microchip!""
+      },
+      ""relationships"": {
+        ""reviewer"": {
+          ""data"": {
+            ""type"": ""people"",
+            ""id"": ""2""
+          }
+        },
+        ""author"": {
+          ""data"": {
+            ""type"": ""people"",
+            ""id"": ""5""
+          }
+        }
+      }
+    },
+    {
+      ""type"": ""people"",
+      ""id"": ""2"",
+      ""attributes"": {
+        ""name"": ""Ernestine Runte""
+      },
+      ""relationships"": {
+        ""blogs"": {
+          ""data"": [
+            {
+              ""type"": ""blogs"",
+              ""id"": ""3""
+            },
+            {
+              ""type"": ""blogs"",
+              ""id"": ""4""
+            }
+          ]
+        },
+        ""favoriteFood"": {
+          ""data"": {
+            ""type"": ""foods"",
+            ""id"": ""6""
+          }
+        }
+      }
+    },
+    {
+      ""type"": ""blogs"",
+      ""id"": ""4"",
+      ""attributes"": {
+        ""title"": ""I'll connect the mobile ADP card, that should card the ADP card!""
+      },
+      ""relationships"": {
+        ""reviewer"": {
+          ""data"": {
+            ""type"": ""people"",
+            ""id"": ""5""
+          }
+        }
+      }
+    },
+    {
+      ""type"": ""people"",
+      ""id"": ""5"",
+      ""attributes"": {
+        ""name"": ""Doug Shields""
+      },
+      ""relationships"": {
+        ""favoriteFood"": {
+          ""data"": {
+            ""type"": ""foods"",
+            ""id"": ""7""
+          }
+        },
+        ""favoriteSong"": {
+          ""data"": {
+            ""type"": ""songs"",
+            ""id"": ""10""
+          }
+        }
+      }
+    },
+    {
+      ""type"": ""foods"",
+      ""id"": ""7"",
+      ""attributes"": {
+        ""dish"": ""Nostrum totam harum totam voluptatibus.""
+      }
+    },
+    {
+      ""type"": ""songs"",
+      ""id"": ""10"",
+      ""attributes"": {
+        ""title"": ""Illum assumenda iste quia natus et dignissimos reiciendis.""
+      }
+    },
+    {
+      ""type"": ""foods"",
+      ""id"": ""6"",
+      ""attributes"": {
+        ""dish"": ""Illum assumenda iste quia natus et dignissimos reiciendis.""
+      }
+    },
+    {
+      ""type"": ""songs"",
+      ""id"": ""11"",
+      ""attributes"": {
+        ""title"": ""Nostrum totam harum totam voluptatibus.""
+      }
+    }
+  ]
+}");
+        }
+
+        [Fact]
+        public void Duplicate_children_in_multiple_chains_occur_once_in_output()
+        {
+            // Arrange
+            var fakers = new ResponseSerializationFakers();
+
+            Person person = fakers.Person.Generate();
+            List<Article> articles = fakers.Article.Generate(5);
+            articles.ForEach(article => article.Author = person);
+            articles.ForEach(article => article.Reviewer = person);
+
+            IJsonApiOptions options = new JsonApiOptions();
+            ResponseModelAdapter responseModelAdapter = CreateAdapter(options, null, "author,reviewer");
+
+            // Act
+            Document document = responseModelAdapter.Convert(articles);
+
+            // Assert
+            document.Included.Should().HaveCount(1);
+
+            document.Included[0].Attributes["name"].Should().Be(person.Name);
+            document.Included[0].Id.Should().Be(person.StringId);
+        }
+
+        private ResponseModelAdapter CreateAdapter(IJsonApiOptions options, string primaryId, string includeChains)
+        {
+            // @formatter:wrap_chained_method_calls chop_always
+            // @formatter:keep_existing_linebreaks true
+
+            IResourceGraph resourceGraph = new ResourceGraphBuilder(options, NullLoggerFactory.Instance)
+                .Add<Article>()
+                .Add<Person>()
+                .Add<Blog>()
+                .Add<Food>()
+                .Add<Song>()
+                .Build();
+
+            // @formatter:wrap_chained_method_calls restore
+            // @formatter:keep_existing_linebreaks restore
+
+            var request = new JsonApiRequest
+            {
+                Kind = EndpointKind.Primary,
+                PrimaryResourceType = resourceGraph.GetResourceType<Article>(),
+                PrimaryId = primaryId
+            };
+
+            var evaluatedIncludeCache = new EvaluatedIncludeCache();
+            var linkBuilder = new FakeLinkBuilder();
+            var metaBuilder = new FakeMetaBuilder();
+            var resourceDefinitionAccessor = new FakeResourceDefinitionAccessor();
+            var sparseFieldSetCache = new SparseFieldSetCache(Array.Empty<IQueryConstraintProvider>(), resourceDefinitionAccessor);
+            var requestQueryStringAccessor = new FakeRequestQueryStringAccessor();
+
+            var parser = new IncludeParser();
+            IncludeExpression include = parser.Parse(includeChains, request.PrimaryResourceType, null);
+            evaluatedIncludeCache.Set(include);
+
+            return new ResponseModelAdapter(request, options, linkBuilder, metaBuilder, resourceDefinitionAccessor, evaluatedIncludeCache, sparseFieldSetCache,
+                requestQueryStringAccessor);
+        }
+
+        private sealed class FakeLinkBuilder : ILinkBuilder
+        {
+            public TopLevelLinks GetTopLevelLinks()
+            {
+                return null;
+            }
+
+            public ResourceLinks GetResourceLinks(ResourceType resourceType, string id)
+            {
+                return null;
+            }
+
+            public RelationshipLinks GetRelationshipLinks(RelationshipAttribute relationship, IIdentifiable leftResource)
+            {
+                return null;
+            }
+        }
+
+        private sealed class FakeMetaBuilder : IMetaBuilder
+        {
+            public void Add(IReadOnlyDictionary<string, object> values)
+            {
+            }
+
+            public IDictionary<string, object> Build()
+            {
+                return null;
+            }
+        }
+
+        private sealed class FakeResourceDefinitionAccessor : IResourceDefinitionAccessor
+        {
+            public IImmutableSet<IncludeElementExpression> OnApplyIncludes(ResourceType resourceType, IImmutableSet<IncludeElementExpression> existingIncludes)
+            {
+                return existingIncludes;
+            }
+
+            public FilterExpression OnApplyFilter(ResourceType resourceType, FilterExpression existingFilter)
+            {
+                return existingFilter;
+            }
+
+            public SortExpression OnApplySort(ResourceType resourceType, SortExpression existingSort)
+            {
+                return existingSort;
+            }
+
+            public PaginationExpression OnApplyPagination(ResourceType resourceType, PaginationExpression existingPagination)
+            {
+                return existingPagination;
+            }
+
+            public SparseFieldSetExpression OnApplySparseFieldSet(ResourceType resourceType, SparseFieldSetExpression existingSparseFieldSet)
+            {
+                return existingSparseFieldSet;
+            }
+
+            public object GetQueryableHandlerForQueryStringParameter(Type resourceClrType, string parameterName)
+            {
+                return null;
+            }
+
+            public IDictionary<string, object> GetMeta(ResourceType resourceType, IIdentifiable resourceInstance)
+            {
+                return null;
+            }
+
+            public Task OnPrepareWriteAsync<TResource>(TResource resource, WriteOperationKind writeOperation, CancellationToken cancellationToken)
+                where TResource : class, IIdentifiable
+            {
+                return Task.CompletedTask;
+            }
+
+            public Task<IIdentifiable> OnSetToOneRelationshipAsync<TResource>(TResource leftResource, HasOneAttribute hasOneRelationship,
+                IIdentifiable rightResourceId, WriteOperationKind writeOperation, CancellationToken cancellationToken)
+                where TResource : class, IIdentifiable
+            {
+                return Task.FromResult(rightResourceId);
+            }
+
+            public Task OnSetToManyRelationshipAsync<TResource>(TResource leftResource, HasManyAttribute hasManyRelationship,
+                ISet<IIdentifiable> rightResourceIds, WriteOperationKind writeOperation, CancellationToken cancellationToken)
+                where TResource : class, IIdentifiable
+            {
+                return Task.CompletedTask;
+            }
+
+            public Task OnAddToRelationshipAsync<TResource, TId>(TId leftResourceId, HasManyAttribute hasManyRelationship, ISet<IIdentifiable> rightResourceIds,
+                CancellationToken cancellationToken)
+                where TResource : class, IIdentifiable<TId>
+            {
+                return Task.CompletedTask;
+            }
+
+            public Task OnRemoveFromRelationshipAsync<TResource>(TResource leftResource, HasManyAttribute hasManyRelationship,
+                ISet<IIdentifiable> rightResourceIds, CancellationToken cancellationToken)
+                where TResource : class, IIdentifiable
+            {
+                return Task.CompletedTask;
+            }
+
+            public Task OnWritingAsync<TResource>(TResource resource, WriteOperationKind writeOperation, CancellationToken cancellationToken)
+                where TResource : class, IIdentifiable
+            {
+                return Task.CompletedTask;
+            }
+
+            public Task OnWriteSucceededAsync<TResource>(TResource resource, WriteOperationKind writeOperation, CancellationToken cancellationToken)
+                where TResource : class, IIdentifiable
+            {
+                return Task.CompletedTask;
+            }
+
+            public void OnDeserialize(IIdentifiable resource)
+            {
+            }
+
+            public void OnSerialize(IIdentifiable resource)
+            {
+            }
+        }
+
+        private sealed class FakeRequestQueryStringAccessor : IRequestQueryStringAccessor
+        {
+            public IQueryCollection Query { get; } = new QueryCollection(0);
+        }
+    }
+}
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/ResponseSerializationFakers.cs b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/ResponseSerializationFakers.cs
new file mode 100644
index 0000000000..acc001a16b
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/ResponseSerializationFakers.cs
@@ -0,0 +1,49 @@
+using Bogus;
+using JsonApiDotNetCoreTests.UnitTests.Serialization.Response.Models;
+using Person = JsonApiDotNetCoreTests.UnitTests.Serialization.Response.Models.Person;
+
+// @formatter:wrap_chained_method_calls chop_always
+// @formatter:keep_existing_linebreaks true
+
+namespace JsonApiDotNetCoreTests.UnitTests.Serialization.Response
+{
+    internal sealed class ResponseSerializationFakers
+    {
+        private const int FakerSeed = 0;
+        private int _index;
+
+        public Faker<Food> Food { get; }
+        public Faker<Song> Song { get; }
+        public Faker<Article> Article { get; }
+        public Faker<Blog> Blog { get; }
+        public Faker<Person> Person { get; }
+
+        public ResponseSerializationFakers()
+        {
+            Article = new Faker<Article>()
+                .UseSeed(FakerSeed)
+                .RuleFor(article => article.Title, faker => faker.Hacker.Phrase())
+                .RuleFor(article => article.Id, _ => ++_index);
+
+            Person = new Faker<Person>()
+                .UseSeed(FakerSeed)
+                .RuleFor(person => person.Name, faker => faker.Person.FullName)
+                .RuleFor(person => person.Id, _ => ++_index);
+
+            Blog = new Faker<Blog>()
+                .UseSeed(FakerSeed)
+                .RuleFor(blog => blog.Title, faker => faker.Hacker.Phrase())
+                .RuleFor(blog => blog.Id, _ => ++_index);
+
+            Song = new Faker<Song>()
+                .UseSeed(FakerSeed)
+                .RuleFor(song => song.Title, faker => faker.Lorem.Sentence())
+                .RuleFor(song => song.Id, _ => ++_index);
+
+            Food = new Faker<Food>()
+                .UseSeed(FakerSeed)
+                .RuleFor(food => food.Dish, faker => faker.Lorem.Sentence())
+                .RuleFor(food => food.Id, _ => ++_index);
+        }
+    }
+}
diff --git a/test/TestBuildingBlocks/HttpResponseMessageExtensions.cs b/test/TestBuildingBlocks/HttpResponseMessageExtensions.cs
index 873cec6d3f..4803600dec 100644
--- a/test/TestBuildingBlocks/HttpResponseMessageExtensions.cs
+++ b/test/TestBuildingBlocks/HttpResponseMessageExtensions.cs
@@ -30,7 +30,7 @@ public AndConstraint<HttpResponseMessageAssertions> HaveStatusCode(HttpStatusCod
                 if (Subject.StatusCode != statusCode)
                 {
                     string responseText = Subject.Content.ReadAsStringAsync().Result;
-                    Subject.StatusCode.Should().Be(statusCode, $"response body returned was:\n{responseText}");
+                    Subject.StatusCode.Should().Be(statusCode, string.IsNullOrEmpty(responseText) ? null : $"response body returned was:\n{responseText}");
                 }
 
                 return new AndConstraint<HttpResponseMessageAssertions>(this);
diff --git a/test/TestBuildingBlocks/IntegrationTest.cs b/test/TestBuildingBlocks/IntegrationTest.cs
index 59e45b0b72..61601c0f6f 100644
--- a/test/TestBuildingBlocks/IntegrationTest.cs
+++ b/test/TestBuildingBlocks/IntegrationTest.cs
@@ -9,7 +9,7 @@
 namespace TestBuildingBlocks
 {
     /// <summary>
-    /// A base class for tests that conveniently enables to execute HTTP requests against json:api endpoints.
+    /// A base class for tests that conveniently enables to execute HTTP requests against JSON:API endpoints.
     /// </summary>
     public abstract class IntegrationTest
     {
@@ -95,6 +95,11 @@ private TResponseDocument DeserializeResponse<TResponseDocument>(string response
                 return (TResponseDocument)(object)responseText;
             }
 
+            if (string.IsNullOrEmpty(responseText))
+            {
+                return default;
+            }
+
             try
             {
                 return JsonSerializer.Deserialize<TResponseDocument>(responseText, SerializerOptions);
diff --git a/test/TestBuildingBlocks/IntegrationTestContext.cs b/test/TestBuildingBlocks/IntegrationTestContext.cs
index 68550f4c26..e909699aa9 100644
--- a/test/TestBuildingBlocks/IntegrationTestContext.cs
+++ b/test/TestBuildingBlocks/IntegrationTestContext.cs
@@ -102,7 +102,7 @@ private WebApplicationFactory<TStartup> CreateFactory()
             // We have placed an appsettings.json in the TestBuildingBlock project folder and set the content root to there. Note that controllers
             // are not discovered in the content root but are registered manually using IntegrationTestContext.UseController.
             WebApplicationFactory<TStartup> factoryWithConfiguredContentRoot =
-                factory.WithWebHostBuilder(builder => builder.UseSolutionRelativeContentRoot("test/" + nameof(TestBuildingBlocks)));
+                factory.WithWebHostBuilder(builder => builder.UseSolutionRelativeContentRoot($"test/{nameof(TestBuildingBlocks)}"));
 
             using IServiceScope scope = factoryWithConfiguredContentRoot.Services.CreateScope();
             var dbContext = scope.ServiceProvider.GetRequiredService<TDbContext>();
@@ -113,7 +113,7 @@ private WebApplicationFactory<TStartup> CreateFactory()
 
         public void Dispose()
         {
-            RunOnDatabaseAsync(async context => await context.Database.EnsureDeletedAsync()).Wait();
+            RunOnDatabaseAsync(async dbContext => await dbContext.Database.EnsureDeletedAsync()).Wait();
 
             Factory.Dispose();
         }
diff --git a/test/TestBuildingBlocks/TestableStartup.cs b/test/TestBuildingBlocks/TestableStartup.cs
index 3f029e4eb6..7b0c927645 100644
--- a/test/TestBuildingBlocks/TestableStartup.cs
+++ b/test/TestBuildingBlocks/TestableStartup.cs
@@ -18,6 +18,7 @@ public virtual void ConfigureServices(IServiceCollection services)
         protected virtual void SetJsonApiOptions(JsonApiOptions options)
         {
             options.IncludeExceptionStackTraceInErrors = true;
+            options.IncludeRequestBodyInErrors = true;
             options.SerializerOptions.WriteIndented = true;
         }
 
diff --git a/test/UnitTests/Builders/ResourceGraphBuilderTests.cs b/test/UnitTests/Builders/ResourceGraphBuilderTests.cs
index b6cd276c99..90171ad268 100644
--- a/test/UnitTests/Builders/ResourceGraphBuilderTests.cs
+++ b/test/UnitTests/Builders/ResourceGraphBuilderTests.cs
@@ -29,10 +29,10 @@ public void Can_Build_ResourceGraph_Using_Builder()
 
             // Assert
             var resourceGraph = container.GetRequiredService<IResourceGraph>();
-            ResourceContext dbResourceContext = resourceGraph.GetResourceContext("dbResources");
-            ResourceContext nonDbResourceContext = resourceGraph.GetResourceContext("nonDbResources");
-            Assert.Equal(typeof(DbResource), dbResourceContext.ResourceType);
-            Assert.Equal(typeof(NonDbResource), nonDbResourceContext.ResourceType);
+            ResourceType dbResourceType = resourceGraph.GetResourceType("dbResources");
+            ResourceType nonDbResourceType = resourceGraph.GetResourceType("nonDbResources");
+            Assert.Equal(typeof(DbResource), dbResourceType.ClrType);
+            Assert.Equal(typeof(NonDbResource), nonDbResourceType.ClrType);
         }
 
         [Fact]
@@ -41,13 +41,14 @@ public void Resources_Without_Names_Specified_Will_Use_Configured_Formatter()
             // Arrange
             var builder = new ResourceGraphBuilder(new JsonApiOptions(), NullLoggerFactory.Instance);
             builder.Add<TestResource>();
+            builder.Add<RelatedResource>();
 
             // Act
             IResourceGraph resourceGraph = builder.Build();
 
             // Assert
-            ResourceContext resourceContext = resourceGraph.GetResourceContext(typeof(TestResource));
-            Assert.Equal("testResources", resourceContext.PublicName);
+            ResourceType testResourceType = resourceGraph.GetResourceType(typeof(TestResource));
+            Assert.Equal("testResources", testResourceType.PublicName);
         }
 
         [Fact]
@@ -56,13 +57,14 @@ public void Attrs_Without_Names_Specified_Will_Use_Configured_Formatter()
             // Arrange
             var builder = new ResourceGraphBuilder(new JsonApiOptions(), NullLoggerFactory.Instance);
             builder.Add<TestResource>();
+            builder.Add<RelatedResource>();
 
             // Act
             IResourceGraph resourceGraph = builder.Build();
 
             // Assert
-            ResourceContext resourceContext = resourceGraph.GetResourceContext(typeof(TestResource));
-            Assert.Contains(resourceContext.Attributes, attribute => attribute.PublicName == "compoundAttribute");
+            ResourceType testResourceType = resourceGraph.GetResourceType(typeof(TestResource));
+            Assert.Contains(testResourceType.Attributes, attribute => attribute.PublicName == "compoundAttribute");
         }
 
         [Fact]
@@ -71,14 +73,15 @@ public void Relationships_Without_Names_Specified_Will_Use_Configured_Formatter(
             // Arrange
             var builder = new ResourceGraphBuilder(new JsonApiOptions(), NullLoggerFactory.Instance);
             builder.Add<TestResource>();
+            builder.Add<RelatedResource>();
 
             // Act
             IResourceGraph resourceGraph = builder.Build();
 
             // Assert
-            ResourceContext resourceContext = resourceGraph.GetResourceContext(typeof(TestResource));
-            Assert.Equal("relatedResource", resourceContext.Relationships.Single(relationship => relationship is HasOneAttribute).PublicName);
-            Assert.Equal("relatedResources", resourceContext.Relationships.Single(relationship => relationship is not HasOneAttribute).PublicName);
+            ResourceType testResourceType = resourceGraph.GetResourceType(typeof(TestResource));
+            Assert.Equal("relatedResource", testResourceType.Relationships.Single(relationship => relationship is HasOneAttribute).PublicName);
+            Assert.Equal("relatedResources", testResourceType.Relationships.Single(relationship => relationship is not HasOneAttribute).PublicName);
         }
 
         private sealed class NonDbResource : Identifiable
diff --git a/test/UnitTests/Extensions/ServiceCollectionExtensionsTests.cs b/test/UnitTests/Extensions/ServiceCollectionExtensionsTests.cs
index 542abd496a..d9d148f46a 100644
--- a/test/UnitTests/Extensions/ServiceCollectionExtensionsTests.cs
+++ b/test/UnitTests/Extensions/ServiceCollectionExtensionsTests.cs
@@ -29,19 +29,15 @@ public void RegisterResource_DeviatingDbContextPropertyName_RegistersCorrectly()
             services.AddLogging();
             services.AddDbContext<TestDbContext>(options => options.UseInMemoryDatabase("UnitTestDb"));
 
-            // this is required because the DbContextResolver requires access to the current HttpContext
-            // to get the request scoped DbContext instance
-            services.AddScoped<IRequestScopedServiceProvider, TestScopedServiceProvider>();
-
             // Act
             services.AddJsonApi<TestDbContext>();
 
             ServiceProvider provider = services.BuildServiceProvider();
             var resourceGraph = provider.GetRequiredService<IResourceGraph>();
-            ResourceContext resourceContext = resourceGraph.GetResourceContext<Person>();
+            ResourceType personType = resourceGraph.GetResourceType<Person>();
 
             // Assert
-            Assert.Equal("people", resourceContext.PublicName);
+            Assert.Equal("people", personType.PublicName);
         }
 
         [Fact]
@@ -171,8 +167,6 @@ public void AddJsonApi_With_Context_Uses_Resource_Type_Name_If_NoOtherSpecified(
             services.AddLogging();
             services.AddDbContext<TestDbContext>(options => options.UseInMemoryDatabase(Guid.NewGuid().ToString()));
 
-            services.AddScoped<IRequestScopedServiceProvider, TestScopedServiceProvider>();
-
             // Act
             services.AddJsonApi<TestDbContext>();
 
@@ -180,8 +174,8 @@ public void AddJsonApi_With_Context_Uses_Resource_Type_Name_If_NoOtherSpecified(
             ServiceProvider provider = services.BuildServiceProvider();
             var resourceGraph = provider.GetRequiredService<IResourceGraph>();
 
-            ResourceContext resourceContext = resourceGraph.GetResourceContext(typeof(IntResource));
-            Assert.Equal("intResources", resourceContext.PublicName);
+            ResourceType intResourceType = resourceGraph.GetResourceType(typeof(IntResource));
+            Assert.Equal("intResources", intResourceType.PublicName);
         }
 
         private sealed class IntResource : Identifiable
@@ -416,7 +410,7 @@ public Task RemoveFromToManyRelationshipAsync(GuidResource leftResource, ISet<II
         [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
         private sealed class IntResourceDefinition : IResourceDefinition<IntResource>
         {
-            public IImmutableList<IncludeElementExpression> OnApplyIncludes(IImmutableList<IncludeElementExpression> existingIncludes)
+            public IImmutableSet<IncludeElementExpression> OnApplyIncludes(IImmutableSet<IncludeElementExpression> existingIncludes)
             {
                 throw new NotImplementedException();
             }
@@ -504,7 +498,7 @@ public void OnSerialize(IntResource resource)
         [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
         private sealed class GuidResourceDefinition : IResourceDefinition<GuidResource, Guid>
         {
-            public IImmutableList<IncludeElementExpression> OnApplyIncludes(IImmutableList<IncludeElementExpression> existingIncludes)
+            public IImmutableSet<IncludeElementExpression> OnApplyIncludes(IImmutableSet<IncludeElementExpression> existingIncludes)
             {
                 throw new NotImplementedException();
             }
diff --git a/test/UnitTests/Graph/ResourceDescriptorAssemblyCacheTests.cs b/test/UnitTests/Graph/ResourceDescriptorAssemblyCacheTests.cs
index 99e8f54931..c602c368a0 100644
--- a/test/UnitTests/Graph/ResourceDescriptorAssemblyCacheTests.cs
+++ b/test/UnitTests/Graph/ResourceDescriptorAssemblyCacheTests.cs
@@ -14,34 +14,34 @@ public sealed class ResourceDescriptorAssemblyCacheTests
         public void GetResourceDescriptorsPerAssembly_Locates_Identifiable_Resource()
         {
             // Arrange
-            Type resourceType = typeof(Model);
+            Type resourceClrType = typeof(Model);
 
             var assemblyCache = new ResourceDescriptorAssemblyCache();
-            assemblyCache.RegisterAssembly(resourceType.Assembly);
+            assemblyCache.RegisterAssembly(resourceClrType.Assembly);
 
             // Act
             IReadOnlyCollection<ResourceDescriptor> descriptors = assemblyCache.GetResourceDescriptors();
 
             // Assert
             descriptors.Should().NotBeEmpty();
-            descriptors.Should().ContainSingle(descriptor => descriptor.ResourceType == resourceType);
+            descriptors.Should().ContainSingle(descriptor => descriptor.ResourceClrType == resourceClrType);
         }
 
         [Fact]
         public void GetResourceDescriptorsPerAssembly_Only_Contains_IIdentifiable_Types()
         {
             // Arrange
-            Type resourceType = typeof(Model);
+            Type resourceClrType = typeof(Model);
 
             var assemblyCache = new ResourceDescriptorAssemblyCache();
-            assemblyCache.RegisterAssembly(resourceType.Assembly);
+            assemblyCache.RegisterAssembly(resourceClrType.Assembly);
 
             // Act
             IReadOnlyCollection<ResourceDescriptor> descriptors = assemblyCache.GetResourceDescriptors();
 
             // Assert
             descriptors.Should().NotBeEmpty();
-            descriptors.Select(descriptor => descriptor.ResourceType).Should().AllBeAssignableTo<IIdentifiable>();
+            descriptors.Select(descriptor => descriptor.ResourceClrType).Should().AllBeAssignableTo<IIdentifiable>();
         }
     }
 }
diff --git a/test/UnitTests/Graph/TypeLocatorTests.cs b/test/UnitTests/Graph/TypeLocatorTests.cs
index 0d44732a2a..4ff9625ebc 100644
--- a/test/UnitTests/Graph/TypeLocatorTests.cs
+++ b/test/UnitTests/Graph/TypeLocatorTests.cs
@@ -85,29 +85,29 @@ public void GetIdType_Correctly_Identifies_NonJsonApiResource()
         public void TryGetResourceDescriptor_Returns_Type_If_Type_Is_IIdentifiable()
         {
             // Arrange
-            Type resourceType = typeof(Model);
+            Type resourceClrType = typeof(Model);
 
             var typeLocator = new TypeLocator();
 
             // Act
-            ResourceDescriptor descriptor = typeLocator.TryGetResourceDescriptor(resourceType);
+            ResourceDescriptor descriptor = typeLocator.TryGetResourceDescriptor(resourceClrType);
 
             // Assert
             Assert.NotNull(descriptor);
-            Assert.Equal(resourceType, descriptor.ResourceType);
-            Assert.Equal(typeof(int), descriptor.IdType);
+            Assert.Equal(resourceClrType, descriptor.ResourceClrType);
+            Assert.Equal(typeof(int), descriptor.IdClrType);
         }
 
         [Fact]
         public void TryGetResourceDescriptor_Returns_False_If_Type_Is_IIdentifiable()
         {
             // Arrange
-            Type resourceType = typeof(string);
+            Type resourceClrType = typeof(string);
 
             var typeLocator = new TypeLocator();
 
             // Act
-            ResourceDescriptor descriptor = typeLocator.TryGetResourceDescriptor(resourceType);
+            ResourceDescriptor descriptor = typeLocator.TryGetResourceDescriptor(resourceClrType);
 
             // Assert
             Assert.Null(descriptor);
diff --git a/test/UnitTests/Internal/ErrorDocumentTests.cs b/test/UnitTests/Internal/ErrorObjectTests.cs
similarity index 79%
rename from test/UnitTests/Internal/ErrorDocumentTests.cs
rename to test/UnitTests/Internal/ErrorObjectTests.cs
index e2426659b2..d60520df84 100644
--- a/test/UnitTests/Internal/ErrorDocumentTests.cs
+++ b/test/UnitTests/Internal/ErrorObjectTests.cs
@@ -6,7 +6,7 @@
 
 namespace UnitTests.Internal
 {
-    public sealed class ErrorDocumentTests
+    public sealed class ErrorObjectTests
     {
         // @formatter:wrap_array_initializer_style wrap_if_long
         [Theory]
@@ -18,13 +18,10 @@ public sealed class ErrorDocumentTests
         public void ErrorDocument_GetErrorStatusCode_IsCorrect(HttpStatusCode[] errorCodes, HttpStatusCode expected)
         {
             // Arrange
-            var document = new Document
-            {
-                Errors = errorCodes.Select(code => new ErrorObject(code)).ToList()
-            };
+            ErrorObject[] errors = errorCodes.Select(code => new ErrorObject(code)).ToArray();
 
             // Act
-            HttpStatusCode status = document.GetErrorStatusCode();
+            HttpStatusCode status = ErrorObject.GetResponseStatusCode(errors);
 
             // Assert
             status.Should().Be(expected);
diff --git a/test/UnitTests/Internal/RequestScopedServiceProviderTests.cs b/test/UnitTests/Internal/RequestScopedServiceProviderTests.cs
deleted file mode 100644
index 49313b4364..0000000000
--- a/test/UnitTests/Internal/RequestScopedServiceProviderTests.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-using System;
-using JetBrains.Annotations;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Resources;
-using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.DependencyInjection;
-using Xunit;
-
-namespace UnitTests.Internal
-{
-    public sealed class RequestScopedServiceProviderTests
-    {
-        [Fact]
-        public void When_http_context_is_unavailable_it_must_fail()
-        {
-            // Arrange
-            Type serviceType = typeof(IIdentifiable<Model>);
-
-            var provider = new RequestScopedServiceProvider(new HttpContextAccessor());
-
-            // Act
-            Action action = () => provider.GetRequiredService(serviceType);
-
-            // Assert
-            var exception = Assert.Throws<InvalidOperationException>(action);
-
-            Assert.StartsWith($"Cannot resolve scoped service '{serviceType.FullName}' outside the context of an HTTP request.", exception.Message);
-        }
-
-        [UsedImplicitly(ImplicitUseTargetFlags.Itself)]
-        private sealed class Model : Identifiable
-        {
-        }
-    }
-}
diff --git a/test/UnitTests/Internal/ResourceGraphBuilderTests.cs b/test/UnitTests/Internal/ResourceGraphBuilderTests.cs
index d1df3947d8..110aa17027 100644
--- a/test/UnitTests/Internal/ResourceGraphBuilderTests.cs
+++ b/test/UnitTests/Internal/ResourceGraphBuilderTests.cs
@@ -24,7 +24,7 @@ public void AddDbContext_Does_Not_Throw_If_Context_Contains_Members_That_Do_Not_
             var resourceGraph = (ResourceGraph)resourceGraphBuilder.Build();
 
             // Assert
-            Assert.Empty(resourceGraph.GetResourceContexts());
+            Assert.Empty(resourceGraph.GetResourceTypes());
         }
 
         [Fact]
@@ -47,7 +47,7 @@ public void Adding_DbContext_Members_That_Do_Not_Implement_IIdentifiable_Logs_Wa
         }
 
         [Fact]
-        public void GetResourceContext_Yields_Right_Type_For_LazyLoadingProxy()
+        public void GetResourceType_Yields_Right_Type_For_LazyLoadingProxy()
         {
             // Arrange
             var resourceGraphBuilder = new ResourceGraphBuilder(new JsonApiOptions(), NullLoggerFactory.Instance);
@@ -57,14 +57,14 @@ public void GetResourceContext_Yields_Right_Type_For_LazyLoadingProxy()
 
             // Act
             var proxy = proxyGenerator.CreateClassProxy<Bar>();
-            ResourceContext resourceContext = resourceGraph.GetResourceContext(proxy.GetType());
+            ResourceType barType = resourceGraph.GetResourceType(proxy.GetType());
 
             // Assert
-            Assert.Equal(typeof(Bar), resourceContext.ResourceType);
+            Assert.Equal(typeof(Bar), barType.ClrType);
         }
 
         [Fact]
-        public void GetResourceContext_Yields_Right_Type_For_Identifiable()
+        public void GetResourceType_Yields_Right_Type_For_Identifiable()
         {
             // Arrange
             var resourceGraphBuilder = new ResourceGraphBuilder(new JsonApiOptions(), NullLoggerFactory.Instance);
@@ -72,10 +72,10 @@ public void GetResourceContext_Yields_Right_Type_For_Identifiable()
             var resourceGraph = (ResourceGraph)resourceGraphBuilder.Build();
 
             // Act
-            ResourceContext resourceContext = resourceGraph.GetResourceContext(typeof(Bar));
+            ResourceType barType = resourceGraph.GetResourceType(typeof(Bar));
 
             // Assert
-            Assert.Equal(typeof(Bar), resourceContext.ResourceType);
+            Assert.Equal(typeof(Bar), barType.ClrType);
         }
 
         [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
diff --git a/test/UnitTests/Middleware/JsonApiMiddlewareTests.cs b/test/UnitTests/Middleware/JsonApiMiddlewareTests.cs
index 93122f9a99..244db92b03 100644
--- a/test/UnitTests/Middleware/JsonApiMiddlewareTests.cs
+++ b/test/UnitTests/Middleware/JsonApiMiddlewareTests.cs
@@ -11,7 +11,6 @@
 using Microsoft.AspNetCore.Mvc.Controllers;
 using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
-using Moq.Language;
 using Xunit;
 
 namespace UnitTests.Middleware
@@ -78,11 +77,11 @@ public async Task ParseUrlBase_UrlHasNegativePrimaryIdAndTypeIsInt_ShouldNotThro
         private Task RunMiddlewareTask(InvokeConfiguration holder)
         {
             IControllerResourceMapping controllerResourceMapping = holder.ControllerResourceMapping.Object;
-            HttpContext context = holder.HttpContext;
+            HttpContext httpContext = holder.HttpContext;
             IJsonApiOptions options = holder.Options;
             JsonApiRequest request = holder.Request;
-            IResourceGraph resourceGraph = holder.ResourceGraph.Object;
-            return holder.MiddleWare.InvokeAsync(context, controllerResourceMapping, options, request, resourceGraph, NullLogger<JsonApiMiddleware>.Instance);
+
+            return holder.MiddleWare.InvokeAsync(httpContext, controllerResourceMapping, options, request, NullLogger<JsonApiMiddleware>.Instance);
         }
 
         private InvokeConfiguration GetConfiguration(string path, string resourceName = "users", string action = "", string id = null, Type relType = null)
@@ -99,21 +98,18 @@ private InvokeConfiguration GetConfiguration(string path, string resourceName =
 
             const string forcedNamespace = "api/v1";
             var mockMapping = new Mock<IControllerResourceMapping>();
-            mockMapping.Setup(mapping => mapping.GetResourceTypeForController(It.IsAny<Type>())).Returns(typeof(string));
+            var resourceType = new ResourceType(resourceName, typeof(object), typeof(string));
+            mockMapping.Setup(mapping => mapping.TryGetResourceTypeForController(It.IsAny<Type>())).Returns(resourceType);
 
             IJsonApiOptions options = CreateOptions(forcedNamespace);
-            Mock<IResourceGraph> mockGraph = CreateMockResourceGraph(resourceName, relType != null);
             var request = new JsonApiRequest();
 
             if (relType != null)
             {
-                request.Relationship = new HasManyAttribute
-                {
-                    RightType = relType
-                };
+                request.Relationship = new HasManyAttribute();
             }
 
-            DefaultHttpContext context = CreateHttpContext(path, relType != null, action, id);
+            DefaultHttpContext httpContext = CreateHttpContext(path, relType != null, action, id);
 
             return new InvokeConfiguration
             {
@@ -121,8 +117,7 @@ private InvokeConfiguration GetConfiguration(string path, string resourceName =
                 ControllerResourceMapping = mockMapping,
                 Options = options,
                 Request = request,
-                HttpContext = context,
-                ResourceGraph = mockGraph
+                HttpContext = httpContext
             };
         }
 
@@ -138,9 +133,17 @@ private static IJsonApiOptions CreateOptions(string forcedNamespace)
 
         private static DefaultHttpContext CreateHttpContext(string path, bool isRelationship = false, string action = "", string id = null)
         {
-            var context = new DefaultHttpContext();
-            context.Request.Path = new PathString(path);
-            context.Response.Body = new MemoryStream();
+            var httpContext = new DefaultHttpContext
+            {
+                Request =
+                {
+                    Path = new PathString(path)
+                },
+                Response =
+                {
+                    Body = new MemoryStream()
+                }
+            };
 
             var feature = new RouteValuesFeature
             {
@@ -156,36 +159,15 @@ private static DefaultHttpContext CreateHttpContext(string path, bool isRelation
                 feature.RouteValues["id"] = id;
             }
 
-            context.Features.Set<IRouteValuesFeature>(feature);
+            httpContext.Features.Set<IRouteValuesFeature>(feature);
 
             var controllerActionDescriptor = new ControllerActionDescriptor
             {
                 ControllerTypeInfo = (TypeInfo)typeof(object)
             };
 
-            context.SetEndpoint(new Endpoint(_ => Task.CompletedTask, new EndpointMetadataCollection(controllerActionDescriptor), null));
-            return context;
-        }
-
-        private Mock<IResourceGraph> CreateMockResourceGraph(string resourceName, bool includeRelationship = false)
-        {
-            var mockGraph = new Mock<IResourceGraph>();
-
-            var resourceContext = new ResourceContext(resourceName, typeof(object), typeof(string), Array.Empty<AttrAttribute>(),
-                Array.Empty<RelationshipAttribute>(), Array.Empty<EagerLoadAttribute>());
-
-            ISetupSequentialResult<ResourceContext> seq = mockGraph.SetupSequence(resourceGraph => resourceGraph.GetResourceContext(It.IsAny<Type>()))
-                .Returns(resourceContext);
-
-            if (includeRelationship)
-            {
-                var relatedContext = new ResourceContext("todoItems", typeof(object), typeof(string), Array.Empty<AttrAttribute>(),
-                    Array.Empty<RelationshipAttribute>(), Array.Empty<EagerLoadAttribute>());
-
-                seq.Returns(relatedContext);
-            }
-
-            return mockGraph;
+            httpContext.SetEndpoint(new Endpoint(_ => Task.CompletedTask, new EndpointMetadataCollection(controllerActionDescriptor), null));
+            return httpContext;
         }
 
         private sealed class InvokeConfiguration
@@ -195,7 +177,6 @@ private sealed class InvokeConfiguration
             public Mock<IControllerResourceMapping> ControllerResourceMapping { get; init; }
             public IJsonApiOptions Options { get; init; }
             public JsonApiRequest Request { get; init; }
-            public Mock<IResourceGraph> ResourceGraph { get; init; }
         }
     }
 }
diff --git a/test/UnitTests/Middleware/JsonApiRequestTests.cs b/test/UnitTests/Middleware/JsonApiRequestTests.cs
index bb6a230fd7..a17bfaf0a5 100644
--- a/test/UnitTests/Middleware/JsonApiRequestTests.cs
+++ b/test/UnitTests/Middleware/JsonApiRequestTests.cs
@@ -58,7 +58,8 @@ public async Task Sets_request_properties_correctly(string requestMethod, string
 
             var controllerResourceMappingMock = new Mock<IControllerResourceMapping>();
 
-            controllerResourceMappingMock.Setup(mapping => mapping.GetResourceTypeForController(It.IsAny<Type>())).Returns(typeof(TodoItem));
+            ResourceType todoItemType = resourceGraph.GetResourceType<TodoItem>();
+            controllerResourceMappingMock.Setup(mapping => mapping.TryGetResourceTypeForController(It.IsAny<Type>())).Returns(todoItemType);
 
             var httpContext = new DefaultHttpContext();
             SetupRoutes(httpContext, requestMethod, requestPath);
@@ -68,16 +69,15 @@ public async Task Sets_request_properties_correctly(string requestMethod, string
             var middleware = new JsonApiMiddleware(_ => Task.CompletedTask, new HttpContextAccessor());
 
             // Act
-            await middleware.InvokeAsync(httpContext, controllerResourceMappingMock.Object, options, request, resourceGraph,
-                NullLogger<JsonApiMiddleware>.Instance);
+            await middleware.InvokeAsync(httpContext, controllerResourceMappingMock.Object, options, request, NullLogger<JsonApiMiddleware>.Instance);
 
             // Assert
             request.IsCollection.Should().Be(expectIsCollection);
             request.Kind.Should().Be(expectKind);
             request.WriteOperation.Should().Be(expectWriteOperation);
             request.IsReadOnly.Should().Be(expectIsReadOnly);
-            request.PrimaryResource.Should().NotBeNull();
-            request.PrimaryResource.PublicName.Should().Be("todoItems");
+            request.PrimaryResourceType.Should().NotBeNull();
+            request.PrimaryResourceType.PublicName.Should().Be("todoItems");
         }
 
         private static void SetupRoutes(HttpContext httpContext, string requestMethod, string requestPath)
diff --git a/test/UnitTests/Models/ResourceConstructionTests.cs b/test/UnitTests/Models/ResourceConstructionTests.cs
deleted file mode 100644
index 81d08fe548..0000000000
--- a/test/UnitTests/Models/ResourceConstructionTests.cs
+++ /dev/null
@@ -1,132 +0,0 @@
-using System;
-using System.ComponentModel.Design;
-using System.Text.Json;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Middleware;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Serialization;
-using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.Logging.Abstractions;
-using Moq;
-using Xunit;
-
-namespace UnitTests.Models
-{
-    public sealed class ResourceConstructionTests
-    {
-        private readonly Mock<IJsonApiRequest> _requestMock;
-        private readonly Mock<IHttpContextAccessor> _mockHttpContextAccessor;
-        private readonly Mock<IResourceDefinitionAccessor> _resourceDefinitionAccessorMock = new();
-
-        public ResourceConstructionTests()
-        {
-            _mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
-            _mockHttpContextAccessor.Setup(mock => mock.HttpContext).Returns(new DefaultHttpContext());
-            _requestMock = new Mock<IJsonApiRequest>();
-            _requestMock.Setup(mock => mock.Kind).Returns(EndpointKind.Primary);
-        }
-
-        [Fact]
-        public void When_resource_has_default_constructor_it_must_succeed()
-        {
-            // Arrange
-            var options = new JsonApiOptions();
-
-            IResourceGraph resourceGraph = new ResourceGraphBuilder(options, NullLoggerFactory.Instance).Add<ResourceWithoutConstructor>().Build();
-
-            var serviceContainer = new ServiceContainer();
-            serviceContainer.AddService(typeof(IResourceDefinitionAccessor), new NeverResourceDefinitionAccessor());
-
-            var serializer = new RequestDeserializer(resourceGraph, new ResourceFactory(serviceContainer), new TargetedFields(),
-                _mockHttpContextAccessor.Object, _requestMock.Object, options, _resourceDefinitionAccessorMock.Object);
-
-            var body = new
-            {
-                data = new
-                {
-                    id = "1",
-                    type = "resourceWithoutConstructors"
-                }
-            };
-
-            string content = JsonSerializer.Serialize(body);
-
-            // Act
-            object result = serializer.Deserialize(content);
-
-            // Assert
-            Assert.NotNull(result);
-            Assert.Equal(typeof(ResourceWithoutConstructor), result.GetType());
-        }
-
-        [Fact]
-        public void When_resource_has_default_constructor_that_throws_it_must_fail()
-        {
-            // Arrange
-            var options = new JsonApiOptions();
-
-            IResourceGraph resourceGraph = new ResourceGraphBuilder(options, NullLoggerFactory.Instance).Add<ResourceWithThrowingConstructor>().Build();
-
-            var serviceContainer = new ServiceContainer();
-            serviceContainer.AddService(typeof(IResourceDefinitionAccessor), new NeverResourceDefinitionAccessor());
-
-            var serializer = new RequestDeserializer(resourceGraph, new ResourceFactory(serviceContainer), new TargetedFields(),
-                _mockHttpContextAccessor.Object, _requestMock.Object, options, _resourceDefinitionAccessorMock.Object);
-
-            var body = new
-            {
-                data = new
-                {
-                    id = "1",
-                    type = "resourceWithThrowingConstructors"
-                }
-            };
-
-            string content = JsonSerializer.Serialize(body);
-
-            // Act
-            Action action = () => serializer.Deserialize(content);
-
-            // Assert
-            var exception = Assert.Throws<InvalidOperationException>(action);
-
-            Assert.Equal("Failed to create an instance of 'UnitTests.Models.ResourceWithThrowingConstructor' using its default constructor.",
-                exception.Message);
-        }
-
-        [Fact]
-        public void When_resource_has_constructor_with_string_parameter_it_must_fail()
-        {
-            // Arrange
-            var options = new JsonApiOptions();
-
-            IResourceGraph resourceGraph = new ResourceGraphBuilder(options, NullLoggerFactory.Instance).Add<ResourceWithStringConstructor>().Build();
-
-            var serviceContainer = new ServiceContainer();
-            serviceContainer.AddService(typeof(IResourceDefinitionAccessor), new NeverResourceDefinitionAccessor());
-
-            var serializer = new RequestDeserializer(resourceGraph, new ResourceFactory(serviceContainer), new TargetedFields(),
-                _mockHttpContextAccessor.Object, _requestMock.Object, options, _resourceDefinitionAccessorMock.Object);
-
-            var body = new
-            {
-                data = new
-                {
-                    id = "1",
-                    type = "resourceWithStringConstructors"
-                }
-            };
-
-            string content = JsonSerializer.Serialize(body);
-
-            // Act
-            Action action = () => serializer.Deserialize(content);
-
-            // Assert
-            var exception = Assert.Throws<InvalidOperationException>(action);
-
-            Assert.Equal("Failed to create an instance of 'UnitTests.Models.ResourceWithStringConstructor' using injected constructor parameters.",
-                exception.Message);
-        }
-    }
-}
diff --git a/test/UnitTests/NeverResourceDefinitionAccessor.cs b/test/UnitTests/NeverResourceDefinitionAccessor.cs
deleted file mode 100644
index f4d0f308bf..0000000000
--- a/test/UnitTests/NeverResourceDefinitionAccessor.cs
+++ /dev/null
@@ -1,104 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Threading;
-using System.Threading.Tasks;
-using JsonApiDotNetCore.Middleware;
-using JsonApiDotNetCore.Queries.Expressions;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-
-namespace UnitTests
-{
-    internal sealed class NeverResourceDefinitionAccessor : IResourceDefinitionAccessor
-    {
-        public IImmutableList<IncludeElementExpression> OnApplyIncludes(Type resourceType, IImmutableList<IncludeElementExpression> existingIncludes)
-        {
-            return existingIncludes;
-        }
-
-        public FilterExpression OnApplyFilter(Type resourceType, FilterExpression existingFilter)
-        {
-            return existingFilter;
-        }
-
-        public SortExpression OnApplySort(Type resourceType, SortExpression existingSort)
-        {
-            return existingSort;
-        }
-
-        public PaginationExpression OnApplyPagination(Type resourceType, PaginationExpression existingPagination)
-        {
-            return existingPagination;
-        }
-
-        public SparseFieldSetExpression OnApplySparseFieldSet(Type resourceType, SparseFieldSetExpression existingSparseFieldSet)
-        {
-            return existingSparseFieldSet;
-        }
-
-        public object GetQueryableHandlerForQueryStringParameter(Type resourceType, string parameterName)
-        {
-            return new QueryStringParameterHandlers<IIdentifiable>();
-        }
-
-        public IDictionary<string, object> GetMeta(Type resourceType, IIdentifiable resourceInstance)
-        {
-            return null;
-        }
-
-        public Task OnPrepareWriteAsync<TResource>(TResource resource, WriteOperationKind writeOperation, CancellationToken cancellationToken)
-            where TResource : class, IIdentifiable
-        {
-            return Task.CompletedTask;
-        }
-
-        public Task<IIdentifiable> OnSetToOneRelationshipAsync<TResource>(TResource leftResource, HasOneAttribute hasOneRelationship,
-            IIdentifiable rightResourceId, WriteOperationKind writeOperation, CancellationToken cancellationToken)
-            where TResource : class, IIdentifiable
-        {
-            return Task.FromResult(rightResourceId);
-        }
-
-        public Task OnSetToManyRelationshipAsync<TResource>(TResource leftResource, HasManyAttribute hasManyRelationship, ISet<IIdentifiable> rightResourceIds,
-            WriteOperationKind writeOperation, CancellationToken cancellationToken)
-            where TResource : class, IIdentifiable
-        {
-            return Task.CompletedTask;
-        }
-
-        public Task OnAddToRelationshipAsync<TResource, TId>(TId leftResourceId, HasManyAttribute hasManyRelationship, ISet<IIdentifiable> rightResourceIds,
-            CancellationToken cancellationToken)
-            where TResource : class, IIdentifiable<TId>
-        {
-            return Task.CompletedTask;
-        }
-
-        public Task OnRemoveFromRelationshipAsync<TResource>(TResource leftResource, HasManyAttribute hasManyRelationship, ISet<IIdentifiable> rightResourceIds,
-            CancellationToken cancellationToken)
-            where TResource : class, IIdentifiable
-        {
-            return Task.CompletedTask;
-        }
-
-        public Task OnWritingAsync<TResource>(TResource resource, WriteOperationKind writeOperation, CancellationToken cancellationToken)
-            where TResource : class, IIdentifiable
-        {
-            return Task.CompletedTask;
-        }
-
-        public Task OnWriteSucceededAsync<TResource>(TResource resource, WriteOperationKind writeOperation, CancellationToken cancellationToken)
-            where TResource : class, IIdentifiable
-        {
-            return Task.CompletedTask;
-        }
-
-        public void OnDeserialize(IIdentifiable resource)
-        {
-        }
-
-        public void OnSerialize(IIdentifiable resource)
-        {
-        }
-    }
-}
diff --git a/test/UnitTests/Serialization/Common/BaseDocumentBuilderTests.cs b/test/UnitTests/Serialization/Common/BaseDocumentBuilderTests.cs
deleted file mode 100644
index 5e590a4e21..0000000000
--- a/test/UnitTests/Serialization/Common/BaseDocumentBuilderTests.cs
+++ /dev/null
@@ -1,81 +0,0 @@
-using System.Collections.Generic;
-using JsonApiDotNetCore;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization.Building;
-using JsonApiDotNetCore.Serialization.Objects;
-using Moq;
-using UnitTests.TestModels;
-using Xunit;
-
-namespace UnitTests.Serialization.Common
-{
-    public sealed class BaseDocumentBuilderTests : SerializerTestsSetup
-    {
-        private readonly TestSerializer _builder;
-
-        public BaseDocumentBuilderTests()
-        {
-            var mock = new Mock<IResourceObjectBuilder>();
-
-            mock.Setup(builder => builder.Build(It.IsAny<IIdentifiable>(), It.IsAny<IReadOnlyCollection<AttrAttribute>>(),
-                It.IsAny<IReadOnlyCollection<RelationshipAttribute>>())).Returns(new ResourceObject());
-
-            _builder = new TestSerializer(mock.Object);
-        }
-
-        [Fact]
-        public void ResourceToDocument_NullResource_CanBuild()
-        {
-            // Act
-            Document document = _builder.PublicBuild((TestResource)null);
-
-            // Assert
-            Assert.Null(document.Data.Value);
-            Assert.True(document.Data.IsAssigned);
-        }
-
-        [Fact]
-        public void ResourceToDocument_EmptyList_CanBuild()
-        {
-            // Act
-            Document document = _builder.PublicBuild(new List<TestResource>());
-
-            // Assert
-            Assert.NotNull(document.Data.Value);
-            Assert.Empty(document.Data.ManyValue);
-        }
-
-        [Fact]
-        public void ResourceToDocument_SingleResource_CanBuild()
-        {
-            // Arrange
-            IIdentifiable dummy = new DummyResource();
-
-            // Act
-            Document document = _builder.PublicBuild(dummy);
-
-            // Assert
-            Assert.NotNull(document.Data.Value);
-            Assert.True(document.Data.IsAssigned);
-        }
-
-        [Fact]
-        public void ResourceToDocument_ResourceList_CanBuild()
-        {
-            // Arrange
-            DummyResource[] resources = ArrayFactory.Create(new DummyResource(), new DummyResource());
-
-            // Act
-            Document document = _builder.PublicBuild(resources);
-            IList<ResourceObject> data = document.Data.ManyValue;
-
-            // Assert
-            Assert.Equal(2, data.Count);
-        }
-
-        private sealed class DummyResource : Identifiable
-        {
-        }
-    }
-}
diff --git a/test/UnitTests/Serialization/Common/BaseDocumentParserTests.cs b/test/UnitTests/Serialization/Common/BaseDocumentParserTests.cs
deleted file mode 100644
index 6e6b417af9..0000000000
--- a/test/UnitTests/Serialization/Common/BaseDocumentParserTests.cs
+++ /dev/null
@@ -1,451 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.ComponentModel.Design;
-using System.Linq;
-using System.Reflection;
-using System.Text.Json;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Serialization;
-using JsonApiDotNetCore.Serialization.Objects;
-using UnitTests.TestModels;
-using Xunit;
-
-namespace UnitTests.Serialization.Common
-{
-    public sealed class BaseDocumentParserTests : DeserializerTestsSetup
-    {
-        private readonly TestDeserializer _deserializer;
-
-        public BaseDocumentParserTests()
-        {
-            _deserializer = new TestDeserializer(ResourceGraph, new ResourceFactory(new ServiceContainer()), Options);
-        }
-
-        [Fact]
-        public void DeserializeResourceIdentifiers_SingleData_CanDeserialize()
-        {
-            // Arrange
-            var content = new Document
-            {
-                Data = new SingleOrManyData<ResourceObject>(new ResourceObject
-                {
-                    Type = "testResource",
-                    Id = "1"
-                })
-            };
-
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            var result = (TestResource)_deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Equal(1, result.Id);
-        }
-
-        [Fact]
-        public void DeserializeResourceIdentifiers_EmptySingleData_CanDeserialize()
-        {
-            // Arrange
-            var content = new Document();
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            object result = _deserializer.Deserialize(body);
-
-            // Arrange
-            Assert.Null(result);
-        }
-
-        [Fact]
-        public void DeserializeResourceIdentifiers_ArrayData_CanDeserialize()
-        {
-            // Arrange
-            var content = new Document
-            {
-                Data = new SingleOrManyData<ResourceObject>(new List<ResourceObject>
-                {
-                    new()
-                    {
-                        Type = "testResource",
-                        Id = "1"
-                    }
-                })
-            };
-
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            var result = (IEnumerable<IIdentifiable>)_deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Equal("1", result.First().StringId);
-        }
-
-        [Fact]
-        public void DeserializeResourceIdentifiers_EmptyArrayData_CanDeserialize()
-        {
-            var content = new Document
-            {
-                Data = new SingleOrManyData<ResourceObject>(Array.Empty<ResourceObject>())
-            };
-
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            var result = (IEnumerable<IIdentifiable>)_deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Empty(result);
-        }
-
-        [Theory]
-        [InlineData("stringField", "some string")]
-        [InlineData("stringField", null)]
-        [InlineData("intField", null, true)]
-        [InlineData("intField", 1)]
-        [InlineData("intField", "1", true)]
-        [InlineData("nullableIntField", null)]
-        [InlineData("nullableIntField", 1)]
-        [InlineData("guidField", "bad format", true)]
-        [InlineData("guidField", "1a68be43-cc84-4924-a421-7f4d614b7781")]
-        [InlineData("dateTimeField", "9/11/2019 11:41:40 AM", true)]
-        [InlineData("dateTimeField", null, true)]
-        [InlineData("nullableDateTimeField", null)]
-        public void DeserializeAttributes_VariousDataTypes_CanDeserialize(string member, object value, bool expectError = false)
-        {
-            // Arrange
-            var content = new Document
-            {
-                Data = new SingleOrManyData<ResourceObject>(new ResourceObject
-                {
-                    Type = "testResource",
-                    Id = "1",
-                    Attributes = new Dictionary<string, object>
-                    {
-                        [member] = value
-                    }
-                })
-            };
-
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            Func<TestResource> action = () => (TestResource)_deserializer.Deserialize(body);
-
-            // Assert
-            if (expectError)
-            {
-                Assert.ThrowsAny<JsonApiSerializationException>(action);
-            }
-            else
-            {
-                TestResource resource = action();
-
-                PropertyInfo pi = ResourceGraph.GetResourceContext("testResource").GetAttributeByPublicName(member).Property;
-                object deserializedValue = pi.GetValue(resource);
-
-                if (member == "intField")
-                {
-                    Assert.Equal(1, deserializedValue);
-                }
-                else if (member == "nullableIntField" && value == null)
-                {
-                    Assert.Null(deserializedValue);
-                }
-                else if (member == "nullableIntField" && (int?)value == 1)
-                {
-                    Assert.Equal(1, deserializedValue);
-                }
-                else if (member == "guidField")
-                {
-                    Assert.Equal(deserializedValue, Guid.Parse("1a68be43-cc84-4924-a421-7f4d614b7781"));
-                }
-                else if (member == "dateTimeField")
-                {
-                    Assert.Equal(deserializedValue, DateTime.Parse("9/11/2019 11:41:40 AM"));
-                }
-                else
-                {
-                    Assert.Equal(value, deserializedValue);
-                }
-            }
-        }
-
-        [Fact]
-        public void DeserializeAttributes_ComplexType_CanDeserialize()
-        {
-            // Arrange
-            var content = new Document
-            {
-                Data = new SingleOrManyData<ResourceObject>(new ResourceObject
-                {
-                    Type = "testResource",
-                    Id = "1",
-                    Attributes = new Dictionary<string, object>
-                    {
-                        ["complexField"] = new Dictionary<string, object>
-                        {
-                            ["compoundName"] = "testName"
-                        }
-                    }
-                })
-            };
-
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            var result = (TestResource)_deserializer.Deserialize(body);
-
-            // Assert
-            Assert.NotNull(result.ComplexField);
-            Assert.Equal("testName", result.ComplexField.CompoundName);
-        }
-
-        [Fact]
-        public void DeserializeAttributes_ComplexListType_CanDeserialize()
-        {
-            // Arrange
-            var content = new Document
-            {
-                Data = new SingleOrManyData<ResourceObject>(new ResourceObject
-                {
-                    Type = "testResource-with-list",
-                    Id = "1",
-                    Attributes = new Dictionary<string, object>
-                    {
-                        ["complexFields"] = new[]
-                        {
-                            new Dictionary<string, object>
-                            {
-                                ["compoundName"] = "testName"
-                            }
-                        }
-                    }
-                })
-            };
-
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            var result = (TestResourceWithList)_deserializer.Deserialize(body);
-
-            // Assert
-            Assert.NotNull(result.ComplexFields);
-            Assert.NotEmpty(result.ComplexFields);
-            Assert.Equal("testName", result.ComplexFields[0].CompoundName);
-        }
-
-        [Fact]
-        public void DeserializeRelationship_SingleDataForToOneRelationship_CannotDeserialize()
-        {
-            // Arrange
-            Document content = CreateDocumentWithRelationships("oneToManyPrincipals", "dependents");
-
-            content.Data.SingleValue.Relationships["dependents"] = new RelationshipObject
-            {
-                Data = new SingleOrManyData<ResourceIdentifierObject>(new ResourceIdentifierObject
-                {
-                    Type = "Dependents",
-                    Id = "1"
-                })
-            };
-
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            Action action = () => _deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Throws<JsonApiSerializationException>(action);
-        }
-
-        [Fact]
-        public void DeserializeRelationship_ManyDataForToManyRelationship_CannotDeserialize()
-        {
-            // Arrange
-            Document content = CreateDocumentWithRelationships("oneToOnePrincipals", "dependent");
-
-            content.Data.SingleValue.Relationships["dependent"] = new RelationshipObject
-            {
-                Data = new SingleOrManyData<ResourceIdentifierObject>(new List<ResourceIdentifierObject>
-                {
-                    new()
-                    {
-                        Type = "Dependent",
-                        Id = "1"
-                    }
-                })
-            };
-
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            Action action = () => _deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Throws<JsonApiSerializationException>(action);
-        }
-
-        [Fact]
-        public void DeserializeRelationships_EmptyOneToOneDependent_NavigationPropertyIsNull()
-        {
-            // Arrange
-            Document content = CreateDocumentWithRelationships("oneToOnePrincipals", "dependent");
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            var result = (OneToOnePrincipal)_deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Equal(1, result.Id);
-            Assert.Null(result.Dependent);
-            Assert.Null(result.AttributeMember);
-        }
-
-        [Fact]
-        public void DeserializeRelationships_PopulatedOneToOneDependent_NavigationPropertyIsPopulated()
-        {
-            // Arrange
-            Document content = CreateDocumentWithRelationships("oneToOnePrincipals", "dependent", "oneToOneDependents");
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            var result = (OneToOnePrincipal)_deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Equal(1, result.Id);
-            Assert.Equal(10, result.Dependent.Id);
-            Assert.Null(result.AttributeMember);
-        }
-
-        [Fact]
-        public void DeserializeRelationships_EmptyOneToOnePrincipal_NavigationIsNull()
-        {
-            // Arrange
-            Document content = CreateDocumentWithRelationships("oneToOneDependents", "principal");
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            var result = (OneToOneDependent)_deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Equal(1, result.Id);
-            Assert.Null(result.Principal);
-        }
-
-        [Fact]
-        public void DeserializeRelationships_EmptyRequiredOneToOnePrincipal_NavigationIsNull()
-        {
-            // Arrange
-            Document content = CreateDocumentWithRelationships("oneToOneRequiredDependents", "principal");
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            var result = (OneToOneRequiredDependent)_deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Equal(1, result.Id);
-            Assert.Null(result.Principal);
-        }
-
-        [Fact]
-        public void DeserializeRelationships_PopulatedOneToOnePrincipal_NavigationIsPopulated()
-        {
-            // Arrange
-            Document content = CreateDocumentWithRelationships("oneToOneDependents", "principal", "oneToOnePrincipals");
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            var result = (OneToOneDependent)_deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Equal(1, result.Id);
-            Assert.NotNull(result.Principal);
-            Assert.Equal(10, result.Principal.Id);
-            Assert.Null(result.AttributeMember);
-        }
-
-        [Fact]
-        public void DeserializeRelationships_EmptyOneToManyPrincipal_NavigationIsNull()
-        {
-            // Arrange
-            Document content = CreateDocumentWithRelationships("oneToManyDependents", "principal");
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            var result = (OneToManyDependent)_deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Equal(1, result.Id);
-            Assert.Null(result.Principal);
-            Assert.Null(result.AttributeMember);
-        }
-
-        [Fact]
-        public void DeserializeRelationships_EmptyOneToManyRequiredPrincipal_NavigationIsNull()
-        {
-            // Arrange
-            Document content = CreateDocumentWithRelationships("oneToMany-requiredDependents", "principal");
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            var result = (OneToManyRequiredDependent)_deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Equal(1, result.Id);
-            Assert.Null(result.Principal);
-            Assert.Null(result.AttributeMember);
-        }
-
-        [Fact]
-        public void DeserializeRelationships_PopulatedOneToManyPrincipal_NavigationIsPopulated()
-        {
-            // Arrange
-            Document content = CreateDocumentWithRelationships("oneToManyDependents", "principal", "oneToManyPrincipals");
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            var result = (OneToManyDependent)_deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Equal(1, result.Id);
-            Assert.NotNull(result.Principal);
-            Assert.Equal(10, result.Principal.Id);
-            Assert.Null(result.AttributeMember);
-        }
-
-        [Fact]
-        public void DeserializeRelationships_EmptyOneToManyDependent_NavigationIsNull()
-        {
-            // Arrange
-            Document content = CreateDocumentWithRelationships("oneToManyPrincipals", "dependents", isToManyData: true);
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            var result = (OneToManyPrincipal)_deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Equal(1, result.Id);
-            Assert.Empty(result.Dependents);
-            Assert.Null(result.AttributeMember);
-        }
-
-        [Fact]
-        public void DeserializeRelationships_PopulatedOneToManyDependent_NavigationIsPopulated()
-        {
-            // Arrange
-            Document content = CreateDocumentWithRelationships("oneToManyPrincipals", "dependents", "oneToManyDependents", true);
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            var result = (OneToManyPrincipal)_deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Equal(1, result.Id);
-            Assert.Single(result.Dependents);
-            Assert.Equal(10, result.Dependents.First().Id);
-            Assert.Null(result.AttributeMember);
-        }
-    }
-}
diff --git a/test/UnitTests/Serialization/Common/ResourceObjectBuilderTests.cs b/test/UnitTests/Serialization/Common/ResourceObjectBuilderTests.cs
deleted file mode 100644
index 3e44774876..0000000000
--- a/test/UnitTests/Serialization/Common/ResourceObjectBuilderTests.cs
+++ /dev/null
@@ -1,235 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization.Building;
-using JsonApiDotNetCore.Serialization.Objects;
-using UnitTests.TestModels;
-using Xunit;
-
-namespace UnitTests.Serialization.Common
-{
-    public sealed class ResourceObjectBuilderTests : SerializerTestsSetup
-    {
-        private readonly ResourceObjectBuilder _builder;
-
-        public ResourceObjectBuilderTests()
-        {
-            _builder = new ResourceObjectBuilder(ResourceGraph, new JsonApiOptions());
-        }
-
-        [Fact]
-        public void ResourceToResourceObject_EmptyResource_CanBuild()
-        {
-            // Arrange
-            var resource = new TestResource();
-
-            // Act
-            ResourceObject resourceObject = _builder.Build(resource);
-
-            // Assert
-            Assert.Null(resourceObject.Attributes);
-            Assert.Null(resourceObject.Relationships);
-            Assert.Null(resourceObject.Id);
-            Assert.Equal("testResource", resourceObject.Type);
-        }
-
-        [Fact]
-        public void ResourceToResourceObject_ResourceWithId_CanBuild()
-        {
-            // Arrange
-            var resource = new TestResource
-            {
-                Id = 1
-            };
-
-            // Act
-            ResourceObject resourceObject = _builder.Build(resource);
-
-            // Assert
-            Assert.Equal("1", resourceObject.Id);
-            Assert.Null(resourceObject.Attributes);
-            Assert.Null(resourceObject.Relationships);
-            Assert.Equal("testResource", resourceObject.Type);
-        }
-
-        [Theory]
-        [InlineData(null, null)]
-        [InlineData("string field", 1)]
-        public void ResourceToResourceObject_ResourceWithIncludedAttrs_CanBuild(string stringFieldValue, int? intFieldValue)
-        {
-            // Arrange
-            var resource = new TestResource
-            {
-                StringField = stringFieldValue,
-                NullableIntField = intFieldValue
-            };
-
-            IReadOnlyCollection<AttrAttribute> attrs = ResourceGraph.GetAttributes<TestResource>(tr => new
-            {
-                tr.StringField,
-                tr.NullableIntField
-            });
-
-            // Act
-            ResourceObject resourceObject = _builder.Build(resource, attrs);
-
-            // Assert
-            Assert.NotNull(resourceObject.Attributes);
-            Assert.Equal(2, resourceObject.Attributes.Keys.Count);
-            Assert.Equal(stringFieldValue, resourceObject.Attributes["stringField"]);
-            Assert.Equal(intFieldValue, resourceObject.Attributes["nullableIntField"]);
-        }
-
-        [Fact]
-        public void ResourceWithRelationshipsToResourceObject_EmptyResource_CanBuild()
-        {
-            // Arrange
-            var resource = new MultipleRelationshipsPrincipalPart();
-
-            // Act
-            ResourceObject resourceObject = _builder.Build(resource);
-
-            // Assert
-            Assert.Null(resourceObject.Attributes);
-            Assert.Null(resourceObject.Relationships);
-            Assert.Null(resourceObject.Id);
-            Assert.Equal("multiPrincipals", resourceObject.Type);
-        }
-
-        [Fact]
-        public void ResourceWithRelationshipsToResourceObject_ResourceWithId_CanBuild()
-        {
-            // Arrange
-            var resource = new MultipleRelationshipsPrincipalPart
-            {
-                PopulatedToOne = new OneToOneDependent
-                {
-                    Id = 10
-                }
-            };
-
-            // Act
-            ResourceObject resourceObject = _builder.Build(resource);
-
-            // Assert
-            Assert.Null(resourceObject.Attributes);
-            Assert.Null(resourceObject.Relationships);
-            Assert.Null(resourceObject.Id);
-            Assert.Equal("multiPrincipals", resourceObject.Type);
-        }
-
-        [Fact]
-        public void ResourceWithRelationshipsToResourceObject_WithIncludedRelationshipsAttributes_CanBuild()
-        {
-            // Arrange
-            var resource = new MultipleRelationshipsPrincipalPart
-            {
-                PopulatedToOne = new OneToOneDependent
-                {
-                    Id = 10
-                },
-                PopulatedToManies = new HashSet<OneToManyDependent>
-                {
-                    new()
-                    {
-                        Id = 20
-                    }
-                }
-            };
-
-            IReadOnlyCollection<RelationshipAttribute> relationships = ResourceGraph.GetRelationships<MultipleRelationshipsPrincipalPart>(tr => new
-            {
-                tr.PopulatedToManies,
-                tr.PopulatedToOne,
-                tr.EmptyToOne,
-                tr.EmptyToManies
-            });
-
-            // Act
-            ResourceObject resourceObject = _builder.Build(resource, relationships: relationships);
-
-            // Assert
-            Assert.Equal(4, resourceObject.Relationships.Count);
-            Assert.Null(resourceObject.Relationships["emptyToOne"].Data.SingleValue);
-            Assert.Empty(resourceObject.Relationships["emptyToManies"].Data.ManyValue);
-            ResourceIdentifierObject populatedToOneData = resourceObject.Relationships["populatedToOne"].Data.SingleValue;
-            Assert.NotNull(populatedToOneData);
-            Assert.Equal("10", populatedToOneData.Id);
-            Assert.Equal("oneToOneDependents", populatedToOneData.Type);
-            IList<ResourceIdentifierObject> populatedToManyData = resourceObject.Relationships["populatedToManies"].Data.ManyValue;
-            Assert.Single(populatedToManyData);
-            Assert.Equal("20", populatedToManyData.First().Id);
-            Assert.Equal("oneToManyDependents", populatedToManyData.First().Type);
-        }
-
-        [Fact]
-        public void ResourceWithRelationshipsToResourceObject_DeviatingForeignKeyWhileRelationshipIncluded_IgnoresForeignKeyDuringBuild()
-        {
-            // Arrange
-            var resource = new OneToOneDependent
-            {
-                Principal = new OneToOnePrincipal
-                {
-                    Id = 10
-                },
-                PrincipalId = 123
-            };
-
-            IReadOnlyCollection<RelationshipAttribute> relationships = ResourceGraph.GetRelationships<OneToOneDependent>(tr => tr.Principal);
-
-            // Act
-            ResourceObject resourceObject = _builder.Build(resource, relationships: relationships);
-
-            // Assert
-            Assert.Single(resourceObject.Relationships);
-            Assert.NotNull(resourceObject.Relationships["principal"].Data.Value);
-            ResourceIdentifierObject ro = resourceObject.Relationships["principal"].Data.SingleValue;
-            Assert.Equal("10", ro.Id);
-        }
-
-        [Fact]
-        public void ResourceWithRelationshipsToResourceObject_DeviatingForeignKeyAndNoNavigationWhileRelationshipIncluded_IgnoresForeignKeyDuringBuild()
-        {
-            // Arrange
-            var resource = new OneToOneDependent
-            {
-                Principal = null,
-                PrincipalId = 123
-            };
-
-            IReadOnlyCollection<RelationshipAttribute> relationships = ResourceGraph.GetRelationships<OneToOneDependent>(tr => tr.Principal);
-
-            // Act
-            ResourceObject resourceObject = _builder.Build(resource, relationships: relationships);
-
-            // Assert
-            Assert.Null(resourceObject.Relationships["principal"].Data.Value);
-        }
-
-        [Fact]
-        public void ResourceWithRequiredRelationshipsToResourceObject_DeviatingForeignKeyWhileRelationshipIncluded_IgnoresForeignKeyDuringBuild()
-        {
-            // Arrange
-            var resource = new OneToOneRequiredDependent
-            {
-                Principal = new OneToOnePrincipal
-                {
-                    Id = 10
-                },
-                PrincipalId = 123
-            };
-
-            IReadOnlyCollection<RelationshipAttribute> relationships = ResourceGraph.GetRelationships<OneToOneRequiredDependent>(tr => tr.Principal);
-
-            // Act
-            ResourceObject resourceObject = _builder.Build(resource, relationships: relationships);
-
-            // Assert
-            Assert.Single(resourceObject.Relationships);
-            Assert.NotNull(resourceObject.Relationships["principal"].Data.SingleValue);
-            ResourceIdentifierObject ro = resourceObject.Relationships["principal"].Data.SingleValue;
-            Assert.Equal("10", ro.Id);
-        }
-    }
-}
diff --git a/test/UnitTests/Serialization/DeserializerTestsSetup.cs b/test/UnitTests/Serialization/DeserializerTestsSetup.cs
deleted file mode 100644
index 05fc33c886..0000000000
--- a/test/UnitTests/Serialization/DeserializerTestsSetup.cs
+++ /dev/null
@@ -1,119 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Text.Json;
-using JsonApiDotNetCore;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization;
-using JsonApiDotNetCore.Serialization.JsonConverters;
-using JsonApiDotNetCore.Serialization.Objects;
-using Microsoft.AspNetCore.Http;
-using Moq;
-
-namespace UnitTests.Serialization
-{
-    public class DeserializerTestsSetup : SerializationTestsSetupBase
-    {
-        protected readonly JsonApiOptions Options = new();
-        protected readonly JsonSerializerOptions SerializerWriteOptions;
-
-        protected Mock<IHttpContextAccessor> MockHttpContextAccessor { get; }
-
-        protected DeserializerTestsSetup()
-        {
-            Options.SerializerOptions.Converters.Add(new ResourceObjectConverter(ResourceGraph));
-
-            SerializerWriteOptions = ((IJsonApiOptions)Options).SerializerWriteOptions;
-            MockHttpContextAccessor = new Mock<IHttpContextAccessor>();
-            MockHttpContextAccessor.Setup(mock => mock.HttpContext).Returns(new DefaultHttpContext());
-        }
-
-        protected Document CreateDocumentWithRelationships(string primaryType, string relationshipMemberName, string relatedType = null,
-            bool isToManyData = false)
-        {
-            Document content = CreateDocumentWithRelationships(primaryType);
-            content.Data.SingleValue.Relationships.Add(relationshipMemberName, CreateRelationshipData(relatedType, isToManyData));
-            return content;
-        }
-
-        protected Document CreateDocumentWithRelationships(string primaryType)
-        {
-            return new()
-            {
-                Data = new SingleOrManyData<ResourceObject>(new ResourceObject
-                {
-                    Id = "1",
-                    Type = primaryType,
-                    Relationships = new Dictionary<string, RelationshipObject>()
-                })
-            };
-        }
-
-        protected RelationshipObject CreateRelationshipData(string relatedType = null, bool isToManyData = false, string id = "10")
-        {
-            var relationshipObject = new RelationshipObject();
-
-            ResourceIdentifierObject rio = relatedType == null
-                ? null
-                : new ResourceIdentifierObject
-                {
-                    Id = id,
-                    Type = relatedType
-                };
-
-            if (isToManyData)
-            {
-                IList<ResourceIdentifierObject> rios = relatedType != null ? rio.AsList() : Array.Empty<ResourceIdentifierObject>();
-                relationshipObject.Data = new SingleOrManyData<ResourceIdentifierObject>(rios);
-            }
-            else
-            {
-                relationshipObject.Data = new SingleOrManyData<ResourceIdentifierObject>(rio);
-            }
-
-            return relationshipObject;
-        }
-
-        protected Document CreateTestResourceDocument()
-        {
-            return new()
-            {
-                Data = new SingleOrManyData<ResourceObject>(new ResourceObject
-                {
-                    Type = "testResource",
-                    Id = "1",
-                    Attributes = new Dictionary<string, object>
-                    {
-                        ["stringField"] = "some string",
-                        ["intField"] = 1,
-                        ["nullableIntField"] = null,
-                        ["guidField"] = "1a68be43-cc84-4924-a421-7f4d614b7781",
-                        ["dateTimeField"] = DateTime.Parse("9/11/2019 11:41:40 AM", CultureInfo.InvariantCulture)
-                    }
-                })
-            };
-        }
-
-        protected sealed class TestDeserializer : BaseDeserializer
-        {
-            private readonly IJsonApiOptions _options;
-
-            public TestDeserializer(IResourceGraph resourceGraph, IResourceFactory resourceFactory, IJsonApiOptions options)
-                : base(resourceGraph, resourceFactory)
-            {
-                _options = options;
-            }
-
-            public object Deserialize(string body)
-            {
-                return DeserializeData(body, _options.SerializerReadOptions);
-            }
-
-            protected override void AfterProcessField(IIdentifiable resource, ResourceFieldAttribute field, RelationshipObject data = null)
-            {
-            }
-        }
-    }
-}
diff --git a/test/UnitTests/Serialization/FakeRequestQueryStringAccessor.cs b/test/UnitTests/Serialization/FakeRequestQueryStringAccessor.cs
deleted file mode 100644
index a2cfc2bebb..0000000000
--- a/test/UnitTests/Serialization/FakeRequestQueryStringAccessor.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using JsonApiDotNetCore.QueryStrings;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.WebUtilities;
-
-namespace UnitTests.Serialization
-{
-    internal sealed class FakeRequestQueryStringAccessor : IRequestQueryStringAccessor
-    {
-        public IQueryCollection Query { get; }
-
-        public FakeRequestQueryStringAccessor()
-            : this(null)
-        {
-        }
-
-        public FakeRequestQueryStringAccessor(string queryString)
-        {
-            Query = string.IsNullOrEmpty(queryString) ? QueryCollection.Empty : new QueryCollection(QueryHelpers.ParseQuery(queryString));
-        }
-    }
-}
diff --git a/test/UnitTests/Serialization/SerializationTestsSetupBase.cs b/test/UnitTests/Serialization/SerializationTestsSetupBase.cs
deleted file mode 100644
index 1d30044321..0000000000
--- a/test/UnitTests/Serialization/SerializationTestsSetupBase.cs
+++ /dev/null
@@ -1,93 +0,0 @@
-using Bogus;
-using JsonApiDotNetCore.Configuration;
-using Microsoft.Extensions.Logging.Abstractions;
-using UnitTests.TestModels;
-using Person = UnitTests.TestModels.Person;
-
-namespace UnitTests.Serialization
-{
-    public class SerializationTestsSetupBase
-    {
-        protected IResourceGraph ResourceGraph { get; }
-        protected Faker<Food> FoodFaker { get; }
-        protected Faker<Song> SongFaker { get; }
-        protected Faker<Article> ArticleFaker { get; }
-        protected Faker<Blog> BlogFaker { get; }
-        protected Faker<Person> PersonFaker { get; }
-
-        protected SerializationTestsSetupBase()
-        {
-            ResourceGraph = BuildGraph();
-
-            // @formatter:wrap_chained_method_calls chop_always
-            // @formatter:keep_existing_linebreaks true
-
-            ArticleFaker = new Faker<Article>()
-                .RuleFor(article => article.Title, faker => faker.Hacker.Phrase())
-                .RuleFor(article => article.Id, faker => faker.UniqueIndex + 1);
-
-            PersonFaker = new Faker<Person>()
-                .RuleFor(person => person.Name, faker => faker.Person.FullName)
-                .RuleFor(person => person.Id, faker => faker.UniqueIndex + 1);
-
-            BlogFaker = new Faker<Blog>()
-                .RuleFor(blog => blog.Title, faker => faker.Hacker.Phrase())
-                .RuleFor(blog => blog.Id, faker => faker.UniqueIndex + 1);
-
-            SongFaker = new Faker<Song>()
-                .RuleFor(song => song.Title, faker => faker.Lorem.Sentence())
-                .RuleFor(song => song.Id, faker => faker.UniqueIndex + 1);
-
-            FoodFaker = new Faker<Food>()
-                .RuleFor(food => food.Dish, faker => faker.Lorem.Sentence())
-                .RuleFor(food => food.Id, faker => faker.UniqueIndex + 1);
-
-            // @formatter:wrap_chained_method_calls restore
-            // @formatter:keep_existing_linebreaks restore
-        }
-
-        private IResourceGraph BuildGraph()
-        {
-            var resourceGraphBuilder = new ResourceGraphBuilder(new JsonApiOptions(), NullLoggerFactory.Instance);
-            resourceGraphBuilder.Add<TestResource>("testResource");
-            resourceGraphBuilder.Add<TestResourceWithList>("testResource-with-list");
-
-            BuildOneToOneRelationships(resourceGraphBuilder);
-            BuildOneToManyRelationships(resourceGraphBuilder);
-            BuildCollectiveRelationships(resourceGraphBuilder);
-
-            resourceGraphBuilder.Add<Article>();
-            resourceGraphBuilder.Add<Person>();
-            resourceGraphBuilder.Add<Blog>();
-            resourceGraphBuilder.Add<Food>();
-            resourceGraphBuilder.Add<Song>();
-
-            resourceGraphBuilder.Add<TestResourceWithAbstractRelationship>();
-            resourceGraphBuilder.Add<BaseModel>();
-            resourceGraphBuilder.Add<FirstDerivedModel>();
-            resourceGraphBuilder.Add<SecondDerivedModel>();
-
-            return resourceGraphBuilder.Build();
-        }
-
-        private static void BuildOneToOneRelationships(ResourceGraphBuilder resourceGraphBuilder)
-        {
-            resourceGraphBuilder.Add<OneToOnePrincipal>("oneToOnePrincipals");
-            resourceGraphBuilder.Add<OneToOneDependent>("oneToOneDependents");
-            resourceGraphBuilder.Add<OneToOneRequiredDependent>("oneToOneRequiredDependents");
-        }
-
-        private static void BuildOneToManyRelationships(ResourceGraphBuilder resourceGraphBuilder)
-        {
-            resourceGraphBuilder.Add<OneToManyPrincipal>("oneToManyPrincipals");
-            resourceGraphBuilder.Add<OneToManyDependent>("oneToManyDependents");
-            resourceGraphBuilder.Add<OneToManyRequiredDependent>("oneToMany-requiredDependents");
-        }
-
-        private static void BuildCollectiveRelationships(ResourceGraphBuilder resourceGraphBuilder)
-        {
-            resourceGraphBuilder.Add<MultipleRelationshipsPrincipalPart>("multiPrincipals");
-            resourceGraphBuilder.Add<MultipleRelationshipsDependentPart>("multiDependents");
-        }
-    }
-}
diff --git a/test/UnitTests/Serialization/SerializerTestsSetup.cs b/test/UnitTests/Serialization/SerializerTestsSetup.cs
deleted file mode 100644
index ccc5dae8e9..0000000000
--- a/test/UnitTests/Serialization/SerializerTestsSetup.cs
+++ /dev/null
@@ -1,190 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using JsonApiDotNetCore;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Queries;
-using JsonApiDotNetCore.Queries.Expressions;
-using JsonApiDotNetCore.Queries.Internal;
-using JsonApiDotNetCore.QueryStrings;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization;
-using JsonApiDotNetCore.Serialization.Building;
-using JsonApiDotNetCore.Serialization.Objects;
-using Moq;
-
-namespace UnitTests.Serialization
-{
-    public class SerializerTestsSetup : SerializationTestsSetupBase
-    {
-        private static readonly IncludeChainConverter IncludeChainConverter = new();
-
-        protected readonly TopLevelLinks DummyTopLevelLinks;
-        protected readonly ResourceLinks DummyResourceLinks;
-        protected readonly RelationshipLinks DummyRelationshipLinks;
-
-        protected SerializerTestsSetup()
-        {
-            DummyTopLevelLinks = new TopLevelLinks
-            {
-                Self = "http://www.dummy.com/dummy-self-link",
-                Next = "http://www.dummy.com/dummy-next-link",
-                Prev = "http://www.dummy.com/dummy-prev-link",
-                First = "http://www.dummy.com/dummy-first-link",
-                Last = "http://www.dummy.com/dummy-last-link"
-            };
-
-            DummyResourceLinks = new ResourceLinks
-            {
-                Self = "http://www.dummy.com/dummy-resource-self-link"
-            };
-
-            DummyRelationshipLinks = new RelationshipLinks
-            {
-                Related = "http://www.dummy.com/dummy-relationship-related-link",
-                Self = "http://www.dummy.com/dummy-relationship-self-link"
-            };
-        }
-
-        protected ResponseSerializer<T> GetResponseSerializer<T>(IEnumerable<IEnumerable<RelationshipAttribute>> inclusionChains = null,
-            Dictionary<string, object> metaDict = null, TopLevelLinks topLinks = null, ResourceLinks resourceLinks = null,
-            RelationshipLinks relationshipLinks = null)
-            where T : class, IIdentifiable
-        {
-            IEnumerable<RelationshipAttribute>[] inclusionChainArray = inclusionChains?.ToArray();
-
-            IMetaBuilder meta = GetMetaBuilder(metaDict);
-            ILinkBuilder link = GetLinkBuilder(topLinks, resourceLinks, relationshipLinks);
-            IEnumerable<IQueryConstraintProvider> includeConstraints = GetIncludeConstraints(inclusionChainArray);
-            IIncludedResourceObjectBuilder includedBuilder = GetIncludedBuilder(inclusionChainArray != null);
-            IFieldsToSerialize fieldsToSerialize = GetSerializableFields();
-            IResourceDefinitionAccessor resourceDefinitionAccessor = GetResourceDefinitionAccessor();
-            IEvaluatedIncludeCache evaluatedIncludeCache = GetEvaluatedIncludeCache(inclusionChainArray);
-            var options = new JsonApiOptions();
-
-            var resourceObjectBuilder = new ResponseResourceObjectBuilder(link, includedBuilder, includeConstraints, ResourceGraph, resourceDefinitionAccessor,
-                options, evaluatedIncludeCache);
-
-            return new ResponseSerializer<T>(meta, link, includedBuilder, fieldsToSerialize, resourceObjectBuilder, resourceDefinitionAccessor, options);
-        }
-
-        protected ResponseResourceObjectBuilder GetResponseResourceObjectBuilder(IEnumerable<IEnumerable<RelationshipAttribute>> inclusionChains = null,
-            ResourceLinks resourceLinks = null, RelationshipLinks relationshipLinks = null)
-        {
-            IEnumerable<RelationshipAttribute>[] inclusionChainArray = inclusionChains?.ToArray();
-
-            ILinkBuilder link = GetLinkBuilder(null, resourceLinks, relationshipLinks);
-            IEnumerable<IQueryConstraintProvider> includeConstraints = GetIncludeConstraints(inclusionChainArray);
-            IIncludedResourceObjectBuilder includedBuilder = GetIncludedBuilder(inclusionChains != null);
-            IEvaluatedIncludeCache evaluatedIncludeCache = GetEvaluatedIncludeCache(inclusionChainArray);
-            var options = new JsonApiOptions();
-
-            return new ResponseResourceObjectBuilder(link, includedBuilder, includeConstraints, ResourceGraph, GetResourceDefinitionAccessor(), options,
-                evaluatedIncludeCache);
-        }
-
-        private IIncludedResourceObjectBuilder GetIncludedBuilder(bool hasIncludeQueryString)
-        {
-            IFieldsToSerialize fieldsToSerialize = GetSerializableFields();
-            ILinkBuilder linkBuilder = GetLinkBuilder();
-            IResourceDefinitionAccessor resourceDefinitionAccessor = GetResourceDefinitionAccessor();
-            IRequestQueryStringAccessor queryStringAccessor = new FakeRequestQueryStringAccessor(hasIncludeQueryString ? "include=" : null);
-            var options = new JsonApiOptions();
-
-            return new IncludedResourceObjectBuilder(fieldsToSerialize, linkBuilder, ResourceGraph, Enumerable.Empty<IQueryConstraintProvider>(),
-                resourceDefinitionAccessor, queryStringAccessor, options);
-        }
-
-        private IResourceDefinitionAccessor GetResourceDefinitionAccessor()
-        {
-            var mock = new Mock<IResourceDefinitionAccessor>();
-            return mock.Object;
-        }
-
-        private IMetaBuilder GetMetaBuilder(Dictionary<string, object> meta = null)
-        {
-            var mock = new Mock<IMetaBuilder>();
-            mock.Setup(metaBuilder => metaBuilder.Build()).Returns(meta);
-            return mock.Object;
-        }
-
-        protected ILinkBuilder GetLinkBuilder(TopLevelLinks top = null, ResourceLinks resource = null, RelationshipLinks relationship = null)
-        {
-            var mock = new Mock<ILinkBuilder>();
-            mock.Setup(linkBuilder => linkBuilder.GetTopLevelLinks()).Returns(top);
-            mock.Setup(linkBuilder => linkBuilder.GetResourceLinks(It.IsAny<string>(), It.IsAny<string>())).Returns(resource);
-            mock.Setup(linkBuilder => linkBuilder.GetRelationshipLinks(It.IsAny<RelationshipAttribute>(), It.IsAny<IIdentifiable>())).Returns(relationship);
-            return mock.Object;
-        }
-
-        protected IFieldsToSerialize GetSerializableFields()
-        {
-            var mock = new Mock<IFieldsToSerialize>();
-            mock.Setup(fields => fields.GetAttributes(It.IsAny<Type>())).Returns<Type>(type => ResourceGraph.GetResourceContext(type).Attributes);
-            mock.Setup(fields => fields.GetRelationships(It.IsAny<Type>())).Returns<Type>(type => ResourceGraph.GetResourceContext(type).Relationships);
-            return mock.Object;
-        }
-
-        private IEnumerable<IQueryConstraintProvider> GetIncludeConstraints(IEnumerable<IEnumerable<RelationshipAttribute>> inclusionChains = null)
-        {
-            var expressionsInScope = new List<ExpressionInScope>();
-
-            if (inclusionChains != null)
-            {
-                List<ResourceFieldChainExpression> chains = inclusionChains.Select(relationships =>
-                    new ResourceFieldChainExpression(relationships.Cast<ResourceFieldAttribute>().ToImmutableArray())).ToList();
-
-                IncludeExpression includeExpression = IncludeChainConverter.FromRelationshipChains(chains);
-                expressionsInScope.Add(new ExpressionInScope(null, includeExpression));
-            }
-
-            var mock = new Mock<IQueryConstraintProvider>();
-            mock.Setup(provider => provider.GetConstraints()).Returns(expressionsInScope);
-
-            IQueryConstraintProvider includeConstraintProvider = mock.Object;
-            return includeConstraintProvider.AsEnumerable();
-        }
-
-        private IEvaluatedIncludeCache GetEvaluatedIncludeCache(IEnumerable<IEnumerable<RelationshipAttribute>> inclusionChains = null)
-        {
-            if (inclusionChains == null)
-            {
-                return new EvaluatedIncludeCache();
-            }
-
-            List<ResourceFieldChainExpression> chains = inclusionChains.Select(relationships =>
-                new ResourceFieldChainExpression(relationships.Cast<ResourceFieldAttribute>().ToImmutableArray())).ToList();
-
-            IncludeExpression includeExpression = IncludeChainConverter.FromRelationshipChains(chains);
-
-            var evaluatedIncludeCache = new EvaluatedIncludeCache();
-            evaluatedIncludeCache.Set(includeExpression);
-            return evaluatedIncludeCache;
-        }
-
-        /// <summary>
-        /// Minimal implementation of abstract JsonApiSerializer base class, with the purpose of testing the business logic for building the document structure.
-        /// </summary>
-        protected sealed class TestSerializer : BaseSerializer
-        {
-            public TestSerializer(IResourceObjectBuilder resourceObjectBuilder)
-                : base(resourceObjectBuilder)
-            {
-            }
-
-            public Document PublicBuild(IIdentifiable resource, IReadOnlyCollection<AttrAttribute> attributes = null,
-                IReadOnlyCollection<RelationshipAttribute> relationships = null)
-            {
-                return Build(resource, attributes, relationships);
-            }
-
-            public Document PublicBuild(IReadOnlyCollection<IIdentifiable> resources, IReadOnlyCollection<AttrAttribute> attributes = null,
-                IReadOnlyCollection<RelationshipAttribute> relationships = null)
-            {
-                return Build(resources, attributes, relationships);
-            }
-        }
-    }
-}
diff --git a/test/UnitTests/Serialization/Server/IncludedResourceObjectBuilderTests.cs b/test/UnitTests/Serialization/Server/IncludedResourceObjectBuilderTests.cs
deleted file mode 100644
index ee4fb88492..0000000000
--- a/test/UnitTests/Serialization/Server/IncludedResourceObjectBuilderTests.cs
+++ /dev/null
@@ -1,217 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Queries;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization;
-using JsonApiDotNetCore.Serialization.Building;
-using JsonApiDotNetCore.Serialization.Objects;
-using Moq;
-using UnitTests.TestModels;
-using Xunit;
-
-namespace UnitTests.Serialization.Server
-{
-    public sealed class IncludedResourceObjectBuilderTests : SerializerTestsSetup
-    {
-        [Fact]
-        public void BuildIncluded_DeeplyNestedCircularChainOfSingleData_CanBuild()
-        {
-            // Arrange
-            (Article article, Person author, _, Person reviewer, _) = GetAuthorChainInstances();
-            IReadOnlyCollection<RelationshipAttribute> authorChain = GetIncludedRelationshipsChain("author.blogs.reviewer.favoriteFood");
-            IncludedResourceObjectBuilder builder = GetBuilder();
-
-            // Act
-            builder.IncludeRelationshipChain(authorChain, article);
-            IList<ResourceObject> result = builder.Build();
-
-            // Assert
-            Assert.Equal(6, result.Count);
-
-            ResourceObject authorResourceObject = result.Single(ro => ro.Type == "people" && ro.Id == author.StringId);
-            ResourceIdentifierObject authorFoodRelation = authorResourceObject.Relationships["favoriteFood"].Data.SingleValue;
-            Assert.Equal(author.FavoriteFood.StringId, authorFoodRelation.Id);
-
-            ResourceObject reviewerResourceObject = result.Single(ro => ro.Type == "people" && ro.Id == reviewer.StringId);
-            ResourceIdentifierObject reviewerFoodRelation = reviewerResourceObject.Relationships["favoriteFood"].Data.SingleValue;
-            Assert.Equal(reviewer.FavoriteFood.StringId, reviewerFoodRelation.Id);
-        }
-
-        [Fact]
-        public void BuildIncluded_DeeplyNestedCircularChainOfManyData_BuildsWithoutDuplicates()
-        {
-            // Arrange
-            (Article article, Person author, _, _, _) = GetAuthorChainInstances();
-            Article secondArticle = ArticleFaker.Generate();
-            secondArticle.Author = author;
-            IncludedResourceObjectBuilder builder = GetBuilder();
-
-            // Act
-            IReadOnlyCollection<RelationshipAttribute> authorChain = GetIncludedRelationshipsChain("author.blogs.reviewer.favoriteFood");
-            builder.IncludeRelationshipChain(authorChain, article);
-            builder.IncludeRelationshipChain(authorChain, secondArticle);
-
-            // Assert
-            IList<ResourceObject> result = builder.Build();
-            Assert.Equal(6, result.Count);
-        }
-
-        [Fact]
-        public void BuildIncluded_OverlappingDeeplyNestedCircularChains_CanBuild()
-        {
-            // Arrange
-            IReadOnlyCollection<RelationshipAttribute> authorChain = GetIncludedRelationshipsChain("author.blogs.reviewer.favoriteFood");
-            (Article article, Person author, _, Person reviewer, Food reviewerFood) = GetAuthorChainInstances();
-            Blog sharedBlog = author.Blogs.First();
-            Person sharedBlogAuthor = reviewer;
-            Song authorSong = GetReviewerChainInstances(article, sharedBlog, sharedBlogAuthor);
-            IReadOnlyCollection<RelationshipAttribute> reviewerChain = GetIncludedRelationshipsChain("reviewer.blogs.author.favoriteSong");
-            IncludedResourceObjectBuilder builder = GetBuilder();
-
-            // Act
-            builder.IncludeRelationshipChain(authorChain, article);
-            builder.IncludeRelationshipChain(reviewerChain, article);
-            IList<ResourceObject> result = builder.Build();
-
-            // Assert
-            Assert.Equal(10, result.Count);
-            ResourceObject overlappingBlogResourceObject = result.Single(ro => ro.Type == "blogs" && ro.Id == sharedBlog.StringId);
-
-            Assert.Equal(2, overlappingBlogResourceObject.Relationships.Keys.Count);
-            List<ResourceObject> nonOverlappingBlogs = result.Where(ro => ro.Type == "blogs" && ro.Id != sharedBlog.StringId).ToList();
-
-            foreach (ResourceObject blog in nonOverlappingBlogs)
-            {
-                Assert.Single(blog.Relationships.Keys);
-            }
-
-            Assert.Equal(authorSong.StringId, sharedBlogAuthor.FavoriteSong.StringId);
-            Assert.Equal(reviewerFood.StringId, sharedBlogAuthor.FavoriteFood.StringId);
-        }
-
-        [Fact]
-        public void BuildIncluded_DuplicateChildrenMultipleChains_OnceInOutput()
-        {
-            Person person = PersonFaker.Generate();
-            List<Article> articles = ArticleFaker.Generate(5);
-            articles.ForEach(article => article.Author = person);
-            articles.ForEach(article => article.Reviewer = person);
-            IncludedResourceObjectBuilder builder = GetBuilder();
-            IReadOnlyCollection<RelationshipAttribute> authorChain = GetIncludedRelationshipsChain("author");
-            IReadOnlyCollection<RelationshipAttribute> reviewerChain = GetIncludedRelationshipsChain("reviewer");
-
-            foreach (Article article in articles)
-            {
-                builder.IncludeRelationshipChain(authorChain, article);
-                builder.IncludeRelationshipChain(reviewerChain, article);
-            }
-
-            IList<ResourceObject> result = builder.Build();
-            Assert.Single(result);
-            Assert.Equal(person.Name, result[0].Attributes["name"]);
-            Assert.Equal(person.StringId, result[0].Id);
-        }
-
-        private Song GetReviewerChainInstances(Article article, Blog sharedBlog, Person sharedBlogAuthor)
-        {
-            Person reviewer = PersonFaker.Generate();
-            article.Reviewer = reviewer;
-
-            List<Blog> blogs = BlogFaker.Generate(1);
-            blogs.Add(sharedBlog);
-            reviewer.Blogs = blogs.ToHashSet();
-
-            blogs[0].Author = reviewer;
-            Person author = PersonFaker.Generate();
-            blogs[1].Author = sharedBlogAuthor;
-
-            Song authorSong = SongFaker.Generate();
-            author.FavoriteSong = authorSong;
-            sharedBlogAuthor.FavoriteSong = authorSong;
-
-            Song reviewerSong = SongFaker.Generate();
-            reviewer.FavoriteSong = reviewerSong;
-
-            return authorSong;
-        }
-
-        private AuthorChainInstances GetAuthorChainInstances()
-        {
-            Article article = ArticleFaker.Generate();
-            Person author = PersonFaker.Generate();
-            article.Author = author;
-
-            List<Blog> blogs = BlogFaker.Generate(2);
-            author.Blogs = blogs.ToHashSet();
-
-            blogs[0].Reviewer = author;
-            Person reviewer = PersonFaker.Generate();
-            blogs[1].Reviewer = reviewer;
-
-            Food authorFood = FoodFaker.Generate();
-            author.FavoriteFood = authorFood;
-            Food reviewerFood = FoodFaker.Generate();
-            reviewer.FavoriteFood = reviewerFood;
-
-            return new AuthorChainInstances(article, author, authorFood, reviewer, reviewerFood);
-        }
-
-        private IReadOnlyCollection<RelationshipAttribute> GetIncludedRelationshipsChain(string chain)
-        {
-            var parsedChain = new List<RelationshipAttribute>();
-            ResourceContext resourceContext = ResourceGraph.GetResourceContext<Article>();
-            string[] splitPath = chain.Split('.');
-
-            foreach (string requestedRelationship in splitPath)
-            {
-                RelationshipAttribute relationship = resourceContext.GetRelationshipByPublicName(requestedRelationship);
-
-                parsedChain.Add(relationship);
-                resourceContext = ResourceGraph.GetResourceContext(relationship.RightType);
-            }
-
-            return parsedChain;
-        }
-
-        private IncludedResourceObjectBuilder GetBuilder()
-        {
-            IFieldsToSerialize fields = GetSerializableFields();
-            ILinkBuilder links = GetLinkBuilder();
-            IResourceDefinitionAccessor resourceDefinitionAccessor = new Mock<IResourceDefinitionAccessor>().Object;
-            var queryStringAccessor = new FakeRequestQueryStringAccessor();
-            var options = new JsonApiOptions();
-
-            return new IncludedResourceObjectBuilder(fields, links, ResourceGraph, Enumerable.Empty<IQueryConstraintProvider>(), resourceDefinitionAccessor,
-                queryStringAccessor, options);
-        }
-
-        private sealed class AuthorChainInstances
-        {
-            public Article Article { get; }
-            public Person Author { get; }
-            public Food AuthorFood { get; }
-            public Person Reviewer { get; }
-            public Food ReviewerFood { get; }
-
-            public AuthorChainInstances(Article article, Person author, Food authorFood, Person reviewer, Food reviewerFood)
-            {
-                Article = article;
-                Author = author;
-                AuthorFood = authorFood;
-                Reviewer = reviewer;
-                ReviewerFood = reviewerFood;
-            }
-
-            public void Deconstruct(out Article article, out Person author, out Food authorFood, out Person reviewer, out Food reviewerFood)
-            {
-                article = Article;
-                author = Author;
-                authorFood = AuthorFood;
-                reviewer = Reviewer;
-                reviewerFood = ReviewerFood;
-            }
-        }
-    }
-}
diff --git a/test/UnitTests/Serialization/Server/RequestDeserializerTests.cs b/test/UnitTests/Serialization/Server/RequestDeserializerTests.cs
deleted file mode 100644
index c6f8747eba..0000000000
--- a/test/UnitTests/Serialization/Server/RequestDeserializerTests.cs
+++ /dev/null
@@ -1,105 +0,0 @@
-using System.Collections.Generic;
-using System.Text.Json;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Middleware;
-using JsonApiDotNetCore.Resources;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization;
-using JsonApiDotNetCore.Serialization.JsonConverters;
-using JsonApiDotNetCore.Serialization.Objects;
-using Moq;
-using Xunit;
-
-namespace UnitTests.Serialization.Server
-{
-    public sealed class RequestDeserializerTests : DeserializerTestsSetup
-    {
-        private readonly RequestDeserializer _deserializer;
-        private readonly Mock<ITargetedFields> _fieldsManagerMock = new();
-        private readonly Mock<IJsonApiRequest> _requestMock = new();
-        private readonly Mock<IResourceDefinitionAccessor> _resourceDefinitionAccessorMock = new();
-
-        public RequestDeserializerTests()
-        {
-            var options = new JsonApiOptions();
-            options.SerializerOptions.Converters.Add(new ResourceObjectConverter(ResourceGraph));
-
-            _deserializer = new RequestDeserializer(ResourceGraph, new TestResourceFactory(), _fieldsManagerMock.Object, MockHttpContextAccessor.Object,
-                _requestMock.Object, options, _resourceDefinitionAccessorMock.Object);
-        }
-
-        [Fact]
-        public void DeserializeAttributes_VariousUpdatedMembers_RegistersTargetedFields()
-        {
-            // Arrange
-            var attributesToUpdate = new HashSet<AttrAttribute>();
-            var relationshipsToUpdate = new HashSet<RelationshipAttribute>();
-            SetupFieldsManager(attributesToUpdate, relationshipsToUpdate);
-
-            Document content = CreateTestResourceDocument();
-
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            _deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Equal(5, attributesToUpdate.Count);
-            Assert.Empty(relationshipsToUpdate);
-        }
-
-        [Fact]
-        public void DeserializeRelationships_MultipleDependentRelationships_RegistersUpdatedRelationships()
-        {
-            // Arrange
-            var attributesToUpdate = new HashSet<AttrAttribute>();
-            var relationshipsToUpdate = new HashSet<RelationshipAttribute>();
-            SetupFieldsManager(attributesToUpdate, relationshipsToUpdate);
-
-            Document content = CreateDocumentWithRelationships("multiPrincipals");
-            content.Data.SingleValue.Relationships.Add("populatedToOne", CreateRelationshipData("oneToOneDependents"));
-            content.Data.SingleValue.Relationships.Add("emptyToOne", CreateRelationshipData());
-            content.Data.SingleValue.Relationships.Add("populatedToManies", CreateRelationshipData("oneToManyDependents", true));
-            content.Data.SingleValue.Relationships.Add("emptyToManies", CreateRelationshipData(isToManyData: true));
-
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            _deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Equal(4, relationshipsToUpdate.Count);
-            Assert.Empty(attributesToUpdate);
-        }
-
-        [Fact]
-        public void DeserializeRelationships_MultiplePrincipalRelationships_RegistersUpdatedRelationships()
-        {
-            // Arrange
-            var attributesToUpdate = new HashSet<AttrAttribute>();
-            var relationshipsToUpdate = new HashSet<RelationshipAttribute>();
-            SetupFieldsManager(attributesToUpdate, relationshipsToUpdate);
-
-            Document content = CreateDocumentWithRelationships("multiDependents");
-            content.Data.SingleValue.Relationships.Add("populatedToOne", CreateRelationshipData("oneToOnePrincipals"));
-            content.Data.SingleValue.Relationships.Add("emptyToOne", CreateRelationshipData());
-            content.Data.SingleValue.Relationships.Add("populatedToMany", CreateRelationshipData("oneToManyPrincipals"));
-            content.Data.SingleValue.Relationships.Add("emptyToMany", CreateRelationshipData());
-
-            string body = JsonSerializer.Serialize(content, SerializerWriteOptions);
-
-            // Act
-            _deserializer.Deserialize(body);
-
-            // Assert
-            Assert.Equal(4, relationshipsToUpdate.Count);
-            Assert.Empty(attributesToUpdate);
-        }
-
-        private void SetupFieldsManager(HashSet<AttrAttribute> attributesToUpdate, HashSet<RelationshipAttribute> relationshipsToUpdate)
-        {
-            _fieldsManagerMock.Setup(fields => fields.Attributes).Returns(attributesToUpdate);
-            _fieldsManagerMock.Setup(fields => fields.Relationships).Returns(relationshipsToUpdate);
-        }
-    }
-}
diff --git a/test/UnitTests/Serialization/Server/ResponseResourceObjectBuilderTests.cs b/test/UnitTests/Serialization/Server/ResponseResourceObjectBuilderTests.cs
deleted file mode 100644
index e103cac808..0000000000
--- a/test/UnitTests/Serialization/Server/ResponseResourceObjectBuilderTests.cs
+++ /dev/null
@@ -1,122 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using JsonApiDotNetCore;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization.Building;
-using JsonApiDotNetCore.Serialization.Objects;
-using UnitTests.TestModels;
-using Xunit;
-
-namespace UnitTests.Serialization.Server
-{
-    public sealed class ResponseResourceObjectBuilderTests : SerializerTestsSetup
-    {
-        private const string RelationshipName = "dependents";
-        private readonly List<RelationshipAttribute> _relationshipsForBuild;
-
-        public ResponseResourceObjectBuilderTests()
-        {
-            _relationshipsForBuild = ResourceGraph.GetRelationships<OneToManyPrincipal>(relationship => new
-            {
-                relationship.Dependents
-            }).ToList();
-        }
-
-        [Fact]
-        public void Build_RelationshipNotIncludedAndLinksEnabled_RelationshipObjectWithLinks()
-        {
-            // Arrange
-            var resource = new OneToManyPrincipal
-            {
-                Id = 10
-            };
-
-            ResponseResourceObjectBuilder builder = GetResponseResourceObjectBuilder(relationshipLinks: DummyRelationshipLinks);
-
-            // Act
-            ResourceObject resourceObject = builder.Build(resource, relationships: _relationshipsForBuild);
-
-            // Assert
-            Assert.True(resourceObject.Relationships.TryGetValue(RelationshipName, out RelationshipObject relationshipObject));
-            Assert.Equal("http://www.dummy.com/dummy-relationship-self-link", relationshipObject.Links.Self);
-            Assert.Equal("http://www.dummy.com/dummy-relationship-related-link", relationshipObject.Links.Related);
-            Assert.False(relationshipObject.Data.IsAssigned);
-        }
-
-        [Fact]
-        public void Build_RelationshipNotIncludedAndLinksDisabled_NoRelationshipObject()
-        {
-            // Arrange
-            var resource = new OneToManyPrincipal
-            {
-                Id = 10
-            };
-
-            ResponseResourceObjectBuilder builder = GetResponseResourceObjectBuilder();
-
-            // Act
-            ResourceObject resourceObject = builder.Build(resource, relationships: _relationshipsForBuild);
-
-            // Assert
-            Assert.Null(resourceObject.Relationships);
-        }
-
-        [Fact]
-        public void Build_RelationshipIncludedAndLinksDisabled_RelationshipObjectWithData()
-        {
-            // Arrange
-            var resource = new OneToManyPrincipal
-            {
-                Id = 10,
-                Dependents = new HashSet<OneToManyDependent>
-                {
-                    new()
-                    {
-                        Id = 20
-                    }
-                }
-            };
-
-            ResponseResourceObjectBuilder builder = GetResponseResourceObjectBuilder(_relationshipsForBuild.AsEnumerable());
-
-            // Act
-            ResourceObject resourceObject = builder.Build(resource, relationships: _relationshipsForBuild);
-
-            // Assert
-            Assert.True(resourceObject.Relationships.TryGetValue(RelationshipName, out RelationshipObject relationshipObject));
-            Assert.Null(relationshipObject.Links);
-            Assert.True(relationshipObject.Data.IsAssigned);
-            Assert.Equal("20", relationshipObject.Data.ManyValue.Single().Id);
-        }
-
-        [Fact]
-        public void Build_RelationshipIncludedAndLinksEnabled_RelationshipObjectWithDataAndLinks()
-        {
-            // Arrange
-            var resource = new OneToManyPrincipal
-            {
-                Id = 10,
-                Dependents = new HashSet<OneToManyDependent>
-                {
-                    new()
-                    {
-                        Id = 20
-                    }
-                }
-            };
-
-            ResponseResourceObjectBuilder builder =
-                GetResponseResourceObjectBuilder(_relationshipsForBuild.AsEnumerable(), relationshipLinks: DummyRelationshipLinks);
-
-            // Act
-            ResourceObject resourceObject = builder.Build(resource, relationships: _relationshipsForBuild);
-
-            // Assert
-            Assert.True(resourceObject.Relationships.TryGetValue(RelationshipName, out RelationshipObject relationshipObject));
-            Assert.Equal("http://www.dummy.com/dummy-relationship-self-link", relationshipObject.Links.Self);
-            Assert.Equal("http://www.dummy.com/dummy-relationship-related-link", relationshipObject.Links.Related);
-            Assert.True(relationshipObject.Data.IsAssigned);
-            Assert.Equal("20", relationshipObject.Data.ManyValue.Single().Id);
-        }
-    }
-}
diff --git a/test/UnitTests/Serialization/Server/ResponseSerializerTests.cs b/test/UnitTests/Serialization/Server/ResponseSerializerTests.cs
deleted file mode 100644
index 2058c79e85..0000000000
--- a/test/UnitTests/Serialization/Server/ResponseSerializerTests.cs
+++ /dev/null
@@ -1,455 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Net;
-using System.Text.Json;
-using System.Text.RegularExpressions;
-using JsonApiDotNetCore;
-using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization;
-using JsonApiDotNetCore.Serialization.Objects;
-using UnitTests.TestModels;
-using Xunit;
-
-namespace UnitTests.Serialization.Server
-{
-    public sealed class ResponseSerializerTests : SerializerTestsSetup
-    {
-        [Fact]
-        public void SerializeSingle_ResourceWithDefaultTargetFields_CanSerialize()
-        {
-            // Arrange
-            var resource = new TestResource
-            {
-                Id = 1,
-                StringField = "value",
-                NullableIntField = 123
-            };
-
-            ResponseSerializer<TestResource> serializer = GetResponseSerializer<TestResource>();
-
-            // Act
-            string serialized = serializer.SerializeSingle(resource);
-
-            // Assert
-            const string expectedFormatted = @"{
-               ""data"":{
-                  ""type"":""testResource"",
-                  ""id"":""1"",
-                  ""attributes"":{
-                     ""stringField"":""value"",
-                     ""dateTimeField"":""0001-01-01T00:00:00"",
-                     ""nullableDateTimeField"":null,
-                     ""intField"":0,
-                     ""nullableIntField"":123,
-                     ""guidField"":""00000000-0000-0000-0000-000000000000"",
-                     ""complexField"":null
-                  }
-               }
-            }";
-
-            string expected = Regex.Replace(expectedFormatted, @"\s+", "");
-
-            Assert.Equal(expected, serialized);
-        }
-
-        [Fact]
-        public void SerializeMany_ResourceWithDefaultTargetFields_CanSerialize()
-        {
-            // Arrange
-            var resource = new TestResource
-            {
-                Id = 1,
-                StringField = "value",
-                NullableIntField = 123
-            };
-
-            ResponseSerializer<TestResource> serializer = GetResponseSerializer<TestResource>();
-
-            // Act
-            string serialized = serializer.SerializeMany(resource.AsArray());
-
-            // Assert
-            const string expectedFormatted = @"{
-               ""data"":[{
-                  ""type"":""testResource"",
-                  ""id"":""1"",
-                  ""attributes"":{
-                     ""stringField"":""value"",
-                     ""dateTimeField"":""0001-01-01T00:00:00"",
-                     ""nullableDateTimeField"":null,
-                     ""intField"":0,
-                     ""nullableIntField"":123,
-                     ""guidField"":""00000000-0000-0000-0000-000000000000"",
-                     ""complexField"":null
-                  }
-               }]
-            }";
-
-            string expected = Regex.Replace(expectedFormatted, @"\s+", "");
-            Assert.Equal(expected, serialized);
-        }
-
-        [Fact]
-        public void SerializeSingle_ResourceWithIncludedRelationships_CanSerialize()
-        {
-            // Arrange
-            var resource = new MultipleRelationshipsPrincipalPart
-            {
-                Id = 1,
-                PopulatedToOne = new OneToOneDependent
-                {
-                    Id = 10
-                },
-                PopulatedToManies = new HashSet<OneToManyDependent>
-                {
-                    new()
-                    {
-                        Id = 20
-                    }
-                }
-            };
-
-            ResourceContext resourceContext = ResourceGraph.GetResourceContext<MultipleRelationshipsPrincipalPart>();
-            List<IEnumerable<RelationshipAttribute>> chain = resourceContext.Relationships.Select(relationship => relationship.AsEnumerable()).ToList();
-
-            ResponseSerializer<MultipleRelationshipsPrincipalPart> serializer = GetResponseSerializer<MultipleRelationshipsPrincipalPart>(chain);
-
-            // Act
-            string serialized = serializer.SerializeSingle(resource);
-
-            // Assert
-            const string expectedFormatted = @"{
-               ""data"":{
-                  ""type"":""multiPrincipals"",
-                  ""id"":""1"",
-                  ""attributes"":{ ""attributeMember"":null },
-                  ""relationships"":{
-                     ""populatedToOne"":{
-                        ""data"":{
-                           ""type"":""oneToOneDependents"",
-                           ""id"":""10""
-                        }
-                     },
-                     ""emptyToOne"": { ""data"":null },
-                     ""populatedToManies"":{
-                        ""data"":[
-                           {
-                              ""type"":""oneToManyDependents"",
-                              ""id"":""20""
-                           }
-                        ]
-                     },
-                     ""emptyToManies"": { ""data"":[ ] },
-                     ""multi"":{ ""data"":null }
-                  }
-               },
-               ""included"":[
-                  {
-                     ""type"":""oneToOneDependents"",
-                     ""id"":""10"",
-                     ""attributes"":{ ""attributeMember"":null }
-                  },
-                  {
-                   ""type"":""oneToManyDependents"",
-                     ""id"":""20"",
-                     ""attributes"":{ ""attributeMember"":null }
-                  }
-               ]
-            }";
-
-            string expected = Regex.Replace(expectedFormatted, @"\s+", "");
-            Assert.Equal(expected, serialized);
-        }
-
-        [Fact]
-        public void SerializeSingle_ResourceWithDeeplyIncludedRelationships_CanSerialize()
-        {
-            // Arrange
-            var deeplyIncludedResource = new OneToManyPrincipal
-            {
-                Id = 30,
-                AttributeMember = "deep"
-            };
-
-            var includedResource = new OneToManyDependent
-            {
-                Id = 20,
-                Principal = deeplyIncludedResource
-            };
-
-            var resource = new MultipleRelationshipsPrincipalPart
-            {
-                Id = 10,
-                PopulatedToManies = new HashSet<OneToManyDependent>
-                {
-                    includedResource
-                }
-            };
-
-            ResourceContext outerResourceContext = ResourceGraph.GetResourceContext<MultipleRelationshipsPrincipalPart>();
-
-            List<List<RelationshipAttribute>> chains = outerResourceContext.Relationships.Select(relationship =>
-            {
-                List<RelationshipAttribute> chain = relationship.AsList();
-
-                if (relationship.PublicName != "populatedToManies")
-                {
-                    return chain;
-                }
-
-                ResourceContext innerResourceContext = ResourceGraph.GetResourceContext<OneToManyDependent>();
-                chain.AddRange(innerResourceContext.Relationships);
-                return chain;
-            }).ToList();
-
-            ResponseSerializer<MultipleRelationshipsPrincipalPart> serializer = GetResponseSerializer<MultipleRelationshipsPrincipalPart>(chains);
-
-            // Act
-            string serialized = serializer.SerializeSingle(resource);
-
-            // Assert
-            const string expectedFormatted = @"{
-               ""data"":{ 
-                  ""type"":""multiPrincipals"",
-                  ""id"":""10"",
-                  ""attributes"":{ 
-                     ""attributeMember"":null
-                  },
-                  ""relationships"":{ 
-                     ""populatedToOne"":{ 
-                        ""data"":null
-                     },
-                     ""emptyToOne"":{ 
-                        ""data"":null
-                     },
-                     ""populatedToManies"":{ 
-                        ""data"":[ 
-                           { 
-                              ""type"":""oneToManyDependents"",
-                              ""id"":""20""
-                           }
-                        ]
-                     },
-                     ""emptyToManies"":{ 
-                        ""data"":[]
-                     },
-                     ""multi"":{ 
-                        ""data"":null
-                     }
-                  }
-               },
-               ""included"":[
-                  { 
-                     ""type"":""oneToManyDependents"",
-                     ""id"":""20"",
-                     ""attributes"":{ 
-                        ""attributeMember"":null
-                     },
-                     ""relationships"":{ 
-                        ""principal"":{ 
-                           ""data"":{ 
-                              ""type"":""oneToManyPrincipals"",
-                              ""id"":""30""
-                           }
-                        }
-                     }
-                  },
-                  { 
-                     ""type"":""oneToManyPrincipals"",
-                     ""id"":""30"",
-                     ""attributes"":{ 
-                        ""attributeMember"":""deep""
-                     }
-                  }
-               ]
-            }";
-
-            string expected = Regex.Replace(expectedFormatted, @"\s+", "");
-            Assert.Equal(expected, serialized);
-        }
-
-        [Fact]
-        public void SerializeSingle_Null_CanSerialize()
-        {
-            // Arrange
-            ResponseSerializer<TestResource> serializer = GetResponseSerializer<TestResource>();
-
-            // Act
-            string serialized = serializer.SerializeSingle(null);
-
-            // Assert
-            const string expectedFormatted = @"{ ""data"": null }";
-            string expected = Regex.Replace(expectedFormatted, @"\s+", "");
-            Assert.Equal(expected, serialized);
-        }
-
-        [Fact]
-        public void SerializeList_EmptyList_CanSerialize()
-        {
-            // Arrange
-            ResponseSerializer<TestResource> serializer = GetResponseSerializer<TestResource>();
-
-            // Act
-            string serialized = serializer.SerializeMany(new List<TestResource>());
-
-            // Assert
-            const string expectedFormatted = @"{ ""data"": [] }";
-            string expected = Regex.Replace(expectedFormatted, @"\s+", "");
-            Assert.Equal(expected, serialized);
-        }
-
-        [Fact]
-        public void SerializeSingle_ResourceWithLinksEnabled_CanSerialize()
-        {
-            // Arrange
-            var resource = new OneToManyPrincipal
-            {
-                Id = 10
-            };
-
-            ResponseSerializer<OneToManyPrincipal> serializer = GetResponseSerializer<OneToManyPrincipal>(topLinks: DummyTopLevelLinks,
-                relationshipLinks: DummyRelationshipLinks, resourceLinks: DummyResourceLinks);
-
-            // Act
-            string serialized = serializer.SerializeSingle(resource);
-
-            // Assert
-            const string expectedFormatted = @"{
-               ""links"":{
-                  ""self"":""http://www.dummy.com/dummy-self-link"",
-                  ""first"":""http://www.dummy.com/dummy-first-link"",
-                  ""last"":""http://www.dummy.com/dummy-last-link"",
-                  ""prev"":""http://www.dummy.com/dummy-prev-link"",
-                  ""next"":""http://www.dummy.com/dummy-next-link""
-               },
-               ""data"":{
-                  ""type"":""oneToManyPrincipals"",
-                  ""id"":""10"",
-                  ""attributes"":{
-                     ""attributeMember"":null
-                  },
-                  ""relationships"":{
-                     ""dependents"":{
-                        ""links"":{
-                           ""self"":""http://www.dummy.com/dummy-relationship-self-link"",
-                           ""related"":""http://www.dummy.com/dummy-relationship-related-link""
-                        }
-                     }
-                  },
-                  ""links"":{
-                     ""self"":""http://www.dummy.com/dummy-resource-self-link""
-                  }
-               }
-            }";
-
-            string expected = Regex.Replace(expectedFormatted, @"\s+", "");
-            Assert.Equal(expected, serialized);
-        }
-
-        [Fact]
-        public void SerializeSingle_ResourceWithMeta_IncludesMetaInResult()
-        {
-            // Arrange
-            var meta = new Dictionary<string, object>
-            {
-                ["test"] = "meta"
-            };
-
-            var resource = new OneToManyPrincipal
-            {
-                Id = 10
-            };
-
-            ResponseSerializer<OneToManyPrincipal> serializer = GetResponseSerializer<OneToManyPrincipal>(metaDict: meta);
-
-            // Act
-            string serialized = serializer.SerializeSingle(resource);
-
-            // Assert
-            const string expectedFormatted = @"{
-                ""data"":{
-                    ""type"":""oneToManyPrincipals"",
-                    ""id"":""10"",
-                    ""attributes"":{
-                        ""attributeMember"":null
-                    }
-                },
-                ""meta"":{ ""test"": ""meta"" }
-            }";
-
-            string expected = Regex.Replace(expectedFormatted, @"\s+", "");
-            Assert.Equal(expected, serialized);
-        }
-
-        [Fact]
-        public void SerializeSingle_NullWithLinksAndMeta_StillShowsLinksAndMeta()
-        {
-            // Arrange
-            var meta = new Dictionary<string, object>
-            {
-                ["test"] = "meta"
-            };
-
-            ResponseSerializer<OneToManyPrincipal> serializer = GetResponseSerializer<OneToManyPrincipal>(metaDict: meta, topLinks: DummyTopLevelLinks,
-                relationshipLinks: DummyRelationshipLinks, resourceLinks: DummyResourceLinks);
-
-            // Act
-            string serialized = serializer.SerializeSingle(null);
-
-            // Assert
-            const string expectedFormatted = @"{
-                ""links"":{
-                    ""self"":""http://www.dummy.com/dummy-self-link"",
-                    ""first"":""http://www.dummy.com/dummy-first-link"",
-                    ""last"":""http://www.dummy.com/dummy-last-link"",
-                    ""prev"":""http://www.dummy.com/dummy-prev-link"",
-                    ""next"":""http://www.dummy.com/dummy-next-link""
-                },
-                ""data"": null,
-                ""meta"":{ ""test"": ""meta"" }
-            }";
-
-            string expected = Regex.Replace(expectedFormatted, @"\s+", "");
-            Assert.Equal(expected, serialized);
-        }
-
-        [Fact]
-        public void SerializeError_Error_CanSerialize()
-        {
-            // Arrange
-            var error = new ErrorObject(HttpStatusCode.InsufficientStorage)
-            {
-                Title = "title",
-                Detail = "detail"
-            };
-
-            var errorDocument = new Document
-            {
-                Errors = error.AsList()
-            };
-
-            string expectedJson = JsonSerializer.Serialize(new
-            {
-                errors = new[]
-                {
-                    new
-                    {
-                        id = error.Id,
-                        status = "507",
-                        title = "title",
-                        detail = "detail"
-                    }
-                }
-            });
-
-            ResponseSerializer<OneToManyPrincipal> serializer = GetResponseSerializer<OneToManyPrincipal>();
-
-            // Act
-            string result = serializer.Serialize(errorDocument);
-
-            // Assert
-            Assert.Equal(expectedJson, result);
-        }
-    }
-}
diff --git a/test/UnitTests/TestResourceFactory.cs b/test/UnitTests/TestResourceFactory.cs
deleted file mode 100644
index 8df6c2e4b1..0000000000
--- a/test/UnitTests/TestResourceFactory.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-using System;
-using System.Linq.Expressions;
-using JsonApiDotNetCore.Resources;
-
-namespace UnitTests
-{
-    internal sealed class TestResourceFactory : IResourceFactory
-    {
-        public IIdentifiable CreateInstance(Type resourceType)
-        {
-            return (IIdentifiable)Activator.CreateInstance(resourceType);
-        }
-
-        public TResource CreateInstance<TResource>()
-            where TResource : IIdentifiable
-        {
-            return (TResource)Activator.CreateInstance(typeof(TResource));
-        }
-
-        public NewExpression CreateNewExpression(Type resourceType)
-        {
-            return Expression.New(resourceType);
-        }
-    }
-}
diff --git a/test/UnitTests/TestScopedServiceProvider.cs b/test/UnitTests/TestScopedServiceProvider.cs
deleted file mode 100644
index f11b031997..0000000000
--- a/test/UnitTests/TestScopedServiceProvider.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-using System;
-using JsonApiDotNetCore.Configuration;
-using Microsoft.AspNetCore.Http;
-using Moq;
-
-namespace UnitTests
-{
-    public sealed class TestScopedServiceProvider : IRequestScopedServiceProvider
-    {
-        private readonly IServiceProvider _serviceProvider;
-        private readonly Mock<IHttpContextAccessor> _httpContextAccessorMock = new();
-
-        public TestScopedServiceProvider(IServiceProvider serviceProvider)
-        {
-            _serviceProvider = serviceProvider;
-        }
-
-        public object GetService(Type serviceType)
-        {
-            if (serviceType == typeof(IHttpContextAccessor))
-            {
-                return _httpContextAccessorMock.Object;
-            }
-
-            return _serviceProvider.GetService(serviceType);
-        }
-    }
-}
diff --git a/wiki/v4/content/serialization.md b/wiki/v4/content/serialization.md
deleted file mode 100644
index 7145333b52..0000000000
--- a/wiki/v4/content/serialization.md
+++ /dev/null
@@ -1,111 +0,0 @@
-
-# Serialization
-
-The main change for serialization is that we have split the serialization responsibilities into two parts:
-
-* **Response (de)serializers** - (de)Serialization regarding serving or interpreting a response.
-* **Request (de)serializer** - (de)Serialization regarding creating or interpreting a request.
-
-This split is done because during deserialization, some parts are relevant only for *client*-side parsing whereas others are only for *server*-side parsing. for example, a server deserializer will never have to deal with a `included` object list. Similarly, in serialization, a client serializer will for example never ever have to populate any other top-level members than the primary data (like `meta`, `included`). 
-
-Throughout the document and the code when referring to fields, members, object types, the technical language of JSON:API spec is used. At the core of (de)serialization is the
-`Document` class, [see document spec](https://jsonapi.org/format/#document-structure).
-
-## Changes
-
-In this section we will detail the changes made to the (de)serialization compared to the previous version.
-
-### Deserialization
-
-The previous `JsonApiDeSerializer` implementation is now split into a `RequestDeserializer` and `ResponseDeserializer`. Both inherit from `BaseDocumentParser` which does the shared parsing.
-
-#### BaseDocumentParser
-
-This (base) class is responsible for:
-
-* Converting the serialized string content into an intance of the `Document` class. Which is the most basic version of JSON:API which has a `Data`, `Meta` and `Included` property.
-* Building instances of the corresponding resource class (eg `Article`) by going through the document's primary data (`Document.Data`) For the spec for this: [Document spec](https://jsonapi.org/format/#document-top-level).
-
-Responsibility of any implementation the base class-specific parsing is shifted through the abstract `BaseDocumentParser.AfterProcessField()` method. This method is fired once each time after a `AttrAttribute` or `RelationshipAttribute` is processed. It allows a implementation of `BaseDocumentParser` to intercept the parsing and add steps that are only required for new implementations.
-
-#### ResponseDeserializer
-
-The client deserializer complements the base deserialization by
-
-* overriding the `AfterProcessField` method which takes care of the Included section \* after a relationship was deserialized, it finds the appended included object and adds it attributs and (nested) relationships
-* taking care of remaining top-level members. that are only relevant to a client-side parser (meta data, server-side errors, links).
-
-#### RequestDeserializer
-
-For server-side parsing, no extra parsing needs to be done after the base deserialization is completed. It only needs to keep track of which `AttrAttribute`s and `RelationshipAttribute`s were targeted by a request. This is needed for the internals of JADNC (eg the repository layer).
-
-* The `AfterProcessField` method is overriden so that every attribute and relationship is registered with the `ITargetedFields` service after it is processed.
-
-## Serialization
-
-Like with the deserializers, `JsonApiSerializer` is now split up into these classes (indentation implies hierarchy/extending):
-
-* `IncludedResourceObjectBuilder`
-
-* `ResourceObjectBuilder` - *abstract* 
-  * `DocumentBuilder` - *abstract* -
-    * `ResponseSerializer`
-    * `RequestSerializer`
-
-### ResourceObjectBuilder
-
-At the core of serialization is the `ResourceObject` class [see resource object spec](https://jsonapi.org/format/#document-resource-objects).
-
-ResourceObjectBuilder is responsible for Building a `ResourceObject` from an entity given a list of `AttrAttribute`s and `RelationshipAttribute`s. - Note: the resource object builder is NOT responsible for figuring out which attributes and relationships should be included in the serialization result, because this differs depending on an the implementation being client or server side. Instead, it is provided with the list.
-
-Additionally, client and server serializers also differ in how relationship members ([see relationship member spec](https://jsonapi.org/format/#document-resource-object-attributes) are formatted. The responsibility for handling this is again shifted, this time by virtual `ResourceObjectBuilder.GetRelationshipData()` method. This method is fired once each time a `RelationshipAttribute` is processed, allowing for additional serialization (like adding links or metadata).
-
-This time, the `GetRelationshipData()` method is not abstract, but virtual with a default implementation. This default implementation is to just create a `RelationshipData` with primary data (like `{"related-foo": { "data": { "id": 1" "type": "foobar"}}}`). Some implementations (server, included builder) need additional logic, others don't (client).
-
-### BaseDocumentBuilder
-Responsible for
-
--   Calling the base resource object serialization for one (or many) entities and wrapping the result in a `Document`.
-
-Thats all. It does not figure out which attributes or relationships are to be serialized.
-
-### RequestSerializer
-
-Responsible for figuring out which attributes and relationships need to be serialized and calling the base document builder with that.
-For example:
-
--   for a POST request, this is often (almost) all attributes.
--   for a PATCH request, this is usually a small subset of attributes.
-
-Note that the client serializer is relatively skinny, because no top-level data (included, meta, links) will ever have to be added anywhere in the document.
-
-### ResponseSerializer
-
-Responsible for figuring out which attributes and relationships need to be serialized and calling the base document builder with that.
-For example, for a GET request, all attributes are usually included in the output, unless
-
-* Sparse field selection was applied in the client request
-* Runtime attribute hiding was applied, see [JADNC docs](https://json-api-dotnet.github.io/JsonApiDotNetCore/usage/resources/resource-definitions.html#runtime-attribute-filtering)
-
-The server serializer is also responsible for adding top-level meta data and links and appending included relationships. For this the `GetRelationshipData()` is overriden:
-
-* it adds links to the `RelationshipData` object (if configured to do so, see `ILinksConfiguration`).
-* it checks if the processed relationship needs to be enclosed in the `included` list. If so, it calls the `IIncludedResourceObjectBuilder` to take care of that.
-
-### IncludedResourceObjectBuilder
-Responsible for building the *included member* of a `Document`. Note that `IncludedResourceObjectBuilder` extends `ResourceObjectBuilder` and not `BaseDocumentBuilder` because it does not need to build an entire document but only resource objects.
-
-Responsible for building the _included member_ of a `Document`. Note that `IncludedResourceObjectBuilder` extends `ResourceObjectBuilder` and not `DocumentBuilder` because it does not need to build an entire document but only resource objects.
-
-Relationship _inclusion chains_ are at the core of building the included member. For example, consider the request `articles?included=author.blogs.reviewers.favorite-food,reviewer.blogs.author.favorite-song`. It contains the following (complex) inclusion chains:
-
-1. `author.blogs.reviewers.favorite-food`
-2. `reviewer.blogs.author.favorite-song`
-
-Like with the `RequestSerializer` and `ResponseSerializer`, the `IncludedResourceObjectBuilder` is responsible for calling the base resource object builder with the list of attributes and relationships. For this implementation, these lists depend strongly on the inclusion chains. The above complex example demonstrates this (note: in this example the relationships `author` and `reviewer` are of the same resource `people`):
-
-* people that were included as reviewers from inclusion chain (1) should come with their `favorite-food` included, but not those from chain (2)
-* people that were included as authors from inclusion chain (2) should come with their `favorite-song` included, but not those from chain (1).
-* a person that was included as both an reviewer and author (i.e. targeted by both chain (1) and (2)), both `favorite-food` and `favorite-song` need to be present.
-
-To achieve this all of this, the `IncludedResourceObjectBuilder` needs to recursively parse an inclusion chain and make sure it does not append the same included more than once. This strategy is different from that of the ResponseSerializer, and for that reason it is a separate service.