Makes the serializer take changes from IResourceDefinition.OnApplyChanges into account. This enables adding extra includes from a resource definition.

Bart Koelman · Bart Koelman · commit 883f65bbf791 · 2021-06-10T19:31:14.000+02:00
diff --git a/src/JsonApiDotNetCore/Configuration/JsonApiApplicationBuilder.cs b/src/JsonApiDotNetCore/Configuration/JsonApiApplicationBuilder.cs
@@ -158,6 +158,7 @@ public void ConfigureServiceContainer(ICollection<Type> dbContextTypes)
             _services.AddScoped<IGenericServiceFactory, GenericServiceFactory>();
             _services.AddScoped(typeof(IResourceChangeTracker<>), typeof(ResourceChangeTracker<>));
             _services.AddScoped<IPaginationContext, PaginationContext>();
+            _services.AddScoped<IEvaluatedIncludeCache, EvaluatedIncludeCache>();
             _services.AddScoped<IQueryLayerComposer, QueryLayerComposer>();
             _services.AddScoped<IInverseNavigationResolver, InverseNavigationResolver>();
         }
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/IncludeChainConverter.cs b/src/JsonApiDotNetCore/Queries/Expressions/IncludeChainConverter.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using JsonApiDotNetCore.Resources.Annotations;
@@ -32,6 +33,11 @@ public IReadOnlyCollection<ResourceFieldChainExpression> GetRelationshipChains(I
         {
             ArgumentGuard.NotNull(include, nameof(include));
 
+            if (!include.Elements.Any())
+            {
+                return Array.Empty<ResourceFieldChainExpression>();
+            }
+
             var converter = new IncludeToChainsConverter();
             converter.Visit(include, null);
 
diff --git a/src/JsonApiDotNetCore/Queries/Internal/EvaluatedIncludeCache.cs b/src/JsonApiDotNetCore/Queries/Internal/EvaluatedIncludeCache.cs
@@ -0,0 +1,22 @@
+using JsonApiDotNetCore.Queries.Expressions;
+
+namespace JsonApiDotNetCore.Queries.Internal
+{
+    /// <inheritdoc />
+    internal sealed class EvaluatedIncludeCache : IEvaluatedIncludeCache
+    {
+        private IncludeExpression _include;
+
+        /// <inheritdoc />
+        public void Set(IncludeExpression include)
+        {
+            _include = include;
+        }
+
+        /// <inheritdoc />
+        public IncludeExpression Get()
+        {
+            return _include;
+        }
+    }
+}
diff --git a/src/JsonApiDotNetCore/Queries/Internal/IEvaluatedIncludeCache.cs b/src/JsonApiDotNetCore/Queries/Internal/IEvaluatedIncludeCache.cs
@@ -0,0 +1,23 @@
+using JsonApiDotNetCore.Queries.Expressions;
+using JsonApiDotNetCore.Resources;
+
+namespace JsonApiDotNetCore.Queries.Internal
+{
+    /// <summary>
+    /// Provides in-memory storage for the evaluated inclusion tree within a request. This tree is produced from query string and resource definition
+    /// callbacks. The cache enables the serialization layer to take changes from <see cref="IResourceDefinition{TResource,TId}.OnApplyIncludes" /> into
+    /// account.
+    /// </summary>
+    public interface IEvaluatedIncludeCache
+    {
+        /// <summary>
+        /// Stores the evaluated inclusion tree for later usage.
+        /// </summary>
+        void Set(IncludeExpression include);
+
+        /// <summary>
+        /// Gets the evaluated inclusion tree that was stored earlier.
+        /// </summary>
+        IncludeExpression Get();
+    }
+}
diff --git a/src/JsonApiDotNetCore/Queries/Internal/QueryLayerComposer.cs b/src/JsonApiDotNetCore/Queries/Internal/QueryLayerComposer.cs
@@ -20,25 +20,28 @@ public class QueryLayerComposer : IQueryLayerComposer
         private readonly IJsonApiOptions _options;
         private readonly IPaginationContext _paginationContext;
         private readonly ITargetedFields _targetedFields;
+        private readonly IEvaluatedIncludeCache _evaluatedIncludeCache;
         private readonly SparseFieldSetCache _sparseFieldSetCache;
 
         public QueryLayerComposer(IEnumerable<IQueryConstraintProvider> constraintProviders, IResourceContextProvider resourceContextProvider,
             IResourceDefinitionAccessor resourceDefinitionAccessor, IJsonApiOptions options, IPaginationContext paginationContext,
-            ITargetedFields targetedFields)
+            ITargetedFields targetedFields, IEvaluatedIncludeCache evaluatedIncludeCache)
         {
             ArgumentGuard.NotNull(constraintProviders, nameof(constraintProviders));
             ArgumentGuard.NotNull(resourceContextProvider, nameof(resourceContextProvider));
             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));
 
             _constraintProviders = constraintProviders;
             _resourceContextProvider = resourceContextProvider;
             _resourceDefinitionAccessor = resourceDefinitionAccessor;
             _options = options;
             _paginationContext = paginationContext;
             _targetedFields = targetedFields;
