feat: dogfood PatternKit behavior pipeline

Directory.Packages.props

@@ -26,6 +26,7 @@
     <PackageVersion Include="NSubstitute" Version="5.3.0" />
     <PackageVersion Include="Scrutor" Version="7.0.0" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.4" />
+    <PackageVersion Include="PatternKit.Core" Version="0.147.1" />
     <!-- gRPC Packages -->
     <PackageVersion Include="Grpc.AspNetCore" Version="2.76.0" />
     <PackageVersion Include="Grpc.AspNetCore.Server.Reflection" Version="2.76.0" />
@@ -71,4 +72,4 @@
     <!-- SOAP Packages -->
     <PackageVersion Include="SoapCore" Version="1.2.1.12" />
   </ItemGroup>
-</Project>
+</Project>

src/QuickApiMapper.Application/Core/BehaviorPipeline.cs

@@ -1,4 +1,5 @@
 using Microsoft.Extensions.Logging;
+using PatternKit.Behavioral.Chain;
 using QuickApiMapper.Contracts;
 using ContractsMappingResult = QuickApiMapper.Contracts.MappingResult;
 
@@ -24,163 +25,167 @@ public async Task<ContractsMappingResult> ExecuteAsync(
         MappingContext context,
         Func<MappingContext, Task<ContractsMappingResult>> coreLogic)
     {
-        // Build the complete pipeline: PreRun -> WholeRun -> Core -> PostRun
-        var pipeline = BuildCompletePipeline(coreLogic);
-
-        // Execute the complete pipeline (exceptions from PreRun behaviors will propagate)
-        var result = await pipeline(context);
+        await ExecutePreRunBehaviors(context);
+        var result = await ExecuteWholeRunWithPostRunBehaviors(context, coreLogic);
 
         logger.LogInformation("Behavior pipeline execution completed. Success: {Success}", result.IsSuccess);
         return result;
     }
 
-    /// <summary>
-    /// Builds the complete pipeline: PreRun -> WholeRun -> Core -> PostRun
-    /// </summary>
-    private Func<MappingContext, Task<ContractsMappingResult>> BuildCompletePipeline(
+    private async Task<ContractsMappingResult> ExecuteWholeRunWithPostRunBehaviors(
+        MappingContext context,
         Func<MappingContext, Task<ContractsMappingResult>> coreLogic)
     {
-
-        var wholeRunPipeline = BuildWholeRunPipeline(coreLogic);
-        var wholeRunWithPost = BuildCoreWithPostRun(wholeRunPipeline);
+        try
+        {
+            var result = await ExecuteWholeRunBehaviors(context, coreLogic);
 
-        return BuildPreRunPipeline(wholeRunWithPost);
-    }
+            await ExecutePostRunBehaviors(context, result);
 
-    /// <summary>
-    /// Builds the PreRun behavior pipeline chain.
-    /// </summary>
-    private Func<MappingContext, Task<ContractsMappingResult>> BuildPreRunPipeline(
-        Func<MappingContext, Task<ContractsMappingResult>> next)
-    {
-        return async context =>
+            return result;
+        }
+        catch (Exception ex) when (IsNonFatalPipelineException(ex))
         {
-            // Execute PreRun behaviors first (let exceptions propagate for fail-fast scenarios)
-            await ExecutePreRunBehaviors(context);
+            var failureResult = ContractsMappingResult.Failure("Core mapping logic failed", ex);
 
-            // Then execute the rest of the pipeline
-            return await next(context);
-        };
+            try
+            {
+                await ExecutePostRunBehaviors(context, failureResult);
+            }
+            catch (Exception postRunEx) when (IsNonFatalPipelineException(postRunEx))
+            {
+                logger.LogError(postRunEx, "PostRun behavior execution failed after core logic failure");
+            }
+
+            return failureResult;
+        }
     }
 
