feat: create request projects for basic CQRS

src/request.dispatcher/RequestDispatcherOptions.cs

@@ -0,0 +1,207 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using System.Collections;
+using System.Collections.Concurrent;
+
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Geekeey.Request.Dispatcher;
+
+internal sealed class RequestDispatcherOptions
+{
+	private readonly List<Type> _search = [];
+	private readonly Lazy<TypeIndex> _behaviorsTypeIndex;
+	private readonly Lazy<TypeIndex> _handlersTypeIndex;
+
+	public RequestDispatcherOptions()
+	{
+		_behaviorsTypeIndex = new Lazy<TypeIndex>(() => new BehaviorTypeIndex(_search.Distinct()));
+		_handlersTypeIndex = new Lazy<TypeIndex>(() => new HandlerTypeIndex(_search.Distinct()));
+	}
+
+	public void Inspect(IEnumerable<Type> assembly)
+	{
+		if (_behaviorsTypeIndex.IsValueCreated || _handlersTypeIndex.IsValueCreated)
+		{
+			throw new InvalidOperationException("The type index has already been created. Cannot inspect new assemblies.");
+		}
+
+		_search.AddRange(assembly);
+	}
+
+	public IEnumerable<T> GetRequestBehaviors<T>(IServiceProvider services)
+	{
+		return _behaviorsTypeIndex.Value.Resolve<T>(services);
+	}
+
+	public IEnumerable<T> GetRequestHandlers<T>(IServiceProvider services)
+	{
+		return _handlersTypeIndex.Value.Resolve<T>(services);
+	}
+
+	private abstract class TypeIndex
+	{
+		private readonly ConcurrentDictionary<Type, Func<IServiceProvider, IEnumerable>> _cache = new();
+
+		protected readonly Dictionary<Type, List<Type>> _closedTypeInfo = [];
+		protected readonly List<Type> _openTypeInfo = [];
+
+		protected TypeIndex(IEnumerable<Type> collection, Func<Type, bool> predicate)
+		{
+			foreach (var type in collection)
+			{
+				if (type.IsGenericTypeDefinition)
+				{
+					if (type.GetInterfaces().Any(predicate))
+					{
+						_openTypeInfo.Add(type);
+					}
+				}
+				else
+				{
+					foreach (var @interface in type.GetInterfaces().Where(predicate))
+					{
+						(_closedTypeInfo.TryGetValue(@interface, out var list) ? list : _closedTypeInfo[@interface] = []).Add(type);
+					}
+				}
+			}
+		}
+
+		public IEnumerable<T> Resolve<T>(IServiceProvider services)
+		{
+			return (IEnumerable<T>)_cache.GetOrAdd(typeof(T), CreateResolverFactory<T>)(services);
+		}
+
+		protected abstract IReadOnlyList<Type> IsAssignableTo(Type type);
+
+		private Func<IServiceProvider, IEnumerable<T>> CreateResolverFactory<T>(Type @interface)
+		{
+			var list = IsAssignableTo(@interface);
+			return ResolverFactory;
+
+			IEnumerable<T> ResolverFactory(IServiceProvider services)
+			{
+				foreach (var type in list)
+				{
+					yield return (T)ActivatorUtilities.GetServiceOrCreateInstance(services, type);
+				}
+			}
+		}
+	}
+
+	internal static bool IsRequestHandlerType(Type type)
+	{
+		return type.IsGenericType &&
+			   (type.GetGenericTypeDefinition() == typeof(IScalarRequestHandler<,>) ||
+				type.GetGenericTypeDefinition() == typeof(IStreamRequestHandler<,>));
+	}
+
+	private sealed class HandlerTypeIndex(IEnumerable<Type> collection)
+		: TypeIndex(collection, IsRequestHandlerType)
+	{
+		protected override IReadOnlyList<Type> IsAssignableTo(Type @interface)
+		{
+			var result = new List<Type>();
+
+			if (_closedTypeInfo.TryGetValue(@interface, out var list))
+			{
+				result.AddRange(list);
+			}
+
+			var requestType = @interface.GetGenericArguments()[0];
+			_ = @interface.GetGenericArguments()[1];
+
+			foreach (var type in _openTypeInfo)
+			{
+				try
+				{
+					// open type case one: Handler<TRequest> : IRequestHandler<TRequest, TOutput>
+					// We try to close it with the request type.
+					var impl = type.MakeGenericType(requestType);
+					if (impl.IsAssignableTo(@interface))
+					{
+						result.Add(impl);
+					}
+				}
+				catch (ArgumentException)
+				{
+				}
+
+				try
+				{
+					// open type case two: Handler<T> : IRequestHandler<WrapperRequest<T>, TOutput>
+					// If the request is generic, we try to close the handler with the request's generic arguments.
+					if (requestType.IsGenericType)
+					{
+						var impl = type.MakeGenericType(requestType.GetGenericArguments());
+						if (impl.IsAssignableTo(@interface))
+						{
+							result.Add(impl);
+						}
+					}
+				}
+				catch (ArgumentException)
+				{
+				}
+			}
+
+			return result;
+		}
+	}
+
+	internal static bool IsRequestBehaviorType(Type type)
+	{
+		return type.IsGenericType &&
+			   (type.GetGenericTypeDefinition() == typeof(IScalarRequestBehavior<,>) ||
+				type.GetGenericTypeDefinition() == typeof(IStreamRequestBehavior<,>));
+	}
+
+	private sealed class BehaviorTypeIndex(IEnumerable<Type> collection)
+		: TypeIndex(collection, IsRequestBehaviorType)
+	{
+		protected override IReadOnlyList<Type> IsAssignableTo(Type @interface)
+		{
+			var result = new List<Type>();
+
+			if (_closedTypeInfo.TryGetValue(@interface, out var list))
+			{
+				result.AddRange(list);
+			}
+
+			var requestType = @interface.GetGenericArguments()[0];
+			var responseType = @interface.GetGenericArguments()[1];
+
+			foreach (var behaviour in _openTypeInfo)
+			{
+				try
+				{
+					// open type case one: Behaviour<TRequest, TResponse> : IRequestBehaviour<TRequest, TResponse>
+					var impl = behaviour.MakeGenericType(requestType, responseType);
+					if (impl.IsAssignableTo(@interface))
+					{
+						result.Add(impl);
+					}
+				}
+				catch (ArgumentException)
+				{
+				}
+
+				try
+				{
+					// open type case two: Behaviour<T> : IRequestBehaviour<WrapperRequest<T>, TResponse>
+					var impl = behaviour.MakeGenericType(requestType.GetGenericArguments());
+					if (impl.IsAssignableTo(@interface))
+					{
+						result.Add(impl);
+					}
+				}
+				catch (ArgumentException)
+				{
+				}
+			}
+
+			return result;
+		}
+	}
+}