feat: ajustes

src/Shop.Core/Interfaces/ITransaction.cs

@@ -6,5 +6,5 @@ namespace Shop.Core.Interfaces;
 
 public interface ITransaction
 {
-    Task ExecuteAsync(Func<Task> action, CancellationToken cancellationToken = default);
+    Task ExecuteAsync(Func<Task> operation, CancellationToken cancellationToken = default);
 }

src/Shop.Infrastructure/Behaviors/TransactionBehaviour.cs

@@ -1,22 +1,35 @@
 using System.Threading;
 using System.Threading.Tasks;
 using MediatR;
+using Microsoft.Extensions.Logging;
+using Shop.Core.Extensions;
 using Shop.Core.Interfaces;
 
 namespace Shop.Infrastructure.Behaviors;
 
-public class TransactionBehaviour<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse> where TRequest : IRequest<TResponse>
+public class TransactionBehaviour<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : IRequest<TResponse>
 {
     private readonly ITransaction _transaction;
+    private readonly ILogger<TransactionBehaviour<TRequest, TResponse>> _logger;
 
-    public TransactionBehaviour(ITransaction transaction) => _transaction = transaction;
+    public TransactionBehaviour(ITransaction transaction, ILogger<TransactionBehaviour<TRequest, TResponse>> logger)
+    {
+        _transaction = transaction;
+        _logger = logger;
+    }
 
     public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
     {
         var response = default(TResponse);
+        var typeName = request.GetGenericTypeName();
+
+        _logger.LogInformation("----- Starting handling transaction for {CommandName} ({@Command})", typeName, request);
 
         await _transaction.ExecuteAsync(async () => response = await next(), cancellationToken);
 
+        _logger.LogInformation("----- Handling transaction completed for {CommandName} ({@Command})", typeName);
+
         return response;
     }
 }

src/Shop.Infrastructure/Data/ShopContextTransaction.cs

@@ -10,37 +10,34 @@ namespace Shop.Infrastructure.Data;
 
 public class ShopContextTransaction : ITransaction
 {
-    private readonly ShopContext _dbContext;
+    private readonly ShopContext _context;
     private readonly ILogger<ShopContextTransaction> _logger;
 
-    public ShopContextTransaction(ShopContext dbContext, ILogger<ShopContextTransaction> logger)
+    public ShopContextTransaction(ShopContext context, ILogger<ShopContextTransaction> logger)
     {
-        _dbContext = dbContext;
+        _context = context;
         _logger = logger;
     }
 
-    public async Task ExecuteAsync(Func<Task> action, CancellationToken cancellationToken = default)
+    public async Task ExecuteAsync(Func<Task> operation, CancellationToken cancellationToken = default)
     {
-        if (action == null)
-            throw new ArgumentNullException(nameof(action));
-
-        var strategy = _dbContext.Database.CreateExecutionStrategy();
+        var strategy = _context.Database.CreateExecutionStrategy();
 
         await strategy.ExecuteAsync(async () =>
         {
-            var transaction = await _dbContext.Database.BeginTransactionAsync(IsolationLevel.ReadCommitted, cancellationToken);
+            var transaction = await _context.Database.BeginTransactionAsync(IsolationLevel.ReadCommitted, cancellationToken);
 
             _logger.LogInformation("----- Begin transaction {TransactionId}", transaction.TransactionId);
 
-            await action();
+            await operation();
 
             try
             {
-                var rowsAffected = await _dbContext.SaveChangesAsync(cancellationToken);
+                await _context.SaveChangesAsync(cancellationToken);
+
+                _logger.LogInformation("----- Commit transaction {TransactionId}", transaction.TransactionId);
 
                 await transaction.CommitAsync(cancellationToken);
-
-                _logger.LogInformation("----- Commit transaction {TransactionId}, row(s) affected {RowsAffected}", transaction.TransactionId, rowsAffected);
             }
             catch (Exception ex)
             {