redb.Route.Http 3.3.0

redb.Route.Http

HTTP/HTTPS transport for redb.Route. HttpClient-based producer (outbound requests) and Kestrel-based consumer (webhook receiver) with CORS, auth, and streaming.

Installation

dotnet add package redb.Route.Http

Usage

Fluent DSL

using redb.Route.Http.Fluent;

// Outbound HTTP call (producer)
From("direct://send")
    .To(Http.Post("api.example.com/orders")
        .Timeout(5000)
        .BearerAuth()
        .ContentType("application/json"));

// Webhook receiver (consumer)
From(Http.Listen("/webhooks/orders")
        .Host("0.0.0.0").Port(8080)
        .Methods("POST")
        .Cors("https://app.example.com")
        .MaxRequestBodySize(1_048_576))
    .Log("Webhook received: ${body}")
    .To("direct://process");

// REST methods shorthand
From("direct://get-data")
    .To(Http.Get("api.example.com/status").NoThrowOnError());

From("direct://update")
    .To(Http.Put("api.example.com/orders/${header.orderId}"));

From("direct://remove")
    .To(Http.Delete("api.example.com/orders/${header.orderId}"));

// HTTPS
From("direct://secure-call")
    .To(Https.Post("api.example.com/data")
        .BearerAuth()
        .AuthToken("${property.jwt}"));

// Named parameters — {name} in URL resolved from .Param() at runtime
From("direct://get-order")
    .To(Http.Get("api.example.com/orders/{orderId}")
        .Param("orderId", Header("orderId")));

// Multiple named parameters + IExpression values
From("direct://user-orders")
    .To(Http.Get("api.example.com/users/{userId}/orders/{status}")
        .Param("userId", Header("userId"))
        .Param("status", Constant("active")));

${...} expressions in URL and options are resolved per message at runtime. {name} placeholders are resolved from .Param() bindings — values are URL-encoded automatically. In fluent DSL, pass the path without http:// / https:// — the scheme is set by Http. vs Https..

Raw URI (non-fluent)

// Raw URI strings include the full scheme — ${...} resolved per message
From("direct://update")
    .To("https://api.example.com/orders/${header.orderId}?method=PUT");

// Fully dynamic URL — host, port, path all from expressions
From("direct://proxy")
    .To("https://${header.targetHost}:${header.targetPort}/api/${header.resource}?method=POST");

Fluent Builder API

Most builder methods (Timeout, BasicAuth, AuthToken, MaxRedirects, Host, Port, MaxRequestBodySize, SslCert, ResponseCode) accept both constant values and IExpression for runtime resolution.

Schemes

Both http and https schemes are supported. Use Https.Get(...) / Https.Post(...) for TLS endpoints.

Routing precedence (shared server)

Multiple consumers can register routes on the same (host, port) — they share one Kestrel server. When several routes match the same request path, the most specific path wins, not the first one registered:

1. Concrete/literal paths (/api/echo) before route-parameter paths (/api/{id}).
2. Fewer route parameters before more.
3. Catch-all templates (/{**path}) are tried last.
4. Registration order breaks ties (first-registered wins among equal specificity).

This means a concrete path and a catch-all fallback can coexist on one port — e.g. a dispatcher mounted on /{**path} plus a dedicated /api/echo route — and /api/echo is routed to the specific handler. The same ordering drives per-route CORS dispatch.

Part of

redb.Route — ESB & EIP Framework for .NET