feat: create request projects for basic CQRS

src/request.dispatcher.tests/.editorconfig

@@ -0,0 +1,15 @@
+
+[*.{cs,vb}]
+# disable CA1822: Mark members as static
+# -> TUnit requiring instance methods for test cases
+dotnet_diagnostic.CA1822.severity = none
+# disable CA1707: Identifiers should not contain underscores
+dotnet_diagnostic.CA1707.severity = none
+# disable IDE0060: Remove unused parameter
+dotnet_diagnostic.IDE0060.severity = none
+# disable IDE0005: Unnecessary using directive
+dotnet_diagnostic.IDE0005.severity = none
+# disable IDE0390: Method can be made synchronous
+dotnet_diagnostic.IDE0390.severity = none
+# disable IDE0391: Method can be made synchronous
+dotnet_diagnostic.IDE0391.severity = none

src/request.dispatcher.tests/Geekeey.Request.Dispatcher.Tests.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="TUnit" />
+    <!-- additional packages -->
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <AssemblyAttribute Include="System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Remove="_fixtures/roslyn/**/*.cs" />
+    <EmbeddedResource Include="_fixtures/roslyn/**/*.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\request.dispatcher\Geekeey.Request.Dispatcher.csproj" />
+  </ItemGroup>
+
+</Project>

src/request.dispatcher.tests/PackageContentsTests.cs

@@ -0,0 +1,49 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using System.Diagnostics;
+using System.IO.Compression;
+
+namespace Geekeey.Request.Tests;
+
+internal sealed class PackageContentsTests
+{
+	private static string RepoRoot => Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..");
+	private static string ArtifactsDir => Path.Combine(RepoRoot, "artifacts");
+	private static string ProjectPath => Path.Combine(RepoRoot, "src", "request.dispatcher", "Geekeey.Request.Dispatcher.csproj");
+
+	private readonly string _outputDir;
+
+	public PackageContentsTests()
+	{
+		_outputDir = Path.Combine(ArtifactsDir, Path.GetRandomFileName());
+	}
+
+	[Before(Test)]
+	public async Task SetUpAsync()
+	{
+		Directory.CreateDirectory(_outputDir);
+	}
+
+	[After(Test)]
+	public async Task CleanUpAsync()
+	{
+		Directory.Delete(_outputDir, true);
+	}
+
+	[Test]
+	public async Task I_can_verify_the_package_contains_the_expected_contents()
+	{
+		using var process = Process.Start("dotnet", $"pack \"{ProjectPath}\" -o \"{_outputDir}\" -c Release");
+		await process.WaitForExitAsync();
+
+		var pkgs = Directory.GetFiles(_outputDir, "*.nupkg");
+		await Assert.That(pkgs.Length).IsGreaterThanOrEqualTo(1);
+
+		await using var archive = await ZipFile.OpenReadAsync(pkgs[0]);
+		var entries = archive.Entries.Select(entry => entry.FullName.Replace('\\', '/')).ToHashSet();
+
+		await Assert.That(entries).Contains("lib/net10.0/Geekeey.Request.Dispatcher.dll");
+		await Assert.That(entries).Contains("lib/net10.0/Geekeey.Request.Dispatcher.xml");
+	}
+}

src/request.dispatcher.tests/RequestDispatcherBuilderExtensionsTests.cs

@@ -0,0 +1,142 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal sealed class RequestDispatcherBuilderExtensionsTests
+{
+	[Test]
+	public async Task I_can_add_a_type_and_register_the_options()
+	{
+		var services = new ServiceCollection();
+		var builder = services.AddRequestDispatcher();
+		var type = typeof(TestHandler);
+
+		builder.Add(type);
+
+		var provider = services.BuildServiceProvider();
+		var options = provider.GetRequiredService<IOptions<RequestDispatcherOptions>>().Value;
+
+		var handlers = options.GetRequestHandlers<IScalarRequestHandler<TestRequest, string>>(provider);
+		await Assert.That(handlers).Count().IsEqualTo(1);
+		await Assert.That(handlers.First()).IsTypeOf<TestHandler>();
+	}
+
+	[Test]
+	public async Task I_can_add_a_type_with_a_lifetime_and_register_the_options_and_service()
+	{
+		var services = new ServiceCollection();
+		var builder = services.AddRequestDispatcher();
+		var type = typeof(TestHandler);
+		var lifetime = ServiceLifetime.Scoped;
+
+		builder.Add(type, lifetime);
+
+		var serviceDescriptor = services.FirstOrDefault(sd => sd.ServiceType == type);
+		await Assert.That(serviceDescriptor).IsNotNull();
+		await Assert.That(serviceDescriptor.Lifetime).IsEqualTo(lifetime);
+		await Assert.That(serviceDescriptor.ImplementationType).IsEqualTo(type);
+
+		var provider = services.BuildServiceProvider();
+		var options = provider.GetRequiredService<IOptions<RequestDispatcherOptions>>().Value;
+		var handlers = options.GetRequestHandlers<IScalarRequestHandler<TestRequest, string>>(provider);
+
+		await Assert.That(handlers).Count().IsEqualTo(1);
+	}
+
+	[Test]
+	public async Task I_can_add_an_enumerable_of_types_and_register_the_options()
+	{
+		var services = new ServiceCollection();
+		var builder = services.AddRequestDispatcher();
+		var types = new[] { typeof(TestHandler), typeof(AnotherTestHandler) };
+
+		builder.Add(types);
+
+		var provider = services.BuildServiceProvider();
+		var options = provider.GetRequiredService<IOptions<RequestDispatcherOptions>>().Value;
+
+		var handlers1 = options.GetRequestHandlers<IScalarRequestHandler<TestRequest, string>>(provider);
+		await Assert.That(handlers1).Count().IsEqualTo(1);
+		await Assert.That(handlers1.First()).IsTypeOf<TestHandler>();
+
+		var handlers2 = options.GetRequestHandlers<IScalarRequestHandler<AnotherTestRequest, string>>(provider);
+		await Assert.That(handlers2).Count().IsEqualTo(1);
+		await Assert.That(handlers2.First()).IsTypeOf<AnotherTestHandler>();
+	}
+
+	[Test]
+	public async Task I_can_add_an_enumerable_of_types_with_a_lifetime_and_register_the_options_and_services()
+	{
+		var services = new ServiceCollection();
+		var builder = services.AddRequestDispatcher();
+		var types = new[] { typeof(TestHandler), typeof(AnotherTestHandler) };
+		var lifetime = ServiceLifetime.Singleton;
+
+		builder.Add(types, lifetime);
+
+		foreach (var type in types)
+		{
+			var serviceDescriptor = services.FirstOrDefault(sd => sd.ServiceType == type);
+			await Assert.That(serviceDescriptor).IsNotNull();
+			await Assert.That(serviceDescriptor.Lifetime).IsEqualTo(lifetime);
+		}
+
+		var provider = services.BuildServiceProvider();
+		var options = provider.GetRequiredService<IOptions<RequestDispatcherOptions>>().Value;
+
+		await Assert.That(options.GetRequestHandlers<IScalarRequestHandler<TestRequest, string>>(provider)).Count().IsEqualTo(1);
+		await Assert.That(options.GetRequestHandlers<IScalarRequestHandler<AnotherTestRequest, string>>(provider)).Count().IsEqualTo(1);
+	}
+
+	[Test]
+	public async Task I_can_see_it_throw_when_the_builder_is_null()
+	{
+		IRequestDispatcherBuilder builder = null!;
+
+		using (Assert.Multiple())
+		{
+			await Assert.That(() => builder.Add(typeof(TestHandler))).Throws<ArgumentNullException>();
+			await Assert.That(() => builder.Add(typeof(TestHandler), ServiceLifetime.Transient))
+				.Throws<ArgumentNullException>();
+			await Assert.That(() => builder.Add([typeof(TestHandler)])).Throws<ArgumentNullException>();
+			await Assert.That(() => builder.Add([typeof(TestHandler)], ServiceLifetime.Transient))
+				.Throws<ArgumentNullException>();
+		}
+	}
+
+	[Test]
+	public async Task I_can_get_an_exception_when_adding_a_nested_request_handler()
+	{
+		var services = new ServiceCollection();
+		var builder = services.AddRequestDispatcher();
+		var assembly = Roslyn.Compile(options =>
+		{
+			options.AddFromEmbeddedSource("BuilderNestedHandler.cs");
+		});
+		var nestedHandlerType = assembly.GetType("Sample.Container+PingHandler", throwOnError: true)!;
+
+		var exception = await Assert.That(() => builder.Add(nestedHandlerType)).Throws<InvalidOperationException>();
+		await Assert.That(exception?.Message).Contains(nestedHandlerType.FullName!);
+	}
+
+	[Test]
+	public async Task I_can_get_an_exception_when_adding_nested_request_handlers_with_a_lifetime()
+	{
+		var services = new ServiceCollection();
+		var builder = services.AddRequestDispatcher();
+		var assembly = Roslyn.Compile(options =>
+		{
+			options.AddFromEmbeddedSource("BuilderNestedHandler.cs");
+		});
+		var nestedHandlerType = assembly.GetType("Sample.Container+PingHandler", throwOnError: true)!;
+
+		var exception = await Assert
+			.That(() => builder.Add([typeof(TestHandler), nestedHandlerType], ServiceLifetime.Transient))
+			.Throws<InvalidOperationException>();
+		await Assert.That(exception?.Message).Contains(nestedHandlerType.FullName!);
+	}
+}

