up

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Infrastructure/Execution/MongoPackRunApprovalStore.cs

@@ -1,164 +0,0 @@
-using MongoDB.Bson;
-using MongoDB.Bson.Serialization.Attributes;
-using MongoDB.Driver;
-using StellaOps.TaskRunner.Core.Configuration;
-using StellaOps.TaskRunner.Core.Execution;
-
-namespace StellaOps.TaskRunner.Infrastructure.Execution;
-
-public sealed class MongoPackRunApprovalStore : IPackRunApprovalStore
-{
-    private readonly IMongoCollection<PackRunApprovalDocument> collection;
-
-    public MongoPackRunApprovalStore(IMongoDatabase database, TaskRunnerMongoOptions options)
-    {
-        ArgumentNullException.ThrowIfNull(database);
-        ArgumentNullException.ThrowIfNull(options);
-
-        collection = database.GetCollection<PackRunApprovalDocument>(options.ApprovalsCollection);
-        EnsureIndexes(collection);
-    }
-
-    public async Task SaveAsync(string runId, IReadOnlyList<PackRunApprovalState> approvals, CancellationToken cancellationToken)
-    {
-        ArgumentException.ThrowIfNullOrWhiteSpace(runId);
-        ArgumentNullException.ThrowIfNull(approvals);
-
-        var filter = Builders<PackRunApprovalDocument>.Filter.Eq(document => document.RunId, runId);
-
-        await collection.DeleteManyAsync(filter, cancellationToken).ConfigureAwait(false);
-
-        if (approvals.Count == 0)
-        {
-            return;
-        }
-
-        var documents = approvals
-            .Select(approval => PackRunApprovalDocument.FromDomain(runId, approval))
-            .ToList();
-
-        await collection.InsertManyAsync(documents, cancellationToken: cancellationToken).ConfigureAwait(false);
-    }
-
-    public async Task<IReadOnlyList<PackRunApprovalState>> GetAsync(string runId, CancellationToken cancellationToken)
-    {
-        ArgumentException.ThrowIfNullOrWhiteSpace(runId);
-
-        var filter = Builders<PackRunApprovalDocument>.Filter.Eq(document => document.RunId, runId);
-
-        var documents = await collection
-            .Find(filter)
-            .SortBy(document => document.ApprovalId)
-            .ToListAsync(cancellationToken)
-            .ConfigureAwait(false);
-
-        return documents
-            .Select(document => document.ToDomain())
-            .ToList();
-    }
-
-    public async Task UpdateAsync(string runId, PackRunApprovalState approval, CancellationToken cancellationToken)
-    {
-        ArgumentException.ThrowIfNullOrWhiteSpace(runId);
-        ArgumentNullException.ThrowIfNull(approval);
-
-        var filter = Builders<PackRunApprovalDocument>.Filter.And(
-            Builders<PackRunApprovalDocument>.Filter.Eq(document => document.RunId, runId),
-            Builders<PackRunApprovalDocument>.Filter.Eq(document => document.ApprovalId, approval.ApprovalId));
-
-        var existingDocument = await collection
-            .Find(filter)
-            .FirstOrDefaultAsync(cancellationToken)
-            .ConfigureAwait(false);
-
-        if (existingDocument is null)
-        {
-            throw new InvalidOperationException($"Approval '{approval.ApprovalId}' not found for run '{runId}'.");
-        }
-
-        var document = PackRunApprovalDocument.FromDomain(runId, approval, existingDocument.Id);
-        await collection
-            .ReplaceOneAsync(filter, document, cancellationToken: cancellationToken)
-            .ConfigureAwait(false);
-    }
-
-    public static IEnumerable<CreateIndexModel<PackRunApprovalDocument>> GetIndexModels()
-    {
-        yield return new CreateIndexModel<PackRunApprovalDocument>(
-            Builders<PackRunApprovalDocument>.IndexKeys
-                .Ascending(document => document.RunId)
-                .Ascending(document => document.ApprovalId),
-            new CreateIndexOptions { Unique = true, Name = "pack_run_approvals_run_approval" });
-
-        yield return new CreateIndexModel<PackRunApprovalDocument>(
-            Builders<PackRunApprovalDocument>.IndexKeys
-                .Ascending(document => document.RunId)
-                .Ascending(document => document.Status),
-            new CreateIndexOptions { Name = "pack_run_approvals_run_status" });
-    }
-
-    private static void EnsureIndexes(IMongoCollection<PackRunApprovalDocument> target)
-        => target.Indexes.CreateMany(GetIndexModels());
-
-    public sealed class PackRunApprovalDocument
-    {
-        [BsonId]
-        public ObjectId Id { get; init; }
-
-        public string RunId { get; init; } = default!;
-
-        public string ApprovalId { get; init; } = default!;
-
-        public IReadOnlyList<string> RequiredGrants { get; init; } = Array.Empty<string>();
-
-        public IReadOnlyList<string> StepIds { get; init; } = Array.Empty<string>();
-
-        public IReadOnlyList<string> Messages { get; init; } = Array.Empty<string>();
-
-        public string? ReasonTemplate { get; init; }
-
-        public DateTime RequestedAt { get; init; }
-
-        public string Status { get; init; } = default!;
-
-        public string? ActorId { get; init; }
-
-        public DateTime? CompletedAt { get; init; }
-
-        public string? Summary { get; init; }
-
-        public static PackRunApprovalDocument FromDomain(string runId, PackRunApprovalState approval, ObjectId? id = null)
-            => new()
-            {
-                Id = id ?? ObjectId.GenerateNewId(),
-                RunId = runId,
-                ApprovalId = approval.ApprovalId,
-                RequiredGrants = approval.RequiredGrants ?? Array.Empty<string>(),
-                StepIds = approval.StepIds ?? Array.Empty<string>(),
-                Messages = approval.Messages ?? Array.Empty<string>(),
-                ReasonTemplate = approval.ReasonTemplate,
-                RequestedAt = approval.RequestedAt.UtcDateTime,
-                Status = approval.Status.ToString(),
-                ActorId = approval.ActorId,
-                CompletedAt = approval.CompletedAt?.UtcDateTime,
-                Summary = approval.Summary
-            };
-
-        public PackRunApprovalState ToDomain()
-        {
-            var status = Enum.Parse<PackRunApprovalStatus>(Status, ignoreCase: true);
-
-            return new PackRunApprovalState(
-                ApprovalId,
-                RequiredGrants?.ToList() ?? new List<string>(),
-                StepIds?.ToList() ?? new List<string>(),
-                Messages?.ToList() ?? new List<string>(),
-                ReasonTemplate,
-                new DateTimeOffset(RequestedAt, TimeSpan.Zero),
-                status,
-                ActorId,
-                CompletedAt is null ? null : new DateTimeOffset(CompletedAt.Value, TimeSpan.Zero),
-                Summary);
-        }
-    }
-}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Infrastructure/Execution/MongoPackRunArtifactReader.cs

