feat: add action when no handler was found

src/KafkaFlow.TypedHandler/TypedHandlerConfiguration.cs

@@ -1,7 +1,11 @@
 namespace KafkaFlow.TypedHandler
 {
+    using System;
+
     internal class TypedHandlerConfiguration
     {
         public HandlerTypeMapping HandlerMapping { get; } = new();
+
+        public Action<IMessageContext> OnNoHandlerFound { get; set; } = (_) => { };
     }
 }

src/KafkaFlow.TypedHandler/TypedHandlerConfigurationBuilder.cs

@@ -13,6 +13,7 @@ public class TypedHandlerConfigurationBuilder
         private readonly IDependencyConfigurator dependencyConfigurator;
         private readonly List<Type> handlers = new();
 
+        private Action<IMessageContext> onNoHandlerFound = (_) => { };
         private InstanceLifetime serviceLifetime = InstanceLifetime.Singleton;
 
         /// <summary>
@@ -29,7 +30,8 @@ public TypedHandlerConfigurationBuilder(IDependencyConfigurator dependencyConfig
         /// </summary>
         /// <typeparam name="T">A type that implements the <see cref="IMessageHandler{TMessage}"/> interface</typeparam>
         /// <returns></returns>
-        public TypedHandlerConfigurationBuilder AddHandlersFromAssemblyOf<T>() => this.AddHandlersFromAssemblyOf(typeof(T));
+        public TypedHandlerConfigurationBuilder AddHandlersFromAssemblyOf<T>() =>
+            this.AddHandlersFromAssemblyOf(typeof(T));
 
         /// <summary>
         /// Adds all classes that implements the <see cref="IMessageHandler{TMessage}"/> interface from the assemblies of the provided types
@@ -70,6 +72,17 @@ public TypedHandlerConfigurationBuilder AddHandler<T>()
             return this;
         }
 
+        /// <summary>
+        /// Register the action to be executed when no handler was found to process the message
+        /// </summary>
+        /// <param name="handler">The handler that will be executed</param>
+        /// <returns></returns>
+        public TypedHandlerConfigurationBuilder WhenNoHandlerFound(Action<IMessageContext> handler)
+        {
+            this.onNoHandlerFound = handler;
+            return this;
+        }
+
         /// <summary>
         /// Set the handler lifetime. The default value is <see cref="InstanceLifetime.Singleton"/>
         /// </summary>
@@ -83,7 +96,10 @@ public TypedHandlerConfigurationBuilder WithHandlerLifetime(InstanceLifetime lif
 
         internal TypedHandlerConfiguration Build()
         {
-            var configuration = new TypedHandlerConfiguration();
+            var configuration = new TypedHandlerConfiguration
+            {
+                OnNoHandlerFound = this.onNoHandlerFound,
+            };
 
             foreach (var handlerType in this.handlers)
             {

src/KafkaFlow.TypedHandler/TypedHandlerMiddleware.cs

@@ -18,19 +18,28 @@ public TypedHandlerMiddleware(
 
         public async Task Invoke(IMessageContext context, MiddlewareDelegate next)
         {
-            await Task.WhenAll(
-                    this.configuration
-                        .HandlerMapping
-                        .GetHandlersTypes(context.Message.Value.GetType())
-                        .Select(
-                            handler =>
-                                HandlerExecutor
-                                    .GetExecutor(context.Message.Value.GetType())
-                                    .Execute(
-                                        this.dependencyResolver.Resolve(handler),
-                                        context,
-                                        context.Message.Value)))
-                .ConfigureAwait(false);
+            var handlers = this.configuration
+                .HandlerMapping
+                .GetHandlersTypes(context.Message.Value.GetType());
+
+            if (!handlers.Any())
+            {
+                this.configuration.OnNoHandlerFound(context);
+            }
+            else
+            {
+                await Task.WhenAll(
+                        handlers
+                            .Select(
+                                handler =>
+                                    HandlerExecutor
+                                        .GetExecutor(context.Message.Value.GetType())
+                                        .Execute(
+                                            this.dependencyResolver.Resolve(handler),
+                                            context,
+                                            context.Message.Value)))
+                    .ConfigureAwait(false);
+            }
 
             await next(context).ConfigureAwait(false);
         }