Added multi-tenancy support with Finbuckled as the initial implementation. (#158)

Co-authored-by: jasonmwebb-lv <jason.webb@leadventure.com>

Author: JasonMWebb

Src/RCommon.Dapper/Crud/DapperRepository.cs

@@ -12,6 +12,7 @@
 using System.ComponentModel;
 using System.Data.Common;
 using RCommon.Entities;
+using RCommon.Security.Claims;
 using System.Threading;
 using Microsoft.Extensions.Options;
 using Dommel;
@@ -45,8 +46,9 @@ public class DapperRepository<TEntity> : SqlRepositoryBase<TEntity>
         /// <param name="defaultDataStoreOptions">Options specifying which data store to use when none is explicitly set.</param>
         public DapperRepository(IDataStoreFactory dataStoreFactory,
             ILoggerFactory logger, IEntityEventTracker eventTracker,
-            IOptions<DefaultDataStoreOptions> defaultDataStoreOptions)
-            : base(dataStoreFactory, logger, eventTracker, defaultDataStoreOptions)
+            IOptions<DefaultDataStoreOptions> defaultDataStoreOptions,
+            ITenantIdAccessor tenantIdAccessor)
+            : base(dataStoreFactory, logger, eventTracker, defaultDataStoreOptions, tenantIdAccessor)
         {
             Logger = logger.CreateLogger(GetType().Name);
         }
@@ -64,6 +66,7 @@ public override async Task AddAsync(TEntity entity, CancellationToken token = de
                         await db.OpenAsync();
                     }
                     EventTracker.AddEntity(entity);
+                    MultiTenantHelper.SetTenantIdIfApplicable(entity, _tenantIdAccessor.GetTenantId());
                     await db.InsertAsync(entity, cancellationToken: token);
 
                 }
@@ -368,6 +371,7 @@ public override async Task<ICollection<TEntity>> FindAsync(Expression<Func<TEnti
                     }
 
                     var filteredExpression = SoftDeleteHelper.CombineWithNotDeletedFilter<TEntity>(expression);
+                    filteredExpression = MultiTenantHelper.CombineWithTenantFilter(filteredExpression, _tenantIdAccessor.GetTenantId());
                     var results = await db.SelectAsync(filteredExpression, cancellationToken: token);
                     return results.ToList();
                 }
@@ -406,6 +410,15 @@ public override async Task<TEntity> FindAsync(object primaryKey, CancellationTok
                         return default!;
                     }
 
+                    // Post-fetch tenant check: if the entity belongs to a different tenant, treat it as not found
+                    var currentTenantId = _tenantIdAccessor.GetTenantId();
+                    if (result != null && MultiTenantHelper.IsMultiTenant<TEntity>()
+                        && !string.IsNullOrEmpty(currentTenantId)
+                        && ((IMultiTenant)result).TenantId != currentTenantId)
+                    {
+                        return default!;
+                    }
+
                     return result!;
                 }
                 catch (ApplicationException exception)
@@ -436,6 +449,7 @@ public override async Task<long> GetCountAsync(ISpecification<TEntity> selectSpe
                     }
 
                     var filteredPredicate = SoftDeleteHelper.CombineWithNotDeletedFilter<TEntity>(selectSpec.Predicate);
+                    filteredPredicate = MultiTenantHelper.CombineWithTenantFilter(filteredPredicate, _tenantIdAccessor.GetTenantId());
                     var results = await db.CountAsync(filteredPredicate);
                     return results;
                 }
@@ -467,6 +481,7 @@ public override async Task<long> GetCountAsync(Expression<Func<TEntity, bool>> e
                     }
 
                     var filteredExpression = SoftDeleteHelper.CombineWithNotDeletedFilter<TEntity>(expression);
+                    filteredExpression = MultiTenantHelper.CombineWithTenantFilter(filteredExpression, _tenantIdAccessor.GetTenantId());
                     var results = await db.CountAsync(filteredExpression);
                     return results;
                 }
@@ -526,6 +541,7 @@ public override async Task<bool> AnyAsync(Expression<Func<TEntity, bool>> expres
                     }
 
                     var filteredExpression = SoftDeleteHelper.CombineWithNotDeletedFilter<TEntity>(expression);
+                    filteredExpression = MultiTenantHelper.CombineWithTenantFilter(filteredExpression, _tenantIdAccessor.GetTenantId());
                     var results = await db.AnyAsync(filteredExpression);
                     return results;
                 }
