Rewrite ChainOfResponsibility as composable Pipeline middleware

- Replace old ResponsibilityChain (7 files) with new ChainOfResponsibility
- Two variants: <TRequest> (no result) and <TRequest, TResult> (with result)
- Implements IMiddleware so it composes with Pipeline via .With(cor) / .Add(cor)
- Also implements ICommandHandler for standalone usage
- Simple list iteration instead of linked-list Link abstraction
- Factory pattern with fluent .Add<T>() builder, DI-integrated
- Add instance overloads .With(instance) and .Add(instance) on IPipelineFactory<T,R>
- Make monitoring optional: TraceFactory tolerates missing IOptionsMonitor
- 7 new tests covering standalone and pipeline-composed scenarios

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Quentin SCHROTER

src/Bones.Flow/Core/ChainOfResponsibility/ChainOfResponsibility.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Bones.Flow.Core
+{
+    internal class ChainOfResponsibility<TRequest> : IChainOfResponsibility<TRequest>
+        where TRequest : IRequest
+    {
+        private List<IChainOfResponsibilityHandler<TRequest>> _handlers;
+        private ILogger<ChainOfResponsibility<TRequest>> _logger;
+
+        public ChainOfResponsibility(
+            ILogger<ChainOfResponsibility<TRequest>> logger
+        )
+        {
+            _logger = logger;
+        }
+
+        public void Configure(List<IChainOfResponsibilityHandler<TRequest>> handlers)
+        {
+            _handlers = handlers ?? throw new ArgumentNullException(nameof(handlers));
+        }
+
+        async Task ICommandHandler<TRequest>.HandleAsync(TRequest request, CancellationToken cancellationToken, bool commit)
+        {
+            foreach (var handler in _handlers)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                try
+                {
+                    if (await handler.HandleAsync(request, cancellationToken))
+                        return;
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "An error occurred in ChainOfResponsibility handler {handler}", handler.GetType().Name);
+                    throw;
+                }
+            }
+        }
+
+        async Task IMiddleware<TRequest>.HandleAsync(TRequest request, Func<Task> next, CancellationToken cancellationToken)
+        {
+            foreach (var handler in _handlers)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                try
+                {
+                    if (await handler.HandleAsync(request, cancellationToken))
+                        break;
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "An error occurred in ChainOfResponsibility handler {handler}", handler.GetType().Name);
+                    throw;
+                }
+            }
+
+            await next();
+        }
+    }
+}

src/Bones.Flow/Core/ChainOfResponsibility/ChainOfResponsibilityFactory.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Bones.Flow.Core
+{
+    internal class ChainOfResponsibilityFactory<TRequest> : IChainOfResponsibilityFactory<TRequest>
+        where TRequest : IRequest
+    {
+        private IServiceProvider _provider;
+        private List<IChainOfResponsibilityHandler<TRequest>> _handlers;
+
+        public ChainOfResponsibilityFactory(IServiceProvider provider)
+        {
+            _provider = provider;
+            _handlers = new List<IChainOfResponsibilityHandler<TRequest>>();
+        }
+
+        public IChainOfResponsibilityFactory<TRequest> Add<THandler>()
+            where THandler : IChainOfResponsibilityHandler<TRequest>
+        {
+            var handler = _provider.GetRequiredService<THandler>();
+            return Add(handler);
+        }
+
+        public IChainOfResponsibilityFactory<TRequest> Add<THandler>(THandler handler)
+            where THandler : IChainOfResponsibilityHandler<TRequest>
+        {
+            _handlers.Add(handler);
+            return this;
+        }
+
+        public IChainOfResponsibility<TRequest> Build()
+        {
+            var chain = _provider.GetRequiredService<IChainOfResponsibility<TRequest>>();
+            chain.Configure(_handlers);
+            return chain;
+        }
+    }
+}