+            _evaluatedIncludeCache = evaluatedIncludeCache;
             _sparseFieldSetCache = new SparseFieldSetCache(_constraintProviders, resourceDefinitionAccessor);
         }
 
@@ -72,6 +75,8 @@ public QueryLayer ComposeFromConstraints(ResourceContext requestResource)
             QueryLayer topLayer = ComposeTopLayer(constraints, requestResource);
             topLayer.Include = ComposeChildren(topLayer, constraints);
 
+            _evaluatedIncludeCache.Set(topLayer.Include);
+
             return topLayer;
         }
 
diff --git a/src/JsonApiDotNetCore/Serialization/AtomicOperationsResponseSerializer.cs b/src/JsonApiDotNetCore/Serialization/AtomicOperationsResponseSerializer.cs
@@ -4,6 +4,7 @@
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Queries.Internal;
 using JsonApiDotNetCore.Resources;
 using JsonApiDotNetCore.Resources.Annotations;
 using JsonApiDotNetCore.Serialization.Building;
@@ -21,27 +22,30 @@ public sealed class AtomicOperationsResponseSerializer : BaseSerializer, IJsonAp
         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, IJsonApiRequest request, IJsonApiOptions options)
+            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;
         }
@@ -93,6 +97,7 @@ private AtomicResultObject SerializeOperation(OperationContainer operation)
             {
                 _request.CopyFrom(operation.Request);
                 _fieldsToSerialize.ResetCache();
+                _evaluatedIncludeCache.Set(null);
 
                 _resourceDefinitionAccessor.OnSerialize(operation.Resource);
 
diff --git a/src/JsonApiDotNetCore/Serialization/Building/ResponseResourceObjectBuilder.cs b/src/JsonApiDotNetCore/Serialization/Building/ResponseResourceObjectBuilder.cs
@@ -5,7 +5,6 @@
 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;
@@ -17,28 +16,31 @@ public class ResponseResourceObjectBuilder : ResourceObjectBuilder
     {
         private static readonly IncludeChainConverter IncludeChainConverter = new IncludeChainConverter();
 
+        private readonly ILinkBuilder _linkBuilder;
         private readonly IIncludedResourceObjectBuilder _includedBuilder;
-        private readonly IEnumerable<IQueryConstraintProvider> _constraintProviders;
         private readonly IResourceDefinitionAccessor _resourceDefinitionAccessor;
-        private readonly ILinkBuilder _linkBuilder;
+        private readonly IEvaluatedIncludeCache _evaluatedIncludeCache;
         private readonly SparseFieldSetCache _sparseFieldSetCache;
+
         private RelationshipAttribute _requestRelationship;
 
         public ResponseResourceObjectBuilder(ILinkBuilder linkBuilder, IIncludedResourceObjectBuilder includedBuilder,
             IEnumerable<IQueryConstraintProvider> constraintProviders, IResourceContextProvider resourceContextProvider,
-            IResourceDefinitionAccessor resourceDefinitionAccessor, IResourceObjectBuilderSettingsProvider settingsProvider)
+            IResourceDefinitionAccessor resourceDefinitionAccessor, IResourceObjectBuilderSettingsProvider settingsProvider,
+            IEvaluatedIncludeCache evaluatedIncludeCache)
             : base(resourceContextProvider, settingsProvider.Get())
         {
             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;
-            _constraintProviders = constraintProviders;
             _resourceDefinitionAccessor = resourceDefinitionAccessor;
-            _sparseFieldSetCache = new SparseFieldSetCache(_constraintProviders, resourceDefinitionAccessor);
+            _evaluatedIncludeCache = evaluatedIncludeCache;
+            _sparseFieldSetCache = new SparseFieldSetCache(constraintProviders, resourceDefinitionAccessor);
         }
 
         public RelationshipEntry Build(IIdentifiable resource, RelationshipAttribute requestRelationship)
@@ -72,7 +74,7 @@ protected override RelationshipEntry GetRelationshipData(RelationshipAttribute r
             ArgumentGuard.NotNull(resource, nameof(resource));
 
             RelationshipEntry relationshipEntry = null;
-            IReadOnlyCollection<IReadOnlyCollection<RelationshipAttribute>> relationshipChains = GetInclusionChain(relationship);
+            IReadOnlyCollection<IReadOnlyCollection<RelationshipAttribute>> relationshipChains = GetInclusionChainsStartingWith(relationship);
 
             if (Equals(relationship, _requestRelationship) || relationshipChains.Any())
             {
@@ -116,35 +118,24 @@ private bool IsRelationshipInSparseFieldSet(RelationshipAttribute relationship)
         }
 
         /// <summary>
-        /// Inspects the included relationship chains (see <see cref="IIncludeQueryStringParameterReader" /> to see if <paramref name="relationship" /> should be
-        /// included or not.
+        /// Inspects the included relationship chains and selects the ones that starts with the specified relationship.
         /// </summary>
-        private IReadOnlyCollection<IReadOnlyCollection<RelationshipAttribute>> GetInclusionChain(RelationshipAttribute relationship)
+        private IReadOnlyCollection<IReadOnlyCollection<RelationshipAttribute>> GetInclusionChainsStartingWith(RelationshipAttribute relationship)
         {
-            // @formatter:wrap_chained_method_calls chop_always
-            // @formatter:keep_existing_linebreaks true
-
-            ResourceFieldChainExpression[] chains = _constraintProviders
-                .SelectMany(provider => provider.GetConstraints())
-                .Select(expressionInScope => expressionInScope.Expression)
-                .OfType<IncludeExpression>()
-                .SelectMany(IncludeChainConverter.GetRelationshipChains)
-                .ToArray();
-
-            // @formatter:keep_existing_linebreaks restore
-            // @formatter:wrap_chained_method_calls restore
+            IncludeExpression include = _evaluatedIncludeCache.Get() ?? IncludeExpression.Empty;
+            IReadOnlyCollection<ResourceFieldChainExpression> chains = IncludeChainConverter.GetRelationshipChains(include);
 
-            var inclusionChain = new List<IReadOnlyCollection<RelationshipAttribute>>();
+            var inclusionChains = new List<IReadOnlyCollection<RelationshipAttribute>>();
 
             foreach (ResourceFieldChainExpression chain in chains)
             {
                 if (chain.Fields.First().Equals(relationship))
                 {
-                    inclusionChain.Add(chain.Fields.Cast<RelationshipAttribute>().ToArray());
+                    inclusionChains.Add(chain.Fields.Cast<RelationshipAttribute>().ToArray());
                 }
             }
 
-            return inclusionChain;
+            return inclusionChains;
         }
     }
 }
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Reading/IClientSettingsProvider.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Reading/IClientSettingsProvider.cs
@@ -4,5 +4,6 @@ public interface IClientSettingsProvider
     {
         bool IsIncludePlanetMoonsBlocked { get; }
         bool ArePlanetsWithPrivateNameHidden { get; }
+        bool IsMoonOrbitingPlanetAutoIncluded { get; }
     }
 }
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Reading/MoonDefinition.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Reading/MoonDefinition.cs
@@ -1,19 +1,45 @@
+using System.Collections.Generic;
 using System.Linq;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Queries.Expressions;
 using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
 using Microsoft.Extensions.Primitives;
 
 namespace JsonApiDotNetCoreExampleTests.IntegrationTests.ResourceDefinitions.Reading
 {
     [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
     public sealed class MoonDefinition : JsonApiResourceDefinition<Moon>
     {
-        public MoonDefinition(IResourceGraph resourceGraph)
+        private readonly IClientSettingsProvider _clientSettingsProvider;
+
+        public MoonDefinition(IResourceGraph resourceGraph, IClientSettingsProvider clientSettingsProvider)
             : base(resourceGraph)
         {
             // This constructor will be resolved from the container, which means
             // you can take on any dependency that is also defined in the container.
+
+            _clientSettingsProvider = clientSettingsProvider;
+        }
+
+        public override IReadOnlyCollection<IncludeElementExpression> OnApplyIncludes(IReadOnlyCollection<IncludeElementExpression> existingIncludes)
+        {
+            if (!_clientSettingsProvider.IsMoonOrbitingPlanetAutoIncluded ||
+                existingIncludes.Any(include => include.Relationship.Property.Name == nameof(Moon.OrbitsAround)))
+            {
+                return existingIncludes;
+            }
+
+            ResourceContext resourceContext = ResourceGraph.GetResourceContext<Moon>();
+
+            RelationshipAttribute orbitsAroundRelationship =
+                resourceContext.Relationships.Single(relationship => relationship.Property.Name == nameof(Moon.OrbitsAround));
+
+            return new List<IncludeElementExpression>(existingIncludes)
+            {
+                new IncludeElementExpression(orbitsAroundRelationship)
+            };
         }
 
         public override QueryStringParameterHandlers<Moon> OnRegisterQueryableHandlersForQueryStringParameters()
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Reading/ResourceDefinitionReadTests.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Reading/ResourceDefinitionReadTests.cs
@@ -74,6 +74,40 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             error.Detail.Should().BeNull();
         }
 
+        [Fact]
+        public async Task Include_from_resource_definition_is_added()
+        {
+            // Arrange
+            var settingsProvider = (TestClientSettingsProvider)_testContext.Factory.Services.GetRequiredService<IClientSettingsProvider>();
+            settingsProvider.AutoIncludeOrbitingPlanetForMoons();
+
+            Moon moon = _fakers.Moon.Generate();
+            moon.OrbitsAround = _fakers.Planet.Generate();
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.Moons.Add(moon);
+                await dbContext.SaveChangesAsync();
+            });
+
+            string route = "/moons/" + moon.StringId;
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecuteGetAsync<Document>(route);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
+
+            responseDocument.SingleData.Should().NotBeNull();
+            responseDocument.SingleData.Relationships["orbitsAround"].SingleData.Type.Should().Be("planets");
+            responseDocument.SingleData.Relationships["orbitsAround"].SingleData.Id.Should().Be(moon.OrbitsAround.StringId);
+
+            responseDocument.Included.Should().HaveCount(1);
+            responseDocument.Included[0].Type.Should().Be("planets");
+            responseDocument.Included[0].Id.Should().Be(moon.OrbitsAround.StringId);
+            responseDocument.Included[0].Attributes["publicName"].Should().Be(moon.OrbitsAround.PublicName);
+        }
+
         [Fact]
         public async Task Filter_from_resource_definition_is_applied()
         {
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Reading/TestClientSettingsProvider.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Reading/TestClientSettingsProvider.cs
@@ -4,11 +4,13 @@ internal sealed class TestClientSettingsProvider : IClientSettingsProvider
     {
         public bool IsIncludePlanetMoonsBlocked { get; private set; }
         public bool ArePlanetsWithPrivateNameHidden { get; private set; }
+        public bool IsMoonOrbitingPlanetAutoIncluded { get; private set; }
 
         public void ResetToDefaults()
         {
             IsIncludePlanetMoonsBlocked = false;
             ArePlanetsWithPrivateNameHidden = false;
+            IsMoonOrbitingPlanetAutoIncluded = false;
         }
 
         public void BlockIncludePlanetMoons()
@@ -20,5 +22,10 @@ public void HidePlanetsWithPrivateName()
         {
             ArePlanetsWithPrivateNameHidden = true;
         }
+
+        public void AutoIncludeOrbitingPlanetForMoons()
+        {
+            IsMoonOrbitingPlanetAutoIncluded = true;
+        }
     }
 }