@@ -571,6 +587,7 @@ public override async Task AddRangeAsync(IEnumerable<TEntity> entities, Cancella
                     foreach (var entity in entities)
                     {
                         EventTracker.AddEntity(entity);
+                        MultiTenantHelper.SetTenantIdIfApplicable(entity, _tenantIdAccessor.GetTenantId());
                         await db.InsertAsync(entity, cancellationToken: token);
                     }
                 }

Src/RCommon.Dapper/DapperPersistenceBuilder.cs

@@ -9,6 +9,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using RCommon.Persistence.Dapper.Crud;
 using RCommon.Persistence.Crud;
+using RCommon.Security.Claims;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 
 namespace RCommon
@@ -38,6 +39,9 @@ public DapperPersistenceBuilder(IServiceCollection services)
         {
             _services = services ?? throw new ArgumentNullException(nameof(services));
 
+            // Default tenant accessor (no-op); overridden when multitenancy is configured
+            services.TryAddTransient<ITenantIdAccessor, NullTenantIdAccessor>();
+
             // Dapper Repository
             services.AddTransient(typeof(ISqlMapperRepository<>), typeof(DapperRepository<>));
             services.AddTransient(typeof(IWriteOnlyRepository<>), typeof(DapperRepository<>));

Src/RCommon.Dapper/README.md

@@ -13,6 +13,8 @@ Dapper implementation of the RCommon persistence abstractions. Provides a lightw
 - Named data store support for multi-database scenarios through `IDataStoreFactory` and `RDbConnection`
 - Fluent DI configuration to register database connections as named data stores
 - Domain event tracking integrated into add, update, and delete operations
+- **Soft delete** -- entities implementing `ISoftDelete` are automatically filtered on reads and logically deleted on writes
+- **Multitenancy** -- entities implementing `IMultiTenant` are automatically filtered by tenant on reads and stamped with `TenantId` on writes
 - Targets .NET 8, .NET 9, and .NET 10
 
 ## Installation
@@ -73,6 +75,38 @@ public class ProductService
 }
 ```
 
+### Soft Delete and Multitenancy
+
+`DapperRepository<TEntity>` automatically supports soft delete and multitenancy when your entities implement the opt-in interfaces:
+
+```csharp
+using RCommon.Entities;
+
+public class Product : BusinessEntity<int>, ISoftDelete, IMultiTenant
+{
+    public string Name { get; set; }
+    public bool IsDeleted { get; set; }
+    public string? TenantId { get; set; }
+}
+```
+
+Reads automatically exclude soft-deleted records and scope to the current tenant:
+
+```csharp
+// Both filters applied transparently
+var products = await _productRepo.FindAsync(p => p.IsActive);
+```
+
+Writes automatically stamp the tenant and support logical deletion:
+
+```csharp
+// TenantId stamped automatically from ITenantIdAccessor
+await _productRepo.AddAsync(new Product { Name = "Widget" });
+
+// Soft delete — sets IsDeleted = true, performs UPDATE via Dapper
+await _productRepo.DeleteAsync(product, isSoftDelete: true);
+```
+
 ## Key Types
 
 | Type | Description |

Src/RCommon.EfCore/Crud/EFCoreRepository.cs

@@ -5,6 +5,7 @@
 using Microsoft.Extensions.Options;
 using RCommon;
 using RCommon.Entities;
+using RCommon.Security.Claims;
 using RCommon.Collections;
 using RCommon.Linq;
 using System;
@@ -52,8 +53,9 @@ public class EFCoreRepository<TEntity> : GraphRepositoryBase<TEntity>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         public EFCoreRepository(IDataStoreFactory dataStoreFactory,
             ILoggerFactory logger, IEntityEventTracker eventTracker,
-            IOptions<DefaultDataStoreOptions> defaultDataStoreOptions)
-            : base(dataStoreFactory, eventTracker, defaultDataStoreOptions)
+            IOptions<DefaultDataStoreOptions> defaultDataStoreOptions,
+            ITenantIdAccessor tenantIdAccessor)
+            : base(dataStoreFactory, eventTracker, defaultDataStoreOptions, tenantIdAccessor)
         {
             if (logger is null)
             {
@@ -159,6 +161,7 @@ protected override IQueryable<TEntity> RepositoryQuery
         public override async Task AddAsync(TEntity entity, CancellationToken token = default)
         {
             EventTracker.AddEntity(entity);
+            MultiTenantHelper.SetTenantIdIfApplicable(entity, _tenantIdAccessor.GetTenantId());
             await ObjectSet.AddAsync(entity, token);
             await SaveAsync(token);
         }
@@ -346,6 +349,15 @@ public override async Task<TEntity> FindAsync(object primaryKey, CancellationTok
                 return default!;
             }
 
+            // Post-fetch tenant check: if the entity belongs to a different tenant, treat it as not found
+            var currentTenantId = _tenantIdAccessor.GetTenantId();
+            if (entity != null && MultiTenantHelper.IsMultiTenant<TEntity>()
+                && !string.IsNullOrEmpty(currentTenantId)
+                && ((IMultiTenant)entity).TenantId != currentTenantId)
+            {
+                return default!;
+            }
+
             return entity!;
         }
 
@@ -498,10 +510,11 @@ public override async Task AddRangeAsync(IEnumerable<TEntity> entities, Cancella
         {
             if (entities == null) throw new ArgumentNullException(nameof(entities));
 
-            // track each entity prior to adding
+            // track each entity and stamp tenant prior to adding
             foreach (var entity in entities)
             {
                 EventTracker.AddEntity(entity);
+                MultiTenantHelper.SetTenantIdIfApplicable(entity, _tenantIdAccessor.GetTenantId());
             }
 
             await ObjectSet.AddRangeAsync(entities, token);

Src/RCommon.EfCore/EFCorePerisistenceBuilder.cs

@@ -11,6 +11,7 @@
 using RCommon.Persistence.Crud;
 using RCommon.Persistence.EFCore;
 using RCommon.Persistence.EFCore.Crud;
+using RCommon.Security.Claims;
 
 namespace RCommon
 {
@@ -37,6 +38,9 @@ public EFCorePerisistenceBuilder(IServiceCollection services)
         {
             _services = services ?? throw new ArgumentNullException(nameof(services));
 
+            // Default tenant accessor (no-op); overridden when multitenancy is configured
+            services.TryAddTransient<ITenantIdAccessor, NullTenantIdAccessor>();
+
             // EF Core Repository
             services.AddTransient(typeof(IReadOnlyRepository<>), typeof(EFCoreRepository<>));
             services.AddTransient(typeof(IWriteOnlyRepository<>), typeof(EFCoreRepository<>));

Src/RCommon.EfCore/README.md

@@ -14,6 +14,8 @@ Entity Framework Core implementation of the RCommon persistence abstractions. Pr
 - `RCommonDbContext` base class implementing `IDataStore` for seamless factory resolution
 - Fluent DI configuration to register DbContexts as named data stores
 - Automatic entity event tracking for domain event dispatching on add, update, and delete
+- **Soft delete** -- entities implementing `ISoftDelete` are automatically filtered on reads and logically deleted on writes
+- **Multitenancy** -- entities implementing `IMultiTenant` are automatically filtered by tenant on reads and stamped with `TenantId` on writes
 - Targets .NET 8, .NET 9, and .NET 10
 
 ## Installation
@@ -70,6 +72,38 @@ public class OrderService
 }
 ```
 