src/Bones.Flow/Core/ChainOfResponsibility/ResultChainOfResponsibility.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Bones.Flow.Core
+{
+    internal class ResultChainOfResponsibility<TRequest, TResult> : IChainOfResponsibility<TRequest, TResult>
+        where TRequest : IRequest<TResult>
+    {
+        private List<IChainOfResponsibilityHandler<TRequest, TResult>> _handlers;
+        private ILogger<ResultChainOfResponsibility<TRequest, TResult>> _logger;
+
+        public ResultChainOfResponsibility(
+            ILogger<ResultChainOfResponsibility<TRequest, TResult>> logger
+        )
+        {
+            _logger = logger;
+        }
+
+        public void Configure(List<IChainOfResponsibilityHandler<TRequest, TResult>> handlers)
+        {
+            _handlers = handlers ?? throw new ArgumentNullException(nameof(handlers));
+        }
+
+        async Task<TResult> ICommandHandler<TRequest, TResult>.HandleAsync(TRequest request, CancellationToken cancellationToken, bool commit)
+        {
+            foreach (var handler in _handlers)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                try
+                {
+                    var (handled, result) = await handler.HandleAsync(request, cancellationToken);
+                    if (handled)
+                        return result;
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "An error occurred in ChainOfResponsibility handler {handler}", handler.GetType().Name);
+                    throw;
+                }
+            }
+
+            return default;
+        }
+
+        async Task<TResult> IMiddleware<TRequest, TResult>.HandleAsync(TRequest request, Func<Task<TResult>> next, CancellationToken cancellationToken)
+        {
+            foreach (var handler in _handlers)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                try
+                {
+                    var (handled, result) = await handler.HandleAsync(request, cancellationToken);
+                    if (handled)
+                        return result;
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "An error occurred in ChainOfResponsibility handler {handler}", handler.GetType().Name);
+                    throw;
+                }
+            }
+
+            return await next();
+        }
+    }
+}

src/Bones.Flow/Core/ChainOfResponsibility/ResultChainOfResponsibilityFactory.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Bones.Flow.Core
+{
+    internal class ResultChainOfResponsibilityFactory<TRequest, TResult> : IChainOfResponsibilityFactory<TRequest, TResult>
+        where TRequest : IRequest<TResult>
+    {
+        private IServiceProvider _provider;
+        private List<IChainOfResponsibilityHandler<TRequest, TResult>> _handlers;
+
+        public ResultChainOfResponsibilityFactory(IServiceProvider provider)
+        {
+            _provider = provider;
+            _handlers = new List<IChainOfResponsibilityHandler<TRequest, TResult>>();
+        }
+
+        public IChainOfResponsibilityFactory<TRequest, TResult> Add<THandler>()
+            where THandler : IChainOfResponsibilityHandler<TRequest, TResult>
+        {
+            var handler = _provider.GetRequiredService<THandler>();
+            return Add(handler);
+        }
+
+        public IChainOfResponsibilityFactory<TRequest, TResult> Add<THandler>(THandler handler)
+            where THandler : IChainOfResponsibilityHandler<TRequest, TResult>
+        {
+            _handlers.Add(handler);
+            return this;
+        }
+
+        public IChainOfResponsibility<TRequest, TResult> Build()
+        {
+            var chain = _provider.GetRequiredService<IChainOfResponsibility<TRequest, TResult>>();
+            chain.Configure(_handlers);
+            return chain;
+        }
+    }
+}

src/Bones.Flow/Core/RequestResultPipeline/RequestResultPipelineFactory.cs

@@ -51,7 +51,11 @@ public IPipeline<TRequest, TResult> Build()
         public IBuildablePipelineFactory<TRequest, TResult> Add<TMiddleware>() where TMiddleware : IMiddleware<TRequest, TResult>
         {
             var middleware = _provider.GetRequiredService<TMiddleware>();
+            return Add(middleware);
+        }
 
+        public IBuildablePipelineFactory<TRequest, TResult> Add<TMiddleware>(TMiddleware middleware) where TMiddleware : IMiddleware<TRequest, TResult>
+        {
             _requestResultMiddlewares.Add(middleware);
             _middlewareTypes.Add(MiddlewareType.RequestResultMiddleware);
 
@@ -61,7 +65,11 @@ public IBuildablePipelineFactory<TRequest, TResult> Add<TMiddleware>() where TMi
         public IPipelineFactory<TRequest, TResult> With<TMiddleware>() where TMiddleware : IMiddleware<TRequest>
         {
             var middleware = _provider.GetRequiredService<TMiddleware>();
+            return With(middleware);
+        }
 
+        public IPipelineFactory<TRequest, TResult> With<TMiddleware>(TMiddleware middleware) where TMiddleware : IMiddleware<TRequest>
+        {
             _requestMiddlewares.Add(middleware);
             _middlewareTypes.Add(MiddlewareType.RequestMiddleware);