src/request.dispatcher.tests/ScalarBehaviourTests.cs

@@ -0,0 +1,111 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal sealed class ScalarBehaviourTests
+{
+	[Test]
+	public async Task I_can_execute_the_closed_behaviour()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<ScalarTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ScalarTestHandler))
+			.Add(typeof(ScalarTestBehavior)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<ScalarTestTracker>();
+
+		var request = new ScalarTestRequest { Value = "Hello" };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Hello-Handled");
+		await Assert.That(tracker.Executed).IsTrue();
+	}
+
+	[Test]
+	public async Task I_can_execute_the_open_behaviour()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<ScalarTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ScalarTestHandler))
+			.Add(typeof(ScalarOpenBehavior<,>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<ScalarTestTracker>();
+
+		var request = new ScalarTestRequest { Value = "Hello" };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Hello-Handled");
+		await Assert.That(tracker.Executed).IsTrue();
+	}
+
+	[Test]
+	public async Task I_can_chain_the_behaviours_in_order()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<ScalarTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ScalarTestHandler))
+			.Add(typeof(ScalarChainedBehaviour1))
+			.Add(typeof(ScalarChainedBehaviour2)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<ScalarTestTracker>();
+
+		var request = new ScalarTestRequest { Value = "Hello" };
+		await dispatcher.DispatchAsync(request);
+
+		// They are discovered in the order they appear in the assembly.
+		// In this file: ChainedBehaviour1, ChainedBehaviour2
+		await Assert.That(tracker.Log).Count().IsEqualTo(2);
+		await Assert.That(tracker.Log[0]).IsEquivalentTo("Behaviour1");
+		await Assert.That(tracker.Log[1]).IsEquivalentTo("Behaviour2");
+	}
+
+	[Test]
+	public async Task I_can_work_with_a_generic_wrapper_request_and_the_open_behaviour()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<ScalarTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ScalarTestWrapperHandler<>))
+			.Add(typeof(ScalarWrapperBehavior<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<ScalarTestTracker>();
+
+		var request = new ScalarTestWrapperRequest<int> { Item = 42 };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Handled-42");
+		await Assert.That(tracker.Executed).IsTrue();
+	}
+
+	[Test]
+	public async Task I_can_maintain_the_ordering_between_open_and_closed_behaviours()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<ScalarTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ScalarTestHandler))
+			.Add(typeof(ScalarOrderingOpenBehavior<,>))
+			.Add(typeof(ScalarOrderingClosedBehavior)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<ScalarTestTracker>();
+
+		var request = new ScalarTestRequest { Value = "Order" };
+		await dispatcher.DispatchAsync(request);
+
+		await Assert.That(tracker.Log).Contains("OrderingOpen");
+		await Assert.That(tracker.Log).Contains("OrderingClosed");
+	}
+}
+
+// Moved to _fixtures

src/request.dispatcher.tests/ScalarDispatcherTests.cs

