Feat: Readonly UnitOfWork

AnnaSasDev · AnnaSasDev · commit 4cb9a3ccbdb0 · 2025-02-27T10:58:21.000+01:00
diff --git a/src/CodeOfChaos.Types.DataSeeder/CodeOfChaos.Types.DataSeeder.csproj b/src/CodeOfChaos.Types.DataSeeder/CodeOfChaos.Types.DataSeeder.csproj
@@ -8,7 +8,7 @@
 
         <!-- Main package name -->
         <PackageId>CodeOfChaos.Types.DataSeeder</PackageId>
-        <Version>0.22.0</Version>
+        <Version>0.24.0</Version>
         <Authors>Anna Sas</Authors>
         <Description>A small library housing DataSeeder typings</Description>
         <PackageProjectUrl>https://github.com/code-of-chaos/cs-code_of_chaos-types</PackageProjectUrl>
diff --git a/src/CodeOfChaos.Types.DataSeeder/OneTimeDataSeederService.cs b/src/CodeOfChaos.Types.DataSeeder/OneTimeDataSeederService.cs
@@ -139,7 +139,7 @@ public IDataSeederService AddSeederGroup(SeederGroup group) {
     /// <inheritdoc />
     public void AddRemainderSeeders(Assembly assembly) {
         Type[] types = CollectTypes(assembly);
-        var errors = new List<Exception>();
+        List<Exception> errors = new List<Exception>();
 
         foreach (Type type in types) {
             if (SeederTypes.Contains(type)) {
@@ -165,7 +165,7 @@ public void AddRemainderSeeders(Assembly assembly) {
     public void AddRemainderSeedersAsOneGroup(Assembly assembly) {
         Type[] types = CollectTypes(assembly);
         var group = new SeederGroup();
-        var errors = new List<Exception>();
+        List<Exception> errors = new List<Exception>();
 
         foreach (Type type in types) {
             if (SeederTypes.Contains(type)) {
diff --git a/src/CodeOfChaos.Types.TypedValueStore/CodeOfChaos.Types.TypedValueStore.csproj b/src/CodeOfChaos.Types.TypedValueStore/CodeOfChaos.Types.TypedValueStore.csproj
@@ -8,7 +8,7 @@
 
         <!-- Main package name -->
         <PackageId>CodeOfChaos.Types.TypedValueStore</PackageId>
-        <Version>0.22.0</Version>
+        <Version>0.24.0</Version>
         <Authors>Anna Sas</Authors>
         <Description>A small library housing TypedValueStore typings</Description>
         <PackageProjectUrl>https://github.com/code-of-chaos/cs-code_of_chaos-types</PackageProjectUrl>
diff --git a/src/CodeOfChaos.Types.UnitOfWork.Contracts/CodeOfChaos.Types.UnitOfWork.Contracts.csproj b/src/CodeOfChaos.Types.UnitOfWork.Contracts/CodeOfChaos.Types.UnitOfWork.Contracts.csproj
@@ -9,7 +9,7 @@
 
         <!-- Main package name -->
         <PackageId>CodeOfChaos.Types.UnitOfWork.Contracts</PackageId>
-        <Version>0.22.0</Version>
+        <Version>0.24.0</Version>
         <Authors>Anna Sas</Authors>
         <Description>A small library housing UnitOfWork typings for EntityFrameworkCore</Description>
         <PackageProjectUrl>https://github.com/code-of-chaos/cs-code_of_chaos-types</PackageProjectUrl>
@@ -30,7 +30,6 @@
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="CodeOfChaos.Extensions.DependencyInjection" Version="0.41.0" />
         <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.2" />
     </ItemGroup>
 
diff --git a/src/CodeOfChaos.Types.UnitOfWork.Contracts/IReadonlyCapableDbContext.cs b/src/CodeOfChaos.Types.UnitOfWork.Contracts/IReadonlyCapableDbContext.cs
@@ -0,0 +1,12 @@
+﻿// ---------------------------------------------------------------------------------------------------------------------
+// Imports
+// ---------------------------------------------------------------------------------------------------------------------
+namespace CodeOfChaos.Types.UnitOfWork;
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Code
+// ---------------------------------------------------------------------------------------------------------------------
+public interface IReadonlyCapableDbContext {
+    bool IsReadonly { get; }
+    void SetAsReadonly();
+}
diff --git a/src/CodeOfChaos.Types.UnitOfWork.Contracts/IReadonlyUnitOfWork.cs b/src/CodeOfChaos.Types.UnitOfWork.Contracts/IReadonlyUnitOfWork.cs
@@ -0,0 +1,9 @@
+﻿// ---------------------------------------------------------------------------------------------------------------------
+// Imports
+// ---------------------------------------------------------------------------------------------------------------------
+namespace CodeOfChaos.Types.UnitOfWork;
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Code
+// ---------------------------------------------------------------------------------------------------------------------
+public interface IReadonlyUnitOfWork : IUnitOfWork;
diff --git a/src/CodeOfChaos.Types.UnitOfWork.Contracts/IReadonlyUnitOfWorkFactory.cs b/src/CodeOfChaos.Types.UnitOfWork.Contracts/IReadonlyUnitOfWorkFactory.cs
@@ -0,0 +1,11 @@
+﻿// ---------------------------------------------------------------------------------------------------------------------
+// Imports
+// ---------------------------------------------------------------------------------------------------------------------
+namespace CodeOfChaos.Types.UnitOfWork;
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Code
+// ---------------------------------------------------------------------------------------------------------------------
+public interface IReadonlyUnitOfWorkFactory {
+    IReadonlyUnitOfWork Create();
+}
diff --git a/src/CodeOfChaos.Types.UnitOfWork.Contracts/IUnitOfWorkFactory.cs b/src/CodeOfChaos.Types.UnitOfWork.Contracts/IUnitOfWorkFactory.cs
@@ -1,13 +1,12 @@
 // ---------------------------------------------------------------------------------------------------------------------
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
-using CodeOfChaos.Extensions.DependencyInjection;
-
 namespace CodeOfChaos.Types.UnitOfWork;
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
-public interface IUnitOfWorkFactory : IFactoryService<IUnitOfWork> {
+public interface IUnitOfWorkFactory {
+    IUnitOfWork Create();
     ValueTask<IUnitOfWork> CreateWithTransactionAsync(CancellationToken ct = default);
     ValueTask<IUnitOfWork?> TryCreateWithTransactionAsync(CancellationToken ct = default);
 }
diff --git a/src/CodeOfChaos.Types.UnitOfWork/CodeOfChaos.Types.UnitOfWork.csproj b/src/CodeOfChaos.Types.UnitOfWork/CodeOfChaos.Types.UnitOfWork.csproj
@@ -7,7 +7,7 @@
 
         <!-- Main package name -->
         <PackageId>CodeOfChaos.Types.UnitOfWork</PackageId>
-        <Version>0.22.0</Version>
+        <Version>0.24.0</Version>
         <Authors>Anna Sas</Authors>
         <Description>A small library housing UnitOfWork typings for EntityFrameworkCore</Description>
         <PackageProjectUrl>https://github.com/code-of-chaos/cs-code_of_chaos-types</PackageProjectUrl>
@@ -28,7 +28,6 @@
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="CodeOfChaos.Extensions.DependencyInjection" Version="0.41.0" />
         <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.2" />
     </ItemGroup>
 
diff --git a/src/CodeOfChaos.Types.UnitOfWork/ReadonlyUnitOfWork.cs b/src/CodeOfChaos.Types.UnitOfWork/ReadonlyUnitOfWork.cs
@@ -0,0 +1,45 @@
+﻿// ---------------------------------------------------------------------------------------------------------------------
+// Imports
+// ---------------------------------------------------------------------------------------------------------------------
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace CodeOfChaos.Types.UnitOfWork;
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Code
+// ---------------------------------------------------------------------------------------------------------------------
+public class ReadonlyUnitOfWork<TDbContext>(
+    IDbContextFactory<TDbContext> dbContextFactory,
+    IServiceScope serviceScope
+) : UnitOfWork<TDbContext>(dbContextFactory, serviceScope), IReadonlyUnitOfWork
+    where TDbContext : DbContext, IReadonlyCapableDbContext {
+ 
+    protected override AsyncLazy<TDbContext> LazyDb { get; } = new(async ct => {
+        TDbContext dbContext = await dbContextFactory.CreateDbContextAsync(ct);
+        dbContext.SetAsReadonly();
+        return dbContext;
+    });
+    
+
+    // -----------------------------------------------------------------------------------------------------------------
+    // Methods
+    // -----------------------------------------------------------------------------------------------------------------
+    public override ValueTask SaveChangesAsync(CancellationToken ct = default) 
+        => throw new NotSupportedException("ReadonlyUnitOfWork cannot save changes.");
+
+    public override ValueTask<bool> TryCommitTransactionAsync(CancellationToken ct = default) 
+        => throw new NotSupportedException("ReadonlyUnitOfWork cannot commit transactions.");
+
+    public override ValueTask<bool> TryCreateTransactionAsync(CancellationToken ct = default) 
+        => throw new NotSupportedException("ReadonlyUnitOfWork cannot create transactions.");
+
+    public override ValueTask<bool> TryRollbackTransactionAsync(CancellationToken ct = default) 
+        => throw new NotSupportedException("ReadonlyUnitOfWork cannot rollback transactions.");
+
+    public override ValueTask<bool> TryRollbackToSavepointAsync(Guid id, CancellationToken ct = default) 
+        => throw new NotSupportedException("ReadonlyUnitOfWork cannot rollback to savepoints.");
+
+    public override ValueTask<bool> TryCreateSavepointAsync(Guid id, CancellationToken ct = default) 
+        => throw new NotSupportedException("ReadonlyUnitOfWork cannot create savepoints.");
+}
diff --git a/src/CodeOfChaos.Types.UnitOfWork/ReadonlyUnitOfWorkFactory.cs b/src/CodeOfChaos.Types.UnitOfWork/ReadonlyUnitOfWorkFactory.cs
@@ -0,0 +1,21 @@
+﻿// ---------------------------------------------------------------------------------------------------------------------
+// Imports
+// ---------------------------------------------------------------------------------------------------------------------
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace CodeOfChaos.Types.UnitOfWork;
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Code
+// ---------------------------------------------------------------------------------------------------------------------
+public class ReadonlyUnitOfWorkFactory<TDbContext>(
+    IDbContextFactory<TDbContext> dbContextFactory,
+    IServiceProvider provider
+) : IReadonlyUnitOfWorkFactory where TDbContext : DbContext, IReadonlyCapableDbContext {
+
+    public IReadonlyUnitOfWork Create() {
+        IServiceScope scope = provider.CreateScope();
+        return new ReadonlyUnitOfWork<TDbContext>(dbContextFactory, scope);
+    }
+}
diff --git a/src/CodeOfChaos.Types.UnitOfWork/ServiceCollectionExtensions.cs b/src/CodeOfChaos.Types.UnitOfWork/ServiceCollectionExtensions.cs
@@ -22,4 +22,24 @@ public static IServiceCollection AddUnitOfWork<TDbContext>(this IServiceCollecti
 
         return services;
     }
+
+    public static IServiceCollection AddReadonlyUnitOfWork<TDbContext>(this IServiceCollection services) where TDbContext : DbContext, IReadonlyCapableDbContext {
+        services.AddScoped<IUnitOfWorkFactory, UnitOfWorkFactory<TDbContext>>();
+        services.AddScoped<IUnitOfWork>(static sp => sp.GetRequiredService<IUnitOfWorkFactory>().Create());
+        
+        services.AddScoped<IReadonlyUnitOfWorkFactory, ReadonlyUnitOfWorkFactory<TDbContext>>();
+        services.AddScoped<IReadonlyUnitOfWork>(static sp => sp.GetRequiredService<IReadonlyUnitOfWorkFactory>().Create());
+        
+        return services;
+    }
+
+    public static IServiceCollection AddReadonlyUnitOfWork<TDbContext>(this IServiceCollection services, string key) where TDbContext : DbContext, IReadonlyCapableDbContext {
+        services.AddKeyedScoped<IUnitOfWorkFactory, UnitOfWorkFactory<TDbContext>>(key);
+        services.AddKeyedScoped<IUnitOfWork>(key, implementationFactory: static (sp, k) => sp.GetRequiredKeyedService<IUnitOfWorkFactory>(k).Create());
+        
+        services.AddKeyedScoped<IReadonlyUnitOfWorkFactory, ReadonlyUnitOfWorkFactory<TDbContext>>(key);
+        services.AddKeyedScoped<IReadonlyUnitOfWork>(key, implementationFactory: static (sp, k) => sp.GetRequiredKeyedService<IReadonlyUnitOfWorkFactory>(k).Create());
+        
+        return services;
+    }
 }
diff --git a/src/CodeOfChaos.Types.UnitOfWork/UnitOfWork.cs b/src/CodeOfChaos.Types.UnitOfWork/UnitOfWork.cs
@@ -11,15 +11,15 @@ namespace CodeOfChaos.Types.UnitOfWork;
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
 public class UnitOfWork<TDbContext>(IDbContextFactory<TDbContext> dbContextFactory, IServiceScope serviceScope) : IUnitOfWork where TDbContext : DbContext {
-    private readonly AsyncLazy<TDbContext> _db = new(async ct => await dbContextFactory.CreateDbContextAsync(ct));
+    protected virtual AsyncLazy<TDbContext> LazyDb { get; } = new(async ct => await dbContextFactory.CreateDbContextAsync(ct));
     private IDbContextTransaction? _transaction;
     private ConcurrentDictionary<Type, IUnitOfWorkRepository> AttachedRepositories { get; } = [];
 
     // -----------------------------------------------------------------------------------------------------------------
     // Methods
     // -----------------------------------------------------------------------------------------------------------------
     public virtual async ValueTask SaveChangesAsync(CancellationToken ct = default) {
-        DbContext dbContext = await _db.GetValueAsync(ct);
+        DbContext dbContext = await LazyDb.GetValueAsync(ct);
         await dbContext.SaveChangesAsync(ct);
     }
 
@@ -36,7 +36,7 @@ public virtual async ValueTask<bool> TryCommitTransactionAsync(CancellationToken
     public virtual async ValueTask<bool> TryCreateTransactionAsync(CancellationToken ct = default) {
         if (_transaction != null) return false;
 
-        TDbContext dbContext = await _db.GetValueAsync(ct);
+        TDbContext dbContext = await LazyDb.GetValueAsync(ct);
         if (dbContext.Database.CurrentTransaction != null) {
             // Something went wrong during saving before and the transaction wasn't set by the unit of work
             _transaction = dbContext.Database.CurrentTransaction;
@@ -79,7 +79,7 @@ public virtual async ValueTask<bool> TryCreateSavepointAsync(Guid id, Cancellati
     public virtual async ValueTask<T> GetDbContextAsync<T>(CancellationToken ct = default) where T : DbContext {
         if (typeof(T) != typeof(TDbContext)) throw new NotSupportedException($"DbContext type '{typeof(T)}' is not supported by this UnitOfWork.");
 
-        TDbContext dbContext = await _db.GetValueAsync(ct);
+        TDbContext dbContext = await LazyDb.GetValueAsync(ct);
         return dbContext as T ?? throw new InvalidCastException($"Cannot cast DbContext of type '{dbContext.GetType()}' to '{typeof(T)}'");
     }
 
@@ -93,7 +93,7 @@ public virtual async ValueTask<TRepo> GetRepositoryAsync<TRepo>(CancellationToke
         return repo;
     }
 
-    public virtual async ValueTask<TRepo> CreateAndAttachRepositoryAsync<TRepo>(CancellationToken ct = default) where TRepo : class, IUnitOfWorkRepository {
+    private async ValueTask<TRepo> CreateAndAttachRepositoryAsync<TRepo>(CancellationToken ct = default) where TRepo : class, IUnitOfWorkRepository {
         var repo = serviceScope.ServiceProvider.GetRequiredService<TRepo>();
         if (repo is not UnitOfWorkRepository<TDbContext> castedRepo) throw new InvalidCastException($"Cannot cast repository of type '{repo.GetType()}' to '{typeof(TRepo)}'");
 
@@ -116,7 +116,7 @@ public virtual async ValueTask DisposeAsync() {
 
         serviceScope.Dispose();
 
-        await _db.DisposeAsync();
+        await LazyDb.DisposeAsync();
 
         GC.SuppressFinalize(this);
     }
diff --git a/src/CodeOfChaos.Types.UnitOfWork/UnitOfWorkFactory.cs b/src/CodeOfChaos.Types.UnitOfWork/UnitOfWorkFactory.cs
@@ -1,7 +1,6 @@
 // ---------------------------------------------------------------------------------------------------------------------
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
-using CodeOfChaos.Extensions.DependencyInjection;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@@ -10,7 +9,6 @@ namespace CodeOfChaos.Types.UnitOfWork;
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
-[InjectableService<IUnitOfWorkFactory>(ServiceLifetime.Scoped)]
 public class UnitOfWorkFactory<TDbContext>(IDbContextFactory<TDbContext> dbContextFactory, IServiceProvider provider, ILogger<UnitOfWorkFactory<TDbContext>> logger) : IUnitOfWorkFactory where TDbContext : DbContext {
     public IUnitOfWork Create() {
         // Each unit of work should have their own scope which they pull their repositories from
@@ -20,7 +18,7 @@ public IUnitOfWork Create() {
         // Because our factory doesn't create the actual dbcontext, yet we are safe, and we can just inject it downwards.
         return new UnitOfWork<TDbContext>(dbContextFactory, scope);
     }
-
+    
     public async ValueTask<IUnitOfWork> CreateWithTransactionAsync(CancellationToken ct = default) {
         IUnitOfWork unitOfWork = Create();
 
diff --git a/src/CodeOfChaos.Types/CodeOfChaos.Types.csproj b/src/CodeOfChaos.Types/CodeOfChaos.Types.csproj
@@ -8,7 +8,7 @@
 
         <!-- Main package name -->
         <PackageId>CodeOfChaos.Types</PackageId>
-        <Version>0.22.0</Version>
+        <Version>0.24.0</Version>
         <Authors>Anna Sas</Authors>
         <Description>A library of common types and classes within the CodeOfChaos project</Description>
         <PackageProjectUrl>https://github.com/code-of-chaos/cs-code_of_chaos-types</PackageProjectUrl>
diff --git a/tests/Tests.CodeOfChaos.Types.DataSeeder/SeederTests.cs b/tests/Tests.CodeOfChaos.Types.DataSeeder/SeederTests.cs
@@ -12,7 +12,7 @@ public class SeederTests {
     [Test]
     public async Task StartAsync_ShouldLogAndReturn_WhenShouldSeedReturnsFalse() {
         // Arrange
-        var serviceProviderMock = new Mock<IServiceProvider>();
+        Mock<IServiceProvider> serviceProviderMock = new Mock<IServiceProvider>();
         var seeder = new TestSeeder {
             ShouldSeedResult = false// Simulate ShouldSeedAsync returning false
         };
@@ -27,7 +27,7 @@ public async Task StartAsync_ShouldLogAndReturn_WhenShouldSeedReturnsFalse() {
     [Test]
     public async Task StartAsync_ShouldCallSeed_WhenShouldSeedReturnsTrue() {
         // Arrange
-        var serviceProviderMock = new Mock<IServiceProvider>();
+        Mock<IServiceProvider> serviceProviderMock = new Mock<IServiceProvider>();
         var seeder = new TestSeeder {
             ShouldSeedResult = true// Simulate ShouldSeedAsync returning true
         };
@@ -42,7 +42,7 @@ public async Task StartAsync_ShouldCallSeed_WhenShouldSeedReturnsTrue() {
     [Test]
     public async Task StartAsync_ShouldRespectCancellationToken() {
         // Arrange
-        var serviceProviderMock = new Mock<IServiceProvider>();
+        Mock<IServiceProvider> serviceProviderMock = new Mock<IServiceProvider>();
         var seeder = new TestSeeder();
         using var cts = new CancellationTokenSource();
         await cts.CancelAsync();// Simulate cancellation
diff --git a/tests/Tests.CodeOfChaos.Types.UnitOfWork/Assets/DefaultDbContext.cs b/tests/Tests.CodeOfChaos.Types.UnitOfWork/Assets/DefaultDbContext.cs
@@ -1,13 +1,16 @@
 ﻿// ---------------------------------------------------------------------------------------------------------------------
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
+using CodeOfChaos.Types.UnitOfWork;
 using Microsoft.EntityFrameworkCore;
 
 namespace Tests.CodeOfChaos.Types.UnitOfWork.Assets;
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
-public class DefaultDbContext : DbContext {
+public class DefaultDbContext : DbContext, IReadonlyCapableDbContext {
+    public bool IsReadonly { get; private set; }
+    public void SetAsReadonly() => IsReadonly = true;
     public DefaultDbContext() {}
     public DefaultDbContext(DbContextOptions<DefaultDbContext> options) : base(options) {}
 }
diff --git a/tests/Tests.CodeOfChaos.Types.UnitOfWork/Assets/MockDbContext.cs b/tests/Tests.CodeOfChaos.Types.UnitOfWork/Assets/MockDbContext.cs
@@ -1,13 +1,17 @@
 ﻿// ---------------------------------------------------------------------------------------------------------------------
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
+using CodeOfChaos.Types.UnitOfWork;
 using Microsoft.EntityFrameworkCore;
 
 namespace Tests.CodeOfChaos.Types.UnitOfWork.Assets;
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
-public class MockDbContext : DbContext {
+public class MockDbContext : DbContext, IReadonlyCapableDbContext {
+    public bool IsReadonly { get; private set; }
+    public void SetAsReadonly() => IsReadonly = true;
+    
     public MockDbContext() {}
     public MockDbContext(DbContextOptions<MockDbContext> options) : base(options) {}
 }
diff --git a/tests/Tests.CodeOfChaos.Types.UnitOfWork/Assets/OtherDbContext.cs b/tests/Tests.CodeOfChaos.Types.UnitOfWork/Assets/OtherDbContext.cs
diff --git a/tests/Tests.CodeOfChaos.Types.UnitOfWork/ReadonlyUnitOfWorkTests.cs b/tests/Tests.CodeOfChaos.Types.UnitOfWork/ReadonlyUnitOfWorkTests.cs
diff --git a/tests/Tests.CodeOfChaos.Types.UnitOfWork/ServiceCollectionTests.cs b/tests/Tests.CodeOfChaos.Types.UnitOfWork/ServiceCollectionTests.cs
diff --git a/tests/Tests.CodeOfChaos.Types.UnitOfWork/UnitOfWorkFactoryTests.cs b/tests/Tests.CodeOfChaos.Types.UnitOfWork/UnitOfWorkFactoryTests.cs
diff --git a/tests/Tests.CodeOfChaos.Types.UnitOfWork/UnitOfWorkTests.cs b/tests/Tests.CodeOfChaos.Types.UnitOfWork/UnitOfWorkTests.cs
diff --git a/tests/Tests.CodeOfChaos.Types/AsyncLazyTests.cs b/tests/Tests.CodeOfChaos.Types/AsyncLazyTests.cs
