git.stella-ops.org/src/Authority/StellaOps.Authority/StellaOps.Auth.Client/MessagingTokenCache.cs

using System;
using System.Threading;
using System.Threading.Tasks;
using StellaOps.Messaging;
using StellaOps.Messaging.Abstractions;

namespace StellaOps.Auth.Client;

/// <summary>
/// Token cache backed by <see cref="IDistributedCache{TValue}"/>.
/// Supports any transport (InMemory, Valkey, PostgreSQL) via factory injection.
/// </summary>
public sealed class MessagingTokenCache : IStellaOpsTokenCache
{
    private readonly IDistributedCache<StellaOpsTokenCacheEntry> _cache;
    private readonly TimeProvider _timeProvider;
    private readonly Func<StellaOpsTokenCacheEntry, StellaOpsTokenCacheEntry> _normalizer;
    private readonly TimeSpan _expirationSkew;

    public MessagingTokenCache(
        IDistributedCacheFactory cacheFactory,
        TimeProvider? timeProvider = null,
        TimeSpan? expirationSkew = null)
    {
        ArgumentNullException.ThrowIfNull(cacheFactory);

        _timeProvider = timeProvider ?? TimeProvider.System;
        _expirationSkew = expirationSkew ?? TimeSpan.FromSeconds(30);
        _normalizer = static entry => entry.NormalizeScopes();

        _cache = cacheFactory.Create<StellaOpsTokenCacheEntry>(new CacheOptions
        {
            KeyPrefix = "auth:token:",
        });
    }

    public async ValueTask<StellaOpsTokenCacheEntry?> GetAsync(string key, CancellationToken cancellationToken = default)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(key);

        var result = await _cache.GetAsync(key, cancellationToken).ConfigureAwait(false);

        if (!result.HasValue)
        {
            return null;
        }

        var entry = result.Value;

        // Check if expired with skew
        if (entry.IsExpired(_timeProvider, _expirationSkew))
        {
            await _cache.InvalidateAsync(key, cancellationToken).ConfigureAwait(false);
            return null;
        }

        return entry;
    }

    public async ValueTask SetAsync(string key, StellaOpsTokenCacheEntry entry, CancellationToken cancellationToken = default)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(key);
        ArgumentNullException.ThrowIfNull(entry);

        var normalizedEntry = _normalizer(entry);
        var now = _timeProvider.GetUtcNow();
        var ttl = normalizedEntry.ExpiresAtUtc - now;

        if (ttl <= TimeSpan.Zero)
        {
            return;
        }

        var entryOptions = new CacheEntryOptions { TimeToLive = ttl };
        await _cache.SetAsync(key, normalizedEntry, entryOptions, cancellationToken).ConfigureAwait(false);
    }

    public async ValueTask RemoveAsync(string key, CancellationToken cancellationToken = default)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(key);
        await _cache.InvalidateAsync(key, cancellationToken).ConfigureAwait(false);
    }
}