Added proper optimistic concurrency check to Simple with EventStoreDB sample

oskardudycz · oskardudycz · commit d762c2a043cf · 2021-10-01T15:36:58.000+02:00
diff --git a/Sample/EventStoreDB/Simple/ECommerce.Api.Tests/ShoppingCarts/Confirming/ConfirmShoppingCartTests.cs b/Sample/EventStoreDB/Simple/ECommerce.Api.Tests/ShoppingCarts/Confirming/ConfirmShoppingCartTests.cs
@@ -28,7 +28,7 @@ public override async Task InitializeAsync()
 
             ShoppingCartId = await initializeResponse.GetResultFromJson<Guid>();
 
-            CommandResponse = await Put($"{ShoppingCartId}/confirmation");
+            CommandResponse = await Put($"{ShoppingCartId}/confirmation", new ConfirmShoppingCartRequest(0));
         }
     }
 
@@ -60,7 +60,7 @@ public async Task Put_Should_Confirm_ShoppingCart()
 
             //send query
             var queryResponse = await fixture.Get(query, 30,
-                check: async response => (await response.GetResultFromJson<ShoppingCartDetails>())?.Version != 1);
+                check: async response => (await response.GetResultFromJson<ShoppingCartDetails>())?.Version == 1);
 
             queryResponse.EnsureSuccessStatusCode();
 
@@ -69,7 +69,7 @@ public async Task Put_Should_Confirm_ShoppingCart()
             cartDetails.Id.Should().Be(fixture.ShoppingCartId);
             cartDetails.Status.Should().Be(ShoppingCartStatus.Confirmed);
             cartDetails.ClientId.Should().Be(fixture.ClientId);
-            cartDetails.Version.Should().Be(2);
+            cartDetails.Version.Should().Be(1);
         }
     }
 }
diff --git a/Sample/EventStoreDB/Simple/ECommerce.Api.Tests/ShoppingCarts/Initializing/InitializeShoppingCartTests.cs b/Sample/EventStoreDB/Simple/ECommerce.Api.Tests/ShoppingCarts/Initializing/InitializeShoppingCartTests.cs
@@ -65,7 +65,7 @@ public async Task Post_Should_Create_ShoppingCart()
             cartDetails.Id.Should().Be(createdId);
             cartDetails.Status.Should().Be(ShoppingCartStatus.Pending);
             cartDetails.ClientId.Should().Be(fixture.ClientId);
-            cartDetails.Version.Should().Be(1);
+            cartDetails.Version.Should().Be(0);
         }
     }
 }
diff --git a/Sample/EventStoreDB/Simple/ECommerce.Api/Controllers/ShoppingCartsController.cs b/Sample/EventStoreDB/Simple/ECommerce.Api/Controllers/ShoppingCartsController.cs
@@ -56,7 +56,8 @@ CancellationToken ct
                 ProductItem.From(
                     request.ProductItem?.ProductId,
                     request.ProductItem?.Quantity
-                )
+                ),
+                request.Version
             );
 
             await handle(command, ct);
@@ -83,7 +84,8 @@ CancellationToken ct
                         request.ProductItem?.Quantity
                     ),
                     request.ProductItem?.UnitPrice
-                )
+                ),
+                request.Version
             );
 
             await handle(command, ct);