@@ -0,0 +1,251 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal sealed class ScalarDispatcherTests
+{
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_open_generic_handler()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(OpenScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new OpenScalarRequest { Data = "Hello" };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Hello-Handled");
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_open_generic_handler_that_has_constraints()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ConstrainedScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new ConstrainedScalarRequest { Value = 123 };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("123-Constrained");
+	}
+
+	[Test]
+	public async Task I_can_see_it_fail_if_no_handler_is_found_even_with_an_open_generic_available()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(OpenScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new UnhandledScalarRequest();
+		await Assert.ThrowsAsync<InvalidOperationException>(async () => await dispatcher.DispatchAsync(request));
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_inherited_request()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(OpenScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		// InheritedScalarRequest : OpenScalarRequest.
+		// There is no Handler<InheritedScalarRequest> but there is OpenScalarHandler<TRequest> where TRequest : OpenScalarRequest.
+		// It should be able to handle InheritedScalarRequest.
+		var request = new InheritedScalarRequest { Data = "Sub" };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Sub-Handled");
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_inherited_handler()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(DerivedScalarHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new DerivedScalarRequest { Value = 42 };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Derived: 42");
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_interface_inherited_request()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(InterfaceInheritedScalarHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new InterfaceInheritedScalarRequest { Name = "InterfaceTest" };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("InterfaceTest-InterfaceHandled");
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_deep_inheritance_in_the_request()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(OpenScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new DeepDerivedScalarRequest { Data = "Deep", DeepValue = 99 };
+		var result = await dispatcher.DispatchAsync(request);
+
+		// OpenScalarHandler<TRequest> where TRequest : OpenScalarRequest should handle this
+		await Assert.That(result).IsEquivalentTo("Deep-Handled");
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_interface_constrained_handler()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(InterfaceInheritedScalarHandler))
+			.Add(typeof(InterfaceConstrainedScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new InterfaceInheritedScalarRequest { Name = "Constrained" };
+		var result = await dispatcher.DispatchAsync(request);
+
+		// Both InterfaceInheritedScalarHandler and InterfaceConstrainedScalarHandler could match.
+		// InterfaceInheritedScalarHandler is a concrete match for InterfaceInheritedScalarRequest.
+		// InterfaceConstrainedScalarHandler is an open generic match.
+		// Currently Dispatcher.SendAsync checks concrete handlers first.
+		await Assert.That(result).IsEquivalentTo("Constrained-InterfaceHandled");
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_interface_only_match()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(InterfaceConstrainedScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new AnotherNamedScalarRequest { Name = "InterfaceOnly" };
+		var result = await dispatcher.DispatchAsync(request);
+
+		// No concrete handler for AnotherNamedScalarRequest, but InterfaceConstrainedScalarHandler<T> where T : INamedScalarRequest matches.
+		await Assert.That(result).IsEquivalentTo("InterfaceOnly-ConstrainedByInterface");
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_a_nested_generic_request()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(WrapperScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new WrapperScalarRequest<int> { Item = 42 };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Handled-42");
+	}
+
+	[Test]
+	public async Task I_can_handle_multiple_interface_implementations()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(MultiInterfaceScalarHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new MultiInterfaceScalarRequest();
+		var result1 = await dispatcher.DispatchAsync<int>(request);
+		var result2 = await dispatcher.DispatchAsync<string>(request);
+
+		await Assert.That(result1).IsEqualTo(1);
+		await Assert.That(result2).IsEquivalentTo("One");
+	}
+
+	[Test]
+	public async Task I_can_see_it_fail_if_there_are_ambiguous_handle_methods()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(AmbiguousScalarHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new AmbiguousScalarRequest();
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Interface-Handled");
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_a_generic_interface_explicit_implementation()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ExplicitGenericScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new ExplicitGenericScalarRequest { Value = "Explicit" };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Explicit-ExplicitHandled");
+	}
+
+	[Test]
+	public async Task I_can_see_it_throw_the_original_exception()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(FailingScalarHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new FailingScalarRequest();
+		var ex = await Assert.That(async () => await dispatcher.DispatchAsync(request)).Throws<InvalidOperationException>();
+
+		using (Assert.Multiple())
+		{
+			await Assert.That(ex?.Message).IsEquivalentTo("Handler failed");
+			// Assert that the stack trace contains the handler's method name,
+			// which proves the exception was rethrown while preserving its origin.
+			await Assert.That(ex?.StackTrace).Contains(nameof(FailingScalarHandler.HandleAsync));
+		}
+	}
+
+	[Test]
+	public async Task I_can_see_it_throw_if_dispatcher_options_are_modified_after_build()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(FailingScalarHandler)));
+		var provider = sc.BuildServiceProvider();
+		var options = provider.GetRequiredService<IOptions<RequestDispatcherOptions>>().Value;
+		options.GetRequestBehaviors<IScalarRequestHandler<FailingScalarRequest, string>>(default!);
+
+		await Assert.That(() => options.Inspect([])).Throws<InvalidOperationException>();
+	}
+}
+
+// Moved to _fixtures

src/request.dispatcher.tests/SearchHandlerInAssemblyTests.cs

@@ -0,0 +1,70 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using System.Collections;
+
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal sealed class SearchHandlerInAssemblyTests
+{
+	[Test]
+	public async Task I_can_search_handlers_in_an_assembly()
+	{
+		var assembly = Roslyn.Compile(options => options.AddFromEmbeddedSource("SearchTopLevelHandler.cs"));
+
+		var services = new ServiceCollection();
+		services.AddRequestDispatcher(builder => builder
+			.SearchHandlerInAssembly(assembly));
+		await using var provider = services.BuildServiceProvider();
+		var options = provider.GetRequiredService<IOptions<RequestDispatcherOptions>>().Value;
+		var requestType = assembly.GetType("Sample.Ping", throwOnError: true)!;
+		var handlerType = assembly.GetType("Sample.PingHandler", throwOnError: true)!;
+		var handlerInterface = typeof(IScalarRequestHandler<,>).MakeGenericType(requestType, typeof(string));
+		var handlers = GetRequestHandlers(options, handlerInterface, provider).ToArray();
+
+		using var scope = Assert.Multiple();
+		await Assert.That(handlers).Count().IsEqualTo(1);
+		await Assert.That(handlers.Single()!.GetType()).IsEqualTo(handlerType);
+	}
+
+	[Test]
+	public async Task I_can_search_handlers_in_an_assembly_with_a_lifetime()
+	{
+		var assembly = Roslyn.Compile(options => options.AddFromEmbeddedSource("SearchTopLevelHandler.cs"));
+
+		var services = new ServiceCollection();
+		services.AddRequestDispatcher(builder => builder
+			.SearchHandlerInAssembly(assembly, ServiceLifetime.Singleton));
+		var handlerType = assembly.GetType("Sample.PingHandler", throwOnError: true)!;
+		var descriptor = services.SingleOrDefault(service => service.ServiceType == handlerType);
+
+		using var scope = Assert.Multiple();
+		await Assert.That(descriptor).IsNotNull();
+		await Assert.That(descriptor!.Lifetime).IsEqualTo(ServiceLifetime.Singleton);
+	}
+
+	[Test]
+	public async Task I_can_get_an_exception_when_nested_handlers_are_present()
+	{
+		var assembly = Roslyn.Compile(options => options.AddFromEmbeddedSource("SearchNestedHandler.cs"));
+
+		var services = new ServiceCollection();
+		var builder = services.AddRequestDispatcher();
+
+		await Assert.That(() => builder.SearchHandlerInAssembly(assembly))
+			.Throws<InvalidOperationException>().And.HasMessageContaining("Sample.Container+PingHandler");
+	}
+
+	private static IEnumerable<object?> GetRequestHandlers(RequestDispatcherOptions options, Type handlerInterface,
+		IServiceProvider provider)
+	{
+		return ((IEnumerable)typeof(RequestDispatcherOptions)
+				.GetMethod(nameof(RequestDispatcherOptions.GetRequestHandlers))!
+				.MakeGenericMethod(handlerInterface)
+				.Invoke(options, [provider])!)
+			.Cast<object?>();
+	}
+}

src/request.dispatcher.tests/StreamBehaviourTests.cs

@@ -0,0 +1,110 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal sealed class StreamBehaviourTests
+{
+	[Test]
+	public async Task I_can_execute_the_closed_behaviour()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<StreamTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(StreamTestHandler))
+			.Add(typeof(StreamTestBehavior)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<StreamTestTracker>();
+
+		var request = new StreamTestRequest { Value = "Hello" };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Hello-Handled-0", "Hello-Handled-1"]);
+		await Assert.That(tracker.Executed).IsTrue();
+	}
+
+	[Test]
+	public async Task I_can_execute_the_open_behaviour()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<StreamTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(StreamTestHandler))
+			.Add(typeof(StreamOpenBehavior<,>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<StreamTestTracker>();
+
+		var request = new StreamTestRequest { Value = "Hello" };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Hello-Handled-0", "Hello-Handled-1"]);
+		await Assert.That(tracker.Executed).IsTrue();
+	}
+
+	[Test]
+	public async Task I_can_chain_the_behaviours_in_order()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<StreamTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(StreamTestHandler))
+			.Add(typeof(StreamChainedBehaviour1))
+			.Add(typeof(StreamChainedBehaviour2)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<StreamTestTracker>();
+
+		var request = new StreamTestRequest { Value = "Hello" };
+		await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(tracker.Log).Count().IsEqualTo(2);
+		await Assert.That(tracker.Log[0]).IsEquivalentTo("Behaviour1");
+		await Assert.That(tracker.Log[1]).IsEquivalentTo("Behaviour2");
+	}
+
+	[Test]
+	public async Task I_can_work_with_a_generic_wrapper_request_and_the_open_behaviour()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<StreamTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(StreamTestWrapperHandler<>))
+			.Add(typeof(StreamWrapperBehavior<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<StreamTestTracker>();
+
+		var request = new StreamTestWrapperRequest<int> { Item = 42 };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Handled-42-0", "Handled-42-1"]);
+		await Assert.That(tracker.Executed).IsTrue();
+	}
+
+	[Test]
+	public async Task I_can_maintain_the_ordering_between_open_and_closed_behaviours()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<StreamTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(StreamTestHandler))
+			.Add(typeof(StreamOrderingOpenBehavior<,>))
+			.Add(typeof(StreamOrderingClosedBehavior)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<StreamTestTracker>();
+
+		var request = new StreamTestRequest { Value = "Order" };
+		await dispatcher.DispatchAsync(request).ToListAsync();
+
+		var log = tracker.Log.ToList();
+		await Assert.That(log).Contains("Open");
+		await Assert.That(log).Contains("Closed");
+	}
+}
+
+// Moved to _fixtures

src/request.dispatcher.tests/StreamDispatcherTests.cs

@@ -0,0 +1,243 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class StreamDispatcherTests
+{
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_open_generic_handler()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(OpenStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new OpenStreamRequest { Data = "Hello" };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Hello-Stream-0", "Hello-Stream-1"]);
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_open_generic_handler_that_has_constraints()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ConstrainedStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new ConstrainedStreamRequest { Value = 123 };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["123-Constrained-0", "123-Constrained-1"]);
+	}
+
+	[Test]
+	public async Task I_can_see_it_fail_if_no_handler_is_found_even_with_an_open_generic_available()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(OpenStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new UnhandledStreamRequest();
+		await Assert.ThrowsAsync<InvalidOperationException>(async () => await dispatcher.DispatchAsync(request).FirstOrDefaultAsync().AsTask());
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_inherited_request()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(OpenStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new InheritedStreamRequest { Data = "Sub" };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Sub-Stream-0", "Sub-Stream-1"]);
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_inherited_handler()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(DerivedStreamHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new DerivedStreamRequest { Value = 42 };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Derived: 42-0", "Derived: 42-1"]);
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_interface_inherited_request()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(InterfaceInheritedStreamHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new InterfaceInheritedStreamRequest { Name = "InterfaceTest" };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["InterfaceTest-InterfaceHandled-0", "InterfaceTest-InterfaceHandled-1"]);
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_deep_inheritance_in_the_request()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(OpenStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new DeepDerivedStreamRequest { Data = "Deep", DeepValue = 99 };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Deep-Stream-0", "Deep-Stream-1"]);
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_interface_constrained_handler()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(InterfaceInheritedStreamHandler))
+			.Add(typeof(InterfaceConstrainedStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new InterfaceInheritedStreamRequest { Name = "Constrained" };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		// Both InterfaceInheritedStreamHandler and InterfaceConstrainedStreamHandler could match.
+		// InterfaceInheritedStreamHandler is a concrete match for InterfaceInheritedStreamRequest.
+		// InterfaceConstrainedStreamHandler is an open generic match.
+		// Currently Dispatcher checks concrete handlers first.
+		await Assert.That(results).IsEquivalentTo(["Constrained-InterfaceHandled-0", "Constrained-InterfaceHandled-1"]);
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_interface_only_match()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(InterfaceConstrainedStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new AnotherNamedStreamRequest { Name = "InterfaceOnly" };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["InterfaceOnly-ConstrainedByInterface-0", "InterfaceOnly-ConstrainedByInterface-1"]);
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_a_nested_generic_request()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(WrapperStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new WrapperStreamRequest<int> { Item = 42 };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Handled-42-0", "Handled-42-1"]);
+	}
+
+	[Test]
+	public async Task I_can_handle_multiple_interface_implementations()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(MultiInterfaceStreamHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new MultiInterfaceStreamRequest();
+
+		var results1 = await dispatcher.DispatchAsync<int>(request).ToListAsync();
+		var results2 = await dispatcher.DispatchAsync<string>(request).ToListAsync();
+
+		await Assert.That(results1).IsEquivalentTo([1, 2]);
+		await Assert.That(results2).IsEquivalentTo(["One", "Two"]);
+	}
+
+	[Test]
+	public async Task I_can_see_it_fail_if_there_are_ambiguous_handle_methods()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(AmbiguousStreamHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new AmbiguousStreamRequest();
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Interface-Handled"]);
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_a_generic_interface_explicit_implementation()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ExplicitGenericStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new ExplicitGenericStreamRequest { Value = "Explicit" };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Explicit-ExplicitHandled"]);
+	}
+
+	[Test]
+	public async Task I_can_see_it_throw_the_original_exception()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(FailingStreamHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new FailingStreamRequest();
+		var enumerable = dispatcher.DispatchAsync(request);
+		var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await enumerable.ToListAsync().AsTask());
+
+		using (Assert.Multiple())
+		{
+			await Assert.That(ex?.Message).IsEquivalentTo("Handler failed");
+			await Assert.That(ex?.StackTrace).Contains(nameof(FailingStreamHandler.HandleAsync));
+		}
+	}
+
+	[Test]
+	public async Task I_can_see_it_throw_if_dispatcher_options_are_modified_after_build()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(FailingStreamHandler)));
+		var provider = sc.BuildServiceProvider();
+		var options = provider.GetRequiredService<Microsoft.Extensions.Options.IOptions<RequestDispatcherOptions>>().Value;
+		options.GetRequestHandlers<IStreamRequestHandler<FailingStreamRequest, string>>(default!);
+
+		await Assert.That(() => options.Inspect([])).Throws<InvalidOperationException>();
+	}
+}

src/request.dispatcher.tests/_fixtures/AmbiguousScalarHandler.cs

@@ -0,0 +1,19 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class AmbiguousScalarHandler : IScalarRequestHandler<AmbiguousScalarRequest, string>
+{
+	// Public method with the same name and signature
+	public Task<string> HandleAsync(AmbiguousScalarRequest request, CancellationToken ct)
+	{
+		return Task.FromResult("Public-Handled");
+	}
+
+	// Explicit interface implementation
+	Task<string> IScalarRequestHandler<AmbiguousScalarRequest, string>.HandleAsync(AmbiguousScalarRequest request, CancellationToken ct)
+	{
+		return Task.FromResult("Interface-Handled");
+	}
+}

src/request.dispatcher.tests/_fixtures/AmbiguousScalarRequest.cs

@@ -0,0 +1,8 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class AmbiguousScalarRequest : IScalarRequest<string>
+{
+}

src/request.dispatcher.tests/_fixtures/AmbiguousStreamHandler.cs

@@ -0,0 +1,19 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class AmbiguousStreamHandler : IStreamRequestHandler<AmbiguousStreamRequest, string>
+{
+	// Public method with the same name and signature
+	public async IAsyncEnumerable<string> HandleAsync(AmbiguousStreamRequest request, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
+	{
+		yield return "Public-Handled";
+	}
+
+	// Explicit interface implementation
+	async IAsyncEnumerable<string> IStreamRequestHandler<AmbiguousStreamRequest, string>.HandleAsync(AmbiguousStreamRequest request, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
+	{
+		yield return "Interface-Handled";
+	}
+}

src/request.dispatcher.tests/_fixtures/AmbiguousStreamRequest.cs

@@ -0,0 +1,8 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class AmbiguousStreamRequest : IStreamRequest<string>
+{
+}

src/request.dispatcher.tests/_fixtures/AnotherNamedScalarRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class AnotherNamedScalarRequest : INamedScalarRequest
+{
+	public string Name { get; set; } = string.Empty;
+}

src/request.dispatcher.tests/_fixtures/AnotherNamedStreamRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class AnotherNamedStreamRequest : INamedStreamRequest
+{
+	public string Name { get; set; } = string.Empty;
+}

src/request.dispatcher.tests/_fixtures/AnotherTestHandler.cs

@@ -0,0 +1,12 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal sealed class AnotherTestHandler : IScalarRequestHandler<AnotherTestRequest, string>
+{
+	public Task<string> HandleAsync(AnotherTestRequest request, CancellationToken ct)
+	{
+		return Task.FromResult("ok");
+	}
+}

src/request.dispatcher.tests/_fixtures/AnotherTestRequest.cs

@@ -0,0 +1,6 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal sealed class AnotherTestRequest : IScalarRequest<string> { }

src/request.dispatcher.tests/_fixtures/BaseScalarHandler.cs

@@ -0,0 +1,10 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public abstract class BaseScalarHandler<TRequest> : IScalarRequestHandler<TRequest, string>
+	where TRequest : IScalarRequest<string>
+{
+	public abstract Task<string> HandleAsync(TRequest request, CancellationToken cancellationToken);
+}

src/request.dispatcher.tests/_fixtures/BaseStreamHandler.cs

@@ -0,0 +1,10 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public abstract class BaseStreamHandler<TRequest> : IStreamRequestHandler<TRequest, string>
+	where TRequest : IStreamRequest<string>
+{
+	public abstract IAsyncEnumerable<string> HandleAsync(TRequest request, CancellationToken cancellationToken);
+}

src/request.dispatcher.tests/_fixtures/ConstrainedScalarHandler.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ConstrainedScalarHandler<TRequest> : IScalarRequestHandler<TRequest, string>
+	where TRequest : ConstrainedScalarRequest
+{
+	public Task<string> HandleAsync(TRequest request, CancellationToken cancellationToken)
+	{
+		return Task.FromResult($"{request.Value}-Constrained");
+	}
+}

src/request.dispatcher.tests/_fixtures/ConstrainedScalarRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ConstrainedScalarRequest : IScalarRequest<string>
+{
+	public int Value { get; set; }
+}

src/request.dispatcher.tests/_fixtures/ConstrainedStreamHandler.cs

@@ -0,0 +1,14 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ConstrainedStreamHandler<TRequest> : IStreamRequestHandler<TRequest, string>
+	where TRequest : ConstrainedStreamRequest
+{
+	public async IAsyncEnumerable<string> HandleAsync(TRequest request, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
+	{
+		yield return $"{request.Value}-Constrained-0";
+		yield return $"{request.Value}-Constrained-1";
+	}
+}

src/request.dispatcher.tests/_fixtures/ConstrainedStreamRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ConstrainedStreamRequest : IStreamRequest<string>
+{
+	public int Value { get; set; }
+}

src/request.dispatcher.tests/_fixtures/DeepDerivedScalarRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class DeepDerivedScalarRequest : InheritedScalarRequest
+{
+	public int DeepValue { get; set; }
+}

src/request.dispatcher.tests/_fixtures/DeepDerivedStreamRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class DeepDerivedStreamRequest : InheritedStreamRequest
+{
+	public int DeepValue { get; set; }
+}

src/request.dispatcher.tests/_fixtures/DerivedScalarHandler.cs

@@ -0,0 +1,12 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class DerivedScalarHandler : BaseScalarHandler<DerivedScalarRequest>
+{
+	public override Task<string> HandleAsync(DerivedScalarRequest request, CancellationToken cancellationToken)
+	{
+		return Task.FromResult($"Derived: {request.Value}");
+	}
+}

src/request.dispatcher.tests/_fixtures/DerivedScalarRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class DerivedScalarRequest : IScalarRequest<string>
+{
+	public int Value { get; set; }
+}

src/request.dispatcher.tests/_fixtures/DerivedStreamHandler.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class DerivedStreamHandler : BaseStreamHandler<DerivedStreamRequest>
+{
+	public override async IAsyncEnumerable<string> HandleAsync(DerivedStreamRequest request, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
+	{
+		yield return $"Derived: {request.Value}-0";
+		yield return $"Derived: {request.Value}-1";
+	}
+}

src/request.dispatcher.tests/_fixtures/DerivedStreamRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class DerivedStreamRequest : IStreamRequest<string>
+{
+	public int Value { get; set; }
+}

src/request.dispatcher.tests/_fixtures/ExplicitGenericScalarHandler.cs

@@ -0,0 +1,12 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ExplicitGenericScalarHandler<T> : IScalarRequestHandler<ExplicitGenericScalarRequest, string>
+{
+	Task<string> IScalarRequestHandler<ExplicitGenericScalarRequest, string>.HandleAsync(ExplicitGenericScalarRequest request, CancellationToken ct)
+	{
+		return Task.FromResult($"{request.Value}-ExplicitHandled");
+	}
+}

src/request.dispatcher.tests/_fixtures/ExplicitGenericScalarRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ExplicitGenericScalarRequest : IScalarRequest<string>
+{
+	public string Value { get; set; } = string.Empty;
+}

src/request.dispatcher.tests/_fixtures/ExplicitGenericStreamHandler.cs

@@ -0,0 +1,12 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ExplicitGenericStreamHandler<T> : IStreamRequestHandler<ExplicitGenericStreamRequest, string>
+{
+	async IAsyncEnumerable<string> IStreamRequestHandler<ExplicitGenericStreamRequest, string>.HandleAsync(ExplicitGenericStreamRequest request, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken ct)
+	{
+		yield return $"{request.Value}-ExplicitHandled";
+	}
+}

src/request.dispatcher.tests/_fixtures/ExplicitGenericStreamRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ExplicitGenericStreamRequest : IStreamRequest<string>
+{
+	public string Value { get; set; } = string.Empty;
+}

src/request.dispatcher.tests/_fixtures/FailingScalarHandler.cs

@@ -0,0 +1,12 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class FailingScalarHandler : IScalarRequestHandler<FailingScalarRequest, string>
+{
+	public Task<string> HandleAsync(FailingScalarRequest request, CancellationToken cancellationToken)
+	{
+		throw new InvalidOperationException("Handler failed");
+	}
+}

src/request.dispatcher.tests/_fixtures/FailingScalarRequest.cs

@@ -0,0 +1,8 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class FailingScalarRequest : IScalarRequest<string>
+{
+}

src/request.dispatcher.tests/_fixtures/FailingStreamHandler.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class FailingStreamHandler : IStreamRequestHandler<FailingStreamRequest, string>
+{
+	public async IAsyncEnumerable<string> HandleAsync(FailingStreamRequest request, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
+	{
+		yield return "Wait for it...";
+		throw new InvalidOperationException("Handler failed");
+	}
+}

src/request.dispatcher.tests/_fixtures/FailingStreamRequest.cs

@@ -0,0 +1,8 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class FailingStreamRequest : IStreamRequest<string>
+{
+}

src/request.dispatcher.tests/_fixtures/INamedScalarRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public interface INamedScalarRequest : IScalarRequest<string>
+{
+	string Name { get; }
+}

src/request.dispatcher.tests/_fixtures/INamedStreamRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public interface INamedStreamRequest : IStreamRequest<string>
+{
+	string Name { get; }
+}

src/request.dispatcher.tests/_fixtures/InheritedScalarRequest.cs

@@ -0,0 +1,8 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class InheritedScalarRequest : OpenScalarRequest
+{
+}

src/request.dispatcher.tests/_fixtures/InheritedStreamRequest.cs

@@ -0,0 +1,8 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class InheritedStreamRequest : OpenStreamRequest
+{
+}

src/request.dispatcher.tests/_fixtures/InterfaceConstrainedScalarHandler.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class InterfaceConstrainedScalarHandler<TRequest> : IScalarRequestHandler<TRequest, string>
+	where TRequest : INamedScalarRequest
+{
+	public Task<string> HandleAsync(TRequest request, CancellationToken cancellationToken)
+	{
+		return Task.FromResult($"{request.Name}-ConstrainedByInterface");
+	}
+}

src/request.dispatcher.tests/_fixtures/InterfaceConstrainedStreamHandler.cs

@@ -0,0 +1,14 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class InterfaceConstrainedStreamHandler<TRequest> : IStreamRequestHandler<TRequest, string>
+	where TRequest : INamedStreamRequest
+{
+	public async IAsyncEnumerable<string> HandleAsync(TRequest request, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
+	{
+		yield return $"{request.Name}-ConstrainedByInterface-0";
+		yield return $"{request.Name}-ConstrainedByInterface-1";
+	}
+}

src/request.dispatcher.tests/_fixtures/InterfaceInheritedScalarHandler.cs

@@ -0,0 +1,12 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class InterfaceInheritedScalarHandler : IScalarRequestHandler<InterfaceInheritedScalarRequest, string>
+{
+	public Task<string> HandleAsync(InterfaceInheritedScalarRequest request, CancellationToken cancellationToken)
+	{
+		return Task.FromResult($"{request.Name}-InterfaceHandled");
+	}
+}

src/request.dispatcher.tests/_fixtures/InterfaceInheritedScalarRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class InterfaceInheritedScalarRequest : INamedScalarRequest
+{
+	public string Name { get; set; } = string.Empty;
+}

src/request.dispatcher.tests/_fixtures/InterfaceInheritedStreamHandler.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class InterfaceInheritedStreamHandler : IStreamRequestHandler<InterfaceInheritedStreamRequest, string>
+{
+	public async IAsyncEnumerable<string> HandleAsync(InterfaceInheritedStreamRequest request, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
+	{
+		yield return $"{request.Name}-InterfaceHandled-0";
+		yield return $"{request.Name}-InterfaceHandled-1";
+	}
+}

src/request.dispatcher.tests/_fixtures/InterfaceInheritedStreamRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class InterfaceInheritedStreamRequest : INamedStreamRequest
+{
+	public string Name { get; set; } = string.Empty;
+}

src/request.dispatcher.tests/_fixtures/MultiInterfaceScalarHandler.cs

@@ -0,0 +1,17 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class MultiInterfaceScalarHandler : IScalarRequestHandler<MultiInterfaceScalarRequest, int>, IScalarRequestHandler<MultiInterfaceScalarRequest, string>
+{
+	public Task<int> HandleAsync(MultiInterfaceScalarRequest request, CancellationToken cancellationToken)
+	{
+		return Task.FromResult(1);
+	}
+
+	Task<string> IScalarRequestHandler<MultiInterfaceScalarRequest, string>.HandleAsync(MultiInterfaceScalarRequest request, CancellationToken ct)
+	{
+		return Task.FromResult("One");
+	}
+}

src/request.dispatcher.tests/_fixtures/MultiInterfaceScalarRequest.cs

@@ -0,0 +1,8 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class MultiInterfaceScalarRequest : IScalarRequest<int>, IScalarRequest<string>
+{
+}

src/request.dispatcher.tests/_fixtures/MultiInterfaceStreamHandler.cs

@@ -0,0 +1,19 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class MultiInterfaceStreamHandler : IStreamRequestHandler<MultiInterfaceStreamRequest, int>, IStreamRequestHandler<MultiInterfaceStreamRequest, string>
+{
+	public async IAsyncEnumerable<int> HandleAsync(MultiInterfaceStreamRequest request, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
+	{
+		yield return 1;
+		yield return 2;
+	}
+
+	async IAsyncEnumerable<string> IStreamRequestHandler<MultiInterfaceStreamRequest, string>.HandleAsync(MultiInterfaceStreamRequest request, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken ct)
+	{
+		yield return "One";
+		yield return "Two";
+	}
+}

src/request.dispatcher.tests/_fixtures/MultiInterfaceStreamRequest.cs

@@ -0,0 +1,8 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class MultiInterfaceStreamRequest : IStreamRequest<int>, IStreamRequest<string>
+{
+}

src/request.dispatcher.tests/_fixtures/OpenScalarHandler.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class OpenScalarHandler<TRequest> : IScalarRequestHandler<TRequest, string>
+where TRequest : OpenScalarRequest
+{
+	public Task<string> HandleAsync(TRequest request, CancellationToken cancellationToken)
+	{
+		return Task.FromResult($"{request.Data}-Handled");
+	}
+}

src/request.dispatcher.tests/_fixtures/OpenScalarRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class OpenScalarRequest : IScalarRequest<string>
+{
+	public string Data { get; set; } = string.Empty;
+}

src/request.dispatcher.tests/_fixtures/OpenStreamHandler.cs

@@ -0,0 +1,14 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class OpenStreamHandler<TRequest> : IStreamRequestHandler<TRequest, string>
+	where TRequest : OpenStreamRequest
+{
+	public async IAsyncEnumerable<string> HandleAsync(TRequest request, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
+	{
+		yield return $"{request.Data}-Stream-0";
+		yield return $"{request.Data}-Stream-1";
+	}
+}

src/request.dispatcher.tests/_fixtures/OpenStreamRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class OpenStreamRequest : IStreamRequest<string>
+{
+	public string Data { get; set; } = string.Empty;
+}

src/request.dispatcher.tests/_fixtures/ScalarChainedBehaviour1.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ScalarChainedBehaviour1(ScalarTestTracker tracker) : IScalarRequestBehavior<ScalarTestRequest, string>
+{
+	public async Task<string> HandleAsync(ScalarTestRequest request, ScalarHandlerDelegate<string> next, CancellationToken cancellationToken)
+	{
+		tracker.Log.Add("Behaviour1");
+		return await next(request, cancellationToken);
+	}
+}

src/request.dispatcher.tests/_fixtures/ScalarChainedBehaviour2.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ScalarChainedBehaviour2(ScalarTestTracker tracker) : IScalarRequestBehavior<ScalarTestRequest, string>
+{
+	public async Task<string> HandleAsync(ScalarTestRequest request, ScalarHandlerDelegate<string> next, CancellationToken cancellationToken)
+	{
+		tracker.Log.Add("Behaviour2");
+		return await next(request, cancellationToken);
+	}
+}

src/request.dispatcher.tests/_fixtures/ScalarOpenBehavior.cs

@@ -0,0 +1,14 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ScalarOpenBehavior<TRequest, TResponse>(ScalarTestTracker tracker) : IScalarRequestBehavior<TRequest, TResponse>
+where TRequest : IScalarRequest<TResponse>
+{
+	public async Task<TResponse> HandleAsync(TRequest request, ScalarHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
+	{
+		tracker.Executed = true;
+		return await next(request, cancellationToken);
+	}
+}

src/request.dispatcher.tests/_fixtures/ScalarOrderingClosedBehavior.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ScalarOrderingClosedBehavior(ScalarTestTracker tracker) : IScalarRequestBehavior<ScalarTestRequest, string>
+{
+	public Task<string> HandleAsync(ScalarTestRequest request, ScalarHandlerDelegate<string> next, CancellationToken cancellationToken)
+	{
+		tracker.Log.Add("OrderingClosed");
+		return next(request, cancellationToken);
+	}
+}

src/request.dispatcher.tests/_fixtures/ScalarOrderingOpenBehavior.cs

@@ -0,0 +1,14 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ScalarOrderingOpenBehavior<TRequest, TOutput>(ScalarTestTracker tracker) : IScalarRequestBehavior<TRequest, TOutput>
+where TRequest : IScalarRequest<TOutput>
+{
+	public Task<TOutput> HandleAsync(TRequest request, ScalarHandlerDelegate<TOutput> next, CancellationToken cancellationToken)
+	{
+		tracker.Log.Add("OrderingOpen");
+		return next(request, cancellationToken);
+	}
+}

src/request.dispatcher.tests/_fixtures/ScalarTestBehavior.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ScalarTestBehavior(ScalarTestTracker tracker) : IScalarRequestBehavior<ScalarTestRequest, string>
+{
+	public async Task<string> HandleAsync(ScalarTestRequest request, ScalarHandlerDelegate<string> next, CancellationToken cancellationToken)
+	{
+		tracker.Executed = true;
+		return await next(request, cancellationToken);
+	}
+}

src/request.dispatcher.tests/_fixtures/ScalarTestHandler.cs

@@ -0,0 +1,12 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ScalarTestHandler : IScalarRequestHandler<ScalarTestRequest, string>
+{
+	public Task<string> HandleAsync(ScalarTestRequest request, CancellationToken cancellationToken)
+	{
+		return Task.FromResult($"{request.Value}-Handled");
+	}
+}

src/request.dispatcher.tests/_fixtures/ScalarTestRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ScalarTestRequest : IScalarRequest<string>
+{
+	public string Value { get; set; } = string.Empty;
+}

src/request.dispatcher.tests/_fixtures/ScalarTestTracker.cs

@@ -0,0 +1,10 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ScalarTestTracker
+{
+	public List<string> Log { get; } = [];
+	public bool Executed { get; set; }
+}

src/request.dispatcher.tests/_fixtures/ScalarTestWrapperHandler.cs

@@ -0,0 +1,12 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ScalarTestWrapperHandler<T> : IScalarRequestHandler<ScalarTestWrapperRequest<T>, string>
+{
+	public Task<string> HandleAsync(ScalarTestWrapperRequest<T> request, CancellationToken cancellationToken)
+	{
+		return Task.FromResult($"Handled-{request.Item}");
+	}
+}

src/request.dispatcher.tests/_fixtures/ScalarTestWrapperRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ScalarTestWrapperRequest<T> : IScalarRequest<string>
+{
+	public T Item { get; set; } = default!;
+}

src/request.dispatcher.tests/_fixtures/ScalarWrapperBehavior.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ScalarWrapperBehavior<T>(ScalarTestTracker tracker) : IScalarRequestBehavior<ScalarTestWrapperRequest<T>, string>
+{
+	public async Task<string> HandleAsync(ScalarTestWrapperRequest<T> request, ScalarHandlerDelegate<string> next, CancellationToken cancellationToken)
+	{
+		tracker.Executed = true;
+		return await next(request, cancellationToken);
+	}
+}

src/request.dispatcher.tests/_fixtures/StreamChainedBehaviour1.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class StreamChainedBehaviour1(StreamTestTracker tracker) : IStreamRequestBehavior<StreamTestRequest, string>
+{
+	public IAsyncEnumerable<string> HandleAsync(StreamTestRequest request, StreamHandlerDelegate<string> next, CancellationToken cancellationToken)
+	{
+		tracker.Log.Add("Behaviour1");
+		return next(request, cancellationToken);
+	}
+}

src/request.dispatcher.tests/_fixtures/StreamChainedBehaviour2.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class StreamChainedBehaviour2(StreamTestTracker tracker) : IStreamRequestBehavior<StreamTestRequest, string>
+{
+	public IAsyncEnumerable<string> HandleAsync(StreamTestRequest request, StreamHandlerDelegate<string> next, CancellationToken cancellationToken)
+	{
+		tracker.Log.Add("Behaviour2");
+		return next(request, cancellationToken);
+	}
+}

src/request.dispatcher.tests/_fixtures/StreamOpenBehavior.cs

@@ -0,0 +1,14 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class StreamOpenBehavior<TRequest, TResponse>(StreamTestTracker tracker) : IStreamRequestBehavior<TRequest, TResponse>
+where TRequest : IStreamRequest<TResponse>
+{
+	public IAsyncEnumerable<TResponse> HandleAsync(TRequest request, StreamHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
+	{
+		tracker.Executed = true;
+		return next(request, cancellationToken);
+	}
+}

src/request.dispatcher.tests/_fixtures/StreamOrderingClosedBehavior.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class StreamOrderingClosedBehavior(StreamTestTracker tracker) : IStreamRequestBehavior<StreamTestRequest, string>
+{
+	public IAsyncEnumerable<string> HandleAsync(StreamTestRequest request, StreamHandlerDelegate<string> next, CancellationToken cancellationToken)
+	{
+		tracker.Log.Add("Closed");
+		return next(request, cancellationToken);
+	}
+}

src/request.dispatcher.tests/_fixtures/StreamOrderingOpenBehavior.cs

@@ -0,0 +1,14 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class StreamOrderingOpenBehavior<TRequest, TOutput>(StreamTestTracker tracker) : IStreamRequestBehavior<TRequest, TOutput>
+where TRequest : IStreamRequest<TOutput>
+{
+	public IAsyncEnumerable<TOutput> HandleAsync(TRequest request, StreamHandlerDelegate<TOutput> next, CancellationToken cancellationToken)
+	{
+		tracker.Log.Add("Open");
+		return next(request, cancellationToken);
+	}
+}

src/request.dispatcher.tests/_fixtures/StreamTestBehavior.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class StreamTestBehavior(StreamTestTracker tracker) : IStreamRequestBehavior<StreamTestRequest, string>
+{
+	public IAsyncEnumerable<string> HandleAsync(StreamTestRequest request, StreamHandlerDelegate<string> next, CancellationToken cancellationToken)
+	{
+		tracker.Executed = true;
+		return next(request, cancellationToken);
+	}
+}

src/request.dispatcher.tests/_fixtures/StreamTestHandler.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class StreamTestHandler : IStreamRequestHandler<StreamTestRequest, string>
+{
+	public async IAsyncEnumerable<string> HandleAsync(StreamTestRequest request, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
+	{
+		yield return $"{request.Value}-Handled-0";
+		yield return $"{request.Value}-Handled-1";
+	}
+}

src/request.dispatcher.tests/_fixtures/StreamTestRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class StreamTestRequest : IStreamRequest<string>
+{
+	public string Value { get; set; } = string.Empty;
+}

src/request.dispatcher.tests/_fixtures/StreamTestTracker.cs

@@ -0,0 +1,10 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class StreamTestTracker
+{
+	public List<string> Log { get; } = [];
+	public bool Executed { get; set; }
+}

src/request.dispatcher.tests/_fixtures/StreamTestWrapperHandler.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class StreamTestWrapperHandler<T> : IStreamRequestHandler<StreamTestWrapperRequest<T>, string>
+{
+	public async IAsyncEnumerable<string> HandleAsync(StreamTestWrapperRequest<T> request, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
+	{
+		yield return $"Handled-{request.Item}-0";
+		yield return $"Handled-{request.Item}-1";
+	}
+}

src/request.dispatcher.tests/_fixtures/StreamTestWrapperRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class StreamTestWrapperRequest<T> : IStreamRequest<string>
+{
+	public T? Item { get; set; }
+}

src/request.dispatcher.tests/_fixtures/StreamWrapperBehavior.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class StreamWrapperBehavior<T>(StreamTestTracker tracker) : IStreamRequestBehavior<StreamTestWrapperRequest<T>, string>
+{
+	public IAsyncEnumerable<string> HandleAsync(StreamTestWrapperRequest<T> request, StreamHandlerDelegate<string> next, CancellationToken cancellationToken)
+	{
+		tracker.Executed = true;
+		return next(request, cancellationToken);
+	}
+}

src/request.dispatcher.tests/_fixtures/TestHandler.cs

@@ -0,0 +1,12 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal sealed class TestHandler : IScalarRequestHandler<TestRequest, string>
+{
+	public Task<string> HandleAsync(TestRequest request, CancellationToken ct)
+	{
+		return Task.FromResult("ok");
+	}
+}

src/request.dispatcher.tests/_fixtures/TestRequest.cs

@@ -0,0 +1,6 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal sealed class TestRequest : IScalarRequest<string> { }

src/request.dispatcher.tests/_fixtures/UnhandledScalarRequest.cs

@@ -0,0 +1,8 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class UnhandledScalarRequest : IScalarRequest<string>
+{
+}

src/request.dispatcher.tests/_fixtures/UnhandledStreamRequest.cs

@@ -0,0 +1,8 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class UnhandledStreamRequest : IStreamRequest<string>
+{
+}

src/request.dispatcher.tests/_fixtures/WrapperScalarHandler.cs

@@ -0,0 +1,12 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class WrapperScalarHandler<T> : IScalarRequestHandler<WrapperScalarRequest<T>, string>
+{
+	public Task<string> HandleAsync(WrapperScalarRequest<T> request, CancellationToken cancellationToken)
+	{
+		return Task.FromResult($"Handled-{request.Item}");
+	}
+}

src/request.dispatcher.tests/_fixtures/WrapperScalarRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class WrapperScalarRequest<T> : IScalarRequest<string>
+{
+	public T Item { get; set; } = default!;
+}

src/request.dispatcher.tests/_fixtures/WrapperStreamHandler.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class WrapperStreamHandler<T> : IStreamRequestHandler<WrapperStreamRequest<T>, string>
+{
+	public async IAsyncEnumerable<string> HandleAsync(WrapperStreamRequest<T> request, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
+	{
+		yield return $"Handled-{request.Item}-0";
+		yield return $"Handled-{request.Item}-1";
+	}
+}

src/request.dispatcher.tests/_fixtures/WrapperStreamRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class WrapperStreamRequest<T> : IStreamRequest<string>
+{
+	public T Item { get; set; } = default!;
+}

src/request.dispatcher.tests/_fixtures/roslyn/BuilderNestedHandler.cs

@@ -0,0 +1,18 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+using Geekeey.Request.Dispatcher;
+
+namespace Sample;
+
+public sealed class Ping : IScalarRequest<string>
+{
+}
+
+public sealed class Container
+{
+	public sealed class PingHandler : IScalarRequestHandler<Ping, string>
+	{
+		public Task<string> HandleAsync(Ping request, CancellationToken cancellationToken) => Task.FromResult("pong");
+	}
+}

src/request.dispatcher.tests/_fixtures/roslyn/SearchNestedHandler.cs

@@ -0,0 +1,18 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+using Geekeey.Request.Dispatcher;
+
+namespace Sample;
+
+public sealed class Ping : IScalarRequest<string>
+{
+}
+
+public sealed class Container
+{
+	public sealed class PingHandler : IScalarRequestHandler<Ping, string>
+	{
+		public Task<string> HandleAsync(Ping request, CancellationToken cancellationToken) => Task.FromResult("pong");
+	}
+}

src/request.dispatcher.tests/_fixtures/roslyn/SearchTopLevelHandler.cs

@@ -0,0 +1,15 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+using Geekeey.Request.Dispatcher;
+
+namespace Sample;
+
+public sealed class Ping : IScalarRequest<string>
+{
+}
+
+public sealed class PingHandler : IScalarRequestHandler<Ping, string>
+{
+	public Task<string> HandleAsync(Ping request, CancellationToken cancellationToken) => Task.FromResult("pong");
+}

src/request.dispatcher.tests/_helpers/Roslyn.cs

@@ -0,0 +1,177 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.RegularExpressions;
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+using Assembly = System.Reflection.Assembly;
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal static class Roslyn
+{
+	private static CSharpCompilation CreateCompilation(CompilerOptions options)
+	{
+		if (options.SourceCode.Count is 0)
+		{
+			throw new InvalidOperationException("At least one source file must be configured.");
+		}
+
+		var syntax = options.SourceCode
+			.Select(static sourceCode => CSharpSyntaxTree.ParseText(sourceCode, CSharpParseOptions.Default
+				.WithLanguageVersion(LanguageVersion.Preview)))
+			.ToArray();
+
+		var references = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!)
+			.Split(Path.PathSeparator)
+			.Concat(options.References.Select(static assembly => assembly.Location))
+			.Distinct(StringComparer.Ordinal)
+			.Select(static path => MetadataReference.CreateFromFile(path));
+
+		var compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
+		return CSharpCompilation.Create(options.AssemblyName, syntax, references, compilationOptions);
+	}
+
+	public sealed class CompilerOptions
+	{
+		public string AssemblyName { get; set; } = Guid.NewGuid().ToString();
+		public ICollection<Assembly> References { get; } = new HashSet<Assembly>();
+		public IDictionary<string, string?> Properties { get; } = new Dictionary<string, string?>(StringComparer.Ordinal);
+		public ICollection<string> SourceCode { get; } = new HashSet<string>(StringComparer.Ordinal);
+
+		public void AddFromEmbeddedSource(string fileName)
+		{
+			var assembly = Assembly.GetExecutingAssembly();
+			var relativePath = $"_fixtures/roslyn/{fileName}";
+			var suffix = relativePath.Replace(Path.DirectorySeparatorChar, '.')
+				.Replace(Path.AltDirectorySeparatorChar, '.');
+			var resourceName = assembly.GetManifestResourceNames()
+				.SingleOrDefault(name => name.EndsWith(suffix, StringComparison.Ordinal));
+
+			if (resourceName is null)
+			{
+				throw new InvalidOperationException($"Embedded fixture '{relativePath}' was not found.");
+			}
+
+			if (assembly.GetManifestResourceStream(resourceName) is not { } stream)
+			{
+				throw new InvalidOperationException($"Embedded fixture '{resourceName}' could not be opened.");
+			}
+
+			using var reader = new StreamReader(stream);
+			SourceCode.Add(reader.ReadToEnd());
+		}
+	}
+
+	public static Assembly Compile(Action<CompilerOptions>? configure = null)
+	{
+		var options = new CompilerOptions();
+		configure?.Invoke(options);
+		var compilation = CreateCompilation(options);
+
+		using var stream = new MemoryStream();
+
+		if (compilation.Emit(stream) is { Success: false, Diagnostics: var diagnostics })
+		{
+			throw new InvalidOperationException(string.Join(Environment.NewLine,
+				diagnostics.Select(static diagnostic => diagnostic.ToString())));
+		}
+
+		stream.Seek(0, SeekOrigin.Begin);
+
+		return Assembly.Load(stream.ToArray());
+	}
+
+	public static GeneratorDriverRunResult SourceGenerator<TGenerator>(Action<CompilerOptions>? configure = null)
+		where TGenerator : IIncrementalGenerator, new()
+	{
+		var options = new CompilerOptions();
+		configure?.Invoke(options);
+		var compilation = CreateCompilation(options);
+
+		GeneratorDriver driver = CSharpGeneratorDriver.Create([new TGenerator().AsSourceGenerator()],
+			parseOptions: (CSharpParseOptions)compilation.SyntaxTrees.First().Options,
+			optionsProvider: new TestAnalyzerConfigOptionsProvider(
+				new Dictionary<string, string?>(options.Properties, StringComparer.Ordinal)
+				{
+					["build_property.AssemblyName"] = options.AssemblyName,
+				}));
+
+		driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out _, out _);
+		return driver.GetRunResult();
+	}
+
+	extension(GeneratorDriverRunResult result)
+	{
+		public string? File([StringSyntax(StringSyntaxAttribute.Regex)] string name)
+		{
+			foreach (var value in result.Results)
+			{
+				foreach (var source in value.GeneratedSources)
+				{
+					if (Regex.IsMatch(source.HintName, name))
+					{
+						return source.SourceText.ToString();
+					}
+				}
+			}
+
+			return null;
+		}
+	}
+
+	private sealed class TestAnalyzerConfigOptionsProvider : AnalyzerConfigOptionsProvider
+	{
+		public TestAnalyzerConfigOptionsProvider(IDictionary<string, string?> values)
+		{
+			GlobalOptions = new TestAnalyzerConfigOptions(values);
+		}
+
+		public override AnalyzerConfigOptions GlobalOptions { get; }
+
+		public override AnalyzerConfigOptions GetOptions(SyntaxTree tree)
+		{
+			return GlobalOptions;
+		}
+
+		public override AnalyzerConfigOptions GetOptions(AdditionalText textFile)
+		{
+			return GlobalOptions;
+		}
+	}
+
+	private sealed class TestAnalyzerConfigOptions : AnalyzerConfigOptions
+	{
+		private readonly ImmutableDictionary<string, string?> _values;
+
+		public TestAnalyzerConfigOptions(IDictionary<string, string?> values)
+		{
+			_values = values.ToImmutableDictionary(StringComparer.Ordinal);
+		}
+
+		public override bool TryGetValue(string key, out string value)
+		{
+			if (_values.TryGetValue(key, out var existingValue) && existingValue is not null)
+			{
+				value = existingValue;
+				return true;
+			}
+
+			if (key.StartsWith("build_property.", StringComparison.Ordinal) &&
+				_values.TryGetValue(key["build_property.".Length..], out existingValue) &&
+				existingValue is not null)
+			{
+				value = existingValue;
+				return true;
+			}
+
+			value = string.Empty;
+			return false;
+		}
+	}
+}

src/request.dispatcher/Geekeey.Request.Dispatcher.csproj

@@ -0,0 +1,36 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Library</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <IsPackable>true</IsPackable>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(Configuration)' == 'Debug'">
+    <InternalsVisibleTo Include="Geekeey.Request.Dispatcher.Tests" />
+  </ItemGroup>
+
+  <PropertyGroup>
+    <PackageReadmeFile>package-readme.md</PackageReadmeFile>
+    <PackageDescription>Simple mediator implementation in .NET with minimal dependencies.</PackageDescription>
+    <PackageIcon>package-icon.png</PackageIcon>
+    <PackageProjectUrl>https://code.geekeey.de/geekeey/request/src/branch/main/src/request.dispatcher</PackageProjectUrl>
+    <PackageLicenseExpression>EUPL-1.2</PackageLicenseExpression>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include=".\package-icon.png" Pack="true" PackagePath="\" Visible="false" />
+    <None Include=".\package-readme.md" Pack="true" PackagePath="\" Visible="false" />
+    <None Include="..\..\LICENSE.md" Pack="true" PackagePath="\" Visible="false" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
+    <PackageReference Include="Microsoft.Extensions.Options" />
+  </ItemGroup>
+
+</Project>

src/request.dispatcher/IRequestDispatcher.cs

@@ -0,0 +1,28 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher;
+
+/// <summary>
+/// Defines functionality to dispatch requests to their corresponding handlers.
+/// </summary>
+public interface IRequestDispatcher
+{
+	/// <summary>
+	/// Asynchronously send a request to a handler producing a scalar value.
+	/// </summary>
+	/// <param name="request">Request object</param>
+	/// <param name="cancellationToken">Optional cancellation token</param>
+	/// <typeparam name="TResponse">Response type</typeparam>
+	/// <returns>A task that represents the send operation. The task result contains the handler response</returns>
+	Task<TResponse> DispatchAsync<TResponse>(IScalarRequest<TResponse> request, CancellationToken cancellationToken = default);
+
+	/// <summary>
+	/// Asynchronously send a request to a handler producing a stream value.
+	/// </summary>
+	/// <param name="request">Request object</param>
+	/// <param name="cancellationToken">Optional cancellation token</param>
+	/// <typeparam name="TResponse">Response type</typeparam>
+	/// <returns>The created async enumerable, representing the stream of responses.</returns>
+	IAsyncEnumerable<TResponse> DispatchAsync<TResponse>(IStreamRequest<TResponse> request, CancellationToken cancellationToken = default);
+}

src/request.dispatcher/IRequestDispatcherBuilder.cs

@@ -0,0 +1,19 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Geekeey.Request.Dispatcher;
+
+/// <summary>
+/// Represents a builder for configuring and registering request dispatchers and their related components.
+/// </summary>
+public interface IRequestDispatcherBuilder
+{
+	/// <summary>
+	/// Gets the <see cref="IServiceCollection"/> associated with the request dispatcher builder.
+	/// Provides access to the underlying service collection for configuring dependencies
+	/// and registering services required by the request dispatcher.
+	/// </summary>
+	IServiceCollection Services { get; }
+}

src/request.dispatcher/IScalarPipelineBehavior.cs

@@ -0,0 +1,35 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+#pragma warning disable CA1711
+#pragma warning disable CA1716
+
+namespace Geekeey.Request.Dispatcher;
+
+/// <summary>
+/// Represents a behavior in the request pipeline, allowing interception, modification,
+/// or chaining of asynchronous stream requests and responses.
+/// </summary>
+/// <typeparam name="TRequest">The type of the request being handled. Must implement <see cref="IScalarRequest{TResponse}"/>.</typeparam>
+/// <typeparam name="TResponse">The type of the response produced by the implementing request handler.</typeparam>
+public interface IScalarRequestBehavior<in TRequest, TResponse> where TRequest : IScalarRequest<TResponse>
+{
+	/// <summary>
+	/// Handles the asynchronous processing of a request, allowing behavior customization
+	/// such as interception, modification, or chaining of the request and its response.
+	/// </summary>
+	/// <param name="request">The request instance being processed.</param>
+	/// <param name="next">The next delegate in the pipeline to execute after the custom behavior.</param>
+	/// <param name="cancellationToken">A token to monitor for cancellation requests.</param>
+	/// <returns>A task that represents the asynchronous operation. The task result contains the response from the request.</returns>
+	Task<TResponse> HandleAsync(TRequest request, ScalarHandlerDelegate<TResponse> next, CancellationToken cancellationToken);
+}
+
+/// <summary>
+/// Represents the delegate responsible for handling asynchronous requests in a pipeline.
+/// </summary>
+/// <typeparam name="TResponse">The type of the response produced by the implementing request handler.</typeparam>
+/// <param name="request">The asynchronous request being processed.</param>
+/// <param name="cancellationToken">A token for monitoring cancellation requests.</param>
+/// <returns>A task, that represents the asynchronous operation, containing the response of type <typeparamref name="TResponse"/>.</returns>
+public delegate Task<TResponse> ScalarHandlerDelegate<TResponse>(IScalarRequest<TResponse> request, CancellationToken cancellationToken);

src/request.dispatcher/IScalarRequest.cs

@@ -0,0 +1,14 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher;
+
+/// <summary>
+/// Represents a request that produces a response of a specified type.
+/// This interface serves as a marker for distinguishing request types,
+/// enabling their integration into request-based pipelines or dispatch mechanisms.
+/// </summary>
+/// <typeparam name="TResponse">The type of the response produced by the implementing request handler.</typeparam>
+public interface IScalarRequest<out TResponse>
+{
+}

src/request.dispatcher/IScalarRequestHandler.cs

@@ -0,0 +1,20 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher;
+
+/// <summary>
+/// Defines a handler for processing requests of a specific type and returning a response.
+/// </summary>
+/// <typeparam name="TRequest">The type of the request to be handled. Must implement <see cref="IScalarRequest{TResponse}"/>.</typeparam>
+/// <typeparam name="TResponse">The type of the response produced by the implementing request handler.</typeparam>
+public interface IScalarRequestHandler<in TRequest, TResponse> where TRequest : IScalarRequest<TResponse>
+{
+	/// <summary>
+	/// Processes a scalar request and returns a response asynchronously.
+	/// </summary>
+	/// <param name="request">The request object to be processed.</param>
+	/// <param name="cancellationToken">A token to observe for cancellation requests.</param>
+	/// <returns>A task representing the asynchronous operation, containing the response of type <typeparamref name="TResponse"/>.</returns>
+	Task<TResponse> HandleAsync(TRequest request, CancellationToken cancellationToken = default);
+}

src/request.dispatcher/IStreamPipelineBehavior.cs

@@ -0,0 +1,35 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+#pragma warning disable CA1711
+#pragma warning disable CA1716
+
+namespace Geekeey.Request.Dispatcher;
+
+/// <summary>
+/// Represents a behavior in the request pipeline, allowing interception, modification,
+/// or chaining of asynchronous stream requests and responses.
+/// </summary>
+/// <typeparam name="TRequest">The type of the request being processed. Must implement <see cref="IStreamRequest{TResponse}"/>.</typeparam>
+/// <typeparam name="TResponse">The type of the response produced by the implementing request handler.</typeparam>
+public interface IStreamRequestBehavior<in TRequest, TResponse> where TRequest : IStreamRequest<TResponse>
+{
+	/// <summary>
+	/// Handles the asynchronous processing of a request, allowing behavior customization
+	/// such as interception, modification, or chaining of the request and its response.
+	/// </summary>
+	/// <param name="request">The request instance being processed.</param>
+	/// <param name="next">The next delegate in the pipeline to execute after the custom behavior.</param>
+	/// <param name="cancellationToken">A token to monitor for cancellation requests.</param>
+	/// <returns>An asynchronous stream of <typeparamref name="TResponse"/> representing the processed response.</returns>
+	IAsyncEnumerable<TResponse> HandleAsync(TRequest request, StreamHandlerDelegate<TResponse> next, CancellationToken cancellationToken);
+}
+
+/// <summary>
+/// Represents the delegate responsible for handling asynchronous requests in a pipeline.
+/// </summary>
+/// <typeparam name="TResponse">The type of the response produced by the implementing request handler.</typeparam>
+/// <param name="request">The asynchronous request being processed.</param>
+/// <param name="cancellationToken">A token for monitoring cancellation requests.</param>
+/// <returns>An asynchronous stream of responses of type <typeparamref name="TResponse"/>.</returns>
+public delegate IAsyncEnumerable<TResponse> StreamHandlerDelegate<TResponse>(IStreamRequest<TResponse> request, CancellationToken cancellationToken);

src/request.dispatcher/IStreamRequest.cs

@@ -0,0 +1,14 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher;
+
+/// <summary>
+/// Represents a request that produces a response of a specified type.
+/// This interface serves as a marker for distinguishing request types,
+/// enabling their integration into request-based pipelines or dispatch mechanisms.
+/// </summary>
+/// <typeparam name="TResponse">The type of the response produced by the implementing request handler.</typeparam>
+public interface IStreamRequest<out TResponse>
+{
+}

src/request.dispatcher/IStreamRequestHandler.cs

@@ -0,0 +1,21 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher;
+
+/// <summary>
+/// Defines a handler for processing streaming requests of a specific type and producing
+/// a stream of responses.
+/// </summary>
+/// <typeparam name="TRequest">The type of the request to handle. This must implement <see cref="IStreamRequest{TResponse}"/>.</typeparam>
+/// <typeparam name="TResponse">The type of the response produced by the implementing request handler.</typeparam>
+public interface IStreamRequestHandler<in TRequest, out TResponse> where TRequest : IStreamRequest<TResponse>
+{
+	/// <summary>
+	/// Handles a streaming request and returns a stream of responses asynchronously.
+	/// </summary>
+	/// <param name="request">The request object to be processed.</param>
+	/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+	/// <returns>An asynchronous stream of responses of type <typeparamref name="TResponse"/>.</returns>
+	IAsyncEnumerable<TResponse> HandleAsync(TRequest request, CancellationToken cancellationToken);
+}