Nabs.Launchpad.Core.Apis 10.0.246

Nabs.Launchpad.Core.Apis

Nabs.Launchpad.Core.Apis gives you granular endpoint abstractions for consistent ASP.NET Core API endpoints.

Installation

dotnet add package Nabs.Launchpad.Core.Apis

The Problem

// 1) Controllers accumulate many actions over time
public class ProductsController : ControllerBase
{
    [HttpGet("{id:guid}")] public IActionResult Get(Guid id) => Ok();
    [HttpPost] public IActionResult Create(ProductRequest request) => Ok();
    [HttpPut("{id:guid}")] public IActionResult Update(Guid id, ProductRequest request) => Ok();
}

// 2) Endpoint intent is harder to isolate by file
// 3) Growth increases merge conflicts and maintenance overhead

Features

• Single-file endpoint abstraction through INabsEndpoint
• Declarative endpoint base class through NabsEndpointBase
• Typed request/response endpoint variants for common API patterns
• Constructor injection support for discovered endpoint classes
• Built-in request validation hooks with automatic ValidationProblem responses
• Automatic endpoint registration through MapNabsEndpoints(...)
• Deterministic endpoint discovery for predictable startup behavior
• Optional shared controller base through NabsControllerBase

Usage

public sealed class GetProductEndpoint : NabsEndpointBase
{
    public GetProductEndpoint()
        : base(new NabsEndpointOptions("/api/products/{id:guid}", HttpMethods.Get)
        {
            EndpointName = "GetProduct",
            Tags = ["Products"],
            Summary = "Get a product by id."
        })
    {
    }

    protected override Task<IResult> HandleAsync(HttpContext httpContext, CancellationToken cancellationToken)
    {
        var id = httpContext.GetRouteValue("id");
        return Task.FromResult<IResult>(Results.Ok(new { id }));
    }
}

public sealed class SecureProductEndpoint : NabsEndpointBase
{
    private readonly IProductService _productService = productService;

    public SecureProductEndpoint(IProductService productService)
        : base(new NabsEndpointOptions("/api/secure-products/{id:guid}", HttpMethods.Get)
        {
            RequireAuthorization = true,
            ExcludeFromDescription = false
        })
    {
        _productService = productService;
    }

    protected override Task<IResult> HandleAsync(HttpContext httpContext, CancellationToken cancellationToken)
    {
        var id = httpContext.GetRouteValue("id");
        return Task.FromResult<IResult>(Results.Ok(_productService.GetById(id)));
    }
}

// Program.cs
app.MapNabsEndpoints<Program>();

You can still implement INabsEndpoint directly for advanced scenarios.

Typed variants are also available:

public sealed class CreateOrderEndpoint : NabsRequestResponseEndpointBase<CreateOrderRequest, CreateOrderResponse>
{
    public CreateOrderEndpoint()
        : base(new NabsEndpointOptions("/api/orders", HttpMethods.Post)
        {
            EndpointName = "CreateOrder"
        })
    {
    }

    protected override Task<CreateOrderResponse> HandleRequestAsync(CreateOrderRequest request, CancellationToken cancellationToken)
    {
        return Task.FromResult(new CreateOrderResponse(Guid.NewGuid()));
    }
}

public sealed class ProcessOrderEndpoint : NabsRequestEndpointBase<ProcessOrderRequest>
{
    public ProcessOrderEndpoint()
        : base("/api/orders/process", HttpMethods.Post)
    {
    }

    protected override Task HandleRequestAsync(ProcessOrderRequest request, CancellationToken cancellationToken)
    {
        return Task.CompletedTask;
    }
}

public sealed class ValidatedOrderEndpoint : NabsRequestResponseEndpointBase<CreateOrderRequest, CreateOrderResponse>
{
    public ValidatedOrderEndpoint()
        : base("/api/orders/validated", HttpMethods.Post)
    {
    }

    protected override Task<IDictionary<string, string[]>?> ValidateRequestAsync(CreateOrderRequest request, CancellationToken cancellationToken)
    {
        if (!string.IsNullOrWhiteSpace(request.CustomerName))
        {
            return Task.FromResult<IDictionary<string, string[]>?>(null);
        }

        IDictionary<string, string[]> errors = new Dictionary<string, string[]>
        {
            ["customerName"] = ["Customer name is required."]
        };

        return Task.FromResult<IDictionary<string, string[]>?>(errors);
    }

    protected override Task<CreateOrderResponse> HandleRequestAsync(CreateOrderRequest request, CancellationToken cancellationToken)
    {
        return Task.FromResult(new CreateOrderResponse(Guid.NewGuid()));
    }
}

public sealed class GetServerInfoEndpoint : NabsResponseEndpointBase<ServerInfoResponse>
{
    public GetServerInfoEndpoint()
        : base("/api/server-info", HttpMethods.Get)
    {
    }

    protected override Task<ServerInfoResponse> HandleResponseAsync(CancellationToken cancellationToken)
    {
        return Task.FromResult(new ServerInfoResponse("v1"));
    }
}

Controller-based APIs remain supported:

[ApiController]
[Route("api/[controller]")]
public sealed class ProductsController : NabsControllerBase
{
    [HttpGet("{id:guid}")]
    public IActionResult Get(Guid id) => Ok(new { id });
}

Configuration

No package-specific configuration is required.

Project Structure

• INabsEndpoint.cs - contract for one endpoint per class/file
• NabsEndpointBase.cs - declarative base class with override-driven configuration
• NabsRequestResponseEndpointBase.cs - typed base for request/response endpoints
• NabsRequestEndpointBase.cs - typed base for request-only fire-and-forget endpoints
• NabsResponseEndpointBase.cs - typed base for response-only endpoints
• NabsEndpointRouteBuilderExtensions.cs - endpoint discovery and mapping extensions
• NabsControllerBase.cs - reusable base class for controller-based APIs

License

Copyright (c) Net Advantage Business Solutions.