@@ -1,44 +0,0 @@
-using MongoDB.Bson;
-using MongoDB.Bson.IO;
-using MongoDB.Driver;
-using StellaOps.TaskRunner.Core.Configuration;
-using StellaOps.TaskRunner.Core.Execution;
-
-namespace StellaOps.TaskRunner.Infrastructure.Execution;
-
-public sealed class MongoPackRunArtifactReader : IPackRunArtifactReader
-{
-    private readonly IMongoCollection<MongoPackRunArtifactUploader.PackRunArtifactDocument> collection;
-
-    public MongoPackRunArtifactReader(IMongoDatabase database, TaskRunnerMongoOptions options)
-    {
-        ArgumentNullException.ThrowIfNull(database);
-        ArgumentNullException.ThrowIfNull(options);
-
-        collection = database.GetCollection<MongoPackRunArtifactUploader.PackRunArtifactDocument>(options.ArtifactsCollection);
-    }
-
-    public async Task<IReadOnlyList<PackRunArtifactRecord>> ListAsync(string runId, CancellationToken cancellationToken)
-    {
-        ArgumentException.ThrowIfNullOrWhiteSpace(runId);
-
-        var filter = Builders<MongoPackRunArtifactUploader.PackRunArtifactDocument>.Filter.Eq(doc => doc.RunId, runId);
-        var documents = await collection
-            .Find(filter)
-            .SortBy(doc => doc.Name)
-            .ToListAsync(cancellationToken)
-            .ConfigureAwait(false);
-
-        return documents
-            .Select(doc => new PackRunArtifactRecord(
-                doc.Name,
-                doc.Type,
-                doc.SourcePath,
-                doc.StoredPath,
-                doc.Status,
-                doc.Notes,
-                new DateTimeOffset(doc.CapturedAt, TimeSpan.Zero),
-                doc.Expression?.ToJson(new JsonWriterSettings())))
-            .ToList();
-    }
-}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Infrastructure/Execution/MongoPackRunArtifactUploader.cs

