builder.Services.AddDsptch(opts =>
{
    opts.RegisterServicesFromAssemblyContaining<Program>();

    // Registering dispatchers using DsptchConfiguration
    opts.RegisterDispatcherDecorator(typeof(LoggingDecorator<,>));
    opts.RegisterDispatcherDecorator(typeof(CachingDecorator<,>));
    opts.RegisterDispatcherDecorator(typeof(AuthorizationDecorator<,>));
});

// Or registering dispatchers manually
builder.Services.TryAddTransient(typeof(IDispatcherDecorator<,>), typeof(LoggingDecorator<,>));

public record GetProductByIdQuery(Guid Id)
    : IQuery<Product>;

public record GetProductByNameQuery(string Name)
    : IRequest<List<Product>>;

public record CreateProductCommand(string Name, decimal Price)
    : ICommand<Guid>;

public class GetProductByIdQueryHandler : IRequestHandler<GetProductByIdQuery, Product>
{
    public Task<Product> Handle(GetProductByIdQuery query, CancellationToken cancellationToken)
    {
        return Task.FromResult(new Product(query.Id, "Product Name", 100.00m));
    }
}

app.MapGet("/products/{id}", async (IDispatcher dispatcher, Guid id) =>
{
    Product? product = await dispatcher.Dispatch<GetProductByIdQuery, Product?>(new GetProductByIdQuery(id));

    return product is not null ? Results.Ok(product) : Results.NotFound();
});

/// <summary>
/// This decorator will log the request before and after it is dispatched.
/// It will be called for all requests (IRequest), including commands and queries.
/// </summary>
public class LoggingDecorator<TRequest, TResult> : IDispatcherDecorator<TRequest, TResult>
    where TRequest : IRequest<TResult>
{
    private readonly ILogger<TRequest> _logger;

    public LoggingDecorator(ILogger<TRequest> logger)
    {
        _logger = logger;
    }

    public async Task<TResult> Dispatch(
        TRequest request,
        RequestHandlerDelegate<TResult> next,
        CancellationToken cancellationToken = default)
    {
        var requestName = typeof(TRequest).Name;
        _logger.LogInformation("Dispatching request: {req}", requestName);

        try
        {
            var result = await next();

            _logger.LogInformation("Request dispatched: {req}", requestName);

            return result;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error dispatching request: {req}", requestName);
            throw;
        }
    }
}

/// <summary>
/// This decorator will only be called only for requests that implement the IQuery interface.
/// It won't be called for commands (ICommand) or requests (IRequest).
/// </summary>
public class CachingDecorator<TQuery, TResult> : IDispatcherDecorator<TQuery, TResult>
    where TQuery : IQuery<TResult>
{
}

/// <summary>
/// This decorator will only be applied to requests that implement the IAuthorizableRequest interface.
/// </summary>
public class AuthorizationDecorator<TRequest, TResult> : IDispatcherDecorator<TRequest, TResult>
    where TRequest : IAuthorizableRequest<TResult>
{
}