Feat: add Redis governance document loading

Author: rian-be

src/Redis/Storage/Documents/Keys/RedisMutationRequestDocumentKeyFactory.cs

@@ -0,0 +1,23 @@
+using ModularityKit.Mutator.Governance.Redis.Keys;
+using StackExchange.Redis;
+
+namespace ModularityKit.Mutator.Governance.Redis.Storage.Documents.Keys;
+
+/// <summary>
+/// Creates Redis document keys for governed mutation requests.
+/// </summary>
+internal sealed class RedisMutationRequestDocumentKeyFactory(RedisMutationRequestKeyspace keyspace)
+{
+    private readonly RedisMutationRequestKeyspace _keyspace = keyspace ?? throw new ArgumentNullException(nameof(keyspace));
+
+    /// <summary>
+    /// Creates document keys for the supplied request identifiers.
+    /// </summary>
+    /// <param name="requestIds">The request identifiers to map.</param>
+    /// <returns>The Redis document keys.</returns>
+    public IReadOnlyList<RedisKey> CreateKeys(IEnumerable<string> requestIds) =>
+        requestIds.Where(requestId => !string.IsNullOrWhiteSpace(requestId))
+        .Distinct(StringComparer.Ordinal)
+        .Select(_keyspace.RequestData)
+        .ToArray();
+}

src/Redis/Storage/Documents/Materialization/RedisMutationRequestDocumentMaterializer.cs

@@ -0,0 +1,38 @@
+using ModularityKit.Mutator.Governance.Abstractions.Requests.Model;
+using ModularityKit.Mutator.Governance.Redis.Serialization;
+using StackExchange.Redis;
+
+namespace ModularityKit.Mutator.Governance.Redis.Storage.Documents.Materialization;
+
+/// <summary>
+/// Materializes governed mutation requests from Redis payload values.
+/// </summary>
+internal static class RedisMutationRequestDocumentMaterializer
+{
+    /// <summary>
+    /// Deserializes request payloads and optionally orders the resulting requests by creation time.
+    /// </summary>
+    /// <param name="values">The raw Redis payload values.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <param name="orderByCreated">Whether to order results by creation timestamp.</param>
+    /// <returns>The materialized mutation requests.</returns>
+    public static IReadOnlyList<MutationRequest> Materialize(IReadOnlyList<RedisValue> values, CancellationToken cancellationToken, bool orderByCreated)
+    {
+        var requests = new List<MutationRequest>(values.Count);
+
+        foreach (var value in values)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (value.HasValue)
+                requests.Add(RedisMutationRequestSerializer.Deserialize(value!));
+        }
+
+        if (!orderByCreated)
+            return requests;
+
+        return requests.OrderBy(request => request.CreatedAt)
+            .ThenBy(request => request.RequestId)
+            .ToList();
+    }
+}

src/Redis/Storage/Documents/Payloads/RedisMutationRequestPayloadReader.cs

@@ -0,0 +1,28 @@
+using StackExchange.Redis;
+
+namespace ModularityKit.Mutator.Governance.Redis.Storage.Documents.Payloads;
+
+/// <summary>
+/// Loads raw request document payloads from Redis.
+/// </summary>
+internal sealed class RedisMutationRequestPayloadReader(IDatabase database)
+{
+    private readonly IDatabase _database = database ?? throw new ArgumentNullException(nameof(database));
+
+    /// <summary>
+    /// Loads raw payload values for the supplied document keys.
+    /// </summary>
+    /// <param name="keys">The Redis document keys to read.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The raw Redis payload values.</returns>
+    public async Task<IReadOnlyList<RedisValue>> LoadAsync(IReadOnlyList<RedisKey> keys, CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        if (keys.Count == 0)
+            return [];
+
+        var values = await _database.StringGetAsync(keys.ToArray()).ConfigureAwait(false);
+        return values;
+    }
+}

src/Redis/Storage/Documents/Reading/RedisMutationRequestDocumentReader.cs

@@ -0,0 +1,47 @@
+using ModularityKit.Mutator.Governance.Abstractions.Requests.Model;
+using ModularityKit.Mutator.Governance.Redis.Storage.Documents.Keys;
+using ModularityKit.Mutator.Governance.Redis.Storage.Documents.Materialization;
+using ModularityKit.Mutator.Governance.Redis.Storage.Documents.Payloads;
+
+namespace ModularityKit.Mutator.Governance.Redis.Storage.Documents.Reading;
+
+/// <summary>
+/// Coordinates Redis document key creation, payload reads, and request materialization.
+/// </summary>
+internal sealed class RedisMutationRequestDocumentReader(
+    RedisMutationRequestDocumentKeyFactory keyFactory,
+    RedisMutationRequestPayloadReader payloadReader)
+{
+    private readonly RedisMutationRequestDocumentKeyFactory _keyFactory =
+        keyFactory ?? throw new ArgumentNullException(nameof(keyFactory));
+    private readonly RedisMutationRequestPayloadReader _payloadReader =
+        payloadReader ?? throw new ArgumentNullException(nameof(payloadReader));
+
+    /// <summary>
+    /// Loads request documents ordered by request creation time.
+    /// </summary>
+    /// <param name="requestIds">The request identifiers to load.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The materialized and ordered mutation requests.</returns>
+    public Task<IReadOnlyList<MutationRequest>> LoadOrderedByCreatedAsync(IEnumerable<string> requestIds, CancellationToken cancellationToken) =>
+        LoadAsync(requestIds, cancellationToken, orderByCreated: true);
+
+    /// <summary>
+    /// Loads request documents for the supplied identifiers.
+    /// </summary>
+    /// <param name="requestIds">The request identifiers to load.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <param name="orderByCreated">Whether to order results by request creation time.</param>
+    /// <returns>The materialized mutation requests.</returns>
+    public async Task<IReadOnlyList<MutationRequest>> LoadAsync(IEnumerable<string> requestIds, CancellationToken cancellationToken, bool orderByCreated)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        var keys = _keyFactory.CreateKeys(requestIds);
+        if (keys.Count == 0)
+            return [];
+
+        var values = await _payloadReader.LoadAsync(keys, cancellationToken).ConfigureAwait(false);
+        return RedisMutationRequestDocumentMaterializer.Materialize(values, cancellationToken, orderByCreated);
+    }
+}