@@ -1,192 +0,0 @@
-using System.Text.Json;
-using System.Text.Json.Nodes;
-using Microsoft.Extensions.Logging;
-using MongoDB.Bson;
-using MongoDB.Bson.Serialization.Attributes;
-using MongoDB.Driver;
-using StellaOps.TaskRunner.Core.Configuration;
-using StellaOps.TaskRunner.Core.Execution;
-using StellaOps.TaskRunner.Core.Planning;
-
-namespace StellaOps.TaskRunner.Infrastructure.Execution;
-
-public sealed class MongoPackRunArtifactUploader : IPackRunArtifactUploader
-{
-    private static readonly JsonSerializerOptions SerializerOptions = new(JsonSerializerDefaults.Web);
-
-    private readonly IMongoCollection<PackRunArtifactDocument> collection;
-    private readonly TimeProvider timeProvider;
-    private readonly ILogger<MongoPackRunArtifactUploader> logger;
-
-    public MongoPackRunArtifactUploader(
-        IMongoDatabase database,
-        TaskRunnerMongoOptions options,
-        TimeProvider? timeProvider,
-        ILogger<MongoPackRunArtifactUploader> logger)
-    {
-        ArgumentNullException.ThrowIfNull(database);
-        ArgumentNullException.ThrowIfNull(options);
-
-        collection = database.GetCollection<PackRunArtifactDocument>(options.ArtifactsCollection);
-        this.timeProvider = timeProvider ?? TimeProvider.System;
-        this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
-        EnsureIndexes(collection);
-    }
-
-    public async Task UploadAsync(
-        PackRunExecutionContext context,
-        PackRunState state,
-        IReadOnlyList<TaskPackPlanOutput> outputs,
-        CancellationToken cancellationToken)
-    {
-        ArgumentNullException.ThrowIfNull(context);
-        ArgumentNullException.ThrowIfNull(state);
-        ArgumentNullException.ThrowIfNull(outputs);
-
-        var filter = Builders<PackRunArtifactDocument>.Filter.Eq(document => document.RunId, context.RunId);
-        await collection.DeleteManyAsync(filter, cancellationToken).ConfigureAwait(false);
-
-        if (outputs.Count == 0)
-        {
-            return;
-        }
-
-        var timestamp = timeProvider.GetUtcNow();
-        var documents = new List<PackRunArtifactDocument>(outputs.Count);
-
-        foreach (var output in outputs)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            documents.Add(ProcessOutput(context, output, timestamp));
-        }
-
-        await collection.InsertManyAsync(documents, cancellationToken: cancellationToken).ConfigureAwait(false);
-    }
-
-    private PackRunArtifactDocument ProcessOutput(
-        PackRunExecutionContext context,
-        TaskPackPlanOutput output,
-        DateTimeOffset capturedAt)
-    {
-        var sourcePath = ResolveString(output.Path);
-        var expressionNode = ResolveExpression(output.Expression);
-        string status = "skipped";
-        string? notes = null;
-        string? storedPath = null;
-
-        if (IsFileOutput(output))
-        {
-            if (string.IsNullOrWhiteSpace(sourcePath))
-            {
-                status = "unresolved";
-                notes = "Output path requires runtime value.";
-            }
-            else if (!File.Exists(sourcePath))
-            {
-                status = "missing";
-                notes = $"Source file '{sourcePath}' not found.";
-                logger.LogWarning(
-                    "Pack run {RunId} output {Output} referenced missing file {Path}.",
-                    context.RunId,
-                    output.Name,
-                    sourcePath);
-            }
-            else
-            {
-                status = "referenced";
-                storedPath = sourcePath;
-            }
-        }
-
-        BsonDocument? expressionDocument = null;
-        if (expressionNode is not null)
-        {
-            var json = expressionNode.ToJsonString(SerializerOptions);
-            expressionDocument = BsonDocument.Parse(json);
-            status = status is "referenced" ? status : "materialized";
-        }
-
-        return new PackRunArtifactDocument
-        {
-            Id = ObjectId.GenerateNewId(),
-            RunId = context.RunId,
-            Name = output.Name,
-            Type = output.Type,
-            SourcePath = sourcePath,
-            StoredPath = storedPath,
-            Status = status,
-            Notes = notes,
-            CapturedAt = capturedAt.UtcDateTime,
-            Expression = expressionDocument
-        };
-    }
-
-    private static bool IsFileOutput(TaskPackPlanOutput output)
-        => string.Equals(output.Type, "file", StringComparison.OrdinalIgnoreCase);
-
-    private static string? ResolveString(TaskPackPlanParameterValue? parameter)
-    {
-        if (parameter is null || parameter.RequiresRuntimeValue || parameter.Value is null)
-        {
-            return null;
-        }
-
-        if (parameter.Value is JsonValue jsonValue && jsonValue.TryGetValue<string>(out var value))
-        {
-            return value;
-        }
-
-        return null;
-    }
-
-    private static JsonNode? ResolveExpression(TaskPackPlanParameterValue? parameter)
-    {
-        if (parameter is null || parameter.RequiresRuntimeValue)
-        {
-            return null;
-        }
-
-        return parameter.Value;
-    }
-
-    public static IEnumerable<CreateIndexModel<PackRunArtifactDocument>> GetIndexModels()
-    {
-        yield return new CreateIndexModel<PackRunArtifactDocument>(
-            Builders<PackRunArtifactDocument>.IndexKeys
-                .Ascending(document => document.RunId)
-                .Ascending(document => document.Name),
-            new CreateIndexOptions { Unique = true, Name = "pack_artifacts_run_name" });
-
-        yield return new CreateIndexModel<PackRunArtifactDocument>(
-            Builders<PackRunArtifactDocument>.IndexKeys
-                .Ascending(document => document.RunId),
-            new CreateIndexOptions { Name = "pack_artifacts_run" });
-    }
-
-    private static void EnsureIndexes(IMongoCollection<PackRunArtifactDocument> target)
-        => target.Indexes.CreateMany(GetIndexModels());
-
-    public sealed class PackRunArtifactDocument
-    {
-        [BsonId]
-        public ObjectId Id { get; init; }
-
-        public string RunId { get; init; } = default!;
-
-        public string Name { get; init; } = default!;
-
-        public string Type { get; init; } = default!;
-
-        public string? SourcePath { get; init; }
-
-        public string? StoredPath { get; init; }
-
-        public string Status { get; init; } = default!;
-
-        public string? Notes { get; init; }
-
-        public DateTime CapturedAt { get; init; }
-
-        public BsonDocument? Expression { get; init; }
-    }
-}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Infrastructure/Execution/MongoPackRunLogStore.cs

