Fix: ICanAttachToUnitOfWork instead of IRepository

Author: AnnaSasDev

src/CodeOfChaos.Types.UnitOfWork.Contracts/IRepository.cs renamed to src/CodeOfChaos.Types.UnitOfWork.Contracts/ICanAttachToUnitOfWork.cs

@@ -5,7 +5,7 @@ namespace CodeOfChaos.Types.UnitOfWork;
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
-public interface IRepository {
+public interface ICanAttachToUnitOfWork {
     void Attach(IUnitOfWork unitOfWork);
     void Detach(IUnitOfWork unitOfWork);
 }

src/CodeOfChaos.Types.UnitOfWork.Contracts/IUnitOfWork.cs

@@ -20,5 +20,5 @@ public interface IUnitOfWork : IAsyncDisposable {
 
     ValueTask<TDbContext> GetDbContextAsync<TDbContext>(CancellationToken ct = default) where TDbContext : DbContext;
 
-    TRepo GetRepository<TRepo>() where TRepo : class, IRepository;
+    TRepo GetRepository<TRepo>() where TRepo : class, ICanAttachToUnitOfWork;
 }

src/CodeOfChaos.Types.UnitOfWork/UnitOfWork.cs

@@ -14,7 +14,7 @@ namespace CodeOfChaos.Types.UnitOfWork;
 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));
     private IDbContextTransaction? _transaction;
-    private ConcurrentDictionary<Type, IRepository> AttachedRepositories { get; } = [];
+    private ConcurrentDictionary<Type, ICanAttachToUnitOfWork> AttachedRepositories { get; } = [];
 
     // -----------------------------------------------------------------------------------------------------------------
     // Methods
@@ -84,8 +84,8 @@ public virtual async ValueTask<T> GetDbContextAsync<T>(CancellationToken ct = de
         return dbContext as T ?? throw new InvalidCastException($"Cannot cast DbContext of type '{dbContext.GetType()}' to '{typeof(T)}'");
     }
 
-    public virtual TRepo GetRepository<TRepo>() where TRepo : class, IRepository {
-        if (AttachedRepositories.TryGetValue(typeof(TRepo), out IRepository? cachedRepo) && cachedRepo is TRepo castedCachedRepo) return castedCachedRepo;
+    public virtual TRepo GetRepository<TRepo>() where TRepo : class, ICanAttachToUnitOfWork {
+        if (AttachedRepositories.TryGetValue(typeof(TRepo), out ICanAttachToUnitOfWork? cachedRepo) && cachedRepo is TRepo castedCachedRepo) return castedCachedRepo;
 
         // Cache miss so we create a new instance
         var repo = serviceScope.ServiceProvider.GetRequiredService<TRepo>();
@@ -100,7 +100,7 @@ public virtual async ValueTask DisposeAsync() {
 
         if (!AttachedRepositories.IsEmpty) {
             // First detach all references to this unit of work
-            foreach ((_, IRepository repo) in AttachedRepositories) {
+            foreach ((_, ICanAttachToUnitOfWork repo) in AttachedRepositories) {
                 repo.Detach(this);
             }
 

tests/Tests.CodeOfChaos.Types.UnitOfWork/UnitOfWorkTests.cs

@@ -193,14 +193,14 @@ public async Task GetDbContextAsync_ShouldThrowForUnsupportedDbContextType() {
     [Test]
     public async Task GetRepository_ShouldRetrieveRepositoryFromServiceProvider() {
         // Arrange
-        var mockRepository = new Mock<IRepository>();
+        var mockRepository = new Mock<ICanAttachToUnitOfWork>();
         _serviceProvider
-            .Setup(sp => sp.GetService(typeof(IRepository)))
+            .Setup(sp => sp.GetService(typeof(ICanAttachToUnitOfWork)))
             .Returns(mockRepository.Object);
 
 
         // Act
-        var repository = _unitOfWork.GetRepository<IRepository>();
+        var repository = _unitOfWork.GetRepository<ICanAttachToUnitOfWork>();
 
         // Assert
         await Assert.That(repository).IsNotNull();