Should we move routing to individual controllers?

[Regenhardt]

Currently, controllers have methods, but the mapping to endpoints happens in BaGetterEndpointBuilder.MapEndpoints. BaGetterEndpointBuilder also has the individual endpoint mapping methods set to public, to technically somebody integrating BaGet/BaGetter into their own application could have used those public methods to map certain controllers and features and not map others (although I can't of a good reason to do so).

So instead of something like this:

endpoints.MapControllerRoute(
    name: Routes.RegistrationIndexRouteName,
    pattern: "v3/registration/{id}/index.json",
    defaults: new { controller = "PackageMetadata", action = "RegistrationIndex" });

endpoints.MapControllerRoute(
    name: Routes.RegistrationLeafRouteName,
    pattern: "v3/registration/{id}/{version}.json",
    defaults: new { controller = "PackageMetadata", action = "RegistrationLeaf" });

I would like to move it to something like this:

/// <summary>
/// The Package Metadata resource, used to fetch packages' information.
/// See: https://docs.microsoft.com/en-us/nuget/api/registration-base-url-resource
/// </summary>
[Route("v3/registration")] // <- New
public class PackageMetadataController : Controller
{
    private readonly IPackageMetadataService _metadata;

    public PackageMetadataController(IPackageMetadataService metadata)
    {
        _metadata = metadata ?? throw new ArgumentNullException(nameof(metadata));
    }

    [HttpGet("{id}/index.json")] // <- Previously just [HttpGet]
    public async Task<ActionResult<BaGetterRegistrationIndexResponse>> RegistrationIndexAsync(string id, CancellationToken cancellationToken)
    {
        var index = await _metadata.GetRegistrationIndexOrNullAsync(id, cancellationToken);
        if (index == null)
        {
            return NotFound();
        }

        return index;
    }

    [HttpGet("{id}/{version}.json")] // <- Previously just [HttpGet]
    public async Task<ActionResult<RegistrationLeafResponse>> RegistrationLeafAsync(string id, string version, CancellationToken cancellationToken)
    {
        if (!NuGetVersion.TryParse(version, out var nugetVersion))
        {
            return NotFound();
        }

        var leaf = await _metadata.GetRegistrationLeafOrNullAsync(id, nugetVersion, cancellationToken);
        if (leaf == null)
        {
            return NotFound();
        }

        return leaf;
    }
}

What do you think? Is the MapEndpoints just a nice way of having everything in one place, or is it just convoluted and complicated to have to look in there to find a route for a controller you're currently working on? Are there reasons to not automatically map the controller endpoints, like when integrating BaGetter in another web application?

[FroggieFrog]

To me the current implementation looks like minimal APIs, which I like a lot and seems to be the new way to implement APIs. At least for somewhat small APIs.
Thare are not that many routes in this project, so I would stick with the current implementation.

[seriouz]

I personally like controllers more than minimal APIs. But before we tackle this here in anyway. I would suggest that we look into bringing the application away from the Startup.cs to the "new" way with a Program.cs only without a Main() function.