diff --git a/test/UnitTests/Serialization/SerializerTestsSetup.cs b/test/UnitTests/Serialization/SerializerTestsSetup.cs

Original file line number	Diff line number	Diff line change
`@@ -158,6 +158,7 @@ public void ConfigureServiceContainer(ICollection<Type> dbContextTypes)`
`158`	`158`	`_services.AddScoped<IGenericServiceFactory, GenericServiceFactory>();`
`159`	`159`	`_services.AddScoped(typeof(IResourceChangeTracker<>), typeof(ResourceChangeTracker<>));`
`160`	`160`	`_services.AddScoped<IPaginationContext, PaginationContext>();`
	`161`	`+ _services.AddScoped<IEvaluatedIncludeCache, EvaluatedIncludeCache>();`
`161`	`162`	`_services.AddScoped<IQueryLayerComposer, QueryLayerComposer>();`
`162`	`163`	`_services.AddScoped<IInverseNavigationResolver, InverseNavigationResolver>();`
`163`	`164`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,5 +4,6 @@ public interface IClientSettingsProvider`
`4`	`4`	`{`
`5`	`5`	`bool IsIncludePlanetMoonsBlocked { get; }`
`6`	`6`	`bool ArePlanetsWithPrivateNameHidden { get; }`
	`7`	`+ bool IsMoonOrbitingPlanetAutoIncluded { get; }`
`7`	`8`	`}`
`8`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,11 +4,13 @@ internal sealed class TestClientSettingsProvider : IClientSettingsProvider`
`4`	`4`	`{`
`5`	`5`	`public bool IsIncludePlanetMoonsBlocked { get; private set; }`
`6`	`6`	`public bool ArePlanetsWithPrivateNameHidden { get; private set; }`
	`7`	`+ public bool IsMoonOrbitingPlanetAutoIncluded { get; private set; }`
`7`	`8`
`8`	`9`	`public void ResetToDefaults()`
`9`	`10`	`{`
`10`	`11`	`IsIncludePlanetMoonsBlocked = false;`
`11`	`12`	`ArePlanetsWithPrivateNameHidden = false;`
	`13`	`+ IsMoonOrbitingPlanetAutoIncluded = false;`
`12`	`14`	`}`
`13`	`15`
`14`	`16`	`public void BlockIncludePlanetMoons()`
`@@ -20,5 +22,10 @@ public void HidePlanetsWithPrivateName()`
`20`	`22`	`{`
`21`	`23`	`ArePlanetsWithPrivateNameHidden = true;`
`22`	`24`	`}`
	`25`	`+`
	`26`	`+ public void AutoIncludeOrbitingPlanetForMoons()`
	`27`	`+ {`
	`28`	`+ IsMoonOrbitingPlanetAutoIncluded = true;`
	`29`	`+ }`
`23`	`30`	`}`
`24`	`31`	`}`