+### Soft Delete and Multitenancy
+
+`EFCoreRepository<TEntity>` automatically supports soft delete and multitenancy when your entities implement the opt-in interfaces:
+
+```csharp
+using RCommon.Entities;
+
+public class Customer : BusinessEntity<int>, ISoftDelete, IMultiTenant
+{
+    public string Name { get; set; }
+    public bool IsDeleted { get; set; }
+    public string? TenantId { get; set; }
+}
+```
+
+Reads automatically exclude soft-deleted records and scope to the current tenant:
+
+```csharp
+// Both filters applied transparently — only active customers for the current tenant
+var customers = await _customerRepo.FindAsync(c => c.Name.StartsWith("A"));
+```
+
+Writes automatically stamp the tenant and support logical deletion:
+
+```csharp
+// TenantId stamped automatically from ITenantIdAccessor
+await _customerRepo.AddAsync(new Customer { Name = "Acme" });
+
+// Soft delete — sets IsDeleted = true, performs UPDATE via EF Core
+await _customerRepo.DeleteAsync(customer, isSoftDelete: true);
+```
+
 ## Key Types
 
 | Type | Description |

Src/RCommon.Entities/IMultiTenant.cs

@@ -0,0 +1,38 @@
+namespace RCommon.Entities
+{
+    /// <summary>
+    /// Marks an entity as belonging to a specific tenant. When multitenancy is configured,
+    /// the repository will automatically set <see cref="TenantId"/> on add operations and
+    /// filter read operations to only return entities matching the current tenant.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This is an opt-in capability interface. Entities that do not implement this interface
+    /// are not tenant-scoped and will not be filtered by tenant. If no <see cref="RCommon.Persistence.Crud.ITenantIdAccessor"/>
+    /// is configured (or the accessor returns <c>null</c>), tenant filtering is bypassed entirely,
+    /// allowing the application to operate without multitenancy.
+    /// </para>
+    /// <para>
+    /// <strong>Usage:</strong> To enable multitenancy for an entity, implement this interface and
+    /// ensure the underlying data store has a corresponding <c>TenantId</c> column (string).
+    /// Configure multitenancy during bootstrapping using <c>.WithMultiTenancy&lt;T&gt;()</c>.
+    /// </para>
+    /// <example>
+    /// <code>
+    /// public class Customer : BusinessEntity&lt;int&gt;, IMultiTenant
+    /// {
+    ///     public string Name { get; set; }
+    ///     public string? TenantId { get; set; }
+    /// }
+    /// </code>
+    /// </example>
+    /// </remarks>
+    public interface IMultiTenant
+    {
+        /// <summary>
+        /// Gets or sets the identifier of the tenant that owns this entity.
+        /// When <c>null</c>, the entity is not associated with any tenant.
+        /// </summary>
+        string? TenantId { get; set; }
+    }
+}