@@ -1,162 +0,0 @@
-using MongoDB.Bson;
-using MongoDB.Bson.Serialization.Attributes;
-using MongoDB.Driver;
-using StellaOps.TaskRunner.Core.Configuration;
-using StellaOps.TaskRunner.Core.Execution;
-
-namespace StellaOps.TaskRunner.Infrastructure.Execution;
-
-public sealed class MongoPackRunLogStore : IPackRunLogStore
-{
-    private readonly IMongoCollection<PackRunLogDocument> collection;
-
-    public MongoPackRunLogStore(IMongoDatabase database, TaskRunnerMongoOptions options)
-    {
-        ArgumentNullException.ThrowIfNull(database);
-        ArgumentNullException.ThrowIfNull(options);
-
-        collection = database.GetCollection<PackRunLogDocument>(options.LogsCollection);
-        EnsureIndexes(collection);
-    }
-
-    public async Task AppendAsync(string runId, PackRunLogEntry entry, CancellationToken cancellationToken)
-    {
-        ArgumentException.ThrowIfNullOrWhiteSpace(runId);
-        ArgumentNullException.ThrowIfNull(entry);
-
-        var filter = Builders<PackRunLogDocument>.Filter.Eq(document => document.RunId, runId);
-
-        for (var attempt = 0; attempt < 5; attempt++)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-
-            var last = await collection
-                .Find(filter)
-                .SortByDescending(document => document.Sequence)
-                .FirstOrDefaultAsync(cancellationToken)
-                .ConfigureAwait(false);
-
-            var nextSequence = last is null ? 1 : last.Sequence + 1;
-
-            var document = PackRunLogDocument.FromDomain(runId, nextSequence, entry);
-
-            try
-            {
-                await collection.InsertOneAsync(document, cancellationToken: cancellationToken).ConfigureAwait(false);
-                return;
-            }
-            catch (MongoWriteException ex) when (ex.WriteError?.Category == ServerErrorCategory.DuplicateKey)
-            {
-                await Task.Delay(TimeSpan.FromMilliseconds(10), cancellationToken).ConfigureAwait(false);
-            }
-        }
-
-        throw new InvalidOperationException($"Failed to append log entry for run '{runId}' after multiple attempts.");
-    }
-
-    public async IAsyncEnumerable<PackRunLogEntry> ReadAsync(
-        string runId,
-        [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
-    {
-        ArgumentException.ThrowIfNullOrWhiteSpace(runId);
-
-        var filter = Builders<PackRunLogDocument>.Filter.Eq(document => document.RunId, runId);
-
-        using var cursor = await collection
-            .Find(filter)
-            .SortBy(document => document.Sequence)
-            .ToCursorAsync(cancellationToken)
-            .ConfigureAwait(false);
-
-        while (await cursor.MoveNextAsync(cancellationToken).ConfigureAwait(false))
-        {
-            foreach (var document in cursor.Current)
-            {
-                yield return document.ToDomain();
-            }
-        }
-    }
-
-    public async Task<bool> ExistsAsync(string runId, CancellationToken cancellationToken)
-    {
-        ArgumentException.ThrowIfNullOrWhiteSpace(runId);
-
-        var filter = Builders<PackRunLogDocument>.Filter.Eq(document => document.RunId, runId);
-        return await collection
-            .Find(filter)
-            .Limit(1)
-            .AnyAsync(cancellationToken)
-            .ConfigureAwait(false);
-    }
-
-    public static IEnumerable<CreateIndexModel<PackRunLogDocument>> GetIndexModels()
-    {
-        yield return new CreateIndexModel<PackRunLogDocument>(
-            Builders<PackRunLogDocument>.IndexKeys
-                .Ascending(document => document.RunId)
-                .Ascending(document => document.Sequence),
-            new CreateIndexOptions { Unique = true, Name = "pack_run_logs_run_sequence" });
-
-        yield return new CreateIndexModel<PackRunLogDocument>(
-            Builders<PackRunLogDocument>.IndexKeys
-                .Ascending(document => document.RunId)
-                .Ascending(document => document.Timestamp),
-            new CreateIndexOptions { Name = "pack_run_logs_run_timestamp" });
-    }
-
-    private static void EnsureIndexes(IMongoCollection<PackRunLogDocument> target)
-        => target.Indexes.CreateMany(GetIndexModels());
-
-    public sealed class PackRunLogDocument
-    {
-        [BsonId]
-        public ObjectId Id { get; init; }
-
-        public string RunId { get; init; } = default!;
-
-        public long Sequence { get; init; }
-
-        public DateTime Timestamp { get; init; }
-
-        public string Level { get; init; } = default!;
-
-        public string EventType { get; init; } = default!;
-
-        public string Message { get; init; } = default!;
-
-        public string? StepId { get; init; }
-
-        public Dictionary<string, string>? Metadata { get; init; }
-
-        public static PackRunLogDocument FromDomain(string runId, long sequence, PackRunLogEntry entry)
-            => new()
-            {
-                Id = ObjectId.GenerateNewId(),
-                RunId = runId,
-                Sequence = sequence,
-                Timestamp = entry.Timestamp.UtcDateTime,
-                Level = entry.Level,
-                EventType = entry.EventType,
-                Message = entry.Message,
-                StepId = entry.StepId,
-                Metadata = entry.Metadata is null
-                    ? null
-                    : new Dictionary<string, string>(entry.Metadata, StringComparer.Ordinal)
-            };
-
-        public PackRunLogEntry ToDomain()
-        {
-            IReadOnlyDictionary<string, string>? metadata = Metadata is null
-                ? null
-                : new Dictionary<string, string>(Metadata, StringComparer.Ordinal);
-
-            return new PackRunLogEntry(
-                new DateTimeOffset(Timestamp, TimeSpan.Zero),
-                Level,
-                EventType,
-                Message,
-                StepId,
-                metadata);
-        }
-    }
-}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Infrastructure/Execution/MongoPackRunProvenanceWriter.cs

@@ -1,67 +0,0 @@
-using System.Text.Json;
-using MongoDB.Bson;
-using MongoDB.Driver;
-using StellaOps.TaskRunner.Core.Configuration;
-using StellaOps.TaskRunner.Core.Execution;
-
-namespace StellaOps.TaskRunner.Infrastructure.Execution;
-
-public sealed class MongoPackRunProvenanceWriter : IPackRunProvenanceWriter
-{
-    private static readonly JsonSerializerOptions SerializerOptions = new(JsonSerializerDefaults.Web);
-
-    private readonly IMongoCollection<ProvenanceDocument> collection;
-    private readonly TimeProvider timeProvider;
-
-    public MongoPackRunProvenanceWriter(IMongoDatabase database, TaskRunnerMongoOptions options, TimeProvider? timeProvider = null)
-    {
-        ArgumentNullException.ThrowIfNull(database);
-        ArgumentNullException.ThrowIfNull(options);
-
-        collection = database.GetCollection<ProvenanceDocument>(options.ArtifactsCollection);
-        this.timeProvider = timeProvider ?? TimeProvider.System;
-    }
-
-    public async Task WriteAsync(PackRunExecutionContext context, PackRunState state, CancellationToken cancellationToken)
-    {
-        ArgumentNullException.ThrowIfNull(context);
-        ArgumentNullException.ThrowIfNull(state);
-
-        var completedAt = timeProvider.GetUtcNow();
-        var manifest = ProvenanceManifestFactory.Create(context, state, completedAt);
-        var manifestJson = JsonSerializer.Serialize(manifest, SerializerOptions);
-        var manifestDocument = BsonDocument.Parse(manifestJson);
-
-        var document = new ProvenanceDocument
-        {
-            RunId = context.RunId,
-            Name = "provenance-manifest",
-            Type = "object",
-            Status = "materialized",
-            CapturedAt = completedAt.UtcDateTime,
-            Expression = manifestDocument
-        };
-
-        var filter = Builders<ProvenanceDocument>.Filter.And(
-            Builders<ProvenanceDocument>.Filter.Eq(doc => doc.RunId, context.RunId),
-            Builders<ProvenanceDocument>.Filter.Eq(doc => doc.Name, document.Name));
-
-        var options = new ReplaceOptions { IsUpsert = true };
-        await collection.ReplaceOneAsync(filter, document, options, cancellationToken).ConfigureAwait(false);
-    }
-
-    private sealed class ProvenanceDocument
-    {
-        public string RunId { get; init; } = default!;
-
-        public string Name { get; init; } = default!;
-
-        public string Type { get; init; } = default!;
-
-        public string Status { get; init; } = default!;
-
-        public DateTime CapturedAt { get; init; }
-
-        public BsonDocument Expression { get; init; } = default!;
-    }
-}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Infrastructure/Execution/MongoPackRunStateStore.cs

@@ -1,216 +0,0 @@
-using System.Collections.ObjectModel;
-using System.Text.Json;
-using MongoDB.Bson;
-using MongoDB.Bson.Serialization.Attributes;
-using MongoDB.Driver;
-using StellaOps.TaskRunner.Core.Configuration;
-using StellaOps.TaskRunner.Core.Execution;
-using StellaOps.TaskRunner.Core.Planning;
-
-namespace StellaOps.TaskRunner.Infrastructure.Execution;
-
-public sealed class MongoPackRunStateStore : IPackRunStateStore
-{
-    private static readonly JsonSerializerOptions SerializerOptions = new(JsonSerializerDefaults.Web);
-
-    private readonly IMongoCollection<PackRunStateDocument> collection;
-
-    public MongoPackRunStateStore(IMongoDatabase database, TaskRunnerMongoOptions options)
-    {
-        ArgumentNullException.ThrowIfNull(database);
-        ArgumentNullException.ThrowIfNull(options);
-
-        collection = database.GetCollection<PackRunStateDocument>(options.RunsCollection);
-        EnsureIndexes(collection);
-    }
-
-    public async Task<PackRunState?> GetAsync(string runId, CancellationToken cancellationToken)
-    {
-        ArgumentException.ThrowIfNullOrWhiteSpace(runId);
-
-        var filter = Builders<PackRunStateDocument>.Filter.Eq(document => document.RunId, runId);
-        var document = await collection
-            .Find(filter)
-            .FirstOrDefaultAsync(cancellationToken)
-            .ConfigureAwait(false);
-
-        return document?.ToDomain();
-    }
-
-    public async Task SaveAsync(PackRunState state, CancellationToken cancellationToken)
-    {
-        ArgumentNullException.ThrowIfNull(state);
-
-        var document = PackRunStateDocument.FromDomain(state);
-        var filter = Builders<PackRunStateDocument>.Filter.Eq(existing => existing.RunId, state.RunId);
-
-        await collection
-            .ReplaceOneAsync(filter, document, new ReplaceOptions { IsUpsert = true }, cancellationToken)
-            .ConfigureAwait(false);
-    }
-
-    public async Task<IReadOnlyList<PackRunState>> ListAsync(CancellationToken cancellationToken)
-    {
-        var documents = await collection
-            .Find(FilterDefinition<PackRunStateDocument>.Empty)
-            .SortByDescending(document => document.UpdatedAt)
-            .ToListAsync(cancellationToken)
-            .ConfigureAwait(false);
-
-        return documents
-            .Select(document => document.ToDomain())
-            .ToList();
-    }
-
-    public static IEnumerable<CreateIndexModel<PackRunStateDocument>> GetIndexModels()
-    {
-        yield return new CreateIndexModel<PackRunStateDocument>(
-            Builders<PackRunStateDocument>.IndexKeys.Descending(document => document.UpdatedAt),
-            new CreateIndexOptions { Name = "pack_runs_updatedAt_desc" });
-
-        yield return new CreateIndexModel<PackRunStateDocument>(
-            Builders<PackRunStateDocument>.IndexKeys
-                .Ascending(document => document.TenantId)
-                .Descending(document => document.UpdatedAt),
-            new CreateIndexOptions { Name = "pack_runs_tenant_updatedAt_desc", Sparse = true });
-    }
-
-    private static void EnsureIndexes(IMongoCollection<PackRunStateDocument> target)
-        => target.Indexes.CreateMany(GetIndexModels());
-
-    public sealed class PackRunStateDocument
-    {
-        [BsonId]
-        public string RunId { get; init; } = default!;
-
-        public string PlanHash { get; init; } = default!;
-
-        public BsonDocument Plan { get; init; } = default!;
-
-        public BsonDocument FailurePolicy { get; init; } = default!;
-
-        public DateTime RequestedAt { get; init; }
-
-        public DateTime CreatedAt { get; init; }
-
-        public DateTime UpdatedAt { get; init; }
-
-        public List<PackRunStepDocument> Steps { get; init; } = new();
-
-        public string? TenantId { get; init; }
-
-        public static PackRunStateDocument FromDomain(PackRunState state)
-        {
-            var planDocument = BsonDocument.Parse(JsonSerializer.Serialize(state.Plan, SerializerOptions));
-            var failurePolicyDocument = BsonDocument.Parse(JsonSerializer.Serialize(state.FailurePolicy, SerializerOptions));
-
-            var steps = state.Steps.Values
-                .OrderBy(step => step.StepId, StringComparer.Ordinal)
-                .Select(PackRunStepDocument.FromDomain)
-                .ToList();
-
-            return new PackRunStateDocument
-            {
-                RunId = state.RunId,
-                PlanHash = state.PlanHash,
-                Plan = planDocument,
-                FailurePolicy = failurePolicyDocument,
-                RequestedAt = state.RequestedAt.UtcDateTime,
-                CreatedAt = state.CreatedAt.UtcDateTime,
-                UpdatedAt = state.UpdatedAt.UtcDateTime,
-                Steps = steps,
-                TenantId = state.TenantId
-            };
-        }
-
-        public PackRunState ToDomain()
-        {
-            var planJson = Plan.ToJson();
-            var plan = JsonSerializer.Deserialize<TaskPackPlan>(planJson, SerializerOptions)
-                ?? throw new InvalidOperationException("Failed to deserialize stored TaskPackPlan.");
-
-            var failurePolicyJson = FailurePolicy.ToJson();
-            var failurePolicy = JsonSerializer.Deserialize<TaskPackPlanFailurePolicy>(failurePolicyJson, SerializerOptions)
-                ?? throw new InvalidOperationException("Failed to deserialize stored TaskPackPlanFailurePolicy.");
-
-            var stepRecords = Steps
-                .Select(step => step.ToDomain())
-                .ToDictionary(record => record.StepId, record => record, StringComparer.Ordinal);
-
-            return new PackRunState(
-                RunId,
-                PlanHash,
-                plan,
-                failurePolicy,
-                new DateTimeOffset(RequestedAt, TimeSpan.Zero),
-                new DateTimeOffset(CreatedAt, TimeSpan.Zero),
-                new DateTimeOffset(UpdatedAt, TimeSpan.Zero),
-                new ReadOnlyDictionary<string, PackRunStepStateRecord>(stepRecords),
-                TenantId);
-        }
-    }
-
-    public sealed class PackRunStepDocument
-    {
-        public string StepId { get; init; } = default!;
-
-        public string Kind { get; init; } = default!;
-
-        public bool Enabled { get; init; }
-
-        public bool ContinueOnError { get; init; }
-
-        public int? MaxParallel { get; init; }
-
-        public string? ApprovalId { get; init; }
-
-        public string? GateMessage { get; init; }
-
-        public string Status { get; init; } = default!;
-
-        public int Attempts { get; init; }
-
-        public DateTime? LastTransitionAt { get; init; }
-
-        public DateTime? NextAttemptAt { get; init; }
-
-        public string? StatusReason { get; init; }
-
-        public static PackRunStepDocument FromDomain(PackRunStepStateRecord record)
-            => new()
-            {
-                StepId = record.StepId,
-                Kind = record.Kind.ToString(),
-                Enabled = record.Enabled,
-                ContinueOnError = record.ContinueOnError,
-                MaxParallel = record.MaxParallel,
-                ApprovalId = record.ApprovalId,
-                GateMessage = record.GateMessage,
-                Status = record.Status.ToString(),
-                Attempts = record.Attempts,
-                LastTransitionAt = record.LastTransitionAt?.UtcDateTime,
-                NextAttemptAt = record.NextAttemptAt?.UtcDateTime,
-                StatusReason = record.StatusReason
-            };
-
-        public PackRunStepStateRecord ToDomain()
-        {
-            var kind = Enum.Parse<PackRunStepKind>(Kind, ignoreCase: true);
-            var status = Enum.Parse<PackRunStepExecutionStatus>(Status, ignoreCase: true);
-
-            return new PackRunStepStateRecord(
-                StepId,
-                kind,
-                Enabled,
-                ContinueOnError,
-                MaxParallel,
-                ApprovalId,
-                GateMessage,
-                status,
-                Attempts,
-                LastTransitionAt is null ? null : new DateTimeOffset(LastTransitionAt.Value, TimeSpan.Zero),
-                NextAttemptAt is null ? null : new DateTimeOffset(NextAttemptAt.Value, TimeSpan.Zero),
-                StatusReason);
-        }
-    }
-}

src/TaskRunner/StellaOps.TaskRunner/StellaOps.TaskRunner.Infrastructure/StellaOps.TaskRunner.Infrastructure.csproj

@@ -3,7 +3,6 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.Http" Version="10.0.0" />
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.0" />
-    <PackageReference Include="MongoDB.Driver" Version="3.5.0" />
     <ProjectReference Include="..\StellaOps.TaskRunner.Core\StellaOps.TaskRunner.Core.csproj" />
   </ItemGroup>