/// <summary>
/// Instantiates a new <see cref="DelegateEndpointConventionBuilder" /> given a single
/// <see cref="IEndpointConventionBuilder" />.
/// </summary>
/// <param name="endpointConventionBuilder">The <see cref="IEndpointConventionBuilder" /> to instantiate with.</param>
internal DelegateEndpointConventionBuilder(IEndpointConventionBuilder endpointConventionBuilder)
{
_endpointConventionBuilders = new List <IEndpointConventionBuilder>()
{
endpointConventionBuilder
};
}
public void Apply(IEndpointConventionBuilder builder)
{
foreach (var a in this._actions)
{
builder.Add(a);
}
}
/// <summary>
/// Instantiates a new <see cref="RouteHandlerBuilder" /> given a single
/// <see cref="IEndpointConventionBuilder" />.
/// </summary>
/// <param name="endpointConventionBuilder">The <see cref="IEndpointConventionBuilder" /> to instantiate with.</param>
internal RouteHandlerBuilder(IEndpointConventionBuilder endpointConventionBuilder)
{
_endpointConventionBuilders = new List <IEndpointConventionBuilder>()
{
endpointConventionBuilder
};
}
public void Execute(IEndpointConventionBuilder endpointConventionBuilder)
{
foreach (var deferredConvention in _deferredConventions)
{
endpointConventionBuilder.Add(deferredConvention);
}
}
/// <summary>
/// Adds Easy.Endpoints routes to EndpointRouteBuilder
/// </summary>
/// <param name="endpoints">Microsoft.AspNetCore.Routing.IEndpointRouteBuilder to add Easy.Endpoints to</param>
/// <returns>Returns Microsoft.AspNetCore.Builder.IEndpointConventionBuilder for endpoints</returns>
public static IEndpointConventionBuilder MapEasyEndpoints(
this IEndpointRouteBuilder endpoints)
{
var requestEndPoints = endpoints.ServiceProvider.GetRequiredService <IEndpointManifest>().ToArray();
var dataSource = endpoints.DataSources.OfType <EasyEndpointDataSource>().FirstOrDefault();
if (dataSource is null)
{
dataSource = new EasyEndpointDataSource();
endpoints.DataSources.Add(dataSource);
}
var results = new IEndpointConventionBuilder[requestEndPoints.Length];
var i = 0;
foreach (var endPoint in requestEndPoints)
{
var builder = new RouteEndpointBuilder(
BuildDelegate(endPoint),
endPoint.Pattern, endPoint.Order)
{
DisplayName = endPoint.Name,
};
foreach (var meta in endPoint.Meta)
{
builder.Metadata.Add(meta);
}
results[i] = dataSource.AddEndpointBuilder(builder);
i++;
}
return(new GroupedEasyEndpointConventionBuilder(results));
}
public static IEndpointConventionBuilder WithName(this IEndpointConventionBuilder endpointBuilder, string endpointName)
{
return(endpointBuilder.WithMetadata(
new EndpointNameMetadata(endpointName),
new RouteNameMetadata(endpointName)
));
}
internal MinimalActionEndpointConventionBuilder(IEndpointConventionBuilder endpointConventionBuilder)
{
_endpointConventionBuilders = new List <IEndpointConventionBuilder>()
{
endpointConventionBuilder
};
}
private void ConfigureAuthorization(IEndpointConventionBuilder builder)
{
bool.TryParse(_config["enableCertAuth"], out var enableCertAuth);
if (enableCertAuth)
{
builder.RequireAuthorization();
}
}
public void ConfigureEndpoint(RequestMethod method, IEndpointConventionBuilder builder)
{
// Note the optional 'configure' parameter in EndpointBroker.BindEndpoint(...)
if (ConfigureAction != null)
{
ConfigureAction.Invoke(method, builder);
}
}
public static IEndpointConventionBuilder RequireAuthorization(this IEndpointConventionBuilder builder, params string[] roles)
{
builder.Apply(endpointBuilder => endpointBuilder.Metadata.Add(new AuthorizeAttribute
{
Roles = string.Join(",", roles)
}));
return(builder);
}
/// <summary>
/// Adds the default authorization policy to the endpoint(s).
/// </summary>
/// <param name="builder">The endpoint convention builder.</param>
/// <returns>The original convention builder parameter.</returns>
public static IEndpointConventionBuilder RequireAuthorization(this IEndpointConventionBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder.RequireAuthorization(new AuthorizeAttribute()));
}
private static void Map <TRequest>(
this IEndpointRouteBuilder endpoints,
string pattern,
HttpMethod method,
string group = null,
CommandEndpointResponse response = null,
OpenApiOperation openApi = null)
{
if (pattern.IsNullOrEmpty())
{
throw new ArgumentNullException($"{typeof(TRequest)} cannot be registered with a null or empty route pattern.");
}
if (!pattern.StartsWith('/'))
{
pattern = $"/{pattern}"; // ensure leading pattern slash
}
var mediator = endpoints.ServiceProvider.GetService <IMediator>()
?? throw new InvalidOperationException("IMediator has not been added to IServiceCollection. You can add it with services.AddMediatR(...);");
var configuration = endpoints.ServiceProvider.GetService <ICommandEndpointConfiguration>() // =singleton
?? throw new InvalidOperationException("ICommandEndpointRegistrations has not been added to IServiceCollection. You can add it with services.AddCommandEndpoints(...);");
var registration = configuration.AddRegistration <TRequest>(pattern, method);
registration.OpenApi = openApi ?? new OpenApiOperation()
{
GroupName = group ?? pattern.SliceFromLast("/").SliceTill("?").SliceTill("{").EmptyToNull() ?? "Undefined"
};
registration.Response = response;
IEndpointConventionBuilder builder = null;
if (method == HttpMethod.Get)
{
builder = endpoints.MapGet(pattern.SliceTill("?"), CommandEndpointRequestHandler.InvokeAsync);
}
else if (method == HttpMethod.Post)
{
builder = endpoints.MapPost(pattern.SliceTill("?"), CommandEndpointRequestHandler.InvokeAsync);
}
else if (method == HttpMethod.Put)
{
builder = endpoints.MapPut(pattern.SliceTill("?"), CommandEndpointRequestHandler.InvokeAsync);
}
else if (method == HttpMethod.Delete)
{
builder = endpoints.MapDelete(pattern.SliceTill("?"), CommandEndpointRequestHandler.InvokeAsync);
}
//else if (method == HttpMethod.Patch)
//{
// builder = endpoints.MapPatch(pattern.SliceTill("?"), CommandEndpointRequestDelegate);
//}
builder?.WithDisplayName(registration.Name);
builder?.WithMetadata(registration);
}
private void ConfigureAuthorization(IEndpointConventionBuilder builder)
{
#if NET5_0_OR_GREATER
bool.TryParse(_config["enableCertAuth"], out var enableCertAuth);
if (enableCertAuth)
{
builder.RequireAuthorization();
}
#endif
}
public static IEndpointConventionBuilder RequireFeature(this IEndpointConventionBuilder builder, string featureName)
{
builder.Add(endpointBuilder =>
{
var featureGate = new EndpointFeatureGateAttribute(true, featureName);
endpointBuilder.Metadata.Add(featureGate);
});
return(builder);
}
/// <summary>
/// Adds a CORS policy with the specified name to the endpoint(s).
/// </summary>
/// <param name="builder">The endpoint convention builder.</param>
/// <param name="policyName">The CORS policy name.</param>
/// <returns>The original convention builder parameter.</returns>
public static IEndpointConventionBuilder WithCorsPolicy(this IEndpointConventionBuilder builder, string policyName)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.Add(endpointBuilder =>
{
endpointBuilder.Metadata.Add(new EnableCorsAttribute(policyName));
});
return(builder);
}
/// <summary>
/// Sets the <see cref="EndpointBuilder.DisplayName"/> to the provided <paramref name="displayName"/> for all
/// builders created by <paramref name="builder"/>.
/// </summary>
/// <param name="builder">The <see cref="IEndpointConventionBuilder"/>.</param>
/// <param name="displayName">The display name.</param>
/// <returns>The <see cref="IEndpointConventionBuilder"/>.</returns>
public static IEndpointConventionBuilder WithDisplayName(this IEndpointConventionBuilder builder, string displayName)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.Add(b =>
{
b.DisplayName = displayName;
});
return(builder);
}
public static IEndpointConventionBuilder RequireAuthorization(this IEndpointConventionBuilder builder, params string[] policyNames)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (policyNames == null)
{
throw new ArgumentNullException(nameof(policyNames));
}
return(builder.RequireAuthorization(policyNames.Select(n => new AuthorizeAttribute(n)).ToArray()));
}
/// <summary>
/// Adds <typeparamref name="TComponent"/> to the list of components registered with this <see cref="ComponentHub"/> instance.
/// </summary>
/// <typeparam name="TComponent">The component type.</typeparam>
/// <param name="builder">The <see cref="IEndpointConventionBuilder"/>.</param>
/// <param name="selector">A CSS selector that identifies the DOM element into which the <typeparamref name="TComponent"/> will be placed.</param>
/// <returns>The <paramref name="builder"/>.</returns>
public static IEndpointConventionBuilder AddComponent <TComponent>(this IEndpointConventionBuilder builder, string selector)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (selector == null)
{
throw new ArgumentNullException(nameof(selector));
}
return(AddComponent(builder, typeof(TComponent), selector));
}
protected virtual TestServer CreateStarWarsServer(
string pattern = "/graphql",
Action <IEndpointConventionBuilder> configureConventions = default)
{
return(ServerFactory.Create(
services => services
.AddRouting()
.AddHttpRequestSerializer(HttpResultSerialization.JsonArray)
.AddGraphQLServer()
.AddStarWarsTypes()
.AddTypeExtension <QueryExtension>()
.AddExportDirectiveType()
.AddStarWarsRepositories()
.AddInMemorySubscriptions()
.AddGraphQLServer("evict")
.AddQueryType(d => d.Name("Query"))
.AddTypeExtension <QueryExtension>()
.AddGraphQLServer("arguments")
.AddQueryType(d =>
{
d
.Name("QueryRoot");
d
.Field("double_arg")
.Argument("d", t => t.Type <FloatType>())
.Type <FloatType>()
.Resolve(c => c.ArgumentValue <double?>("d"));
d
.Field("decimal_arg")
.Argument("d", t => t.Type <DecimalType>())
.Type <DecimalType>()
.Resolve(c => c.ArgumentValue <decimal?>("d"));
}),
app => app
.UseWebSockets()
.UseRouting()
.UseEndpoints(endpoints =>
{
IEndpointConventionBuilder builder = endpoints.MapGraphQL(pattern);
if (configureConventions is { })
{
configureConventions(builder);
}
endpoints.MapGraphQL("/evict", "evict");
endpoints.MapGraphQL("/arguments", "arguments");
})));
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
app.UseForwardedHeaders();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/error");
}
app
.UseMiddleware <RequestLoggingMiddleware>()
.UseMiddleware <OpenTracingSpanTaggingMiddleware>()
.UseSwagger()
.UseSwaggerUI(options =>
{
options.SwaggerEndpoint("/swagger/v1/swagger.json", "Scaffold.WebApi v1");
});
app
.UseRouting()
.UseHttpMetrics()
.UseAuthorization()
.UseEndpoints(endpoints =>
{
IEndpointConventionBuilder healthCheckEndpoint = endpoints.MapHealthChecks("/health");
if (this.Configuration["HealthCheckPort"] != null)
{
healthCheckEndpoint.RequireHost($"*:{this.Configuration["HealthCheckPort"]}");
}
IEndpointConventionBuilder metricsEndpoint = endpoints.MapMetrics();
if (this.Configuration["MetricsPort"] != null)
{
metricsEndpoint.RequireHost($"*:{this.Configuration["MetricsPort"]}");
}
endpoints.MapControllers();
});
}
/// <summary>
/// Requires that endpoints match one of the specified hosts during routing.
/// </summary>
/// <param name="builder">The <see cref="IEndpointConventionBuilder"/> to add the metadata to.</param>
/// <param name="hosts">
/// The hosts used during routing.
/// Hosts should be Unicode rather than punycode, and may have a port.
/// An empty collection means any host will be accepted.
/// </param>
/// <returns>A reference to this instance after the operation has completed.</returns>
public static IEndpointConventionBuilder RequireHost(this IEndpointConventionBuilder builder, params string[] hosts)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (hosts == null)
{
throw new ArgumentNullException(nameof(hosts));
}
builder.Add(endpointBuilder =>
{
endpointBuilder.Metadata.Add(new HostAttribute(hosts));
});
return(builder);
}
/// <summary>
/// Sets the <see cref="EndpointBuilder.DisplayName"/> using the provided <paramref name="func"/> for all
/// builders created by <paramref name="builder"/>.
/// </summary>
/// <param name="builder">The <see cref="IEndpointConventionBuilder"/>.</param>
/// <param name="func">A delegate that produces the display name for each <see cref="EndpointBuilder"/>.</param>
/// <returns>The <see cref="IEndpointConventionBuilder"/>.</returns>
public static IEndpointConventionBuilder WithDisplayName(this IEndpointConventionBuilder builder, Func <EndpointBuilder, string> func)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (func == null)
{
throw new ArgumentNullException(nameof(func));
}
builder.Add(b =>
{
b.DisplayName = func(b);
});
return(builder);
}
/// <summary>
/// Adds <paramref name="componentType"/> to the list of components registered with this <see cref="ComponentHub"/> instance.
/// The selector will default to the component name in lowercase.
/// </summary>
/// <param name="builder">The <see cref="IEndpointConventionBuilder"/>.</param>
/// <param name="componentType">The component type.</param>
/// <param name="selector">The component selector in the DOM for the <paramref name="componentType"/>.</param>
/// <returns>The <paramref name="builder"/>.</returns>
public static IEndpointConventionBuilder AddComponent(this IEndpointConventionBuilder builder, Type componentType, string selector)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (componentType == null)
{
throw new ArgumentNullException(nameof(componentType));
}
if (selector == null)
{
throw new ArgumentNullException(nameof(selector));
}
builder.Add(endpointBuilder => AddComponent(endpointBuilder.Metadata, componentType, selector));
return(builder);
}
public static IEndpointConventionBuilder RequireAuthorization(this IEndpointConventionBuilder builder, params IAuthorizeData[] authorizeData)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (authorizeData == null)
{
throw new ArgumentNullException(nameof(authorizeData));
}
builder.Apply(endpointBuilder =>
{
foreach (var data in authorizeData)
{
endpointBuilder.Metadata.Add(data);
}
});
return(builder);
}
private static void ApplyAuthRolesAndPolicies(IEndpointConventionBuilder builder, bool auth, string roles,
params string[] policies)
{
if (policies is not null && policies.Any())
{
builder.RequireAuthorization(policies);
return;
}
var hasRoles = !string.IsNullOrWhiteSpace(roles);
var authorize = new AuthorizeAttribute();
if (hasRoles)
{
authorize.Roles = roles;
}
if (auth || hasRoles)
{
builder.RequireAuthorization(authorize);
}
}
/// <summary>
/// Adds the provided metadata <paramref name="items"/> to <see cref="EndpointBuilder.Metadata"/> for all builders
/// produced by <paramref name="builder"/>.
/// </summary>
/// <param name="builder">The <see cref="IEndpointConventionBuilder"/>.</param>
/// <param name="items">A collection of metadata items.</param>
/// <returns>The <see cref="IEndpointConventionBuilder"/>.</returns>
public static IEndpointConventionBuilder WithMetadata(this IEndpointConventionBuilder builder, params object[] items)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (items == null)
{
throw new ArgumentNullException(nameof(items));
}
builder.Add(b =>
{
foreach (var item in items)
{
b.Metadata.Add(item);
}
});
return(builder);
}
/// <summary>
/// Adds the specified CORS policy to the endpoint(s).
/// </summary>
/// <param name="builder">The endpoint convention builder.</param>
/// <param name="configurePolicy">A delegate which can use a policy builder to build a policy.</param>
/// <returns>The original convention builder parameter.</returns>
public static IEndpointConventionBuilder WithCorsPolicy(this IEndpointConventionBuilder builder, Action <CorsPolicyBuilder> configurePolicy)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configurePolicy == null)
{
throw new ArgumentNullException(nameof(configurePolicy));
}
var policyBuilder = new CorsPolicyBuilder();
configurePolicy(policyBuilder);
var policy = policyBuilder.Build();
builder.Add(endpointBuilder =>
{
endpointBuilder.Metadata.Add(new CorsPolicyMetadata(policy));
});
return(builder);
}
/// <summary>
/// Adds a Banana Cake Pop endpoint to the endpoint configurations.
/// </summary>
/// <param name="endpointRouteBuilder">
/// The <see cref="IEndpointConventionBuilder"/>.
/// </param>
/// <param name="toolPath">
/// The path to which banana cake pop is mapped.
/// </param>
/// <param name="relativeRequestPath">
/// The relative path on which the server is listening for GraphQL requests.
/// </param>
/// <returns>
/// Returns the <see cref="IEndpointConventionBuilder"/> so that
/// configuration can be chained.
/// </returns>
public static BananaCakePopEndpointConventionBuilder MapBananaCakePop(
this IEndpointRouteBuilder endpointRouteBuilder,
PathString?toolPath = default,
string?relativeRequestPath = "..")
{
if (endpointRouteBuilder is null)
{
throw new ArgumentNullException(nameof(endpointRouteBuilder));
}
toolPath ??= "/graphql/ui";
relativeRequestPath ??= "..";
RoutePattern pattern = Parse(toolPath.ToString() + "/{**slug}");
IApplicationBuilder requestPipeline = endpointRouteBuilder.CreateApplicationBuilder();
IFileProvider fileProvider = CreateFileProvider();
requestPipeline
.UseCancellation()
.UseMiddleware <ToolDefaultFileMiddleware>(fileProvider, toolPath)
.UseMiddleware <ToolOptionsFileMiddleware>(toolPath)
.UseMiddleware <ToolStaticFileMiddleware>(fileProvider, toolPath)
.Use(_ => context =>
{
context.Response.StatusCode = 404;
return(Task.CompletedTask);
});
IEndpointConventionBuilder builder = endpointRouteBuilder
.Map(pattern, requestPipeline.Build())
.WithDisplayName("Banana Cake Pop Pipeline")
.WithMetadata(new GraphQLEndpointOptions {
GraphQLEndpoint = relativeRequestPath
});
return(new BananaCakePopEndpointConventionBuilder(builder));
}
internal ComponentEndpointConventionBuilder(IEndpointConventionBuilder endpointConventionBuilder)
{
_endpointConventionBuilder = endpointConventionBuilder;
}
internal GraphQLHttpEndpointConventionBuilder(IEndpointConventionBuilder builder)
{
_builder = builder;
}
