Improved support for soft-deletion

Bart Koelman · Bart Koelman · commit 2a4d12907263 · 2021-04-16T17:50:31.000+02:00
diff --git a/src/JsonApiDotNetCore/Services/JsonApiResourceService.cs b/src/JsonApiDotNetCore/Services/JsonApiResourceService.cs
@@ -103,8 +103,7 @@ public virtual async Task<TResource> GetAsync(TId id, CancellationToken cancella
 
             _hookExecutor.BeforeReadSingle<TResource, TId>(id, ResourcePipeline.GetSingle);
 
-            TResource primaryResource = await TryGetPrimaryResourceByIdAsync(id, TopFieldSelection.PreserveExisting, cancellationToken);
-            AssertPrimaryResourceExists(primaryResource);
+            TResource primaryResource = await GetPrimaryResourceByIdAsync(id, TopFieldSelection.PreserveExisting, cancellationToken);
 
             _hookExecutor.AfterReadSingle(primaryResource, ResourcePipeline.GetSingle);
             _hookExecutor.OnReturnSingle(primaryResource, ResourcePipeline.GetSingle);
@@ -225,10 +224,7 @@ public virtual async Task<TResource> CreateAsync(TResource resource, Cancellatio
                 throw;
             }
 
-            TResource resourceFromDatabase =
-                await TryGetPrimaryResourceByIdAsync(resourceForDatabase.Id, TopFieldSelection.WithAllAttributes, cancellationToken);
-
-            AssertPrimaryResourceExists(resourceFromDatabase);
+            TResource resourceFromDatabase = await GetPrimaryResourceByIdAsync(resourceForDatabase.Id, TopFieldSelection.WithAllAttributes, cancellationToken);
 
             await _resourceDefinitionAccessor.OnAfterCreateResourceAsync(resourceFromDatabase, cancellationToken);
 
@@ -247,13 +243,14 @@ public virtual async Task<TResource> CreateAsync(TResource resource, Cancellatio
             return resourceFromDatabase;
         }
 
-        private async Task AssertResourcesToAssignInRelationshipsExistAsync(TResource resource, CancellationToken cancellationToken)
+        protected async Task AssertResourcesToAssignInRelationshipsExistAsync(TResource primaryResource, CancellationToken cancellationToken)
         {
             var missingResources = new List<MissingResourceInRelationship>();
 
-            foreach ((QueryLayer queryLayer, RelationshipAttribute relationship) in _queryLayerComposer.ComposeForGetTargetedSecondaryResourceIds(resource))
+            foreach ((QueryLayer queryLayer, RelationshipAttribute relationship) in _queryLayerComposer.ComposeForGetTargetedSecondaryResourceIds(
+                primaryResource))
             {
-                object rightValue = relationship.GetValue(resource);
+                object rightValue = relationship.GetValue(primaryResource);
                 ICollection<IIdentifiable> rightResourceIds = _collectionConverter.ExtractResources(rightValue);
 
                 IAsyncEnumerable<MissingResourceInRelationship> missingResourcesInRelationship =
@@ -287,7 +284,7 @@ private async IAsyncEnumerable<MissingResourceInRelationship> GetMissingRightRes
         }
 
         /// <inheritdoc />
-        public async Task AddToToManyRelationshipAsync(TId primaryId, string relationshipName, ISet<IIdentifiable> secondaryResourceIds,
+        public virtual async Task AddToToManyRelationshipAsync(TId primaryId, string relationshipName, ISet<IIdentifiable> secondaryResourceIds,
             CancellationToken cancellationToken)
         {
             _traceWriter.LogMethodStart(new
@@ -316,10 +313,8 @@ public async Task AddToToManyRelationshipAsync(TId primaryId, string relationshi
                 }
                 catch (DataStoreUpdateException)
                 {
-                    TResource primaryResource = await TryGetPrimaryResourceByIdAsync(primaryId, TopFieldSelection.OnlyIdAttribute, cancellationToken);
-                    AssertPrimaryResourceExists(primaryResource);
-
-                    await AssertResourcesExistAsync(secondaryResourceIds, cancellationToken);
+                    _ = await GetPrimaryResourceByIdAsync(primaryId, TopFieldSelection.OnlyIdAttribute, cancellationToken);
+                    await AssertRightResourcesExistAsync(secondaryResourceIds, cancellationToken);
                     throw;
                 }
             }
@@ -340,16 +335,22 @@ private async Task RemoveExistingIdsFromSecondarySetAsync(TId primaryId, ISet<II
             secondaryResourceIds.ExceptWith(existingRightResourceIds);
         }
 
-        private async Task AssertResourcesExistAsync(ICollection<IIdentifiable> secondaryResourceIds, CancellationToken cancellationToken)
+        protected async Task AssertRightResourcesExistAsync(object rightResourceIds, CancellationToken cancellationToken)
         {
-            QueryLayer queryLayer = _queryLayerComposer.ComposeForGetRelationshipRightIds(_request.Relationship, secondaryResourceIds);
+            ICollection<IIdentifiable> secondaryResourceIds = _collectionConverter.ExtractResources(rightResourceIds);
 
-            List<MissingResourceInRelationship> missingResources =
-                await GetMissingRightResourcesAsync(queryLayer, _request.Relationship, secondaryResourceIds, cancellationToken).ToListAsync(cancellationToken);
-
-            if (missingResources.Any())
+            if (secondaryResourceIds.Any())
             {
-                throw new ResourcesInRelationshipsNotFoundException(missingResources);
+                QueryLayer queryLayer = _queryLayerComposer.ComposeForGetRelationshipRightIds(_request.Relationship, secondaryResourceIds);
+
+                List<MissingResourceInRelationship> missingResources =
+                    await GetMissingRightResourcesAsync(queryLayer, _request.Relationship, secondaryResourceIds, cancellationToken)
+                        .ToListAsync(cancellationToken);
+
+                if (missingResources.Any())
+                {
+                    throw new ResourcesInRelationshipsNotFoundException(missingResources);
+                }
             }
         }
 
@@ -385,8 +386,7 @@ public virtual async Task<TResource> UpdateAsync(TId id, TResource resource, Can
                 throw;
             }
 
-            TResource afterResourceFromDatabase = await TryGetPrimaryResourceByIdAsync(id, TopFieldSelection.WithAllAttributes, cancellationToken);
-            AssertPrimaryResourceExists(afterResourceFromDatabase);
+            TResource afterResourceFromDatabase = await GetPrimaryResourceByIdAsync(id, TopFieldSelection.WithAllAttributes, cancellationToken);
 
             await _resourceDefinitionAccessor.OnAfterUpdateResourceAsync(afterResourceFromDatabase, cancellationToken);
 
@@ -429,7 +429,7 @@ public virtual async Task SetRelationshipAsync(TId primaryId, string relationshi
             }
             catch (DataStoreUpdateException)
             {
-                await AssertResourcesExistAsync(_collectionConverter.ExtractResources(secondaryResourceIds), cancellationToken);
+                await AssertRightResourcesExistAsync(secondaryResourceIds, cancellationToken);
                 throw;
             }
 
@@ -454,8 +454,7 @@ public virtual async Task DeleteAsync(TId id, CancellationToken cancellationToke
             }
             catch (DataStoreUpdateException)
             {
-                TResource primaryResource = await TryGetPrimaryResourceByIdAsync(id, TopFieldSelection.OnlyIdAttribute, cancellationToken);
-                AssertPrimaryResourceExists(primaryResource);
+                _ = await GetPrimaryResourceByIdAsync(id, TopFieldSelection.OnlyIdAttribute, cancellationToken);
                 throw;
             }
 
@@ -465,7 +464,7 @@ public virtual async Task DeleteAsync(TId id, CancellationToken cancellationToke
         }
 
         /// <inheritdoc />
-        public async Task RemoveFromToManyRelationshipAsync(TId primaryId, string relationshipName, ISet<IIdentifiable> secondaryResourceIds,
+        public virtual async Task RemoveFromToManyRelationshipAsync(TId primaryId, string relationshipName, ISet<IIdentifiable> secondaryResourceIds,
             CancellationToken cancellationToken)
         {
             _traceWriter.LogMethodStart(new
@@ -481,14 +480,22 @@ public async Task RemoveFromToManyRelationshipAsync(TId primaryId, string relati
             AssertHasRelationship(_request.Relationship, relationshipName);
 
             TResource resourceFromDatabase = await GetPrimaryResourceForUpdateAsync(primaryId, cancellationToken);
-            await AssertResourcesExistAsync(secondaryResourceIds, cancellationToken);
+            await AssertRightResourcesExistAsync(secondaryResourceIds, cancellationToken);
 
             if (secondaryResourceIds.Any())
             {
                 await _repositoryAccessor.RemoveFromToManyRelationshipAsync(resourceFromDatabase, secondaryResourceIds, cancellationToken);
             }
         }
 
+        protected async Task<TResource> GetPrimaryResourceByIdAsync(TId id, TopFieldSelection fieldSelection, CancellationToken cancellationToken)
+        {
+            TResource primaryResource = await TryGetPrimaryResourceByIdAsync(id, fieldSelection, cancellationToken);
+            AssertPrimaryResourceExists(primaryResource);
+
+            return primaryResource;
+        }
+
         private async Task<TResource> TryGetPrimaryResourceByIdAsync(TId id, TopFieldSelection fieldSelection, CancellationToken cancellationToken)
         {
             QueryLayer primaryLayer = _queryLayerComposer.ComposeForGetById(id, _request.PrimaryResource, fieldSelection);
@@ -497,7 +504,7 @@ private async Task<TResource> TryGetPrimaryResourceByIdAsync(TId id, TopFieldSel
             return primaryResources.SingleOrDefault();
         }
 
-        private async Task<TResource> GetPrimaryResourceForUpdateAsync(TId id, CancellationToken cancellationToken)
+        protected async Task<TResource> GetPrimaryResourceForUpdateAsync(TId id, CancellationToken cancellationToken)
         {
             QueryLayer queryLayer = _queryLayerComposer.ComposeForUpdate(id, _request.PrimaryResource);
             var resource = await _repositoryAccessor.GetForUpdateAsync<TResource>(queryLayer, cancellationToken);
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/SoftDeletion/Company.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/SoftDeletion/Company.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Resources;
@@ -11,8 +12,7 @@ public sealed class Company : Identifiable, ISoftDeletable
         [Attr]
         public string Name { get; set; }
 
-        [Attr]
-        public bool IsSoftDeleted { get; set; }
+        public DateTimeOffset? SoftDeletedAt { get; set; }
 
         [HasMany]
         public ICollection<Department> Departments { get; set; }
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/SoftDeletion/Department.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/SoftDeletion/Department.cs
@@ -1,3 +1,4 @@
+using System;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Resources;
 using JsonApiDotNetCore.Resources.Annotations;
@@ -10,8 +11,7 @@ public sealed class Department : Identifiable, ISoftDeletable
         [Attr]
         public string Name { get; set; }
 
-        [Attr]
-        public bool IsSoftDeleted { get; set; }
+        public DateTimeOffset? SoftDeletedAt { get; set; }
 
         [HasOne]
         public Company Company { get; set; }
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/SoftDeletion/ISoftDeletable.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/SoftDeletion/ISoftDeletable.cs
@@ -1,7 +1,11 @@
+using System;
+using JetBrains.Annotations;
+
 namespace JsonApiDotNetCoreExampleTests.IntegrationTests.SoftDeletion
 {
+    [UsedImplicitly(ImplicitUseTargetFlags.Members)]
     public interface ISoftDeletable
     {
-        bool IsSoftDeleted { get; set; }
+        DateTimeOffset? SoftDeletedAt { get; set; }
     }
 }
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/SoftDeletion/SoftDeletionAwareResourceService.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/SoftDeletion/SoftDeletionAwareResourceService.cs
@@ -0,0 +1,129 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Hooks;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Queries;
+using JsonApiDotNetCore.Repositories;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Services;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.Extensions.Logging;
+
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.SoftDeletion
+{
+    [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
+    public class SoftDeletionAwareResourceService<TResource, TId> : JsonApiResourceService<TResource, TId>
+        where TResource : class, IIdentifiable<TId>
+    {
+        private readonly ISystemClock _systemClock;
+        private readonly ITargetedFields _targetedFields;
+        private readonly IResourceRepositoryAccessor _repositoryAccessor;
+        private readonly IJsonApiRequest _request;
+
+        public SoftDeletionAwareResourceService(ISystemClock systemClock, ITargetedFields targetedFields, IResourceRepositoryAccessor repositoryAccessor,
+            IQueryLayerComposer queryLayerComposer, IPaginationContext paginationContext, IJsonApiOptions options, ILoggerFactory loggerFactory,
+            IJsonApiRequest request, IResourceChangeTracker<TResource> resourceChangeTracker, IResourceHookExecutorFacade hookExecutor)
+            : base(repositoryAccessor, queryLayerComposer, paginationContext, options, loggerFactory, request, resourceChangeTracker, hookExecutor)
+        {
+            _systemClock = systemClock;
+            _targetedFields = targetedFields;
+            _repositoryAccessor = repositoryAccessor;
+            _request = request;
+        }
+
+        // To optimize performance, the default resource service does not always fetch all resources on write operations.
+        // We do that here, to assure a 404 error is thrown for soft-deleted resources.
+
+        public override async Task<TResource> CreateAsync(TResource resource, CancellationToken cancellationToken)
+        {
+            if (_targetedFields.Relationships.Any(relationship => IsSoftDeletable(relationship.RightType)))
+            {
+                await AssertResourcesToAssignInRelationshipsExistAsync(resource, cancellationToken);
+            }
+
+            return await base.CreateAsync(resource, cancellationToken);
+        }
+
+        public override async Task<TResource> UpdateAsync(TId id, TResource resource, CancellationToken cancellationToken)
+        {
+            if (_targetedFields.Relationships.Any(relationship => IsSoftDeletable(relationship.RightType)))
+            {
+                await AssertResourcesToAssignInRelationshipsExistAsync(resource, cancellationToken);
+            }
+
+            return await base.UpdateAsync(id, resource, cancellationToken);
+        }
+
+        public override async Task SetRelationshipAsync(TId primaryId, string relationshipName, object secondaryResourceIds,
+            CancellationToken cancellationToken)
+        {
+            if (IsSoftDeletable(_request.Relationship.RightType))
+            {
+                await AssertRightResourcesExistAsync(secondaryResourceIds, cancellationToken);
+            }
+
+            await base.SetRelationshipAsync(primaryId, relationshipName, secondaryResourceIds, cancellationToken);
+        }
+
+        public override async Task AddToToManyRelationshipAsync(TId primaryId, string relationshipName, ISet<IIdentifiable> secondaryResourceIds,
+            CancellationToken cancellationToken)
+        {
+            if (IsSoftDeletable(typeof(TResource)))
+            {
+                _ = await GetPrimaryResourceByIdAsync(primaryId, TopFieldSelection.OnlyIdAttribute, cancellationToken);
+            }
+
+            if (IsSoftDeletable(_request.Relationship.RightType))
+            {
+                await AssertRightResourcesExistAsync(secondaryResourceIds, cancellationToken);
+            }
+
+            await base.AddToToManyRelationshipAsync(primaryId, relationshipName, secondaryResourceIds, cancellationToken);
+        }
+
+        public override async Task DeleteAsync(TId id, CancellationToken cancellationToken)
+        {
+            if (IsSoftDeletable(typeof(TResource)))
+            {
+                await SoftDeleteAsync(id, cancellationToken);
+            }
+            else
+            {
+                await base.DeleteAsync(id, cancellationToken);
+            }
+        }
+
+        private async Task SoftDeleteAsync(TId id, CancellationToken cancellationToken)
+        {
+            TResource resourceFromDatabase = await GetPrimaryResourceForUpdateAsync(id, cancellationToken);
+
+            ((ISoftDeletable)resourceFromDatabase).SoftDeletedAt = _systemClock.UtcNow;
+
+            // A delete operation does not target any fields, so we can just pass resourceFromDatabase twice.
+            await _repositoryAccessor.UpdateAsync(resourceFromDatabase, resourceFromDatabase, cancellationToken);
+        }
+
+        private static bool IsSoftDeletable(Type resourceType)
+        {
+            return typeof(ISoftDeletable).IsAssignableFrom(resourceType);
+        }
+    }
+
+    [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
+    public class SoftDeletionAwareResourceService<TResource> : SoftDeletionAwareResourceService<TResource, int>, IResourceService<TResource>
+        where TResource : class, IIdentifiable<int>
+    {
+        public SoftDeletionAwareResourceService(ISystemClock systemClock, ITargetedFields targetedFields, IResourceRepositoryAccessor repositoryAccessor,
+            IQueryLayerComposer queryLayerComposer, IPaginationContext paginationContext, IJsonApiOptions options, ILoggerFactory loggerFactory,
+            IJsonApiRequest request, IResourceChangeTracker<TResource> resourceChangeTracker, IResourceHookExecutorFacade hookExecutor)
+            : base(systemClock, targetedFields, repositoryAccessor, queryLayerComposer, paginationContext, options, loggerFactory, request,
+                resourceChangeTracker, hookExecutor)
+        {
+        }
+    }
+}
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/SoftDeletion/SoftDeletionDbContext.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/SoftDeletion/SoftDeletionDbContext.cs
@@ -1,6 +1,8 @@
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore;
 
+// @formatter:wrap_chained_method_calls chop_always
+
 namespace JsonApiDotNetCoreExampleTests.IntegrationTests.SoftDeletion
 {
     [UsedImplicitly(ImplicitUseTargetFlags.Members)]
@@ -13,5 +15,14 @@ public SoftDeletionDbContext(DbContextOptions<SoftDeletionDbContext> options)
             : base(options)
         {
         }
+
+        protected override void OnModelCreating(ModelBuilder builder)
+        {
+            builder.Entity<Company>()
+                .HasQueryFilter(company => company.SoftDeletedAt == null);
+
+            builder.Entity<Department>()
+                .HasQueryFilter(department => department.SoftDeletedAt == null);
+        }
     }
 }
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/SoftDeletion/SoftDeletionFakers.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/SoftDeletion/SoftDeletionFakers.cs
@@ -0,0 +1,25 @@
+using System;
+using Bogus;
+using TestBuildingBlocks;
+
+// @formatter:wrap_chained_method_calls chop_always
+// @formatter:keep_existing_linebreaks true
+
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.SoftDeletion
+{
+    internal sealed class SoftDeletionFakers : FakerContainer
+    {
+        private readonly Lazy<Faker<Company>> _lazyCompanyFaker = new Lazy<Faker<Company>>(() =>
+            new Faker<Company>()
+                .UseSeed(GetFakerSeed())
+                .RuleFor(company => company.Name, faker => faker.Company.CompanyName()));
+
+        private readonly Lazy<Faker<Department>> _lazyDepartmentFaker = new Lazy<Faker<Department>>(() =>
+            new Faker<Department>()
+                .UseSeed(GetFakerSeed())
+                .RuleFor(department => department.Name, faker => faker.Commerce.Department()));
+
+        public Faker<Company> Company => _lazyCompanyFaker.Value;
+        public Faker<Department> Department => _lazyDepartmentFaker.Value;
+    }
+}
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/SoftDeletion/SoftDeletionResourceDefinition.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/SoftDeletion/SoftDeletionResourceDefinition.cs
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/SoftDeletion/SoftDeletionTests.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/SoftDeletion/SoftDeletionTests.cs

Original file line number	Diff line number	Diff line change
`@@ -103,8 +103,7 @@ public virtual async Task<TResource> GetAsync(TId id, CancellationToken cancella`
`103`	`103`
`104`	`104`	`_hookExecutor.BeforeReadSingle<TResource, TId>(id, ResourcePipeline.GetSingle);`
`105`	`105`
`106`		`- TResource primaryResource = await TryGetPrimaryResourceByIdAsync(id, TopFieldSelection.PreserveExisting, cancellationToken);`
`107`		`- AssertPrimaryResourceExists(primaryResource);`
	`106`	`+ TResource primaryResource = await GetPrimaryResourceByIdAsync(id, TopFieldSelection.PreserveExisting, cancellationToken);`
`108`	`107`
`109`	`108`	`_hookExecutor.AfterReadSingle(primaryResource, ResourcePipeline.GetSingle);`
`110`	`109`	`_hookExecutor.OnReturnSingle(primaryResource, ResourcePipeline.GetSingle);`
`@@ -225,10 +224,7 @@ public virtual async Task<TResource> CreateAsync(TResource resource, Cancellatio`
`225`	`224`	`throw;`
`226`	`225`	`}`
`227`	`226`
`228`		`- TResource resourceFromDatabase =`
`229`		`- await TryGetPrimaryResourceByIdAsync(resourceForDatabase.Id, TopFieldSelection.WithAllAttributes, cancellationToken);`
`230`		`-`
`231`		`- AssertPrimaryResourceExists(resourceFromDatabase);`
	`227`	`+ TResource resourceFromDatabase = await GetPrimaryResourceByIdAsync(resourceForDatabase.Id, TopFieldSelection.WithAllAttributes, cancellationToken);`
`232`	`228`
`233`	`229`	`await _resourceDefinitionAccessor.OnAfterCreateResourceAsync(resourceFromDatabase, cancellationToken);`
`234`	`230`
`@@ -247,13 +243,14 @@ public virtual async Task<TResource> CreateAsync(TResource resource, Cancellatio`
`247`	`243`	`return resourceFromDatabase;`
`248`	`244`	`}`
`249`	`245`
`250`		`- private async Task AssertResourcesToAssignInRelationshipsExistAsync(TResource resource, CancellationToken cancellationToken)`
	`246`	`+ protected async Task AssertResourcesToAssignInRelationshipsExistAsync(TResource primaryResource, CancellationToken cancellationToken)`
`251`	`247`	`{`
`252`	`248`	`var missingResources = new List<MissingResourceInRelationship>();`
`253`	`249`
`254`		`- foreach ((QueryLayer queryLayer, RelationshipAttribute relationship) in _queryLayerComposer.ComposeForGetTargetedSecondaryResourceIds(resource))`
	`250`	`+ foreach ((QueryLayer queryLayer, RelationshipAttribute relationship) in _queryLayerComposer.ComposeForGetTargetedSecondaryResourceIds(`
	`251`	`+ primaryResource))`
`255`	`252`	`{`
`256`		`- object rightValue = relationship.GetValue(resource);`
	`253`	`+ object rightValue = relationship.GetValue(primaryResource);`
`257`	`254`	`ICollection<IIdentifiable> rightResourceIds = _collectionConverter.ExtractResources(rightValue);`
`258`	`255`
`259`	`256`	`IAsyncEnumerable<MissingResourceInRelationship> missingResourcesInRelationship =`
`@@ -287,7 +284,7 @@ private async IAsyncEnumerable<MissingResourceInRelationship> GetMissingRightRes`
`287`	`284`	`}`
`288`	`285`
`289`	`286`	`/// <inheritdoc />`
`290`		`- public async Task AddToToManyRelationshipAsync(TId primaryId, string relationshipName, ISet<IIdentifiable> secondaryResourceIds,`
	`287`	`+ public virtual async Task AddToToManyRelationshipAsync(TId primaryId, string relationshipName, ISet<IIdentifiable> secondaryResourceIds,`
`291`	`288`	`CancellationToken cancellationToken)`
`292`	`289`	`{`
`293`	`290`	`_traceWriter.LogMethodStart(new`
`@@ -316,10 +313,8 @@ public async Task AddToToManyRelationshipAsync(TId primaryId, string relationshi`
`316`	`313`	`}`
`317`	`314`	`catch (DataStoreUpdateException)`
`318`	`315`	`{`
`319`		`- TResource primaryResource = await TryGetPrimaryResourceByIdAsync(primaryId, TopFieldSelection.OnlyIdAttribute, cancellationToken);`
`320`		`- AssertPrimaryResourceExists(primaryResource);`
`321`		`-`
`322`		`- await AssertResourcesExistAsync(secondaryResourceIds, cancellationToken);`
	`316`	`+ _ = await GetPrimaryResourceByIdAsync(primaryId, TopFieldSelection.OnlyIdAttribute, cancellationToken);`
	`317`	`+ await AssertRightResourcesExistAsync(secondaryResourceIds, cancellationToken);`
`323`	`318`	`throw;`
`324`	`319`	`}`
`325`	`320`	`}`
`@@ -340,16 +335,22 @@ private async Task RemoveExistingIdsFromSecondarySetAsync(TId primaryId, ISet<II`
`340`	`335`	`secondaryResourceIds.ExceptWith(existingRightResourceIds);`
`341`	`336`	`}`
`342`	`337`
`343`		`- private async Task AssertResourcesExistAsync(ICollection<IIdentifiable> secondaryResourceIds, CancellationToken cancellationToken)`
	`338`	`+ protected async Task AssertRightResourcesExistAsync(object rightResourceIds, CancellationToken cancellationToken)`
`344`	`339`	`{`
`345`		`- QueryLayer queryLayer = _queryLayerComposer.ComposeForGetRelationshipRightIds(_request.Relationship, secondaryResourceIds);`
	`340`	`+ ICollection<IIdentifiable> secondaryResourceIds = _collectionConverter.ExtractResources(rightResourceIds);`
`346`	`341`
`347`		`- List<MissingResourceInRelationship> missingResources =`
`348`		`- await GetMissingRightResourcesAsync(queryLayer, _request.Relationship, secondaryResourceIds, cancellationToken).ToListAsync(cancellationToken);`
`349`		`-`
`350`		`- if (missingResources.Any())`
	`342`	`+ if (secondaryResourceIds.Any())`
`351`	`343`	`{`
`352`		`- throw new ResourcesInRelationshipsNotFoundException(missingResources);`
	`344`	`+ QueryLayer queryLayer = _queryLayerComposer.ComposeForGetRelationshipRightIds(_request.Relationship, secondaryResourceIds);`
	`345`	`+`
	`346`	`+ List<MissingResourceInRelationship> missingResources =`
	`347`	`+ await GetMissingRightResourcesAsync(queryLayer, _request.Relationship, secondaryResourceIds, cancellationToken)`
	`348`	`+ .ToListAsync(cancellationToken);`
	`349`	`+`
	`350`	`+ if (missingResources.Any())`
	`351`	`+ {`
	`352`	`+ throw new ResourcesInRelationshipsNotFoundException(missingResources);`
	`353`	`+ }`
`353`	`354`	`}`
`354`	`355`	`}`
`355`	`356`
`@@ -385,8 +386,7 @@ public virtual async Task<TResource> UpdateAsync(TId id, TResource resource, Can`
`385`	`386`	`throw;`
`386`	`387`	`}`
`387`	`388`
`388`		`- TResource afterResourceFromDatabase = await TryGetPrimaryResourceByIdAsync(id, TopFieldSelection.WithAllAttributes, cancellationToken);`
`389`		`- AssertPrimaryResourceExists(afterResourceFromDatabase);`
	`389`	`+ TResource afterResourceFromDatabase = await GetPrimaryResourceByIdAsync(id, TopFieldSelection.WithAllAttributes, cancellationToken);`
`390`	`390`
`391`	`391`	`await _resourceDefinitionAccessor.OnAfterUpdateResourceAsync(afterResourceFromDatabase, cancellationToken);`
`392`	`392`
`@@ -429,7 +429,7 @@ public virtual async Task SetRelationshipAsync(TId primaryId, string relationshi`
`429`	`429`	`}`
`430`	`430`	`catch (DataStoreUpdateException)`
`431`	`431`	`{`
`432`		`- await AssertResourcesExistAsync(_collectionConverter.ExtractResources(secondaryResourceIds), cancellationToken);`
	`432`	`+ await AssertRightResourcesExistAsync(secondaryResourceIds, cancellationToken);`
`433`	`433`	`throw;`
`434`	`434`	`}`
`435`	`435`
`@@ -454,8 +454,7 @@ public virtual async Task DeleteAsync(TId id, CancellationToken cancellationToke`
`454`	`454`	`}`
`455`	`455`	`catch (DataStoreUpdateException)`
`456`	`456`	`{`
`457`		`- TResource primaryResource = await TryGetPrimaryResourceByIdAsync(id, TopFieldSelection.OnlyIdAttribute, cancellationToken);`
`458`		`- AssertPrimaryResourceExists(primaryResource);`
	`457`	`+ _ = await GetPrimaryResourceByIdAsync(id, TopFieldSelection.OnlyIdAttribute, cancellationToken);`
`459`	`458`	`throw;`
`460`	`459`	`}`
`461`	`460`
`@@ -465,7 +464,7 @@ public virtual async Task DeleteAsync(TId id, CancellationToken cancellationToke`
`465`	`464`	`}`
`466`	`465`
`467`	`466`	`/// <inheritdoc />`
`468`		`- public async Task RemoveFromToManyRelationshipAsync(TId primaryId, string relationshipName, ISet<IIdentifiable> secondaryResourceIds,`
	`467`	`+ public virtual async Task RemoveFromToManyRelationshipAsync(TId primaryId, string relationshipName, ISet<IIdentifiable> secondaryResourceIds,`
`469`	`468`	`CancellationToken cancellationToken)`
`470`	`469`	`{`
`471`	`470`	`_traceWriter.LogMethodStart(new`
`@@ -481,14 +480,22 @@ public async Task RemoveFromToManyRelationshipAsync(TId primaryId, string relati`
`481`	`480`	`AssertHasRelationship(_request.Relationship, relationshipName);`
`482`	`481`
`483`	`482`	`TResource resourceFromDatabase = await GetPrimaryResourceForUpdateAsync(primaryId, cancellationToken);`
`484`		`- await AssertResourcesExistAsync(secondaryResourceIds, cancellationToken);`
	`483`	`+ await AssertRightResourcesExistAsync(secondaryResourceIds, cancellationToken);`
`485`	`484`
`486`	`485`	`if (secondaryResourceIds.Any())`
`487`	`486`	`{`
`488`	`487`	`await _repositoryAccessor.RemoveFromToManyRelationshipAsync(resourceFromDatabase, secondaryResourceIds, cancellationToken);`
`489`	`488`	`}`
`490`	`489`	`}`
`491`	`490`
	`491`	`+ protected async Task<TResource> GetPrimaryResourceByIdAsync(TId id, TopFieldSelection fieldSelection, CancellationToken cancellationToken)`
	`492`	`+ {`
	`493`	`+ TResource primaryResource = await TryGetPrimaryResourceByIdAsync(id, fieldSelection, cancellationToken);`
	`494`	`+ AssertPrimaryResourceExists(primaryResource);`
	`495`	`+`
	`496`	`+ return primaryResource;`
	`497`	`+ }`
	`498`	`+`
`492`	`499`	`private async Task<TResource> TryGetPrimaryResourceByIdAsync(TId id, TopFieldSelection fieldSelection, CancellationToken cancellationToken)`
`493`	`500`	`{`
`494`	`501`	`QueryLayer primaryLayer = _queryLayerComposer.ComposeForGetById(id, _request.PrimaryResource, fieldSelection);`
`@@ -497,7 +504,7 @@ private async Task<TResource> TryGetPrimaryResourceByIdAsync(TId id, TopFieldSel`
`497`	`504`	`return primaryResources.SingleOrDefault();`
`498`	`505`	`}`
`499`	`506`
`500`		`- private async Task<TResource> GetPrimaryResourceForUpdateAsync(TId id, CancellationToken cancellationToken)`
	`507`	`+ protected async Task<TResource> GetPrimaryResourceForUpdateAsync(TId id, CancellationToken cancellationToken)`
`501`	`508`	`{`
`502`	`509`	`QueryLayer queryLayer = _queryLayerComposer.ComposeForUpdate(id, _request.PrimaryResource);`
`503`	`510`	`var resource = await _repositoryAccessor.GetForUpdateAsync<TResource>(queryLayer, cancellationToken);`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,11 @@`
	`1`	`+using System;`
	`2`	`+using JetBrains.Annotations;`
	`3`	`+`
`1`	`4`	`namespace JsonApiDotNetCoreExampleTests.IntegrationTests.SoftDeletion`
`2`	`5`	`{`
	`6`	`+ [UsedImplicitly(ImplicitUseTargetFlags.Members)]`
`3`	`7`	`public interface ISoftDeletable`
`4`	`8`	`{`
`5`		`- bool IsSoftDeleted { get; set; }`
	`9`	`+ DateTimeOffset? SoftDeletedAt { get; set; }`
`6`	`10`	`}`
`7`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,8 @@`
`1`	`1`	`using JetBrains.Annotations;`
`2`	`2`	`using Microsoft.EntityFrameworkCore;`
`3`	`3`
	`4`	`+// @formatter:wrap_chained_method_calls chop_always`
	`5`	`+`
`4`	`6`	`namespace JsonApiDotNetCoreExampleTests.IntegrationTests.SoftDeletion`
`5`	`7`	`{`
`6`	`8`	`[UsedImplicitly(ImplicitUseTargetFlags.Members)]`
`@@ -13,5 +15,14 @@ public SoftDeletionDbContext(DbContextOptions<SoftDeletionDbContext> options)`
`13`	`15`	`: base(options)`
`14`	`16`	`{`
`15`	`17`	`}`
	`18`	`+`
	`19`	`+ protected override void OnModelCreating(ModelBuilder builder)`
	`20`	`+ {`
	`21`	`+ builder.Entity<Company>()`
	`22`	`+ .HasQueryFilter(company => company.SoftDeletedAt == null);`
	`23`	`+`
	`24`	`+ builder.Entity<Department>()`
	`25`	`+ .HasQueryFilter(department => department.SoftDeletedAt == null);`
	`26`	`+ }`
`16`	`27`	`}`
`17`	`28`	`}`