-    /// <summary>
-    /// Builds the WholeRun behavior pipeline chain.
-    /// </summary>
-    private Func<MappingContext, Task<ContractsMappingResult>> BuildWholeRunPipeline(
+    private async Task<ContractsMappingResult> ExecuteWholeRunBehaviors(
+        MappingContext context,
         Func<MappingContext, Task<ContractsMappingResult>> coreLogic)
     {
-        // Get ordered WholeRun behaviors
-        var orderedBehaviors = wholeRunBehaviors
-            .OrderBy(b => b.Order)
-            .ToList();
-
-        // Build the pipeline from right to left (last behavior wraps the core logic)
-        var pipeline = coreLogic;
+        var state = new BehaviorExecutionState(context, coreLogic);
+        var builder = AsyncActionChain<BehaviorExecutionState>.Create();
 
-        // Wrap with WholeRun behaviors in reverse order
-        for (var i = orderedBehaviors.Count - 1; i >= 0; i--)
+        foreach (var behavior in wholeRunBehaviors.OrderBy(b => b.Order))
         {
-            var behavior = orderedBehaviors[i];
-            var next = pipeline; // Capture the current pipeline
-
-            pipeline = async context =>
+            builder.Use(async (current, ct, next) =>
             {
                 logger.LogDebug("Executing WholeRun behavior: {BehaviorName}", behavior.Name);
-                return await behavior.ExecuteAsync(context, next);
-            };
+                current.Result = await behavior.ExecuteAsync(current.Context, ContinueAsync).ConfigureAwait(false);
+
+                async Task<ContractsMappingResult> ContinueAsync(MappingContext nextContext)
+                {
+                    var previousContext = current.Context;
+                    current.Context = nextContext;
+
+                    try
+                    {
+                        await next(current, ct).ConfigureAwait(false);
+                        return current.Result ?? CreateMissingResultFailure();
+                    }
+                    finally
+                    {
+                        current.Context = previousContext;
+                    }
+                }
+            });
         }
 
-        return pipeline;
+        builder.Finally(async (current, _) =>
+        {
+            current.Result = await current.CoreLogic(current.Context).ConfigureAwait(false);
+        });
+
+        await builder.Build().ExecuteAsync(state, context.CancellationToken).ConfigureAwait(false);
+
+        return state.Result ?? CreateMissingResultFailure();
     }
 
-    /// <summary>
-    /// Builds the core logic wrapped with PostRun behaviors.
-    /// </summary>
-    private Func<MappingContext, Task<ContractsMappingResult>> BuildCoreWithPostRun(
-        Func<MappingContext, Task<ContractsMappingResult>> coreLogic)
+    private async Task ExecutePreRunBehaviors(MappingContext context)
     {
-        return async context =>
-        {
-            try
-            {
-                // Execute core logic
-                var result = await coreLogic(context);
-
-                // Execute PostRun behaviors
-                await ExecutePostRunBehaviors(context, result);
+        var builder = AsyncActionChain<MappingContext>.Create();
 
-                return result;
-            }
-            catch (Exception ex)
+        foreach (var behavior in preRunBehaviors.OrderBy(b => b.Order))
+        {
+            builder.Use(async (current, ct, next) =>
             {
-                var failureResult = ContractsMappingResult.Failure("Core mapping logic failed", ex);
+                logger.LogDebug("Executing PreRun behavior: {BehaviorName}", behavior.Name);
 
-                // Still try to execute PostRun behaviors even if core logic failed
                 try
                 {
-                    await ExecutePostRunBehaviors(context, failureResult);
+                    await behavior.ExecuteAsync(current).ConfigureAwait(false);
+                    logger.LogDebug("PreRun behavior completed successfully: {BehaviorName}", behavior.Name);
                 }
-                catch (Exception postRunEx)
+                catch (Exception ex) when (IsNonFatalPipelineException(ex))
                 {
-                    logger.LogError(postRunEx, "PostRun behavior execution failed after core logic failure");
+                    logger.LogError(ex, "PreRun behavior failed: {BehaviorName}", behavior.Name);
+                    throw;
                 }
 
-                return failureResult;
-            }
-        };
-    }
+                await next(current, ct).ConfigureAwait(false);
+            });
+        }
 
+        await builder.Build().ExecuteAsync(context, context.CancellationToken).ConfigureAwait(false);
+    }
 
-    /// <summary>
-    /// Executes all PreRun behaviors in order.
-    /// </summary>
-    private async Task ExecutePreRunBehaviors(MappingContext context)
+    private async Task ExecutePostRunBehaviors(
+        MappingContext context,
+        ContractsMappingResult result)
     {
-        var orderedBehaviors = preRunBehaviors
-            .OrderBy(b => b.Order)
-            .ToList();
+        var state = new PostRunBehaviorExecutionState(context, result);
+        var builder = AsyncActionChain<PostRunBehaviorExecutionState>.Create();
 
-        foreach (var behavior in orderedBehaviors)
+        foreach (var behavior in postRunBehaviors.OrderBy(b => b.Order))
         {
-            logger.LogDebug("Executing PreRun behavior: {BehaviorName}", behavior.Name);
-
-            try
-            {
-                await behavior.ExecuteAsync(context);
-                logger.LogDebug("PreRun behavior completed successfully: {BehaviorName}", behavior.Name);
-            }
-            catch (Exception ex)
+            builder.Use(async (current, ct, next) =>
             {
-                logger.LogError(ex, "PreRun behavior failed: {BehaviorName}", behavior.Name);
-                throw;
-            }
+                logger.LogDebug("Executing PostRun behavior: {BehaviorName}", behavior.Name);
+
+                try
+                {
+                    await behavior.ExecuteAsync(current.Context, current.Result).ConfigureAwait(false);
+                    logger.LogDebug("PostRun behavior completed successfully: {BehaviorName}", behavior.Name);
+                }
+                catch (Exception ex) when (IsNonFatalPipelineException(ex))
+                {
+                    logger.LogError(ex, "PostRun behavior failed: {BehaviorName}", behavior.Name);
+                }
+
+                await next(current, ct).ConfigureAwait(false);
+            });
         }
