davidfowl
commented
4 years ago UseCarter should hang off IEndpointConventionBuilder instead of hanging off IApplicationBuilder (and would be renamed to MapCarter).
Middleware can act on selected endpoints when chosen so things like authorization/cors can be moved outside of the framework into middleware. As part of route registration users should have a way to add metadata to their route.
public class ProductsModule : CaterModule
{
public MyModule() : base("/products")
{
this.Get("/", ctx => ctx.WriteAsync("hi")).RequireAuthorization();
}
}The CarterModule would be a mini DSL over routing.
Quickly looking at the code I'm not sure how you could expose the IEndpointConventionBuilder from the route registration methods without a breaking change. Maybe it could be an argument instead?
Here's a strawman:
using System;
using System.Collections.Generic;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace CarterDemo
{
public class HelloModule : CarterModule
{
public HelloModule()
{
Get("/", context => context.Response.WriteAsync("Hello World")).RequireAuthorization();
}
}
public class CarterModule
{
internal readonly Dictionary<(string verb, string path), (RequestDelegate handler, RouteConventions conventions)> Routes = new Dictionary<(string verb, string path), (RequestDelegate handler, RouteConventions conventions)>();
public IEndpointConventionBuilder Get(string path, RequestDelegate handler)
{
var conventions= new RouteConventions();
Routes.Add((HttpMethods.Get, path), (handler, conventions));
return conventions;
}
internal class RouteConventions : IEndpointConventionBuilder
{
private readonly List<Action<EndpointBuilder>> _actions = new List<Action<EndpointBuilder>>();
public void Add(Action<EndpointBuilder> convention)
{
_actions.Add(convention);
}
public void Apply(IEndpointConventionBuilder builder)
{
foreach (var a in _actions)
{
builder.Add(a);
}
}
}
}
public static class CarterExtensions
{
public static IEndpointConventionBuilder MapCarter(this IEndpointRouteBuilder builder)
{
var builders = new List<IEndpointConventionBuilder>();
using var scope = builder.ServiceProvider.CreateScope();
foreach (var module in scope.ServiceProvider.GetServices<CarterModule>())
{
foreach (var route in module.Routes)
{
var conventionBuilder = builder.MapMethods(route.Key.path, new[] { route.Key.verb }, route.Value.handler);
route.Value.conventions.Apply(conventionBuilder);
builders.Add(conventionBuilder);
}
}
// Allow the user to apply conventions to all modules
return new CompositeConventionBuilder(builders);
}
private class CompositeConventionBuilder : IEndpointConventionBuilder
{
private readonly List<IEndpointConventionBuilder> _builders;
public CompositeConventionBuilder(List<IEndpointConventionBuilder> builders)
{
_builders = builders;
}
public void Add(Action<EndpointBuilder> convention)
{
foreach (var builder in _builders)
{
builder.Add(convention);
}
}
}
}
public class Startup
{
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddAuthorization();
services.AddScoped<CarterModule, HelloModule>();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapCarter();
});
}
}
}
jchannon
I have been thinking about what we have in #112 and what we can do there. I have been thinking Carter could expose the ASP.NET Core APIs yet still offer its own features. This means we could offer the same as ASP.NET Core APIs such as
this.Get("/", ctx => ctx.WriteAsync("hi").RequiresAuth().RequiresHost()however I am currently unsure how to wire this up.We currently do this for ASPNET3 https://github.com/CarterCommunity/Carter/blob/aspnetcore3/src/CarterExtensions.cs#L58 but I'm not sure if CarterModule should expose a list of
IEndpointConventionBuilderpotentially and then wire that up to the endpoint routing middleware.Hoping @davidfowl can help point in the right direction