radiant - v2.0.0

radiant

Backwards-compatible facade for import radiant. The implementation is split across focused radiant/* modules; this module remains the compatibility surface for application code.

Types

CorsConfig

</> 
pub type CorsConfig {
  CorsConfig(
    origins: List(String),
    methods: List(http.Method),
    headers: List(String),
    max_age: Int,
  )
}

Constructors 

  • CorsConfig(
  origins: List(String),
  methods: List(http.Method),
  headers: List(String),
  max_age: Int,
)

FileSystem

</> 
pub type FileSystem {
  FileSystem(
    read_bits: fn(String) -> Result(BitArray, Nil),
    is_file: fn(String) -> Bool,
  )
}

Constructors 

  • FileSystem(
  read_bits: fn(String) -> Result(BitArray, Nil),
  is_file: fn(String) -> Bool,
)

Key

</> 
pub type Key(a) =
  request.Key(a)

Middleware

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

Param

</> 
pub type Param(a) =
  router.Param(a)

RadiantError

</> 
pub type RadiantError {
  MissingHeader(String)
  InvalidUtf8Body
  MissingPathParam(String)
  InvalidIntParam(String, String)
  MissingQuery(String)
  InvalidIntQuery(String, String)
  InvalidFloatQuery(String, String)
  InvalidBoolQuery(String, String)
  MalformedQuery(String)
  MissingContext(String)
}

Constructors 

  • MissingHeader(String)
  • InvalidUtf8Body
  • MissingPathParam(String)
  • InvalidIntParam(String, String)
  • MissingQuery(String)
  • InvalidIntQuery(String, String)
  • InvalidFloatQuery(String, String)
  • InvalidBoolQuery(String, String)
  • MalformedQuery(String)
  • MissingContext(String)

Req

</> 
pub type Req =
  request.Req

Router

</> 
pub type Router =
  router.Router

TestRequest

</> 
pub type TestRequest =
  testing.TestRequest

Values

any

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

bad_request

</> 
pub fn bad_request() -> response.Response(BitArray)

bad_request_with

</> 
pub fn bad_request_with(
  body_text: String,
) -> response.Response(BitArray)

body

</> 
pub fn body(req: request.Req) -> BitArray

build

</> 
pub fn build(
  test_request: testing.TestRequest,
) -> request.Request(BitArray)

cors

</> 
pub fn cors(
  config: CorsConfig,
) -> fn(fn(request.Req) -> response.Response(BitArray)) -> fn(
  request.Req,
) -> response.Response(BitArray)

created

</> 
pub fn created(body_text: String) -> response.Response(BitArray)

default_cors

</> 
pub fn default_cors() -> CorsConfig

delete

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

delete1

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

delete2

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

delete3

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

delete4

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

delete5

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

delete6

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

error_message

</> 
pub fn error_message(error: RadiantError) -> String

Return a concise, stable message for a RadiantError.

fallback

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

forbidden

</> 
pub fn forbidden() -> response.Response(BitArray)

forbidden_with

</> 
pub fn forbidden_with(
  body_text: String,
) -> response.Response(BitArray)

get

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

get1

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

get2

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

get3

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

get4

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

get5

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

get6

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

get_context

</> 
pub fn get_context(
  req: request.Req,
  k: request.Key(a),
) -> Result(a, RadiantError)

handle

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

handle_with

</> 
pub fn handle_with(
  router: router.Router,
  req: request.Request(anything),
  body: BitArray,
) -> response.Response(BitArray)
</> 
pub fn header(
  req: request.Req,
  key: String,
) -> Result(String, RadiantError)

headers

</> 
pub fn headers(req: request.Req) -> List(#(String, String))

html

</> 
pub fn html(body_text: String) -> response.Response(BitArray)

int

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

int_param

</> 
pub fn int_param(
  req: request.Req,
  name: String,
) -> Result(Int, RadiantError)

internal_server_error

</> 
pub fn internal_server_error() -> response.Response(BitArray)

internal_server_error_with

</> 
pub fn internal_server_error_with(
  body_text: String,
) -> response.Response(BitArray)

json

</> 
pub fn json(body_text: String) -> response.Response(BitArray)

json_body

</> 
pub fn json_body(
  key: request.Key(a),
  decoder: decode.Decoder(a),
) -> fn(fn(request.Req) -> response.Response(BitArray)) -> fn(
  request.Req,
) -> response.Response(BitArray)

json_error

</> 
pub fn json_error(
  status: Int,
  message: String,
) -> response.Response(BitArray)

json_error_from

</> 
pub fn json_error_from(
  status: Int,
  error: RadiantError,
) -> response.Response(BitArray)

Build a JSON error response from a detailed RadiantError.

key

</> 
pub fn key(name: String) -> request.Key(a)

key_named

</> 
pub fn key_named(
  namespace: String,
  name: String,
) -> request.Key(a)

log

</> 
pub fn log(
  logger: fn(String) -> a,
) -> fn(fn(request.Req) -> response.Response(BitArray)) -> fn(
  request.Req,
) -> response.Response(BitArray)

method

</> 
pub fn method(req: request.Req) -> http.Method

method_not_allowed

</> 
pub fn method_not_allowed(
  allowed: String,
) -> response.Response(BitArray)

middleware

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

mount

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

new

</> 
pub fn new() -> router.Router

no_content

</> 
pub fn no_content() -> response.Response(BitArray)

not_found

</> 
pub fn not_found() -> response.Response(BitArray)

not_found_with

</> 
pub fn not_found_with(
  body_text: String,
) -> response.Response(BitArray)

ok

</> 
pub fn ok(body_text: String) -> response.Response(BitArray)

options

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

original

</> 
pub fn original(req: request.Req) -> request.Request(BitArray)

patch

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

patch1

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

patch2

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

patch3

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

patch4

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

patch5

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

patch6

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

path_for

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

path_for1

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

path_for2

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

path_for3

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

path_for4

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

path_for5

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

path_for6

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

post

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

post1

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

post2

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

post3

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

post4

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

post5

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

post6

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

put

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

put1

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

put2

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

put3

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

put4

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

put5

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

put6

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

queries

</> 
pub fn queries(req: request.Req) -> List(#(String, String))

query

</> 
pub fn query(
  req: request.Req,
  key: String,
) -> Result(String, RadiantError)

query_bool

</> 
pub fn query_bool(
  req: request.Req,
  key: String,
) -> Result(Bool, RadiantError)

query_float

</> 
pub fn query_float(
  req: request.Req,
  key: String,
) -> Result(Float, RadiantError)

query_int

</> 
pub fn query_int(
  req: request.Req,
  key: String,
) -> Result(Int, RadiantError)

query_method

</> 
pub const query_method: http.Method

query_route

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

redirect

</> 
pub fn redirect(uri: String) -> response.Response(BitArray)

req_path

</> 
pub fn req_path(req: request.Req) -> String

request

</> 
pub fn request(
  method: http.Method,
  raw_path: String,
) -> testing.TestRequest

rescue

</> 
pub fn rescue(
  on_error: fn(exception.Exception) -> response.Response(BitArray),
) -> fn(fn(request.Req) -> response.Response(BitArray)) -> fn(
  request.Req,
) -> response.Response(BitArray)

response

</> 
pub fn response(
  status: Int,
  body_text: String,
) -> response.Response(BitArray)

route

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

Register a route for any HTTP method.

routes

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

scope

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

serve_static

</> 
pub fn serve_static(
  prefix prefix: String,
  from directory: String,
  via fs: FileSystem,
) -> fn(fn(request.Req) -> response.Response(BitArray)) -> fn(
  request.Req,
) -> response.Response(BitArray)

set_context

</> 
pub fn set_context(
  req: request.Req,
  k: request.Key(a),
  value: a,
) -> request.Req

should_have_body

</> 
pub fn should_have_body(
  resp: response.Response(BitArray),
  expected: String,
) -> response.Response(BitArray)

should_have_header

</> 
pub fn should_have_header(
  resp: response.Response(BitArray),
  name: String,
  expected: String,
) -> response.Response(BitArray)

should_have_json_body

</> 
pub fn should_have_json_body(
  resp: response.Response(BitArray),
  decoder: decode.Decoder(a),
) -> a

should_have_status

</> 
pub fn should_have_status(
  resp: response.Response(BitArray),
  expected: Int,
) -> response.Response(BitArray)

str

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

str_param

</> 
pub fn str_param(
  req: request.Req,
  name: String,
) -> Result(String, RadiantError)

test_delete

</> 
pub fn test_delete(raw_path: String) -> request.Request(BitArray)

test_get

</> 
pub fn test_get(raw_path: String) -> request.Request(BitArray)

test_head

</> 
pub fn test_head(raw_path: String) -> request.Request(BitArray)

test_options

</> 
pub fn test_options(
  raw_path: String,
) -> request.Request(BitArray)

test_patch

</> 
pub fn test_patch(
  raw_path: String,
  body_text: String,
) -> request.Request(BitArray)

test_post

</> 
pub fn test_post(
  raw_path: String,
  body_text: String,
) -> request.Request(BitArray)

test_put

</> 
pub fn test_put(
  raw_path: String,
  body_text: String,
) -> request.Request(BitArray)

test_request

</> 
pub fn test_request(
  method: http.Method,
  raw_path: String,
) -> request.Request(BitArray)

text_body

</> 
pub fn text_body(
  req: request.Req,
) -> Result(String, RadiantError)

unauthorized

</> 
pub fn unauthorized() -> response.Response(BitArray)

unauthorized_with

</> 
pub fn unauthorized_with(
  body_text: String,
) -> response.Response(BitArray)

unprocessable_entity

</> 
pub fn unprocessable_entity() -> response.Response(BitArray)

unprocessable_entity_with

</> 
pub fn unprocessable_entity_with(
  body_text: String,
) -> response.Response(BitArray)

with_header

</> 
pub fn with_header(
  resp: response.Response(BitArray),
  key: String,
  value: String,
) -> response.Response(BitArray)

with_query

</> 
pub fn with_query(
  test_request: testing.TestRequest,
  key: String,
  value: String,
) -> testing.TestRequest

with_request_body

</> 
pub fn with_request_body(
  test_request: testing.TestRequest,
  body: String,
) -> testing.TestRequest

with_request_header

</> 
pub fn with_request_header(
  test_request: testing.TestRequest,
  key: String,
  value: String,
) -> testing.TestRequest

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