Src/RCommon.Entities/README.md

@@ -10,6 +10,8 @@ Domain entity base classes for the RCommon framework, providing a strongly-typed
 - `AuditedEntity` base classes that track `CreatedBy`, `DateCreated`, `LastModifiedBy`, and `DateLastModified` with flexible user types
 - `ITrackedEntity` interface for opting entities into event tracking
 - `IEntityEventTracker` and `InMemoryEntityEventTracker` for collecting entity events across object graphs and routing them through `IEventRouter`
+- **Soft delete** -- `ISoftDelete` opt-in interface for logical deletion (`IsDeleted` flag) instead of physical removal
+- **Multitenancy** -- `IMultiTenant` opt-in interface for tenant-scoped entities (`TenantId` property)
 - `EntityNotFoundException` for consistent "entity not found" error handling with type and ID context
 
 ## Installation
@@ -63,6 +65,53 @@ public class OrderService
 }
 ```
 
+### Soft Delete
+
+Implement `ISoftDelete` to opt an entity into logical deletion. Repositories will set `IsDeleted = true` and perform an UPDATE instead of a physical DELETE:
+
+```csharp
+using RCommon.Entities;
+
+public class Customer : BusinessEntity<int>, ISoftDelete
+{
+    public string Name { get; set; }
+    public bool IsDeleted { get; set; }
+}
+
+// Soft delete — sets IsDeleted = true, performs UPDATE
+await repository.DeleteAsync(customer, isSoftDelete: true);
+
+// Physical delete — removes the record entirely
+await repository.DeleteAsync(customer, isSoftDelete: false);
+```
+
+Entities implementing `ISoftDelete` are automatically filtered on read operations -- soft-deleted records are excluded from query results by default.
+
+### Multitenancy
+
+Implement `IMultiTenant` to scope an entity to a specific tenant. Repositories will automatically stamp the `TenantId` on add operations and filter reads to only return records for the current tenant:
+
+```csharp
+using RCommon.Entities;
+
+public class Product : BusinessEntity<int>, IMultiTenant
+{
+    public string Name { get; set; }
+    public string? TenantId { get; set; }
+}
+```
+
+When both interfaces are combined, the entity supports soft delete and tenant isolation:
+
+```csharp
+public class Invoice : BusinessEntity<Guid>, ISoftDelete, IMultiTenant
+{
+    public decimal Amount { get; set; }
+    public bool IsDeleted { get; set; }
+    public string? TenantId { get; set; }
+}
+```
+
 ## Key Types
 
 | Type | Description |
@@ -76,6 +125,8 @@ public class OrderService
 | `ITrackedEntity` | Marks an entity as eligible for event tracking via `AllowEventTracking` |
 | `IEntityEventTracker` | Collects tracked entities and emits their transactional events |
 | `InMemoryEntityEventTracker` | In-memory implementation that traverses entity object graphs and routes events |
+| `ISoftDelete` | Opt-in interface for soft delete; adds `IsDeleted` property for logical deletion |
+| `IMultiTenant` | Opt-in interface for multitenancy; adds `TenantId` property for tenant scoping |
 | `EntityNotFoundException` | Exception for when an expected entity does not exist, with type and ID context |
 
 ## Documentation