Move transaction scaffolding into MongoDbContext

Author: imnasnainaec

Backend.Tests/Mocks/MongoDbContextMock.cs

@@ -8,27 +8,28 @@ namespace Backend.Tests.Mocks;
 public class MongoDbContextMock : IMongoDbContext
 {
     public IMongoDatabase Db => throw new NotSupportedException();
+
     public Task<IMongoTransaction> BeginTransaction()
+        => Task.FromResult<IMongoTransaction>(new MongoTransactionMock());
+
+    public Task<T> ExecuteWithTransaction<T>(Func<IClientSessionHandle, Task<T>> operation)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<T?> ExecuteWithTransactionAllowNull<T>(Func<IClientSessionHandle, Task<T?>> operation) where T : class
     {
-        return Task.FromResult<IMongoTransaction>(new MongoTransactionMock());
+        throw new NotImplementedException();
     }
 
     private sealed class MongoTransactionMock : IMongoTransaction
     {
         public IClientSessionHandle Session => null!;
 
-        public Task CommitTransactionAsync()
-        {
-            return Task.CompletedTask;
-        }
+        public Task CommitTransactionAsync() => Task.CompletedTask;
 
-        public Task AbortTransactionAsync()
-        {
-            return Task.CompletedTask;
-        }
+        public Task AbortTransactionAsync() => Task.CompletedTask;
 
-        public void Dispose()
-        {
-        }
+        public void Dispose() { }
     }
 }

Backend/Contexts/MongoDbContext.cs

@@ -1,46 +1,105 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading.Tasks;
 using BackendFramework.Interfaces;
 using Microsoft.Extensions.Options;
 using MongoDB.Driver;
 
 namespace BackendFramework.Contexts;
 
+/// <summary>
+/// MongoDB context for accessing the configured database and executing transactional operations.
+/// </summary>
 public class MongoDbContext : IMongoDbContext
 {
+    /// <summary>
+    /// Gets the configured MongoDB database instance.
+    /// </summary>
     public IMongoDatabase Db { get; }
 
+    /// <summary>
+    /// Creates a new <see cref="MongoDbContext"/> from application settings.
+    /// </summary>
+    /// <param name="options">Options containing the Mongo connection string and database name.</param>
     public MongoDbContext(IOptions<Startup.Settings> options)
     {
         var client = new MongoClient(options.Value.ConnectionString);
         Db = client.GetDatabase(options.Value.CombineDatabase);
     }
 
+    /// <summary>
+    /// Begins a MongoDB transaction and returns a disposable transaction wrapper.
+    /// </summary>
+    /// <returns>A transaction wrapper containing the active client session.</returns>
     public async Task<IMongoTransaction> BeginTransaction()
     {
         var session = await Db.Client.StartSessionAsync();
         session.StartTransaction();
         return new MongoTransactionWrapper(session);
     }
 
-    private class MongoTransactionWrapper(IClientSessionHandle session) : IMongoTransaction
+    /// <summary>
+    /// Executes an operation in a transaction, committing on success and aborting on exception.
+    /// </summary>
+    /// <typeparam name="T">The operation result type.</typeparam>
+    /// <param name="operation">Operation to execute with the transaction session.</param>
+    /// <returns>The operation result.</returns>
+    public async Task<T> ExecuteWithTransaction<T>(Func<IClientSessionHandle, Task<T>> operation)
     {
-        private readonly IClientSessionHandle _session = session;
-
-        public IClientSessionHandle Session => _session;
-
-        public Task CommitTransactionAsync()
+        using var transaction = await BeginTransaction();
+        try
         {
-            return _session.CommitTransactionAsync();
+            var result = await operation(transaction.Session);
+            await transaction.CommitTransactionAsync();
+            return result;
         }
-
-        public Task AbortTransactionAsync()
+        catch
         {
-            return _session.AbortTransactionAsync();
+            await transaction.AbortTransactionAsync();
+            throw;
         }
+    }
 
-        public void Dispose()
+    /// <summary>
+    /// Executes an operation in a transaction, committing when a non-null result is returned.
+    /// </summary>
+    /// <typeparam name="T">The operation result reference type.</typeparam>
+    /// <param name="operation">Operation to execute with the transaction session.</param>
+    /// <returns>
+    /// The operation result when non-null; otherwise <see langword="null"/> after aborting the transaction.
+    /// </returns>
+    public async Task<T?> ExecuteWithTransactionAllowNull<T>(Func<IClientSessionHandle, Task<T?>> operation)
+        where T : class
+    {
+        using var transaction = await BeginTransaction();
+        try
+        {
+            var result = await operation(transaction.Session);
+            if (result is null)
+            {
+                await transaction.AbortTransactionAsync();
+                return null;
+            }
+
+            await transaction.CommitTransactionAsync();
+            return result;
+        }
+        catch
         {
-            _session.Dispose();
+            await transaction.AbortTransactionAsync();
+            throw;
         }
     }
+
+    private class MongoTransactionWrapper(IClientSessionHandle session) : IMongoTransaction
+    {
+        private readonly IClientSessionHandle _session = session;
+
+        public IClientSessionHandle Session => _session;
+
+        public Task CommitTransactionAsync() => _session.CommitTransactionAsync();
+
+        public Task AbortTransactionAsync() => _session.AbortTransactionAsync();
+
+        public void Dispose() => _session.Dispose();
+    }
 }

