wrap operations in EF transaction

Author: jaredcnance

src/JsonApiDotNetCore/Internal/JsonApiException.cs

@@ -8,7 +8,7 @@ public class JsonApiException : Exception
         private readonly ErrorCollection _errors = new ErrorCollection();
 
         public JsonApiException(ErrorCollection errorCollection)
-        { 
+        {
             _errors = errorCollection;
         }
 
@@ -42,15 +42,15 @@ public JsonApiException(int statusCode, string message, Exception innerException
 
         public int GetStatusCode()
         {
-            if(_errors.Errors.Count == 1)
+            if (_errors.Errors.Count == 1)
                 return _errors.Errors[0].StatusCode;
 
-            if(_errors.Errors.FirstOrDefault(e => e.StatusCode >= 500) != null)
+            if (_errors.Errors.FirstOrDefault(e => e.StatusCode >= 500) != null)
                 return 500;
-                
-            if(_errors.Errors.FirstOrDefault(e => e.StatusCode >= 400) != null)
+
+            if (_errors.Errors.FirstOrDefault(e => e.StatusCode >= 400) != null)
                 return 400;
-            
+
             return 500;
         }
     }

src/JsonApiDotNetCore/Services/Operations/OperationsProcessor.cs

@@ -5,6 +5,7 @@
 using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Models.Operations;
 using JsonApiDotNetCore.Models.Pointers;
+using Microsoft.EntityFrameworkCore;
 
 namespace JsonApiDotNetCore.Services.Operations
 {
@@ -16,35 +17,60 @@ public interface IOperationsProcessor
     public class OperationsProcessor : IOperationsProcessor
     {
         private readonly IOperationProcessorResolver _processorResolver;
+        private readonly DbContext _dbContext;
 
-        public OperationsProcessor(IOperationProcessorResolver processorResolver)
+        public OperationsProcessor(
+            IOperationProcessorResolver processorResolver,
+            DbContext dbContext)
         {
             _processorResolver = processorResolver;
+            _dbContext = dbContext;
         }
 
         public async Task<List<Operation>> ProcessAsync(List<Operation> inputOps)
         {
             var outputOps = new List<Operation>();
-
-            foreach (var op in inputOps)
+            var opIndex = 0;
+            using (var transaction = await _dbContext.Database.BeginTransactionAsync())
             {
-                // TODO: parse pointers:
-                // locate all objects within the document and replace them
-                var operationsPointer = new OperationsPointer();
-
-                ReplaceDataPointers(op.DataObject, outputOps);
-                ReplaceRefPointers(op.Ref, outputOps);
-
-                var processor = GetOperationsProcessor(op);
-                var resultOp = await processor.ProcessAsync(op);
+                try
+                {
+                    foreach (var op in inputOps)
+                    {
+                        await ProcessOperation(op, outputOps);
+                        opIndex++;
+                    }
 
-                if (resultOp != null)
-                    outputOps.Add(resultOp);
+                    transaction.Commit();
+                }
+                catch (JsonApiException e)
+                {
+                    outputOps = new List<Operation>();
+                    throw new JsonApiException(e.GetStatusCode(), $"Transaction failed on operation[{opIndex}].", e);
+                }
+                catch (Exception e)
+                {
+                    throw new JsonApiException(500, $"Transaction failed on operation[{opIndex}] for an unexpected reason.", e);
+                }
             }
 
             return outputOps;
         }
 
+        private async Task ProcessOperation(Operation op, List<Operation> outputOps)
+        {
+            var operationsPointer = new OperationsPointer();
+
+            ReplaceDataPointers(op.DataObject, outputOps);
+            ReplaceRefPointers(op.Ref, outputOps);
+
+            var processor = GetOperationsProcessor(op);
+            var resultOp = await processor.ProcessAsync(op);
+
+            if (resultOp != null)
+                outputOps.Add(resultOp);
+        }
+
         private void ReplaceDataPointers(DocumentData dataObject, List<Operation> outputOps)
         {
             if (dataObject == null) return;

test/OperationsExampleTests/Add/AddTests.cs

@@ -1,7 +1,10 @@
+using System.Collections.Generic;
 using System.Linq;
 using System.Net;
 using System.Threading.Tasks;
+using Bogus;
 using JsonApiDotNetCore.Extensions;
+using JsonApiDotNetCore.Models.Operations;
 using Microsoft.EntityFrameworkCore;
 using OperationsExample.Data;
 using OperationsExampleTests.Factories;
@@ -13,6 +16,7 @@ namespace OperationsExampleTests
     public class AddTests
     {
         private readonly Fixture _fixture;
+        private readonly Faker _faker = new Faker();
 
         public AddTests(Fixture fixture)
         {
@@ -41,62 +45,61 @@ public async Task Can_Create_Article()
             };
 
             // act
-            var response = await _fixture.PatchAsync("api/bulk", content);
+            var result = await _fixture.PatchAsync<OperationsDocument>("api/bulk", content);
 
             // assert
-            Assert.NotNull(response);
-            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.NotNull(result);
+            Assert.Equal(HttpStatusCode.OK, result.response.StatusCode);
 
-            var lastArticle = await context.Articles.LastAsync();
+            var id = (string)result.data.Operations.Single().DataObject.Id;
+            var lastArticle = await context.Articles.SingleAsync(a => a.StringId == id);
             Assert.Equal(article.Name, lastArticle.Name);
         }
 
         [Fact]
         public async Task Can_Create_Articles()
         {
             // arrange
+            var expectedCount = _faker.Random.Int(1, 10);
             var context = _fixture.GetService<AppDbContext>();
-            var articles = ArticleFactory.Get(2);
+            var articles = ArticleFactory.Get(expectedCount);
             var content = new
             {
-                operations = new[] {
-                    new {
-                        op = "add",
-                        data = new {
-                            type = "articles",
-                            attributes = new {
-                                name = articles[0].Name
-                            }
-                        }
-                    },
-                    new {
-                        op = "add",
-                        data = new {
-                            type = "articles",
-                            attributes = new {
-                                name = articles[1].Name
-                            }
-                        }
-                    }
-                }
+                operations = new List<object>()
             };
 
+            for (int i = 0; i < expectedCount; i++)
+            {
+                content.operations.Add(
+                     new
+                     {
+                         op = "add",
+                         data = new
+                         {
+                             type = "articles",
+                             attributes = new
+                             {
+                                 name = articles[i].Name
+                             }
+                         }
+                     }
+                );
+            }
+
             // act
-            var response = await _fixture.PatchAsync("api/bulk", content);
+            var result = await _fixture.PatchAsync<OperationsDocument>("api/bulk", content);
 
             // assert
-            Assert.NotNull(response);
-            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.NotNull(result);
+            Assert.Equal(HttpStatusCode.OK, result.response.StatusCode);
+            Assert.Equal(expectedCount, result.data.Operations.Count);
 
-            var lastArticles = (await context.Articles
-                .OrderByDescending(d => d.Id)
-                .Take(2)
-                .ToListAsync())
-                .OrderBy(l => l.Id)
-                .ToList();
-
-            Assert.Equal(articles[0].Name, lastArticles[0].Name);
-            Assert.Equal(articles[1].Name, lastArticles[1].Name);
+            for (int i = 0; i < expectedCount; i++)
+            {
+                var data = result.data.Operations[i].DataObject;
+                var article = context.Articles.Single(a => a.StringId == data.Id.ToString());
+                Assert.Equal(articles[i].Name, article.Name);
+            }
         }
     }
 }