Since EF Core 5, SaveChanges automatically creates a savepoint and rolls back to it on failure. This produces more correct error responses in operations, compared to rolling back the entire transaction. For example, when an operations request creates a resource and the next operation fails, the resource service may incorrectly conclude that the resource from the first operation does not exist.

Author: Bart Koelman

src/JsonApiDotNetCore/Repositories/EntityFrameworkCoreRepository.cs

@@ -571,13 +571,6 @@ protected virtual async Task SaveChangesAsync(CancellationToken cancellationToke
             }
             catch (Exception exception) when (exception is DbUpdateException or InvalidOperationException)
             {
-                if (_dbContext.Database.CurrentTransaction != null)
-                {
-                    // The ResourceService calling us needs to run additional SQL queries after an aborted transaction,
-                    // to determine error cause. This fails when a failed transaction is still in progress.
-                    await _dbContext.Database.CurrentTransaction.RollbackAsync(cancellationToken);
-                }
-
                 _dbContext.ResetChangeTracker();
 
                 throw new DataStoreUpdateException(exception);

test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Transactions/AtomicRollbackTests.cs

@@ -36,7 +36,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 await dbContext.ClearTablesAsync<Performer, MusicTrack>();
             });
 
-            string performerId = Unknown.StringId.For<Performer, int>();
+            string unknownPerformerId = Unknown.StringId.For<Performer, int>();
 
             var requestBody = new
             {
@@ -74,7 +74,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                                         new
                                         {
                                             type = "performers",
-                                            id = performerId
+                                            id = unknownPerformerId
                                         }
                                     }
                                 }
@@ -97,7 +97,87 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             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 'performers' with ID '{performerId}' in relationship 'performers' does not exist.");
+            error.Detail.Should().Be($"Related resource of type 'performers' with ID '{unknownPerformerId}' in relationship 'performers' does not exist.");
+            error.Source.ShouldNotBeNull();
+            error.Source.Pointer.Should().Be("/atomic:operations[1]");
+
+            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();
+            });
+        }
+
+        [Fact]
+        public async Task Can_restore_to_previous_savepoint_on_error()
+        {
+            // Arrange
+            string newTrackTitle = _fakers.MusicTrack.Generate().Title;
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                await dbContext.ClearTablesAsync<Performer, MusicTrack>();
+            });
+
+            const string trackLid = "track-1";
+
+            string unknownPerformerId = Unknown.StringId.For<Performer, int>();
+
+            var requestBody = new
+            {
+                atomic__operations = new object[]
+                {
+                    new
+                    {
+                        op = "add",
+                        data = new
+                        {
+                            type = "musicTracks",
+                            lid = trackLid,
+                            attributes = new
+                            {
+                                title = newTrackTitle
+                            }
+                        }
+                    },
+                    new
+                    {
+                        op = "add",
+                        @ref = new
+                        {
+                            type = "musicTracks",
+                            lid = trackLid,
+                            relationship = "performers"
+                        },
+                        data = new[]
+                        {
+                            new
+                            {
+                                type = "performers",
+                                id = unknownPerformerId
+                            }
+                        }
+                    }
+                }
+            };
+
+            const string route = "/operations";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAtomicAsync<Document>(route, requestBody);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.NotFound);
+
+            responseDocument.Errors.ShouldHaveCount(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 'performers' with ID '{unknownPerformerId}' in relationship 'performers' does not exist.");
             error.Source.ShouldNotBeNull();
             error.Source.Pointer.Should().Be("/atomic:operations[1]");