radiant - v2.0.0

radiant/router

Router types, route registration, and dispatch.

Types

Middleware

</>

A middleware transforms a handler into a new handler.

pub type Middleware =
  fn(fn(request.Req) -> response.Response(BitArray)) -> fn(
    request.Req,
  ) -> response.Response(BitArray)

Param

opaque </>

A typed path parameter for use with get1, get2, and friends.

pub opaque type Param(a)

Router

opaque </>

An opaque router that maps HTTP method + path pattern to handlers.

pub opaque type Router

Values

any

</> 
pub fn any(
  router: Router,
  pattern: String,
  handler: fn(request.Req) -> response.Response(BitArray),
) -> Router

delete

</> 
pub fn delete(
  router: Router,
  pattern: String,
  handler: fn(request.Req) -> response.Response(BitArray),
) -> Router

delete1

</> 
pub fn delete1(
  router: Router,
  pattern: String,
  p1: Param(a),
  handler: fn(request.Req, a) -> response.Response(BitArray),
) -> Router

delete2

</> 
pub fn delete2(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  handler: fn(request.Req, a, b) -> response.Response(BitArray),
) -> Router

delete3

</> 
pub fn delete3(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  handler: fn(request.Req, a, b, c) -> response.Response(BitArray),
) -> Router

delete4

</> 
pub fn delete4(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  p4: Param(d),
  handler: fn(request.Req, a, b, c, d) -> response.Response(
    BitArray,
  ),
) -> Router

delete5

</> 
pub fn delete5(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  p4: Param(d),
  p5: Param(e),
  handler: fn(request.Req, a, b, c, d, e) -> response.Response(
    BitArray,
  ),
) -> Router

delete6

</> 
pub fn delete6(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  p4: Param(d),
  p5: Param(e),
  p6: Param(f),
  handler: fn(request.Req, a, b, c, d, e, f) -> response.Response(
    BitArray,
  ),
) -> Router

fallback

</> 
pub fn fallback(
  router: Router,
  handler: fn(request.Req) -> response.Response(BitArray),
) -> Router

get

</> 
pub fn get(
  router: Router,
  pattern: String,
  handler: fn(request.Req) -> response.Response(BitArray),
) -> Router

get1

</> 
pub fn get1(
  router: Router,
  pattern: String,
  p1: Param(a),
  handler: fn(request.Req, a) -> response.Response(BitArray),
) -> Router

get2

</> 
pub fn get2(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  handler: fn(request.Req, a, b) -> response.Response(BitArray),
) -> Router

get3

</> 
pub fn get3(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  handler: fn(request.Req, a, b, c) -> response.Response(BitArray),
) -> Router

get4

</> 
pub fn get4(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  p4: Param(d),
  handler: fn(request.Req, a, b, c, d) -> response.Response(
    BitArray,
  ),
) -> Router

get5

</> 
pub fn get5(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  p4: Param(d),
  p5: Param(e),
  handler: fn(request.Req, a, b, c, d, e) -> response.Response(
    BitArray,
  ),
) -> Router

get6

</> 
pub fn get6(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  p4: Param(d),
  p5: Param(e),
  p6: Param(f),
  handler: fn(request.Req, a, b, c, d, e, f) -> response.Response(
    BitArray,
  ),
) -> Router

handle

</> 
pub fn handle(
  router: Router,
  req: request.Request(BitArray),
) -> response.Response(BitArray)

handle_with

</> 
pub fn handle_with(
  router: Router,
  req: request.Request(anything),
  body: BitArray,
) -> response.Response(BitArray)

int

</> 
pub fn int(name: String) -> Param(Int)

middleware

</> 
pub fn middleware(
  router: Router,
  mw: fn(fn(request.Req) -> response.Response(BitArray)) -> fn(
    request.Req,
  ) -> response.Response(BitArray),
) -> Router

mount

</> 
pub fn mount(
  router: Router,
  prefix: String,
  sub_router: Router,
) -> Router

new

</> 
pub fn new() -> Router

options

</> 
pub fn options(
  router: Router,
  pattern: String,
  handler: fn(request.Req) -> response.Response(BitArray),
) -> Router

patch

</> 
pub fn patch(
  router: Router,
  pattern: String,
  handler: fn(request.Req) -> response.Response(BitArray),
) -> Router

patch1

</> 
pub fn patch1(
  router: Router,
  pattern: String,
  p1: Param(a),
  handler: fn(request.Req, a) -> response.Response(BitArray),
) -> Router

patch2

</> 
pub fn patch2(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  handler: fn(request.Req, a, b) -> response.Response(BitArray),
) -> Router

patch3

</> 
pub fn patch3(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  handler: fn(request.Req, a, b, c) -> response.Response(BitArray),
) -> Router

patch4

</> 
pub fn patch4(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  p4: Param(d),
  handler: fn(request.Req, a, b, c, d) -> response.Response(
    BitArray,
  ),
) -> Router

patch5

</> 
pub fn patch5(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  p4: Param(d),
  p5: Param(e),
  handler: fn(request.Req, a, b, c, d, e) -> response.Response(
    BitArray,
  ),
) -> Router

patch6

</> 
pub fn patch6(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  p4: Param(d),
  p5: Param(e),
  p6: Param(f),
  handler: fn(request.Req, a, b, c, d, e, f) -> response.Response(
    BitArray,
  ),
) -> Router

