git.stella-ops.org/src/Policy/StellaOps.Policy.Engine/Attestation/InMemoryVerificationPolicyStore.cs

using System.Collections.Concurrent;

namespace StellaOps.Policy.Engine.Attestation;

/// <summary>
/// In-memory implementation of verification policy store per CONTRACT-VERIFICATION-POLICY-006.
/// </summary>
internal sealed class InMemoryVerificationPolicyStore : IVerificationPolicyStore
{
    private readonly ConcurrentDictionary<string, VerificationPolicy> _policies = new(StringComparer.OrdinalIgnoreCase);

    public Task<VerificationPolicy?> GetAsync(string policyId, CancellationToken cancellationToken = default)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(policyId);

        _policies.TryGetValue(policyId, out var policy);
        return Task.FromResult(policy);
    }

    public Task<IReadOnlyList<VerificationPolicy>> ListAsync(
        string? tenantScope = null,
        CancellationToken cancellationToken = default)
    {
        IEnumerable<VerificationPolicy> policies = _policies.Values;

        if (!string.IsNullOrWhiteSpace(tenantScope))
        {
            policies = policies.Where(p =>
                p.TenantScope == "*" ||
                p.TenantScope.Equals(tenantScope, StringComparison.OrdinalIgnoreCase));
        }

        var result = policies
            .OrderBy(p => p.PolicyId)
            .ToList() as IReadOnlyList<VerificationPolicy>;

        return Task.FromResult(result);
    }

    public Task<VerificationPolicy> CreateAsync(
        VerificationPolicy policy,
        CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(policy);

        if (!_policies.TryAdd(policy.PolicyId, policy))
        {
            throw new InvalidOperationException($"Policy '{policy.PolicyId}' already exists.");
        }

        return Task.FromResult(policy);
    }

    public Task<VerificationPolicy?> UpdateAsync(
        string policyId,
        Func<VerificationPolicy, VerificationPolicy> update,
        CancellationToken cancellationToken = default)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(policyId);
        ArgumentNullException.ThrowIfNull(update);

        if (!_policies.TryGetValue(policyId, out var existing))
        {
            return Task.FromResult<VerificationPolicy?>(null);
        }

        var updated = update(existing);
        _policies[policyId] = updated;

        return Task.FromResult<VerificationPolicy?>(updated);
    }

    public Task<bool> DeleteAsync(string policyId, CancellationToken cancellationToken = default)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(policyId);

        return Task.FromResult(_policies.TryRemove(policyId, out _));
    }

    public Task<bool> ExistsAsync(string policyId, CancellationToken cancellationToken = default)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(policyId);

        return Task.FromResult(_policies.ContainsKey(policyId));
    }
}