+
+        await builder.Build().ExecuteAsync(state, context.CancellationToken).ConfigureAwait(false);
     }
 
-    /// <summary>
-    /// Executes all PostRun behaviors in order.
-    /// </summary>
-    private async Task ExecutePostRunBehaviors(
-        MappingContext context, 
-        ContractsMappingResult result)
-    {
-        var orderedBehaviors = postRunBehaviors
-            .OrderBy(b => b.Order)
-            .ToList();
+    private static ContractsMappingResult CreateMissingResultFailure()
+        => ContractsMappingResult.Failure("Behavior pipeline completed without producing a mapping result");
 
-        foreach (var behavior in orderedBehaviors)
-        {
-            logger.LogDebug("Executing PostRun behavior: {BehaviorName}", behavior.Name);
+    private static bool IsNonFatalPipelineException(Exception exception)
+        => exception is not OperationCanceledException
+            and not OutOfMemoryException
+            and not StackOverflowException
+            and not AccessViolationException
+            and not AppDomainUnloadedException
+            and not BadImageFormatException;
 
-            try
-            {
-                await behavior.ExecuteAsync(context, result);
-                logger.LogDebug("PostRun behavior completed successfully: {BehaviorName}", behavior.Name);
-            }
-            catch (Exception ex)
-            {
-                logger.LogError(ex, "PostRun behavior failed: {BehaviorName}", behavior.Name);
-            }
-        }
+    private sealed class BehaviorExecutionState(
+        MappingContext context,
+        Func<MappingContext, Task<ContractsMappingResult>> coreLogic)
+    {
+        public MappingContext Context { get; set; } = context;
+        public Func<MappingContext, Task<ContractsMappingResult>> CoreLogic { get; } = coreLogic;
+        public ContractsMappingResult? Result { get; set; }
+    }
+
+    private sealed class PostRunBehaviorExecutionState(
+        MappingContext context,
+        ContractsMappingResult result)
+    {
+        public MappingContext Context { get; } = context;
+        public ContractsMappingResult Result { get; } = result;
     }
-}
+}

src/QuickApiMapper.Application/QuickApiMapper.Application.csproj

@@ -7,6 +7,7 @@
       <PackageReference Include="Microsoft.Extensions.Caching.Memory" />
       <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" />
       <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
+      <PackageReference Include="PatternKit.Core" />
       <PackageReference Include="Scrutor" />
     </ItemGroup>
 

tests/QuickApiMapper.UnitTests/BehaviorIntegrationTests.cs

@@ -438,6 +438,36 @@ public async Task BehaviorTestCollection_WithFactoryMethods_ShouldBuildCorrectPi
         });
     }
 
+    [Test]
+    public async Task Pipeline_WithShortCircuitingWholeRunBehavior_ShouldStillExecutePostRun()
+    {
+        // Arrange
+        var executionOrder = new List<string>();
+        var postRunBehavior = new TestPostRunBehavior(executionOrder);
+        var shortCircuitBehavior = new TestShortCircuitWholeRunBehavior(executionOrder);
+
+        var pipeline = _behaviorCollection
+            .AddWholeRunBehavior(shortCircuitBehavior)
+            .AddPostRunBehavior(postRunBehavior)
+            .BuildPipeline(_serviceProvider);
+
+        var context = CreateMappingContext();
+
+        // Act
+        var result = await pipeline.ExecuteAsync(context, _ =>
+        {
+            executionOrder.Add("Core");
+            return Task.FromResult(MappingResult.Success());
+        });
+
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(result.IsSuccess, Is.True);
+            Assert.That(executionOrder, Is.EqualTo(new[] { "ShortCircuit", "PostRun" }));
+        });
+    }
+
     private class TestPreRunBehavior(
         List<string> executionOrder
     ) :
@@ -490,6 +520,21 @@ public async Task<MappingResult> ExecuteAsync(MappingContext context, Func<Mappi
         }
     }
 
+    private class TestShortCircuitWholeRunBehavior(
+        List<string> executionOrder
+    ) :
+        IWholeRunBehavior
+    {
+        public string Name => "TestShortCircuit";
+        public int Order => 10;
+
+        public Task<MappingResult> ExecuteAsync(MappingContext context, Func<MappingContext, Task<MappingResult>> next)
+        {
+            executionOrder.Add("ShortCircuit");
+            return Task.FromResult(MappingResult.Success());
+        }
+    }
+
 
 #pragma warning disable IDISP013
 #pragma warning disable IDISP014
@@ -551,4 +596,4 @@ public void Dispose()
         _httpClient.Dispose();
         _httpClientFactory.Dispose();
     }
-}
+}