refactor(governance-runtime): extract execution orchestration helpers

Author: rian-be

src/Governance/Runtime/Execution/Orchestration/GovernanceExecutionManager.cs

@@ -46,39 +46,35 @@ public async Task<GovernedExecutionResult<TState>> ExecuteApproved<TState>(
         ArgumentNullException.ThrowIfNull(resultingStateVersionProvider);
         ArgumentNullException.ThrowIfNull(governanceContext);
 
-        var resolution = await _resolutionManager.ResolveAndStore(
+        var execution = await ResolveExecutionContext(
             requestId,
+            mutation,
+            currentState,
             currentStateVersion,
+            resultingStateVersionProvider,
             governanceContext,
             strategy,
             cancellationToken).ConfigureAwait(false);
 
-        if (resolution.Outcome is MutationRequestVersionResolutionOutcome.RejectedAsStale or
+        if (execution.Resolution.Outcome is MutationRequestVersionResolutionOutcome.RejectedAsStale or
             MutationRequestVersionResolutionOutcome.RequiresRenewedApproval)
         {
-            return _outcomeHandler.BuildNonExecutedResult<TState>(resolution);
+            return _outcomeHandler.BuildNonExecutedResult<TState>(execution.Resolution);
         }
 
-        var governedMutation = new GovernedMutation<TState>(mutation, requestId, resolution.Request.StateId);
         MutationResult<TState> mutationResult;
 
         try
         {
-            mutationResult = await _mutationEngine
-                .ExecuteAsync(governedMutation, currentState, cancellationToken)
-                .ConfigureAwait(false);
+            mutationResult = await ExecuteMutation(execution, cancellationToken).ConfigureAwait(false);
         }
         catch (Exception ex)
         {
             await _outcomeHandler.PersistRejectedExecution(
-                resolution.Request,
-                governanceContext,
+                execution.Resolution.Request,
+                execution.GovernanceContext,
                 $"Governed execution threw '{ex.GetType().Name}': {ex.Message}",
-                new Dictionary<string, object>
-                {
-                    ["CurrentStateVersion"] = currentStateVersion,
-                    ["ExecutionFailureType"] = ex.GetType().Name
-                },
+                GovernedExecutionFailureMetadataFactory.CreateExceptionMetadata(execution.CurrentStateVersion, ex),
                 cancellationToken).ConfigureAwait(false);
 
             throw;
@@ -87,35 +83,32 @@ await _outcomeHandler.PersistRejectedExecution(
         if (!mutationResult.IsSuccess || mutationResult.NewState is null)
         {
             var rejectedRequest = await _outcomeHandler.PersistRejectedExecution(
-                resolution.Request,
-                governanceContext,
+                execution.Resolution.Request,
+                execution.GovernanceContext,
                 GovernedExecutionDecisionFactory.BuildRejectedExecutionReason(mutationResult),
-                new Dictionary<string, object>
-                {
-                    ["CurrentStateVersion"] = currentStateVersion,
-                    ["HasPolicyDecisions"] = mutationResult.PolicyDecisions.Count > 0,
-                    ["HasValidationErrors"] = !mutationResult.ValidationResult.IsValid
-                },
+                GovernedExecutionFailureMetadataFactory.CreateRejectedExecutionMetadata(
+                    execution.CurrentStateVersion,
+                    mutationResult),
                 cancellationToken).ConfigureAwait(false);
 
             return _outcomeHandler.BuildNonExecutedResult(
-                resolution with { Request = rejectedRequest },
+                execution.Resolution with { Request = rejectedRequest },
                 mutationResult);
         }
 
-        var resultingStateVersion = resultingStateVersionProvider(mutationResult.NewState);
+        var resultingStateVersion = execution.ResultingStateVersionProvider(mutationResult.NewState);
         if (string.IsNullOrWhiteSpace(resultingStateVersion))
             throw new InvalidOperationException("Governed execution requires a non-empty resulting state version.");
 
         var executedRequest = await _outcomeHandler.PersistExecutedRequest(
-            resolution.Request,
+            execution.Resolution.Request,
             resultingStateVersion,
-            governanceContext,
+            execution.GovernanceContext,
             mutationResult,
             cancellationToken).ConfigureAwait(false);
 
         return _outcomeHandler.BuildExecutedResult(
-            resolution,
+            execution.Resolution,
             mutationResult,
             executedRequest,
             resultingStateVersion);
@@ -138,4 +131,38 @@ public Task<GovernedExecutionResult<TState>> ExecuteApproved<TState>(
             governanceContext,
             strategy,
             cancellationToken);
+
+    private async Task<GovernedExecutionContext<TState>> ResolveExecutionContext<TState>(
+        string requestId,
+        IMutation<TState> mutation,
+        TState currentState,
+        string currentStateVersion,
+        Func<TState, string> resultingStateVersionProvider,
+        MutationContext governanceContext,
+        VersionedRequestResolutionStrategy strategy,
+        CancellationToken cancellationToken)
+    {
+        var resolution = await _resolutionManager.ResolveAndStore(
+            requestId,
+            currentStateVersion,
+            governanceContext,
+            strategy,
+            cancellationToken).ConfigureAwait(false);
+
+        return new GovernedExecutionContext<TState>(
+            resolution,
+            new GovernedMutation<TState>(mutation, resolution.Request),
+            currentState,
+            currentStateVersion,
+            resultingStateVersionProvider,
+            governanceContext);
+    }
+
+    private Task<MutationResult<TState>> ExecuteMutation<TState>(
+        GovernedExecutionContext<TState> execution,
+        CancellationToken cancellationToken)
+        => _mutationEngine.ExecuteAsync(
+            execution.Mutation,
+            execution.CurrentState,
+            cancellationToken);
 }

src/Governance/Runtime/Execution/Orchestration/GovernedExecutionContext.cs

@@ -0,0 +1,16 @@
+using ModularityKit.Mutator.Abstractions.Context;
+using ModularityKit.Mutator.Governance.Abstractions.Resolution.Model;
+using ModularityKit.Mutator.Governance.Runtime.Execution.Mutation;
+
+namespace ModularityKit.Mutator.Governance.Runtime.Execution.Orchestration;
+
+/// <summary>
+/// Carries the resolved runtime inputs for one governed execution attempt.
+/// </summary>
+internal sealed record GovernedExecutionContext<TState>(
+    MutationRequestVersionResolution Resolution,
+    GovernedMutation<TState> Mutation,
+    TState CurrentState,
+    string CurrentStateVersion,
+    Func<TState, string> ResultingStateVersionProvider,
+    MutationContext GovernanceContext);

src/Governance/Runtime/Execution/Orchestration/GovernedExecutionFailureMetadataFactory.cs

@@ -0,0 +1,28 @@
+using ModularityKit.Mutator.Abstractions.Results;
+
+namespace ModularityKit.Mutator.Governance.Runtime.Execution.Orchestration;
+
+/// <summary>
+/// Builds consistent governance metadata payloads for execution failures.
+/// </summary>
+internal static class GovernedExecutionFailureMetadataFactory
+{
+    public static IReadOnlyDictionary<string, object> CreateExceptionMetadata(
+        string currentStateVersion,
+        Exception exception)
+        => new Dictionary<string, object>
+        {
+            ["CurrentStateVersion"] = currentStateVersion,
+            ["ExecutionFailureType"] = exception.GetType().Name
+        };
+
+    public static IReadOnlyDictionary<string, object> CreateRejectedExecutionMetadata<TState>(
+        string currentStateVersion,
+        MutationResult<TState> mutationResult)
+        => new Dictionary<string, object>
+        {
+            ["CurrentStateVersion"] = currentStateVersion,
+            ["HasPolicyDecisions"] = mutationResult.PolicyDecisions.Count > 0,
+            ["HasValidationErrors"] = !mutationResult.ValidationResult.IsValid
+        };
+}