Backend/Interfaces/IMongoDbContext.cs

@@ -4,12 +4,45 @@
 
 namespace BackendFramework.Interfaces;
 
+/// <summary>
+/// Abstraction over MongoDB database access and transaction execution.
+/// </summary>
 public interface IMongoDbContext
 {
+    /// <summary>
+    /// Gets the configured MongoDB database instance.
+    /// </summary>
     IMongoDatabase Db { get; }
+
+    /// <summary>
+    /// Begins a new transaction and returns the transaction wrapper.
+    /// </summary>
+    /// <returns>A transaction wrapper containing the active client session.</returns>
     Task<IMongoTransaction> BeginTransaction();
+
+    /// <summary>
+    /// Executes an operation in a transaction, committing on success and aborting on exception.
+    /// </summary>
+    /// <typeparam name="T">The operation result type.</typeparam>
+    /// <param name="operation">Operation to execute with the transaction session.</param>
+    /// <returns>The operation result.</returns>
+    Task<T> ExecuteWithTransaction<T>(Func<IClientSessionHandle, Task<T>> operation);
+
+    /// <summary>
+    /// Executes an operation in a transaction, committing only when a non-null result is returned.
+    /// </summary>
+    /// <typeparam name="T">The operation result reference type.</typeparam>
+    /// <param name="operation">Operation to execute with the transaction session.</param>
+    /// <returns>
+    /// The operation result when non-null; otherwise <see langword="null"/> after aborting the transaction.
+    /// </returns>
+    Task<T?> ExecuteWithTransactionAllowNull<T>(Func<IClientSessionHandle, Task<T?>> operation)
+        where T : class;
 }
 
+/// <summary>
+/// Represents a MongoDB transaction wrapper that exposes the active session and transaction controls.
+/// </summary>
 public interface IMongoTransaction : IDisposable
 {
     IClientSessionHandle Session { get; }

Backend/Repositories/WordRepository.cs

@@ -142,7 +142,7 @@ public async Task<List<Word>> RepoCreate(List<Word> words)
 
             return words.Count == 0
                 ? []
-                : await ExecuteWithTransaction(async s => await CreateWithSession(s, words));
+                : await _dbContext.ExecuteWithTransaction(async s => await CreateWithSession(s, words));
         }
 
         /// <summary>
@@ -175,7 +175,7 @@ public async Task<List<Word>> RepoCreate(List<Word> words)
             using var activity = OtelService.StartActivityWithTag(
                 otelTagName, "updating a word in WordsCollection and Frontier, deleting old word from Frontier");
 