@@ -95,11 +97,15 @@ CancellationToken ct
         public async Task<IActionResult> ConfirmCart(
             [FromServices] Func<ConfirmShoppingCart, CancellationToken, ValueTask> handle,
             Guid id,
+            [FromBody] ConfirmShoppingCartRequest request,
             CancellationToken ct
             )
         {
+            if (request == null)
+                throw new ArgumentNullException(nameof(request));
+
             var command =
-                ConfirmShoppingCart.From(id);
+                ConfirmShoppingCart.From(id, request.Version);
 
             await handle(command, ct);
 
diff --git a/Sample/EventStoreDB/Simple/ECommerce.Api/Requests/ShoppingCartsRequests.cs b/Sample/EventStoreDB/Simple/ECommerce.Api/Requests/ShoppingCartsRequests.cs
@@ -15,7 +15,8 @@ public class ProductItemRequest
 
     public record AddProductRequest(
         Guid? ShoppingCartId,
-        ProductItemRequest? ProductItem
+        ProductItemRequest? ProductItem,
+        uint? Version
     );
 
     public record PricedProductItemRequest(
@@ -26,6 +27,11 @@ public record PricedProductItemRequest(
 
     public record RemoveProductRequest(
         Guid? ShoppingCartId,
-        PricedProductItemRequest? ProductItem
+        PricedProductItemRequest? ProductItem,
+        uint? Version
+    );
+
+    public record ConfirmShoppingCartRequest(
+        uint? Version
     );
 }
diff --git a/Sample/EventStoreDB/Simple/ECommerce.Core/Commands/CommandHandler.cs b/Sample/EventStoreDB/Simple/ECommerce.Core/Commands/CommandHandler.cs
@@ -26,6 +26,7 @@ public static async Task HandleUpdateCommand<TCommand, TEntity>(
             IEventStoreDBRepository<TEntity> repository,
             Func<TCommand, TEntity, object> handle,
             Func<TCommand, string> getId,
+            Func<TCommand, uint> getVersion,
             Func<TEntity?, object, TEntity> when,
             TCommand command,
             CancellationToken ct
@@ -36,7 +37,7 @@ CancellationToken ct
 
             var @event = handle(command, entity);
 
-            await repository.Append(id, @event, ct);
+            await repository.Append(id, @event, getVersion(command), ct);
         }
 
         public static IServiceCollection AddCreateCommandHandler<TCommand, TEntity>(
@@ -65,22 +66,24 @@ public static IServiceCollection AddUpdateCommandHandler<TCommand, TEntity>(
             this IServiceCollection services,
             Func<TCommand, TEntity, object> handle,
             Func<TCommand, string> getId,
+            Func<TCommand, uint> getVersion,
             Func<TEntity?, object, TEntity> when
         ) where TEntity : notnull
-            => AddUpdateCommandHandler(services, _ =>  handle, getId, when);
+            => AddUpdateCommandHandler(services, _ =>  handle, getId, getVersion, when);
 
         public static IServiceCollection AddUpdateCommandHandler<TCommand, TEntity>(
             this IServiceCollection services,
             Func<IServiceProvider, Func<TCommand, TEntity, object>> handle,
             Func<TCommand, string> getId,
+            Func<TCommand, uint> getVersion,
             Func<TEntity?, object, TEntity> when
         ) where TEntity : notnull
             => services
                 .AddTransient<Func<TCommand, CancellationToken, ValueTask>>(sp =>
                 {
                     var repository = sp.GetRequiredService<IEventStoreDBRepository<TEntity>>();
                     return async (command, ct) =>
-                        await HandleUpdateCommand(repository, handle(sp), getId, when, command, ct);
+                        await HandleUpdateCommand(repository, handle(sp), getId, getVersion, when, command, ct);
                 });
 
 
diff --git a/Sample/EventStoreDB/Simple/ECommerce.Core/Entities/EventStoreDBRepository.cs b/Sample/EventStoreDB/Simple/ECommerce.Core/Entities/EventStoreDBRepository.cs
@@ -13,6 +13,8 @@ public interface IEventStoreDBRepository<TEntity> where TEntity: notnull
         Task<TEntity> Find(Func<TEntity?, object, TEntity> when, string id, CancellationToken cancellationToken);
 
         Task Append(string id, object @event, CancellationToken cancellationToken);
+
+        Task Append(string id, object @event, uint version, CancellationToken cancellationToken);
     }
 
     public class EventStoreDBRepository<TEntity>: IEventStoreDBRepository<TEntity> where TEntity: class
@@ -53,6 +55,39 @@ public async Task Append(
             object @event,
             CancellationToken cancellationToken
         )
+
+        {
+            await eventStore.AppendToStreamAsync(
+                id,
+                // TODO: Add proper optimistic concurrency handling
+                StreamState.NoStream,
+                new[] { @event.ToJsonEventData() },
+                cancellationToken: cancellationToken
+            );
+        }
+
+
+        public async Task Append(
+            string id,
+            object @event,
+            uint version,
+            CancellationToken cancellationToken
+        )
+        {
+            await eventStore.AppendToStreamAsync(
+                id,
+                StreamRevision.FromInt64(version),
+                new[] { @event.ToJsonEventData() },
+                cancellationToken: cancellationToken
+            );
+        }
+
+        private async Task Append(
+            string id,
+            object @event,
+            uint? version,
+            CancellationToken cancellationToken
+        )
         {
             await eventStore.AppendToStreamAsync(
                 id,
diff --git a/Sample/EventStoreDB/Simple/ECommerce/ShoppingCarts/AddingProductItem/AddProductItemToShoppingCart.cs b/Sample/EventStoreDB/Simple/ECommerce/ShoppingCarts/AddingProductItem/AddProductItemToShoppingCart.cs
@@ -6,17 +6,20 @@ namespace ECommerce.ShoppingCarts.AddingProductItem
 {
     public record AddProductItemToShoppingCart(
         Guid ShoppingCartId,
-        ProductItem ProductItem
+        ProductItem ProductItem,
+        uint Version
     )
     {
-        public static AddProductItemToShoppingCart From(Guid? cartId, ProductItem? productItem)
+        public static AddProductItemToShoppingCart From(Guid? cartId, ProductItem? productItem, uint? version)
         {
             if (cartId == null || cartId == Guid.Empty)
                 throw new ArgumentOutOfRangeException(nameof(cartId));
             if (productItem == null)
                 throw new ArgumentOutOfRangeException(nameof(productItem));
+            if (version == null)
+                throw new ArgumentOutOfRangeException(nameof(version));
 
-            return new AddProductItemToShoppingCart(cartId.Value, productItem);
+            return new AddProductItemToShoppingCart(cartId.Value, productItem, version.Value);
         }
 
         public static ProductItemAddedToShoppingCart Handle(
@@ -25,7 +28,7 @@ public static ProductItemAddedToShoppingCart Handle(
             ShoppingCart shoppingCart
         )
         {
-            var (cartId, productItem) = command;
+            var (cartId, productItem, _) = command;
 
             if(shoppingCart.Status != ShoppingCartStatus.Pending)
                 throw new InvalidOperationException($"Adding product item for cart in '{shoppingCart.Status}' status is not allowed.");
diff --git a/Sample/EventStoreDB/Simple/ECommerce/ShoppingCarts/Configuration.cs b/Sample/EventStoreDB/Simple/ECommerce/ShoppingCarts/Configuration.cs
@@ -30,16 +30,19 @@ public static IServiceCollection AddShoppingCartsModule(this IServiceCollection
                             command,
                             shoppingCart),
                     command => ShoppingCart.MapToStreamId(command.ShoppingCartId),
+                    command => command.Version,
                     ShoppingCart.When
                 )
                 .AddUpdateCommandHandler<RemoveProductItemFromShoppingCart, ShoppingCart>(
                     RemoveProductItemFromShoppingCart.Handle,
                     command => ShoppingCart.MapToStreamId(command.ShoppingCartId),
+                    command => command.Version,
                     ShoppingCart.When
                 )
                 .AddUpdateCommandHandler<ConfirmShoppingCart, ShoppingCart>(
                     ConfirmShoppingCart.Handle,
                     command => ShoppingCart.MapToStreamId(command.ShoppingCartId),
+                    command => command.Version,
                     ShoppingCart.When
                 )
                 .For<ShoppingCartDetails, ECommerceDbContext>(
diff --git a/Sample/EventStoreDB/Simple/ECommerce/ShoppingCarts/Confirming/ConfirmShoppingCart.cs b/Sample/EventStoreDB/Simple/ECommerce/ShoppingCarts/Confirming/ConfirmShoppingCart.cs
@@ -3,15 +3,19 @@
 namespace ECommerce.ShoppingCarts.Confirming
 {
     public record ConfirmShoppingCart(
-        Guid ShoppingCartId
+        Guid ShoppingCartId,
+        uint Version
     )
     {
-        public static ConfirmShoppingCart From(Guid? cartId)
+        public static ConfirmShoppingCart From(Guid? cartId, uint? version)
         {
             if (cartId == null || cartId == Guid.Empty)
                 throw new ArgumentOutOfRangeException(nameof(cartId));
 
-            return new ConfirmShoppingCart(cartId.Value);
+            if (version == null)
+                throw new ArgumentOutOfRangeException(nameof(version));
+
+            return new ConfirmShoppingCart(cartId.Value, version.Value);
         }
 
         public static ShoppingCartConfirmed Handle(ConfirmShoppingCart command, ShoppingCart shoppingCart)
diff --git a/Sample/EventStoreDB/Simple/ECommerce/ShoppingCarts/GettingCartById/ShoppingCartDetails.cs b/Sample/EventStoreDB/Simple/ECommerce/ShoppingCarts/GettingCartById/ShoppingCartDetails.cs
@@ -31,7 +31,7 @@ public static ShoppingCartDetails Handle(ShoppingCartInitialized @event)
                 Id = shoppingCartId,
                 ClientId = clientId,
                 Status = shoppingCartStatus,
-                Version = 1
+                Version = 0
             };
         }
 
diff --git a/Sample/EventStoreDB/Simple/ECommerce/ShoppingCarts/GettingCarts/ShoppingCartShortInfo.cs b/Sample/EventStoreDB/Simple/ECommerce/ShoppingCarts/GettingCarts/ShoppingCartShortInfo.cs
@@ -24,7 +24,7 @@ public static ShoppingCartShortInfo Handle(ShoppingCartInitialized @event)
                 ClientId = clientId,
                 TotalItemsCount = 0,
                 Status = shoppingCartStatus,
-                Version = 1
+                Version = 0
             };
         }
 
diff --git a/Sample/EventStoreDB/Simple/ECommerce/ShoppingCarts/RemovingProductItem/RemoveProductItemFromShoppingCart.cs b/Sample/EventStoreDB/Simple/ECommerce/ShoppingCarts/RemovingProductItem/RemoveProductItemFromShoppingCart.cs
@@ -5,25 +5,28 @@ namespace ECommerce.ShoppingCarts.RemovingProductItem
 {
     public record RemoveProductItemFromShoppingCart(
         Guid ShoppingCartId,
-        PricedProductItem ProductItem
+        PricedProductItem ProductItem,
+        uint Version
     )
     {
-        public static RemoveProductItemFromShoppingCart From(Guid? cartId, PricedProductItem? productItem)
+        public static RemoveProductItemFromShoppingCart From(Guid? cartId, PricedProductItem? productItem, uint? version)
         {
             if (cartId == null || cartId == Guid.Empty)
                 throw new ArgumentOutOfRangeException(nameof(cartId));
             if (productItem == null)
                 throw new ArgumentOutOfRangeException(nameof(productItem));
+            if (version == null)
+                throw new ArgumentOutOfRangeException(nameof(version));
 
-            return new RemoveProductItemFromShoppingCart(cartId.Value, productItem);
+            return new RemoveProductItemFromShoppingCart(cartId.Value, productItem, version.Value);
         }
 
         public static ProductItemRemovedFromShoppingCart Handle(
             RemoveProductItemFromShoppingCart command,
             ShoppingCart shoppingCart
         )
         {
-            var (cartId, productItem) = command;
+            var (cartId, productItem, _) = command;
 
             if(shoppingCart.Status != ShoppingCartStatus.Pending)
                 throw new InvalidOperationException($"Adding product item for cart in '{shoppingCart.Status}' status is not allowed.");

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public override async Task InitializeAsync()`
`28`	`28`
`29`	`29`	`ShoppingCartId = await initializeResponse.GetResultFromJson<Guid>();`
`30`	`30`
`31`		`- CommandResponse = await Put($"{ShoppingCartId}/confirmation");`
	`31`	`+ CommandResponse = await Put($"{ShoppingCartId}/confirmation", new ConfirmShoppingCartRequest(0));`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`
`@@ -60,7 +60,7 @@ public async Task Put_Should_Confirm_ShoppingCart()`
`60`	`60`
`61`	`61`	`//send query`
`62`	`62`	`var queryResponse = await fixture.Get(query, 30,`
`63`		`- check: async response => (await response.GetResultFromJson<ShoppingCartDetails>())?.Version != 1);`
	`63`	`+ check: async response => (await response.GetResultFromJson<ShoppingCartDetails>())?.Version == 1);`
`64`	`64`
`65`	`65`	`queryResponse.EnsureSuccessStatusCode();`
`66`	`66`
`@@ -69,7 +69,7 @@ public async Task Put_Should_Confirm_ShoppingCart()`
`69`	`69`	`cartDetails.Id.Should().Be(fixture.ShoppingCartId);`
`70`	`70`	`cartDetails.Status.Should().Be(ShoppingCartStatus.Confirmed);`
`71`	`71`	`cartDetails.ClientId.Should().Be(fixture.ClientId);`
`72`		`- cartDetails.Version.Should().Be(2);`
	`72`	`+ cartDetails.Version.Should().Be(1);`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ public async Task Post_Should_Create_ShoppingCart()`
`65`	`65`	`cartDetails.Id.Should().Be(createdId);`
`66`	`66`	`cartDetails.Status.Should().Be(ShoppingCartStatus.Pending);`
`67`	`67`	`cartDetails.ClientId.Should().Be(fixture.ClientId);`
`68`		`- cartDetails.Version.Should().Be(1);`
	`68`	`+ cartDetails.Version.Should().Be(0);`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,17 +6,20 @@ namespace ECommerce.ShoppingCarts.AddingProductItem`
`6`	`6`	`{`
`7`	`7`	`public record AddProductItemToShoppingCart(`
`8`	`8`	`Guid ShoppingCartId,`
`9`		`- ProductItem ProductItem`
	`9`	`+ ProductItem ProductItem,`
	`10`	`+ uint Version`
`10`	`11`	`)`
`11`	`12`	`{`
`12`		`- public static AddProductItemToShoppingCart From(Guid? cartId, ProductItem? productItem)`
	`13`	`+ public static AddProductItemToShoppingCart From(Guid? cartId, ProductItem? productItem, uint? version)`
`13`	`14`	`{`
`14`	`15`	`if (cartId == null \|\| cartId == Guid.Empty)`
`15`	`16`	`throw new ArgumentOutOfRangeException(nameof(cartId));`
`16`	`17`	`if (productItem == null)`
`17`	`18`	`throw new ArgumentOutOfRangeException(nameof(productItem));`
	`19`	`+ if (version == null)`
	`20`	`+ throw new ArgumentOutOfRangeException(nameof(version));`
`18`	`21`
`19`		`- return new AddProductItemToShoppingCart(cartId.Value, productItem);`
	`22`	`+ return new AddProductItemToShoppingCart(cartId.Value, productItem, version.Value);`
`20`	`23`	`}`
`21`	`24`
`22`	`25`	`public static ProductItemAddedToShoppingCart Handle(`
`@@ -25,7 +28,7 @@ public static ProductItemAddedToShoppingCart Handle(`
`25`	`28`	`ShoppingCart shoppingCart`
`26`	`29`	`)`
`27`	`30`	`{`
`28`		`- var (cartId, productItem) = command;`
	`31`	`+ var (cartId, productItem, _) = command;`
`29`	`32`
`30`	`33`	`if(shoppingCart.Status != ShoppingCartStatus.Pending)`
`31`	`34`	`throw new InvalidOperationException($"Adding product item for cart in '{shoppingCart.Status}' status is not allowed.");`
Original file line number	Diff line number	Diff line change
`@@ -3,15 +3,19 @@`
`3`	`3`	`namespace ECommerce.ShoppingCarts.Confirming`
`4`	`4`	`{`
`5`	`5`	`public record ConfirmShoppingCart(`
`6`		`- Guid ShoppingCartId`
	`6`	`+ Guid ShoppingCartId,`
	`7`	`+ uint Version`
`7`	`8`	`)`
`8`	`9`	`{`
`9`		`- public static ConfirmShoppingCart From(Guid? cartId)`
	`10`	`+ public static ConfirmShoppingCart From(Guid? cartId, uint? version)`
`10`	`11`	`{`
`11`	`12`	`if (cartId == null \|\| cartId == Guid.Empty)`
`12`	`13`	`throw new ArgumentOutOfRangeException(nameof(cartId));`
`13`	`14`
`14`		`- return new ConfirmShoppingCart(cartId.Value);`
	`15`	`+ if (version == null)`
	`16`	`+ throw new ArgumentOutOfRangeException(nameof(version));`
	`17`	`+`
	`18`	`+ return new ConfirmShoppingCart(cartId.Value, version.Value);`
`15`	`19`	`}`
`16`	`20`
`17`	`21`	`public static ShoppingCartConfirmed Handle(ConfirmShoppingCart command, ShoppingCart shoppingCart)`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public static ShoppingCartDetails Handle(ShoppingCartInitialized @event)`
`31`	`31`	`Id = shoppingCartId,`
`32`	`32`	`ClientId = clientId,`
`33`	`33`	`Status = shoppingCartStatus,`
`34`		`- Version = 1`
	`34`	`+ Version = 0`
`35`	`35`	`};`
`36`	`36`	`}`
`37`	`37`