Feat: add Redis governance identifier set loading

Author: rian-be

src/Redis/Storage/Identifiers/Loading/RedisMutationRequestIdSetReader.cs

@@ -0,0 +1,44 @@
+using ModularityKit.Mutator.Governance.Redis.Storage.Identifiers.Models;
+using StackExchange.Redis;
+
+namespace ModularityKit.Mutator.Governance.Redis.Storage.Identifiers.Loading;
+
+/// <summary>
+/// Provides higher level Redis request id set reads for candidate execution.
+/// </summary>
+internal sealed class RedisMutationRequestIdSetReader(
+    RedisMutationRequestIdentifierSetLoader setLoader)
+{
+    private readonly RedisMutationRequestIdentifierSetLoader _setLoader = setLoader ?? throw new ArgumentNullException(nameof(setLoader));
+
+    /// <summary>
+    /// Loads request identifiers from a single Redis set.
+    /// </summary>
+    /// <param name="key">The Redis set key.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The resolved request identifiers.</returns>
+    public async Task<IReadOnlyList<string>> LoadIdsAsync(RedisKey key, CancellationToken cancellationToken) =>
+        await _setLoader.LoadAsync(RedisMutationRequestIdentifierSetOperation.Members, [key], cancellationToken)
+            .ConfigureAwait(false);
+
+    /// <summary>
+    /// Loads request identifiers from the union of the supplied Redis sets.
+    /// </summary>
+    /// <param name="keys">The Redis set keys to union.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The resolved request identifiers.</returns>
+    public async Task<IReadOnlyList<string>> LoadUnionedIdsAsync(IReadOnlyList<RedisKey> keys, CancellationToken cancellationToken) =>
+        await _setLoader.LoadAsync(RedisMutationRequestIdentifierSetOperation.Union, keys, cancellationToken)
+            .ConfigureAwait(false);
+
+    /// <summary>
+    /// Loads request identifiers from the intersection of two Redis sets.
+    /// </summary>
+    /// <param name="left">The left Redis set key.</param>
+    /// <param name="right">The right Redis set key.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The resolved request identifiers.</returns>
+    public async Task<IReadOnlyList<string>> LoadIntersectedIdsAsync(RedisKey left, RedisKey right, CancellationToken cancellationToken) =>
+        await _setLoader.LoadAsync(RedisMutationRequestIdentifierSetOperation.Intersection, [left, right], cancellationToken)
+            .ConfigureAwait(false);
+}

src/Redis/Storage/Identifiers/Loading/RedisMutationRequestIdentifierSetLoader.cs

@@ -0,0 +1,55 @@
+using ModularityKit.Mutator.Governance.Redis.Storage.Identifiers.Models;
+using StackExchange.Redis;
+
+namespace ModularityKit.Mutator.Governance.Redis.Storage.Identifiers.Loading;
+
+/// <summary>
+/// Executes low-level Redis set operations used to resolve request identifiers.
+/// </summary>
+internal sealed class RedisMutationRequestIdentifierSetLoader(IDatabase database)
+{
+    private readonly IDatabase _database = database ?? throw new ArgumentNullException(nameof(database));
+
+    /// <summary>
+    /// Loads request identifiers using the supplied Redis set operation.
+    /// </summary>
+    /// <param name="operation">The Redis set operation to execute.</param>
+    /// <param name="keys">The Redis set keys participating in the operation.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The normalized request identifiers.</returns>
+    public async Task<IReadOnlyList<string>> LoadAsync(RedisMutationRequestIdentifierSetOperation operation, IReadOnlyList<RedisKey> keys, CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        if (keys.Count == 0)
+            return [];
+
+        var values = operation switch
+        {
+            RedisMutationRequestIdentifierSetOperation.Members => await _database
+                .SetMembersAsync(keys[0])
+                .ConfigureAwait(false),
+            RedisMutationRequestIdentifierSetOperation.Union => await LoadCombinedAsync(
+                SetOperation.Union,
+                keys,
+                cancellationToken).ConfigureAwait(false),
+            RedisMutationRequestIdentifierSetOperation.Intersection => await LoadCombinedAsync(
+                SetOperation.Intersect,
+                keys,
+                cancellationToken).ConfigureAwait(false),
+            _ => throw new InvalidOperationException($"Unsupported identifier set operation '{operation}'.")
+        };
+
+        return RedisMutationRequestIdentifierValueNormalizer.Normalize(values);
+    }
+
+    private async Task<RedisValue[]> LoadCombinedAsync(SetOperation operation, IReadOnlyList<RedisKey> keys, CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        if (keys.Count == 1)
+            return await _database.SetMembersAsync(keys[0]).ConfigureAwait(false);
+
+        return await _database.SetCombineAsync(operation, keys.ToArray()).ConfigureAwait(false);
+    }
+}

src/Redis/Storage/Identifiers/Loading/RedisMutationRequestIdentifierValueNormalizer.cs

@@ -0,0 +1,21 @@
+using StackExchange.Redis;
+
+namespace ModularityKit.Mutator.Governance.Redis.Storage.Identifiers.Loading;
+
+/// <summary>
+/// Normalizes raw Redis set members into stable request-id lists.
+/// </summary>
+internal static class RedisMutationRequestIdentifierValueNormalizer
+{
+    /// <summary>
+    /// Converts Redis values into distinct, non-empty request identifiers.
+    /// </summary>
+    /// <param name="values">The Redis values to normalize.</param>
+    /// <returns>The normalized request identifiers.</returns>
+    public static IReadOnlyList<string> Normalize(RedisValue[] values) => 
+        values.Where(value => value.HasValue)
+            .Select(value => value.ToString())
+            .Where(value => !string.IsNullOrWhiteSpace(value))
+            .Distinct(StringComparer.Ordinal)
+            .ToArray();
+}

src/Redis/Storage/Identifiers/Models/RedisMutationRequestIdentifierSetOperation.cs

@@ -0,0 +1,22 @@
+namespace ModularityKit.Mutator.Governance.Redis.Storage.Identifiers.Models;
+
+/// <summary>
+/// Defines the Redis set operation used to resolve request identifiers.
+/// </summary>
+internal enum RedisMutationRequestIdentifierSetOperation
+{
+    /// <summary>
+    /// Reads the members of a single Redis set.
+    /// </summary>
+    Members = 0,
+
+    /// <summary>
+    /// Reads the union of multiple Redis sets.
+    /// </summary>
+    Union = 1,
+
+    /// <summary>
+    /// Reads the intersection of multiple Redis sets.
+    /// </summary>
+    Intersection = 2
+}