path_for

</> 
pub fn path_for(
  pattern: String,
  params: List(#(String, String)),
) -> Result(String, request.RadiantError)

path_for1

</> 
pub fn path_for1(
  pattern: String,
  p1: Param(a),
  v1: a,
) -> Result(String, request.RadiantError)

path_for2

</> 
pub fn path_for2(
  pattern: String,
  p1: Param(a),
  v1: a,
  p2: Param(b),
  v2: b,
) -> Result(String, request.RadiantError)

path_for3

</> 
pub fn path_for3(
  pattern: String,
  p1: Param(a),
  v1: a,
  p2: Param(b),
  v2: b,
  p3: Param(c),
  v3: c,
) -> Result(String, request.RadiantError)

path_for4

</> 
pub fn path_for4(
  pattern: String,
  p1: Param(a),
  v1: a,
  p2: Param(b),
  v2: b,
  p3: Param(c),
  v3: c,
  p4: Param(d),
  v4: d,
) -> Result(String, request.RadiantError)

path_for5

</> 
pub fn path_for5(
  pattern: String,
  p1: Param(a),
  v1: a,
  p2: Param(b),
  v2: b,
  p3: Param(c),
  v3: c,
  p4: Param(d),
  v4: d,
  p5: Param(e),
  v5: e,
) -> Result(String, request.RadiantError)

path_for6

</> 
pub fn path_for6(
  pattern: String,
  p1: Param(a),
  v1: a,
  p2: Param(b),
  v2: b,
  p3: Param(c),
  v3: c,
  p4: Param(d),
  v4: d,
  p5: Param(e),
  v5: e,
  p6: Param(f),
  v6: f,
) -> Result(String, request.RadiantError)

post

</> 
pub fn post(
  router: Router,
  pattern: String,
  handler: fn(request.Req) -> response.Response(BitArray),
) -> Router

post1

</> 
pub fn post1(
  router: Router,
  pattern: String,
  p1: Param(a),
  handler: fn(request.Req, a) -> response.Response(BitArray),
) -> Router

post2

</> 
pub fn post2(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  handler: fn(request.Req, a, b) -> response.Response(BitArray),
) -> Router

post3

</> 
pub fn post3(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  handler: fn(request.Req, a, b, c) -> response.Response(BitArray),
) -> Router

post4

</> 
pub fn post4(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  p4: Param(d),
  handler: fn(request.Req, a, b, c, d) -> response.Response(
    BitArray,
  ),
) -> Router

post5

</> 
pub fn post5(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  p4: Param(d),
  p5: Param(e),
  handler: fn(request.Req, a, b, c, d, e) -> response.Response(
    BitArray,
  ),
) -> Router

post6

</> 
pub fn post6(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  p4: Param(d),
  p5: Param(e),
  p6: Param(f),
  handler: fn(request.Req, a, b, c, d, e, f) -> response.Response(
    BitArray,
  ),
) -> Router

put

</> 
pub fn put(
  router: Router,
  pattern: String,
  handler: fn(request.Req) -> response.Response(BitArray),
) -> Router

put1

</> 
pub fn put1(
  router: Router,
  pattern: String,
  p1: Param(a),
  handler: fn(request.Req, a) -> response.Response(BitArray),
) -> Router

put2

</> 
pub fn put2(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  handler: fn(request.Req, a, b) -> response.Response(BitArray),
) -> Router

put3

</> 
pub fn put3(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  handler: fn(request.Req, a, b, c) -> response.Response(BitArray),
) -> Router

put4

</> 
pub fn put4(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  p4: Param(d),
  handler: fn(request.Req, a, b, c, d) -> response.Response(
    BitArray,
  ),
) -> Router

put5

</> 
pub fn put5(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  p4: Param(d),
  p5: Param(e),
  handler: fn(request.Req, a, b, c, d, e) -> response.Response(
    BitArray,
  ),
) -> Router

put6

</> 
pub fn put6(
  router: Router,
  pattern: String,
  p1: Param(a),
  p2: Param(b),
  p3: Param(c),
  p4: Param(d),
  p5: Param(e),
  p6: Param(f),
  handler: fn(request.Req, a, b, c, d, e, f) -> response.Response(
    BitArray,
  ),
) -> Router

query_method

</> 
pub const query_method: http.Method

The HTTP QUERY method from RFC 10008.

query_route

</> 
pub fn query_route(
  router: Router,
  pattern: String,
  handler: fn(request.Req) -> response.Response(BitArray),
) -> Router

route

</> 
pub fn route(
  router: Router,
  method: http.Method,
  pattern: String,
  handler: fn(request.Req) -> response.Response(BitArray),
) -> Router

Register a route for any HTTP method.

routes

</> 
pub fn routes(router: Router) -> List(#(http.Method, String))

scope

</> 
pub fn scope(
  router: Router,
  prefix: String,
  builder: fn(Router) -> Router,
) -> Router

str

</> 
pub fn str(name: String) -> Param(String)

wrap

</> 
pub fn wrap(
  mw: fn(fn(request.Req) -> response.Response(BitArray)) -> fn(
    request.Req,
  ) -> response.Response(BitArray),
  handler: fn(request.Req) -> response.Response(BitArray),
) -> fn(request.Req) -> response.Response(BitArray)
✨ Search Document