Persist saga metadata to Redis

Implement RedisPersistableSagaRepository<TSaga, TMetaData>

Author: Sneed, Anthony

src/EventDriven.Sagas.Persistence.Mongo/Repositories/PersistableSagaRepository.cs

@@ -34,10 +34,13 @@ public PersistableSagaRepository(
     /// <inheritdoc />
     public async Task<TSaga?> GetAsync(Guid id, TSaga newEntity)
     {
-        var dto = await FindOneAsync(e => e.SagaId == id);
-        if (dto is null) return null;
-        _mapper.Map(dto, newEntity);
-        return newEntity;
+        using (await _syncRoot.LockAsync())
+        {
+            var dto = await FindOneAsync(e => e.SagaId == id);
+            if (dto is null) return null;
+            _mapper.Map(dto, newEntity);
+            return newEntity;
+        }
     }
 
     /// <inheritdoc />

src/EventDriven.Sagas.Persistence.Pool.Abstractions/Pools/PersistableSagaPool.cs

@@ -111,7 +111,8 @@ protected async Task<TSaga> ConfigureSagaAsync()
 /// </summary>
 /// <typeparam name="TSaga">Persistable saga.</typeparam>
 /// <typeparam name="TMetadata">Saga metadata.</typeparam>
-public class PersistableSagaPool<TSaga,TMetadata>: PersistableSagaPool<TSaga>, IPersistableSagaPool<TSaga, TMetadata>
+public class PersistableSagaPool<TSaga,TMetadata> :
+    PersistableSagaPool<TSaga>, IPersistableSagaPool<TSaga, TMetadata>
     where TSaga : PersistableSaga<TMetadata>
     where TMetadata : class
 {

src/EventDriven.Sagas.Persistence.Redis/EventDriven.Sagas.Persistence.Redis.csproj

@@ -7,15 +7,15 @@
         <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
         <Authors>Tony Sneed</Authors>
         <PackageReadmeFile>ReadMe.md</PackageReadmeFile>
-        <PackageVersion>1.6.0</PackageVersion>
+        <PackageVersion>1.6.1-beta1</PackageVersion>
         <Description>A set of abstractions for implementing the Saga pattern.</Description>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <PackageProjectUrl>https://github.com/event-driven-dotnet/EventDriven.Sagas</PackageProjectUrl>
         <PackageIcon>eda-logo.jpeg</PackageIcon>
         <RepositoryUrl>https://github.com/event-driven-dotnet/EventDriven.Sagas.git</RepositoryUrl>
         <RepositoryType>git</RepositoryType>
         <PackageTags>sagas event-driven event-driven-architecture</PackageTags>
-        <PackageReleaseNotes>https://github.com/event-driven-dotnet/EventDriven.Sagas/releases/tag/v1.6.0</PackageReleaseNotes>
+        <PackageReleaseNotes>https://github.com/event-driven-dotnet/EventDriven.Sagas/releases/tag/v1.6.1-beta1</PackageReleaseNotes>
         <PackageId>EventDriven.Sagas.Persistence.Redis</PackageId>
         <GenerateDocumentationFile>True</GenerateDocumentationFile>
     </PropertyGroup>

src/EventDriven.Sagas.Persistence.Redis/Repositories/RedisPersistableSagaRepository.cs

@@ -1,6 +1,5 @@
 using System.Text.Json;
 using AutoMapper;
-using EventDriven.DDD.Abstractions.Repositories;
 using EventDriven.Sagas.Persistence.Abstractions;
 using EventDriven.Sagas.Persistence.Abstractions.DTO;
 using EventDriven.Sagas.Persistence.Abstractions.Repositories;
@@ -15,11 +14,23 @@ namespace EventDriven.Sagas.Persistence.Redis.Repositories;
 public class RedisPersistableSagaRepository<TSaga> : IPersistableSagaRepository<TSaga>
     where TSaga : PersistableSaga
 {
-    private readonly IDistributedCache _cache;
-    private readonly DistributedCacheEntryOptions _cacheOptions;
-    private readonly IMapper _mapper;
     private readonly AsyncLock _syncRoot = new();
 
+    /// <summary>
+    /// Distributed cache.
+    /// </summary>
+    protected readonly IDistributedCache Cache;
+    
+    /// <summary>
+    /// Distributed cache entry options.
+    /// </summary>
+    protected readonly DistributedCacheEntryOptions CacheOptions;
+    
+    /// <summary>
+    /// Auto mapper.
+    /// </summary>
+    protected readonly IMapper Mapper;
+
     /// <summary>
     /// PersistableSagaRepository constructor.
     /// </summary>
@@ -30,37 +41,40 @@ public RedisPersistableSagaRepository(IDistributedCache cache,
         DistributedCacheEntryOptions cacheOptions,
         IMapper mapper)
     {
-        _cache = cache;
-        _cacheOptions = cacheOptions;
-        _mapper = mapper;
+        Cache = cache;
+        CacheOptions = cacheOptions;
+        Mapper = mapper;
     }
 
     /// <inheritdoc />
-    public async Task<TSaga?> GetAsync(Guid id, TSaga newEntity)
+    public virtual async Task<TSaga?> GetAsync(Guid id, TSaga newEntity)
     {
-        var json = await _cache.GetStringAsync(id.ToString());
-        if (json is null) return null;
-        var dto = JsonSerializer.Deserialize<PersistableSagaDto>(json);
-        _mapper.Map(dto, newEntity);
-        return newEntity;
+        using (await _syncRoot.LockAsync())
+        {
+            var json = await Cache.GetStringAsync(id.ToString());
+            if (json is null) return null;
+            var dto = JsonSerializer.Deserialize<PersistableSagaDto>(json);
+            Mapper.Map(dto, newEntity);
+            return newEntity;
+        }
     }
 
     /// <inheritdoc />
-    public async Task<TSaga> CreateAsync(TSaga newEntity)
+    public virtual async Task<TSaga> CreateAsync(TSaga newEntity)
     {
         using (await _syncRoot.LockAsync())
         {
             newEntity.ETag = Guid.NewGuid().ToString();
-            var dto = _mapper.Map<PersistableSagaDto>(newEntity);
+            var dto = Mapper.Map<PersistableSagaDto>(newEntity);
             dto.Id = Guid.NewGuid();
             await InsertAsync(dto);
-            _mapper.Map(dto, newEntity);
+            Mapper.Map(dto, newEntity);
             return newEntity;
         }
     }
 
     /// <inheritdoc />
-    public async Task<TSaga> SaveAsync(TSaga existingEntity, TSaga newEntity)
+    public virtual async Task<TSaga> SaveAsync(TSaga existingEntity, TSaga newEntity)
     {
         using (await _syncRoot.LockAsync())
         {
@@ -69,23 +83,23 @@ public async Task<TSaga> SaveAsync(TSaga existingEntity, TSaga newEntity)
                 return await CreateAsync(newEntity);
 
             existingEntity.ETag = Guid.NewGuid().ToString();
-            var dto = _mapper.Map<PersistableSagaDto>(existingEntity);
+            var dto = Mapper.Map<PersistableSagaDto>(existingEntity);
             dto.Id = Guid.NewGuid();
             await RemoveAsync(existingEntity.Id);
             await InsertAsync(dto);
-            _mapper.Map(dto, newEntity);
+            Mapper.Map(dto, newEntity);
             return newEntity;
         }
     }
 
     /// <inheritdoc />
-    public async Task RemoveAsync(Guid id) =>
-        await _cache.RemoveAsync(id.ToString());
+    public virtual Task RemoveAsync(Guid id) =>
+        Cache.RemoveAsync(id.ToString());
 
-    private async Task InsertAsync(PersistableSagaDto dto)
+    private Task InsertAsync(PersistableSagaDto dto)
     {
         var json = JsonSerializer.Serialize(dto);
-        await _cache.SetStringAsync(dto.SagaId.ToString(), json, _cacheOptions);
+        return Cache.SetStringAsync(dto.SagaId.ToString(), json, CacheOptions);
     }
 }
 
@@ -100,10 +114,67 @@ public class RedisPersistableSagaRepository<TSaga, TMetaData> :
     where TSaga : PersistableSaga<TMetaData>
     where TMetaData : class
 {
+    private readonly AsyncLock _syncRoot = new();
+
     /// <inheritdoc />
     public RedisPersistableSagaRepository(IDistributedCache cache,
         DistributedCacheEntryOptions cacheOptions, IMapper mapper) :
         base(cache, cacheOptions, mapper)
     {
     }
+    
+    /// <inheritdoc />
+    public override async Task<TSaga?> GetAsync(Guid id, TSaga newEntity)
+    {
+        using (await _syncRoot.LockAsync())
+        {
+            var json = await Cache.GetStringAsync(id.ToString());
+            if (json is null) return null;
+            var dto = JsonSerializer.Deserialize<PersistableSagaMetadataDto>(json);
+            if (dto is null) return null;
+            Mapper.Map(dto, newEntity);
+            var metadata = JsonSerializer.Deserialize<TMetaData>(dto.Metadata);
+            newEntity.Metadata = metadata;
+            return newEntity;
+        }
+    }
+    
+    /// <inheritdoc />
+    public override async Task<TSaga> CreateAsync(TSaga newEntity)
+    {
+        using (await _syncRoot.LockAsync())
+        {
+            newEntity.ETag = Guid.NewGuid().ToString();
+            var dto = Mapper.Map<PersistableSagaMetadataDto>(newEntity);
+            dto.Id = Guid.NewGuid();
+            await InsertAsync(dto);
+            Mapper.Map(dto, newEntity);
+            return newEntity;
+        }
+    }
+    
+    /// <inheritdoc />
+    public override async Task<TSaga> SaveAsync(TSaga existingEntity, TSaga newEntity)
+    {
+        using (await _syncRoot.LockAsync())
+        {
+            var existing = await GetAsync(existingEntity.Id, newEntity);
+            if (existing is null)
+                return await CreateAsync(newEntity);
+
+            existingEntity.ETag = Guid.NewGuid().ToString();
+            var dto = Mapper.Map<PersistableSagaMetadataDto>(existingEntity);
+            dto.Id = Guid.NewGuid();
+            await RemoveAsync(existingEntity.Id);
+            await InsertAsync(dto);
+            Mapper.Map(dto, newEntity);
+            return newEntity;
+        }
+    }
+    
+    private Task InsertAsync(PersistableSagaMetadataDto dto)
+    {
+        var json = JsonSerializer.Serialize(dto);
+        return Cache.SetStringAsync(dto.SagaId.ToString(), json, CacheOptions);
+    }
 }