-            return await ExecuteWithTransactionAllowNull(async session =>
+            return await _dbContext.ExecuteWithTransactionAllowNull(async session =>
                 {
                     // Make sure old word exists in the Frontier.
                     var deletedWord =
@@ -208,7 +208,7 @@ public async Task<List<Word>> RepoCreate(List<Word> words)
             using var activity = OtelService.StartActivityWithTag(
                 otelTagName, "creating word in WordsCollection and Frontier, deleting old word from Frontier");
 
-            return await ExecuteWithTransactionAllowNull(
+            return await _dbContext.ExecuteWithTransactionAllowNull(
                 async s => await RepoUpdateFrontierWithSession(s, word, false, modifyNewWordFromOldWord));
         }
 
@@ -227,7 +227,7 @@ public async Task<List<Word>> RepoCreate(List<Word> words)
 
             var oldIdSet = idsToDelete.ToHashSet();
 
-            return await ExecuteWithTransactionAllowNull(async session =>
+            return await _dbContext.ExecuteWithTransactionAllowNull(async session =>
                 {
                     // Update the new words
                     foreach (var word in newWords)
@@ -260,7 +260,7 @@ public async Task<List<Word>> RepoRevertReplaceFrontier(
                 throw new ArgumentException("Ids to delete and restore must be disjoint");
             }
 
-            return await ExecuteWithTransaction(async session =>
+            return await _dbContext.ExecuteWithTransaction(async session =>
                 {
                     var restoredWords = await RepoRestoreFrontierWithSession(session, projectId, restoreSet.ToList());
                     if (restoredWords.Count != restoreSet.Count)
@@ -334,7 +334,7 @@ private async Task RepoDeleteFrontierWithSession(IClientSessionHandle session,
             using var activity = OtelService.StartActivityWithTag(
                 otelTagName, "adding word to WordsCollection, deleting word from Frontier");
 
-            return await ExecuteWithTransactionAllowNull(
+            return await _dbContext.ExecuteWithTransactionAllowNull(
                 async s => await RepoDeleteFrontierWithSession(s, projectId, wordId, modifyWord)
             );
         }
@@ -431,7 +431,8 @@ public async Task<List<Word>> RepoRestoreFrontier(string projectId, List<string>
 
             return wordIds.Count == 0
                 ? []
-                : await ExecuteWithTransaction(async s => await RepoRestoreFrontierWithSession(s, projectId, wordIds));
+                : await _dbContext.ExecuteWithTransaction(
+                    async s => await RepoRestoreFrontierWithSession(s, projectId, wordIds));
         }
 
         /// <summary> Adds a list of <see cref="Word"/>s only to the Frontier </summary>
@@ -472,51 +473,5 @@ public async Task<int> CountFrontierWordsWithDomain(string projectId, string dom
 
         // TODO: Move them all here.
 
-        // TRANSACTION SCAFFOLDING
-
-        /// <summary>
-        /// Executes the given operation in a transaction and commits if it succeeds.
-        /// </summary>
-        private async Task<T> ExecuteWithTransaction<T>(Func<IClientSessionHandle, Task<T>> operation)
-        {
-            using var transaction = await _dbContext.BeginTransaction();
-            try
-            {
-                var result = await operation(transaction.Session);
-                await transaction.CommitTransactionAsync();
-                return result;
-            }
-            catch
-            {
-                await transaction.AbortTransactionAsync();
-                throw;
-            }
-        }
-
-        /// <summary>
-        /// Executes the given operation in a transaction and aborts if the operation returns null.
-        /// </summary>
-        private async Task<T?> ExecuteWithTransactionAllowNull<T>(Func<IClientSessionHandle, Task<T?>> operation)
-            where T : class
-        {
-            using var transaction = await _dbContext.BeginTransaction();
-            try
-            {
-                var result = await operation(transaction.Session);
-                if (result is null)
-                {
-                    await transaction.AbortTransactionAsync();
-                    return null;
-                }
-
-                await transaction.CommitTransactionAsync();
-                return result;
-            }
-            catch
-            {
-                await transaction.AbortTransactionAsync();
-                throw;
-            }
-        }
     }
 }