NPv.CQS.Infrastructure 1.1.0

NPv.CQS.Infrastructure

Infrastructure for declarative execution of commands and queries in CQS-based applications.
Includes default implementations, Unit of Work executor, and Autofac integration.

✨ Overview

NPv.CQS.Infrastructure provides essential building blocks for executing commands and queries defined using NPv.CQS.Abstractions.

It includes:

• ICommandBuilder and IQueryBuilder for resolving and executing handlers,
• UnitOfWorkCommandExecutor for transactional command execution,
• Autofac module for automatic handler registration by namespace.

This package is intended for the application or composition root layers, where behaviors are wired and executed.

🔧 Key Features

• 📦 Built-in ICommandBuilder and IQueryBuilder implementations
• 📡 Centralized command and query execution via ICommandBuilder and IQueryBuilder
• 🧩 CQSModule for seamless Autofac integration via namespace scanning
• 💼 UnitOfWorkCommandExecutor for wrapping commands in a Unit of Work with automatic commit
• 💡 Compatible with all abstractions from NPv.CQS.Abstractions

📦 Installation

dotnet add package NPv.CQS.Infrastructure

🧪 Usage Example

1. Register Autofac Module (in Program.cs)

builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());

builder.Host.ConfigureContainer<ContainerBuilder>(container =>
{
    container.RegisterModule(new CQSModule("YourApp.HandlersNamespace"));
});

2. Execute a Command Declaratively

await _commandBuilder.ExecuteAsync(new CreateOrderCommandContext(orderId, amount));

3. Execute a Query Declaratively

var order = await _queryBuilder.For<Order>().With(new FindById(orderId));

No need to resolve handlers manually — the infrastructure handles it based on context and criterion types.

4. Execute a Command with Unit of Work

UnitOfWorkCommandExecutor is a new class in the library that wraps command execution in a Unit of Work.

It is automatically registered via CQSModule, so no extra setup is required.
When using it, you no longer inject ICommandBuilder directly into controllers — instead, you inject ICommandExecutor.

Class Implementation:

using Autofac;
using NPv.CQS.Abstractions.Commands;
using NPv.Uow.Abstractions;

namespace NPv.CQS.Infrastructure.Commands;

public class UnitOfWorkCommandExecutor(ILifetimeScope root) : ICommandExecutor
{
    public async Task ExecuteAsync<TContext>(TContext ctx) where TContext : ICommandContext
    {
        using var scope = root.BeginLifetimeScope();
        var commands = scope.Resolve<ICommandBuilder>();
        var uow = scope.Resolve<IUnitOfWork>();

        await using (uow)
        {
            await commands.ExecuteAsync(ctx);
            await uow.CommitAsync();
        }
    }
}

Usage in Controller:

[ApiController]
[Route("api/[controller]")]
public class OrdersController(ICommandExecutor executor) : ControllerBase
{
    [HttpPost]
    public Task CreateOrder(CreateOrderCommandContext context)
        => executor.ExecuteAsync(context);
}

🧩 Components Included

📚 Related Packages

• NPv.CQS.Abstractions – core interfaces and contracts
• NPv.Events.Abstractions (planned) – contracts for event-driven extensions

Author's Note

This library grew out of my long-standing personal interest in structuring and publishing open source packages. Over time, I’ve revisited and refined earlier internal utilities and ideas, giving them a more consistent shape and preparing them for wider reuse. Along the way, I’ve also taken the opportunity to explore how open source distribution and licensing work in the .NET ecosystem.

It’s a small step toward something I’ve always wanted to try — sharing practical, minimal tools that reflect years of learning, experimentation, and refinement.

Hopefully, someone finds it useful.

Nikolai 😛

⚖️ License

MIT — you are free to use this in commercial and open-source software.