Merge branch 'release' into dependabot/nuget/GraphQL_Version-4.3.0

Author: AntonioFalcaoJr

src/Dotnet6.GraphQL4.Repositories.Abstractions/Transactions/TransactionScopeExecutor.cs

@@ -58,6 +58,12 @@ public TransactionScopeExecutor<T> WithConditionAsync(Func<CancellationToken, Ta
             return this;
         }
 
+        public T Execute()
+            => Execute(_operation);
+
+        public Task<T> ExecuteAsync(CancellationToken cancellationToken)
+            => ExecuteAsync(_operationAsync, cancellationToken);
+
         public T Execute(Func<T> operation)
         {
             using var scope = CreateScope();
@@ -66,12 +72,6 @@ public T Execute(Func<T> operation)
             return result;
         }
 
-        public T Execute()
-            => Execute(_operation);
-
-        public Task<T> ExecuteAsync(CancellationToken cancellationToken)
-            => ExecuteAsync(_operationAsync, cancellationToken);
-
         public async Task<T> ExecuteAsync(Func<CancellationToken, Task<T>> operationAsync, CancellationToken cancellationToken)
         {
             using var scope = CreateScope();

src/Dotnet6.GraphQL4.Repositories.Abstractions/UnitsOfWork/IUnitOfWork.cs

@@ -6,8 +6,8 @@ namespace Dotnet6.GraphQL4.Repositories.Abstractions.UnitsOfWork
 {
     public interface IUnitOfWork
     {
-        TResult ExecuteInTransaction<TResult>(Func<TResult> operation, Func<bool> condition);
-        Task<TResult> ExecuteInTransactionAsync<TResult>(Func<CancellationToken, Task<TResult>> operationAsync, Func<CancellationToken, Task<bool>> condition, CancellationToken cancellationToken);
+        TResult ExecuteInTransactionScope<TResult>(Func<TResult> operation, Func<bool> condition);
+        Task<TResult> ExecuteInTransactionScopeAsync<TResult>(Func<CancellationToken, Task<TResult>> operationAsync, Func<CancellationToken, Task<bool>> condition, CancellationToken cancellationToken);
 
         bool SaveChanges();
         Task<bool> SaveChangesAsync(CancellationToken cancellationToken);

src/Dotnet6.GraphQL4.Repositories.Abstractions/UnitsOfWork/UnitOfWork.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Transactions;
 using Dotnet6.GraphQL4.CrossCutting.Notifications;
 using Dotnet6.GraphQL4.Repositories.Abstractions.DependencyInjection.Options;
 using Dotnet6.GraphQL4.Repositories.Abstractions.Transactions.Extensions;
@@ -21,46 +20,46 @@ public class UnitOfWork : IUnitOfWork
 
         public UnitOfWork(
             DbContext dbContext, 
-            IOptionsMonitor<ApplicationTransactionOptions> optionsMonitor, 
+            IOptionsSnapshot<ApplicationTransactionOptions> optionsMonitor, 
             INotificationContext notificationContext)
         {
             _dbContext = dbContext;
-            _options = optionsMonitor.CurrentValue;
+            _options = optionsMonitor.Value;
             _database = _dbContext.Database;
             _notificationContext = notificationContext;
         }
 
-        public TResult ExecuteInTransaction<TResult>(Func<TResult> operation, Func<bool> condition)
-            => CreateExecutionStrategy().Execute(() => ExecuteWithScope(operation, condition));
+        public TResult ExecuteInTransactionScope<TResult>(Func<TResult> operation, Func<bool> condition)
+            => CreateExecutionStrategy().Execute(() => ExecuteInScope(operation, condition));
 
-        public Task<TResult> ExecuteInTransactionAsync<TResult>(Func<CancellationToken, Task<TResult>> operationAsync, Func<CancellationToken, Task<bool>> condition, CancellationToken cancellationToken)
-            => CreateExecutionStrategy().ExecuteAsync(ct => ExecuteWithScopeAsync(operationAsync, condition, ct), cancellationToken);
+        public Task<TResult> ExecuteInTransactionScopeAsync<TResult>(Func<CancellationToken, Task<TResult>> operationAsync, Func<CancellationToken, Task<bool>> condition, CancellationToken cancellationToken)
+            => CreateExecutionStrategy().ExecuteAsync(ct => ExecuteInScopeAsync(operationAsync, condition, ct), cancellationToken);
 
-        private Task<TResult> ExecuteWithScopeAsync<TResult>(Func<CancellationToken, Task<TResult>> operationAsync, Func<CancellationToken, Task<bool>> condition, CancellationToken cancellationToken)
+        private Task<TResult> ExecuteInScopeAsync<TResult>(Func<CancellationToken, Task<TResult>> operationAsync, Func<CancellationToken, Task<bool>> condition, CancellationToken cancellationToken)
             => operationAsync
                 .BeginTransactionScope()
-                .WithScopeOption(TransactionScopeOption.Required)
+                .WithScopeOption()
                 .WithOptions(options => options.IsolationLevel = _options.IsolationLevel)
-                .WithScopeAsyncFlowOption(TransactionScopeAsyncFlowOption.Enabled)
+                .WithScopeAsyncFlowOption()
                 .WithConditionAsync(condition ?? (_ => _notificationContext.AllValidAsync))
                 .ExecuteAsync(cancellationToken);
 
-        private TResult ExecuteWithScope<TResult>(Func<TResult> operation, Func<bool> condition)
+        private TResult ExecuteInScope<TResult>(Func<TResult> operation, Func<bool> condition)
             => operation
                 .BeginTransactionScope()
-                .WithScopeOption(TransactionScopeOption.Required)
+                .WithScopeOption()
                 .WithOptions(options => options.IsolationLevel = _options.IsolationLevel)
-                .WithScopeAsyncFlowOption(TransactionScopeAsyncFlowOption.Enabled)
+                .WithScopeAsyncFlowOption()
                 .WithCondition(condition ?? (() => _notificationContext.AllValid))
                 .Execute();
 
         private IExecutionStrategy CreateExecutionStrategy()
             => _database.CreateExecutionStrategy();
 
         public bool SaveChanges()
-            => _dbContext.SaveChanges(false) > default(int);
+            => _dbContext.SaveChanges(false) > 0;
 
         public async Task<bool> SaveChangesAsync(CancellationToken cancellationToken)
-            => await _dbContext.SaveChangesAsync(false, cancellationToken) > default(int);
+            => await _dbContext.SaveChangesAsync(false, cancellationToken) > 0;
     }
 }

src/Dotnet6.GraphQL4.Store.Repositories/Contexts/StoreDbContext.cs

@@ -21,12 +21,12 @@ public StoreDbContext(
             DbContextOptions options, 
             ILoggerFactory loggerFactory, 
             IConfiguration configuration,
-            IOptionsMonitor<SqlServerRetryingOptions> optionsMonitor)
+            IOptionsSnapshot<SqlServerRetryingOptions> optionsMonitor)
             : base(options)
         {
             _loggerFactory = loggerFactory;
             _configuration = configuration;
-            _options = optionsMonitor.CurrentValue;
+            _options = optionsMonitor.Value;
         }
 
         public DbSet<Product> Products { get; set; }
@@ -45,7 +45,8 @@ protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
         {
             if (optionsBuilder.IsConfigured) return;
 
-            optionsBuilder.EnableDetailedErrors()
+            optionsBuilder
+                .EnableDetailedErrors()
                 .EnableSensitiveDataLogging()
                 .UseSqlServer(
                     connectionString:_configuration.GetConnectionString("DefaultConnection"), 

src/Dotnet6.GraphQL4.Store.Services/ProductService.cs

@@ -30,7 +30,7 @@ public Task<Review> AddReviewAsync(ReviewModel reviewModel, CancellationToken ca
                 return default;
             }
 
-            return UnitOfWork.ExecuteInTransactionAsync(
+            return UnitOfWork.ExecuteInTransactionScopeAsync(
                 operationAsync: async ct =>
                 {
                     var product = await Repository.GetByIdAsync(