Current section
Files
Jump to
Current section
Files
src/radiant.erl
-module(radiant).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/radiant.gleam").
-export([int/1, str/1, key/1, fallback/2, middleware/2, mount/3, routes/1, path_for/2, path_for1/3, path_for2/5, path_for3/7, path_for4/9, path_for5/11, path_for6/13, get/3, post/3, put/3, patch/3, delete/3, options/3, any/3, get1/4, post1/4, put1/4, patch1/4, delete1/4, get2/5, post2/5, put2/5, patch2/5, delete2/5, get3/6, post3/6, put3/6, patch3/6, delete3/6, get4/7, post4/7, put4/7, patch4/7, delete4/7, get5/8, post5/8, put5/8, patch5/8, delete5/8, get6/9, post6/9, put6/9, patch6/9, delete6/9, method/1, req_path/1, header/2, headers/1, body/1, text_body/1, str_param/2, int_param/2, queries/1, 'query'/2, query_int/2, query_float/2, query_bool/2, original/1, set_context/3, get_context/2, response/2, ok/1, created/1, no_content/0, not_found/0, new/0, scope/3, bad_request/0, unauthorized/0, forbidden/0, unprocessable_entity/0, internal_server_error/0, bad_request_with/1, unauthorized_with/1, forbidden_with/1, not_found_with/1, unprocessable_entity_with/1, internal_server_error_with/1, redirect/1, with_header/3, method_not_allowed/1, handle/2, handle_with/3, json_error/2, json/1, html/1, default_cors/0, cors/1, log/1, rescue/1, json_body/2, serve_static/3, test_request/2, test_get/1, test_post/2, test_put/2, test_patch/2, test_delete/1, test_head/1, test_options/1, should_have_status/2, should_have_body/2, should_have_header/3, should_have_json_body/2]).
-export_type([router/0, file_system/0, req/0, key/1, param/1, cors_config/0]).
-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.
?MODULEDOC(
" A trie-based HTTP router for Gleam on BEAM.\n"
" One import, no sub-modules. See the [README](https://hexdocs.pm/radiant/) for examples.\n"
).
-opaque router() :: {router,
radiant@internal@tree:node_(fun((req()) -> gleam@http@response:response(bitstring()))),
fun((req()) -> gleam@http@response:response(bitstring())),
list(fun((fun((req()) -> gleam@http@response:response(bitstring()))) -> fun((req()) -> gleam@http@response:response(bitstring()))))}.
-type file_system() :: {file_system,
fun((binary()) -> {ok, bitstring()} | {error, nil}),
fun((binary()) -> boolean())}.
-opaque req() :: {req,
gleam@http@request:request(bitstring()),
gleam@dict:dict(binary(), binary()),
gleam@dict:dict(binary(), gleam@dynamic:dynamic_())}.
-opaque key(PDB) :: {key, binary()} | {gleam_phantom, PDB}.
-opaque param(PDC) :: {param,
binary(),
fun((binary()) -> {ok, PDC} | {error, nil}),
radiant@internal@path:param_type(),
fun((PDC) -> binary())}.
-type cors_config() :: {cors_config,
list(binary()),
list(gleam@http:method()),
list(binary()),
integer()}.
-file("src/radiant.gleam", 98).
?DOC(
" A `Param(Int)` that matches only integer path segments.\n"
" For use with `get1`, `get2`, `get3`, etc.\n"
"\n"
" ```gleam\n"
" router |> radiant.get1(\"/users/:id\", radiant.int(\"id\"), fn(req, id) {\n"
" radiant.ok(int.to_string(id)) // id: Int, guaranteed\n"
" })\n"
" ```\n"
).
-spec int(binary()) -> param(integer()).
int(Name) ->
{param,
Name,
fun gleam_stdlib:parse_int/1,
int_t,
fun erlang:integer_to_binary/1}.
-file("src/radiant.gleam", 115).
?DOC(
" A `Param(String)` that matches any path segment.\n"
" For use with `get1`, `get2`, `get3`, etc.\n"
"\n"
" ```gleam\n"
" router |> radiant.get1(\"/posts/:slug\", radiant.str(\"slug\"), fn(req, slug) {\n"
" radiant.ok(slug) // slug: String, no extraction needed\n"
" })\n"
" ```\n"
).
-spec str(binary()) -> param(binary()).
str(Name) ->
{param, Name, fun(S) -> {ok, S} end, string_t, fun(S@1) -> S@1 end}.
-file("src/radiant.gleam", 136).
?DOC(
" Create a typed context key. Pair with `set_context` and `get_context`\n"
" for type-safe request context passing through middlewares.\n"
"\n"
" ```gleam\n"
" pub const user_key: radiant.Key(User) = radiant.key(\"user\")\n"
"\n"
" // In middleware:\n"
" radiant.set_context(req, user_key, authenticated_user)\n"
"\n"
" // In handler:\n"
" let assert Ok(user) = radiant.get_context(req, user_key)\n"
" ```\n"
).
-spec key(binary()) -> key(any()).
key(Name) ->
{key, Name}.
-file("src/radiant.gleam", 146).
?DOC(" Set a custom fallback handler for unmatched requests.\n").
-spec fallback(
router(),
fun((req()) -> gleam@http@response:response(bitstring()))
) -> router().
fallback(Router, Handler) ->
{router, erlang:element(2, Router), Handler, erlang:element(4, Router)}.
-file("src/radiant.gleam", 162).
?DOC(
" Add a middleware that wraps every request through this router.\n"
" Middlewares are applied in the order they are added (first added = outermost).\n"
"\n"
" ```gleam\n"
" radiant.new()\n"
" |> radiant.middleware(radiant.log(fn(msg) { io.println(msg) }))\n"
" |> radiant.middleware(radiant.cors(radiant.default_cors()))\n"
" |> radiant.get(\"/\", handler)\n"
" ```\n"
).
-spec middleware(
router(),
fun((fun((req()) -> gleam@http@response:response(bitstring()))) -> fun((req()) -> gleam@http@response:response(bitstring())))
) -> router().
middleware(Router, Mw) ->
{router,
erlang:element(2, Router),
erlang:element(3, Router),
[Mw | erlang:element(4, Router)]}.
-file("src/radiant.gleam", 626).
?DOC(
" Mount a complete sub-router at a given path prefix.\n"
"\n"
" Unlike `scope`, which builds routes in the same context, `mount` allows\n"
" you to define independent routers (with their own middlewares) and\n"
" attach them to a parent router.\n"
"\n"
" Note: The sub-router's fallback handler is ignored. Unmatched requests\n"
" will fall through to the parent router's fallback.\n"
).
-spec mount(router(), binary(), router()) -> router().
mount(Router, Prefix, Sub_router) ->
Prefix_segs = radiant@internal@path:parse(Prefix),
Sub_routes = radiant@internal@tree:to_routes(erlang:element(2, Sub_router)),
gleam@list:fold(
Sub_routes,
Router,
fun(Acc_router, R) ->
{Method, Segments, Handler} = R,
With_middlewares = gleam@list:fold(
erlang:element(4, Sub_router),
Handler,
fun(H, Mw) -> Mw(H) end
),
Full_segments = lists:append(Prefix_segs, Segments),
New_tree = radiant@internal@tree:insert(
erlang:element(2, Acc_router),
Method,
Full_segments,
With_middlewares
),
{router,
New_tree,
erlang:element(3, Acc_router),
erlang:element(4, Acc_router)}
end
).
-file("src/radiant.gleam", 748).
-spec segments_to_pattern(list(radiant@internal@path:segment())) -> binary().
segments_to_pattern(Segments) ->
case Segments of
[] ->
<<"/"/utf8>>;
_ ->
<<"/"/utf8,
(begin
_pipe = gleam@list:map(Segments, fun(Seg) -> case Seg of
{literal, S} ->
S;
{capture, Name, int_t} ->
<<<<"<"/utf8, Name/binary>>/binary,
":int>"/utf8>>;
{capture, Name@1, string_t} ->
<<<<"<"/utf8, Name@1/binary>>/binary,
":string>"/utf8>>;
{wildcard, Name@2} ->
<<"*"/utf8, Name@2/binary>>
end end),
gleam@string:join(_pipe, <<"/"/utf8>>)
end)/binary>>
end.
-file("src/radiant.gleam", 740).
?DOC(
" Return all registered routes as `(method, pattern)` pairs.\n"
"\n"
" Useful for logging the route table at startup, contract tests,\n"
" or building documentation from a live router.\n"
"\n"
" ```gleam\n"
" radiant.routes(router)\n"
" // → [#(http.Get, \"/\"), #(http.Get, \"/users/<id:int>\"), ...]\n"
" ```\n"
).
-spec routes(router()) -> list({gleam@http:method(), binary()}).
routes(Router) ->
_pipe = radiant@internal@tree:to_routes(erlang:element(2, Router)),
gleam@list:map(
_pipe,
fun(R) ->
{Method, Segments, _} = R,
{Method, segments_to_pattern(Segments)}
end
).
-file("src/radiant.gleam", 779).
?DOC(
" Build a URL path from a route pattern and a list of `(name, value)` pairs.\n"
"\n"
" Returns `Error(Nil)` if any named parameter is missing from the list.\n"
" Extra keys in the list are silently ignored.\n"
"\n"
" ```gleam\n"
" radiant.path_for(\"/users/<id:int>/posts/<pid:int>\", [\n"
" #(\"id\", \"42\"), #(\"pid\", \"7\"),\n"
" ])\n"
" // → Ok(\"/users/42/posts/7\")\n"
"\n"
" radiant.path_for(\"/users/<id:int>\", [])\n"
" // → Error(Nil)\n"
" ```\n"
).
-spec path_for(binary(), list({binary(), binary()})) -> {ok, binary()} |
{error, nil}.
path_for(Pattern, Params) ->
Segments = radiant@internal@path:parse(Pattern),
Lookup = maps:from_list(Params),
gleam@result:'try'(gleam@list:try_map(Segments, fun(Seg) -> case Seg of
{literal, S} ->
{ok, S};
{capture, Name, _} ->
gleam_stdlib:map_get(Lookup, Name);
{wildcard, Name@1} ->
gleam_stdlib:map_get(Lookup, Name@1)
end end), fun(Parts) -> case Parts of
[] ->
{ok, <<"/"/utf8>>};
_ ->
{ok,
<<"/"/utf8,
(gleam@string:join(Parts, <<"/"/utf8>>))/binary>>}
end end).
-file("src/radiant.gleam", 816).
?DOC(
" Build a URL path using typed `Param` objects — more refactor-safe than `path_for`.\n"
"\n"
" Because you pass the same `Param` constant used for route registration,\n"
" renaming a capture in the pattern and updating the `Param` name is enough:\n"
" `validate_param` will catch any remaining mismatch at startup.\n"
"\n"
" ```gleam\n"
" pub const user_id = radiant.int(\"id\")\n"
"\n"
" // Route registration\n"
" router |> radiant.get1(\"/users/<id:int>\", user_id, handler)\n"
"\n"
" // URL building — user_id.name is always in sync with the route\n"
" radiant.path_for1(\"/users/<id:int>\", user_id, 42)\n"
" // → Ok(\"/users/42\")\n"
" ```\n"
).
-spec path_for1(binary(), param(PNH), PNH) -> {ok, binary()} | {error, nil}.
path_for1(Pattern, P1, V1) ->
path_for(Pattern, [{erlang:element(2, P1), (erlang:element(5, P1))(V1)}]).
-file("src/radiant.gleam", 821).
?DOC(" Build a URL path with two typed parameters.\n").
-spec path_for2(binary(), param(PNL), PNL, param(PNN), PNN) -> {ok, binary()} |
{error, nil}.
path_for2(Pattern, P1, V1, P2, V2) ->
path_for(
Pattern,
[{erlang:element(2, P1), (erlang:element(5, P1))(V1)},
{erlang:element(2, P2), (erlang:element(5, P2))(V2)}]
).
-file("src/radiant.gleam", 832).
?DOC(" Build a URL path with three typed parameters.\n").
-spec path_for3(binary(), param(PNR), PNR, param(PNT), PNT, param(PNV), PNV) -> {ok,
binary()} |
{error, nil}.
path_for3(Pattern, P1, V1, P2, V2, P3, V3) ->
path_for(
Pattern,
[{erlang:element(2, P1), (erlang:element(5, P1))(V1)},
{erlang:element(2, P2), (erlang:element(5, P2))(V2)},
{erlang:element(2, P3), (erlang:element(5, P3))(V3)}]
).
-file("src/radiant.gleam", 849).
?DOC(" Build a URL path with four typed parameters.\n").
-spec path_for4(
binary(),
param(PNZ),
PNZ,
param(POB),
POB,
param(POD),
POD,
param(POF),
POF
) -> {ok, binary()} | {error, nil}.
path_for4(Pattern, P1, V1, P2, V2, P3, V3, P4, V4) ->
path_for(
Pattern,
[{erlang:element(2, P1), (erlang:element(5, P1))(V1)},
{erlang:element(2, P2), (erlang:element(5, P2))(V2)},
{erlang:element(2, P3), (erlang:element(5, P3))(V3)},
{erlang:element(2, P4), (erlang:element(5, P4))(V4)}]
).
-file("src/radiant.gleam", 869).
?DOC(" Build a URL path with five typed parameters.\n").
-spec path_for5(
binary(),
param(POJ),
POJ,
param(POL),
POL,
param(PON),
PON,
param(POP),
POP,
param(POR),
POR
) -> {ok, binary()} | {error, nil}.
path_for5(Pattern, P1, V1, P2, V2, P3, V3, P4, V4, P5, V5) ->
path_for(
Pattern,
[{erlang:element(2, P1), (erlang:element(5, P1))(V1)},
{erlang:element(2, P2), (erlang:element(5, P2))(V2)},
{erlang:element(2, P3), (erlang:element(5, P3))(V3)},
{erlang:element(2, P4), (erlang:element(5, P4))(V4)},
{erlang:element(2, P5), (erlang:element(5, P5))(V5)}]
).
-file("src/radiant.gleam", 892).
?DOC(" Build a URL path with six typed parameters.\n").
-spec path_for6(
binary(),
param(POV),
POV,
param(POX),
POX,
param(POZ),
POZ,
param(PPB),
PPB,
param(PPD),
PPD,
param(PPF),
PPF
) -> {ok, binary()} | {error, nil}.
path_for6(Pattern, P1, V1, P2, V2, P3, V3, P4, V4, P5, V5, P6, V6) ->
path_for(
Pattern,
[{erlang:element(2, P1), (erlang:element(5, P1))(V1)},
{erlang:element(2, P2), (erlang:element(5, P2))(V2)},
{erlang:element(2, P3), (erlang:element(5, P3))(V3)},
{erlang:element(2, P4), (erlang:element(5, P4))(V4)},
{erlang:element(2, P5), (erlang:element(5, P5))(V5)},
{erlang:element(2, P6), (erlang:element(5, P6))(V6)}]
).
-file("src/radiant.gleam", 926).
-spec add_route_raw(
router(),
gleam@http:method(),
list(radiant@internal@path:segment()),
fun((req()) -> gleam@http@response:response(bitstring()))
) -> router().
add_route_raw(Router, Method, Segments, Handler) ->
_ = case radiant@internal@tree:check_capture_ambiguity(
erlang:element(2, Router),
Segments
) of
{ok, Existing} ->
Pattern = segments_to_pattern(Segments),
erlang:error(#{gleam_error => panic,
message => (<<<<<<<<<<"Radiant: Ambiguous capture in '"/utf8,
Pattern/binary>>/binary,
"'. A capture named '"/utf8>>/binary,
Existing/binary>>/binary,
"' of the same type already exists at the same path depth. "/utf8>>/binary,
"Routing between them is order-dependent. Use distinct types or restructure your routes."/utf8>>),
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"add_route_raw"/utf8>>,
line => 935});
{error, _} ->
nil
end,
case radiant@internal@tree:get_handler(
erlang:element(2, Router),
Segments,
Method
) of
{ok, _} ->
Router;
{error, _} ->
{router,
radiant@internal@tree:insert(
erlang:element(2, Router),
Method,
Segments,
Handler
),
erlang:element(3, Router),
erlang:element(4, Router)}
end.
-file("src/radiant.gleam", 917).
-spec add_route(
router(),
gleam@http:method(),
binary(),
fun((req()) -> gleam@http@response:response(bitstring()))
) -> router().
add_route(Router, Method, Pattern, Handler) ->
add_route_raw(Router, Method, radiant@internal@path:parse(Pattern), Handler).
-file("src/radiant.gleam", 167).
?DOC(" Register a GET route.\n").
-spec get(
router(),
binary(),
fun((req()) -> gleam@http@response:response(bitstring()))
) -> router().
get(Router, Pattern, Handler) ->
add_route(Router, get, Pattern, Handler).
-file("src/radiant.gleam", 176).
?DOC(" Register a POST route.\n").
-spec post(
router(),
binary(),
fun((req()) -> gleam@http@response:response(bitstring()))
) -> router().
post(Router, Pattern, Handler) ->
add_route(Router, post, Pattern, Handler).
-file("src/radiant.gleam", 185).
?DOC(" Register a PUT route.\n").
-spec put(
router(),
binary(),
fun((req()) -> gleam@http@response:response(bitstring()))
) -> router().
put(Router, Pattern, Handler) ->
add_route(Router, put, Pattern, Handler).
-file("src/radiant.gleam", 194).
?DOC(" Register a PATCH route.\n").
-spec patch(
router(),
binary(),
fun((req()) -> gleam@http@response:response(bitstring()))
) -> router().
patch(Router, Pattern, Handler) ->
add_route(Router, patch, Pattern, Handler).
-file("src/radiant.gleam", 203).
?DOC(" Register a DELETE route.\n").
-spec delete(
router(),
binary(),
fun((req()) -> gleam@http@response:response(bitstring()))
) -> router().
delete(Router, Pattern, Handler) ->
add_route(Router, delete, Pattern, Handler).
-file("src/radiant.gleam", 213).
?DOC(
" Register an OPTIONS route.\n"
" Useful for custom preflight handling when the `cors` middleware is not used.\n"
).
-spec options(
router(),
binary(),
fun((req()) -> gleam@http@response:response(bitstring()))
) -> router().
options(Router, Pattern, Handler) ->
add_route(Router, options, Pattern, Handler).
-file("src/radiant.gleam", 722).
?DOC(
" Register the same handler for all standard HTTP methods on a pattern.\n"
" Useful for health check endpoints or method-agnostic catch-alls.\n"
"\n"
" ```gleam\n"
" radiant.new()\n"
" |> radiant.any(\"/health\", fn(_req) { radiant.ok(\"ok\") })\n"
" ```\n"
).
-spec any(
router(),
binary(),
fun((req()) -> gleam@http@response:response(bitstring()))
) -> router().
any(Router, Pattern, Handler) ->
_pipe = [get, post, put, patch, delete],
gleam@list:fold(
_pipe,
Router,
fun(R, M) -> add_route(R, M, Pattern, Handler) end
).
-file("src/radiant.gleam", 958).
-spec validate_param(
param(any()),
list(radiant@internal@path:segment()),
binary()
) -> nil.
validate_param(P, Segments, Pattern) ->
case gleam@list:any(Segments, fun(Seg) -> case Seg of
{capture, Name, _} ->
Name =:= erlang:element(2, P);
{wildcard, Name@1} ->
Name@1 =:= erlang:element(2, P);
_ ->
false
end end) of
true ->
nil;
false ->
erlang:error(#{gleam_error => panic,
message => (<<<<<<<<"Radiant: param '"/utf8,
(erlang:element(2, P))/binary>>/binary,
"' not found in pattern '"/utf8>>/binary,
Pattern/binary>>/binary,
"'. The Param name must match a capture in the route pattern."/utf8>>),
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"validate_param"/utf8>>,
line => 974})
end.
-file("src/radiant.gleam", 985).
-spec apply_param_type(list(radiant@internal@path:segment()), param(any())) -> list(radiant@internal@path:segment()).
apply_param_type(Segments, P) ->
gleam@list:map(Segments, fun(Seg) -> case Seg of
{capture, Name, _} when Name =:= erlang:element(2, P) ->
{capture, Name, erlang:element(4, P)};
_ ->
Seg
end end).
-file("src/radiant.gleam", 997).
-spec typed1(
router(),
gleam@http:method(),
binary(),
param(PPT),
fun((req(), PPT) -> gleam@http@response:response(bitstring()))
) -> router().
typed1(Router, Method, Pattern, P1, Handler) ->
Raw = radiant@internal@path:parse(Pattern),
validate_param(P1, Raw, Pattern),
Segments = apply_param_type(Raw, P1),
Wrapped = fun(Req) ->
V1@1 = case begin
_pipe = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P1)
),
gleam@result:'try'(_pipe, erlang:element(3, P1))
end of
{ok, V1} -> V1;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed1"/utf8>>,
line => 1008,
value => _assert_fail,
start => 25752,
'end' => 25825,
pattern_start => 25763,
pattern_end => 25769})
end,
Handler(Req, V1@1)
end,
add_route_raw(Router, Method, Segments, Wrapped).
-file("src/radiant.gleam", 233).
?DOC(
" Register a GET route with one typed path parameter.\n"
" The handler receives the extracted value directly — no manual extraction.\n"
"\n"
" ```gleam\n"
" router |> radiant.get1(\"/users/:id\", radiant.int(\"id\"), fn(req, id) {\n"
" radiant.ok(\"User \" <> int.to_string(id))\n"
" })\n"
" ```\n"
).
-spec get1(
router(),
binary(),
param(PDQ),
fun((req(), PDQ) -> gleam@http@response:response(bitstring()))
) -> router().
get1(Router, Pattern, P1, Handler) ->
typed1(Router, get, Pattern, P1, Handler).
-file("src/radiant.gleam", 242).
-spec post1(
router(),
binary(),
param(PDT),
fun((req(), PDT) -> gleam@http@response:response(bitstring()))
) -> router().
post1(Router, Pattern, P1, Handler) ->
typed1(Router, post, Pattern, P1, Handler).
-file("src/radiant.gleam", 251).
-spec put1(
router(),
binary(),
param(PDW),
fun((req(), PDW) -> gleam@http@response:response(bitstring()))
) -> router().
put1(Router, Pattern, P1, Handler) ->
typed1(Router, put, Pattern, P1, Handler).
-file("src/radiant.gleam", 260).
-spec patch1(
router(),
binary(),
param(PDZ),
fun((req(), PDZ) -> gleam@http@response:response(bitstring()))
) -> router().
patch1(Router, Pattern, P1, Handler) ->
typed1(Router, patch, Pattern, P1, Handler).
-file("src/radiant.gleam", 269).
-spec delete1(
router(),
binary(),
param(PEC),
fun((req(), PEC) -> gleam@http@response:response(bitstring()))
) -> router().
delete1(Router, Pattern, P1, Handler) ->
typed1(Router, delete, Pattern, P1, Handler).
-file("src/radiant.gleam", 1014).
-spec typed2(
router(),
gleam@http:method(),
binary(),
param(PPW),
param(PPY),
fun((req(), PPW, PPY) -> gleam@http@response:response(bitstring()))
) -> router().
typed2(Router, Method, Pattern, P1, P2, Handler) ->
Raw = radiant@internal@path:parse(Pattern),
validate_param(P1, Raw, Pattern),
validate_param(P2, Raw, Pattern),
Segments = begin
_pipe = Raw,
_pipe@1 = apply_param_type(_pipe, P1),
apply_param_type(_pipe@1, P2)
end,
Wrapped = fun(Req) ->
V1@1 = case begin
_pipe@2 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P1)
),
gleam@result:'try'(_pipe@2, erlang:element(3, P1))
end of
{ok, V1} -> V1;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed2"/utf8>>,
line => 1027,
value => _assert_fail,
start => 26294,
'end' => 26367,
pattern_start => 26305,
pattern_end => 26311})
end,
V2@1 = case begin
_pipe@3 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P2)
),
gleam@result:'try'(_pipe@3, erlang:element(3, P2))
end of
{ok, V2} -> V2;
_assert_fail@1 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed2"/utf8>>,
line => 1028,
value => _assert_fail@1,
start => 26372,
'end' => 26445,
pattern_start => 26383,
pattern_end => 26389})
end,
Handler(Req, V1@1, V2@1)
end,
add_route_raw(Router, Method, Segments, Wrapped).
-file("src/radiant.gleam", 287).
?DOC(
" Register a GET route with two typed path parameters.\n"
"\n"
" ```gleam\n"
" router |> radiant.get2(\n"
" \"/users/:uid/posts/:pid\",\n"
" radiant.int(\"uid\"), radiant.int(\"pid\"),\n"
" fn(req, uid, pid) { radiant.ok(int.to_string(uid) <> \"/\" <> int.to_string(pid)) },\n"
" )\n"
" ```\n"
).
-spec get2(
router(),
binary(),
param(PEF),
param(PEH),
fun((req(), PEF, PEH) -> gleam@http@response:response(bitstring()))
) -> router().
get2(Router, Pattern, P1, P2, Handler) ->
typed2(Router, get, Pattern, P1, P2, Handler).
-file("src/radiant.gleam", 297).
-spec post2(
router(),
binary(),
param(PEK),
param(PEM),
fun((req(), PEK, PEM) -> gleam@http@response:response(bitstring()))
) -> router().
post2(Router, Pattern, P1, P2, Handler) ->
typed2(Router, post, Pattern, P1, P2, Handler).
-file("src/radiant.gleam", 307).
-spec put2(
router(),
binary(),
param(PEP),
param(PER),
fun((req(), PEP, PER) -> gleam@http@response:response(bitstring()))
) -> router().
put2(Router, Pattern, P1, P2, Handler) ->
typed2(Router, put, Pattern, P1, P2, Handler).
-file("src/radiant.gleam", 317).
-spec patch2(
router(),
binary(),
param(PEU),
param(PEW),
fun((req(), PEU, PEW) -> gleam@http@response:response(bitstring()))
) -> router().
patch2(Router, Pattern, P1, P2, Handler) ->
typed2(Router, patch, Pattern, P1, P2, Handler).
-file("src/radiant.gleam", 327).
-spec delete2(
router(),
binary(),
param(PEZ),
param(PFB),
fun((req(), PEZ, PFB) -> gleam@http@response:response(bitstring()))
) -> router().
delete2(Router, Pattern, P1, P2, Handler) ->
typed2(Router, delete, Pattern, P1, P2, Handler).
-file("src/radiant.gleam", 1034).
-spec typed3(
router(),
gleam@http:method(),
binary(),
param(PQB),
param(PQD),
param(PQF),
fun((req(), PQB, PQD, PQF) -> gleam@http@response:response(bitstring()))
) -> router().
typed3(Router, Method, Pattern, P1, P2, P3, Handler) ->
Raw = radiant@internal@path:parse(Pattern),
validate_param(P1, Raw, Pattern),
validate_param(P2, Raw, Pattern),
validate_param(P3, Raw, Pattern),
Segments = begin
_pipe = Raw,
_pipe@1 = apply_param_type(_pipe, P1),
_pipe@2 = apply_param_type(_pipe@1, P2),
apply_param_type(_pipe@2, P3)
end,
Wrapped = fun(Req) ->
V1@1 = case begin
_pipe@3 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P1)
),
gleam@result:'try'(_pipe@3, erlang:element(3, P1))
end of
{ok, V1} -> V1;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed3"/utf8>>,
line => 1050,
value => _assert_fail,
start => 27000,
'end' => 27073,
pattern_start => 27011,
pattern_end => 27017})
end,
V2@1 = case begin
_pipe@4 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P2)
),
gleam@result:'try'(_pipe@4, erlang:element(3, P2))
end of
{ok, V2} -> V2;
_assert_fail@1 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed3"/utf8>>,
line => 1051,
value => _assert_fail@1,
start => 27078,
'end' => 27151,
pattern_start => 27089,
pattern_end => 27095})
end,
V3@1 = case begin
_pipe@5 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P3)
),
gleam@result:'try'(_pipe@5, erlang:element(3, P3))
end of
{ok, V3} -> V3;
_assert_fail@2 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed3"/utf8>>,
line => 1052,
value => _assert_fail@2,
start => 27156,
'end' => 27229,
pattern_start => 27167,
pattern_end => 27173})
end,
Handler(Req, V1@1, V2@1, V3@1)
end,
add_route_raw(Router, Method, Segments, Wrapped).
-file("src/radiant.gleam", 338).
?DOC(" Register a GET route with three typed path parameters.\n").
-spec get3(
router(),
binary(),
param(PFE),
param(PFG),
param(PFI),
fun((req(), PFE, PFG, PFI) -> gleam@http@response:response(bitstring()))
) -> router().
get3(Router, Pattern, P1, P2, P3, Handler) ->
typed3(Router, get, Pattern, P1, P2, P3, Handler).
-file("src/radiant.gleam", 349).
-spec post3(
router(),
binary(),
param(PFL),
param(PFN),
param(PFP),
fun((req(), PFL, PFN, PFP) -> gleam@http@response:response(bitstring()))
) -> router().
post3(Router, Pattern, P1, P2, P3, Handler) ->
typed3(Router, post, Pattern, P1, P2, P3, Handler).
-file("src/radiant.gleam", 360).
-spec put3(
router(),
binary(),
param(PFS),
param(PFU),
param(PFW),
fun((req(), PFS, PFU, PFW) -> gleam@http@response:response(bitstring()))
) -> router().
put3(Router, Pattern, P1, P2, P3, Handler) ->
typed3(Router, put, Pattern, P1, P2, P3, Handler).
-file("src/radiant.gleam", 371).
-spec patch3(
router(),
binary(),
param(PFZ),
param(PGB),
param(PGD),
fun((req(), PFZ, PGB, PGD) -> gleam@http@response:response(bitstring()))
) -> router().
patch3(Router, Pattern, P1, P2, P3, Handler) ->
typed3(Router, patch, Pattern, P1, P2, P3, Handler).
-file("src/radiant.gleam", 382).
-spec delete3(
router(),
binary(),
param(PGG),
param(PGI),
param(PGK),
fun((req(), PGG, PGI, PGK) -> gleam@http@response:response(bitstring()))
) -> router().
delete3(Router, Pattern, P1, P2, P3, Handler) ->
typed3(Router, delete, Pattern, P1, P2, P3, Handler).
-file("src/radiant.gleam", 1058).
-spec typed4(
router(),
gleam@http:method(),
binary(),
param(PQI),
param(PQK),
param(PQM),
param(PQO),
fun((req(), PQI, PQK, PQM, PQO) -> gleam@http@response:response(bitstring()))
) -> router().
typed4(Router, Method, Pattern, P1, P2, P3, P4, Handler) ->
Raw = radiant@internal@path:parse(Pattern),
validate_param(P1, Raw, Pattern),
validate_param(P2, Raw, Pattern),
validate_param(P3, Raw, Pattern),
validate_param(P4, Raw, Pattern),
Segments = begin
_pipe = Raw,
_pipe@1 = apply_param_type(_pipe, P1),
_pipe@2 = apply_param_type(_pipe@1, P2),
_pipe@3 = apply_param_type(_pipe@2, P3),
apply_param_type(_pipe@3, P4)
end,
Wrapped = fun(Req) ->
V1@1 = case begin
_pipe@4 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P1)
),
gleam@result:'try'(_pipe@4, erlang:element(3, P1))
end of
{ok, V1} -> V1;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed4"/utf8>>,
line => 1080,
value => _assert_fail,
start => 27882,
'end' => 27955,
pattern_start => 27893,
pattern_end => 27899})
end,
V2@1 = case begin
_pipe@5 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P2)
),
gleam@result:'try'(_pipe@5, erlang:element(3, P2))
end of
{ok, V2} -> V2;
_assert_fail@1 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed4"/utf8>>,
line => 1081,
value => _assert_fail@1,
start => 27960,
'end' => 28033,
pattern_start => 27971,
pattern_end => 27977})
end,
V3@1 = case begin
_pipe@6 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P3)
),
gleam@result:'try'(_pipe@6, erlang:element(3, P3))
end of
{ok, V3} -> V3;
_assert_fail@2 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed4"/utf8>>,
line => 1082,
value => _assert_fail@2,
start => 28038,
'end' => 28111,
pattern_start => 28049,
pattern_end => 28055})
end,
V4@1 = case begin
_pipe@7 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P4)
),
gleam@result:'try'(_pipe@7, erlang:element(3, P4))
end of
{ok, V4} -> V4;
_assert_fail@3 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed4"/utf8>>,
line => 1083,
value => _assert_fail@3,
start => 28116,
'end' => 28189,
pattern_start => 28127,
pattern_end => 28133})
end,
Handler(Req, V1@1, V2@1, V3@1, V4@1)
end,
add_route_raw(Router, Method, Segments, Wrapped).
-file("src/radiant.gleam", 394).
?DOC(" Register a GET route with four typed path parameters.\n").
-spec get4(
router(),
binary(),
param(PGN),
param(PGP),
param(PGR),
param(PGT),
fun((req(), PGN, PGP, PGR, PGT) -> gleam@http@response:response(bitstring()))
) -> router().
get4(Router, Pattern, P1, P2, P3, P4, Handler) ->
typed4(Router, get, Pattern, P1, P2, P3, P4, Handler).
-file("src/radiant.gleam", 406).
-spec post4(
router(),
binary(),
param(PGW),
param(PGY),
param(PHA),
param(PHC),
fun((req(), PGW, PGY, PHA, PHC) -> gleam@http@response:response(bitstring()))
) -> router().
post4(Router, Pattern, P1, P2, P3, P4, Handler) ->
typed4(Router, post, Pattern, P1, P2, P3, P4, Handler).
-file("src/radiant.gleam", 418).
-spec put4(
router(),
binary(),
param(PHF),
param(PHH),
param(PHJ),
param(PHL),
fun((req(), PHF, PHH, PHJ, PHL) -> gleam@http@response:response(bitstring()))
) -> router().
put4(Router, Pattern, P1, P2, P3, P4, Handler) ->
typed4(Router, put, Pattern, P1, P2, P3, P4, Handler).
-file("src/radiant.gleam", 430).
-spec patch4(
router(),
binary(),
param(PHO),
param(PHQ),
param(PHS),
param(PHU),
fun((req(), PHO, PHQ, PHS, PHU) -> gleam@http@response:response(bitstring()))
) -> router().
patch4(Router, Pattern, P1, P2, P3, P4, Handler) ->
typed4(Router, patch, Pattern, P1, P2, P3, P4, Handler).
-file("src/radiant.gleam", 442).
-spec delete4(
router(),
binary(),
param(PHX),
param(PHZ),
param(PIB),
param(PID),
fun((req(), PHX, PHZ, PIB, PID) -> gleam@http@response:response(bitstring()))
) -> router().
delete4(Router, Pattern, P1, P2, P3, P4, Handler) ->
typed4(Router, delete, Pattern, P1, P2, P3, P4, Handler).
-file("src/radiant.gleam", 1089).
-spec typed5(
router(),
gleam@http:method(),
binary(),
param(PQR),
param(PQT),
param(PQV),
param(PQX),
param(PQZ),
fun((req(), PQR, PQT, PQV, PQX, PQZ) -> gleam@http@response:response(bitstring()))
) -> router().
typed5(Router, Method, Pattern, P1, P2, P3, P4, P5, Handler) ->
Raw = radiant@internal@path:parse(Pattern),
validate_param(P1, Raw, Pattern),
validate_param(P2, Raw, Pattern),
validate_param(P3, Raw, Pattern),
validate_param(P4, Raw, Pattern),
validate_param(P5, Raw, Pattern),
Segments = begin
_pipe = Raw,
_pipe@1 = apply_param_type(_pipe, P1),
_pipe@2 = apply_param_type(_pipe@1, P2),
_pipe@3 = apply_param_type(_pipe@2, P3),
_pipe@4 = apply_param_type(_pipe@3, P4),
apply_param_type(_pipe@4, P5)
end,
Wrapped = fun(Req) ->
V1@1 = case begin
_pipe@5 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P1)
),
gleam@result:'try'(_pipe@5, erlang:element(3, P1))
end of
{ok, V1} -> V1;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed5"/utf8>>,
line => 1114,
value => _assert_fail,
start => 28928,
'end' => 29001,
pattern_start => 28939,
pattern_end => 28945})
end,
V2@1 = case begin
_pipe@6 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P2)
),
gleam@result:'try'(_pipe@6, erlang:element(3, P2))
end of
{ok, V2} -> V2;
_assert_fail@1 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed5"/utf8>>,
line => 1115,
value => _assert_fail@1,
start => 29006,
'end' => 29079,
pattern_start => 29017,
pattern_end => 29023})
end,
V3@1 = case begin
_pipe@7 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P3)
),
gleam@result:'try'(_pipe@7, erlang:element(3, P3))
end of
{ok, V3} -> V3;
_assert_fail@2 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed5"/utf8>>,
line => 1116,
value => _assert_fail@2,
start => 29084,
'end' => 29157,
pattern_start => 29095,
pattern_end => 29101})
end,
V4@1 = case begin
_pipe@8 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P4)
),
gleam@result:'try'(_pipe@8, erlang:element(3, P4))
end of
{ok, V4} -> V4;
_assert_fail@3 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed5"/utf8>>,
line => 1117,
value => _assert_fail@3,
start => 29162,
'end' => 29235,
pattern_start => 29173,
pattern_end => 29179})
end,
V5@1 = case begin
_pipe@9 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P5)
),
gleam@result:'try'(_pipe@9, erlang:element(3, P5))
end of
{ok, V5} -> V5;
_assert_fail@4 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed5"/utf8>>,
line => 1118,
value => _assert_fail@4,
start => 29240,
'end' => 29313,
pattern_start => 29251,
pattern_end => 29257})
end,
Handler(Req, V1@1, V2@1, V3@1, V4@1, V5@1)
end,
add_route_raw(Router, Method, Segments, Wrapped).
-file("src/radiant.gleam", 455).
?DOC(" Register a GET route with five typed path parameters.\n").
-spec get5(
router(),
binary(),
param(PIG),
param(PII),
param(PIK),
param(PIM),
param(PIO),
fun((req(), PIG, PII, PIK, PIM, PIO) -> gleam@http@response:response(bitstring()))
) -> router().
get5(Router, Pattern, P1, P2, P3, P4, P5, Handler) ->
typed5(Router, get, Pattern, P1, P2, P3, P4, P5, Handler).
-file("src/radiant.gleam", 468).
-spec post5(
router(),
binary(),
param(PIR),
param(PIT),
param(PIV),
param(PIX),
param(PIZ),
fun((req(), PIR, PIT, PIV, PIX, PIZ) -> gleam@http@response:response(bitstring()))
) -> router().
post5(Router, Pattern, P1, P2, P3, P4, P5, Handler) ->
typed5(Router, post, Pattern, P1, P2, P3, P4, P5, Handler).
-file("src/radiant.gleam", 481).
-spec put5(
router(),
binary(),
param(PJC),
param(PJE),
param(PJG),
param(PJI),
param(PJK),
fun((req(), PJC, PJE, PJG, PJI, PJK) -> gleam@http@response:response(bitstring()))
) -> router().
put5(Router, Pattern, P1, P2, P3, P4, P5, Handler) ->
typed5(Router, put, Pattern, P1, P2, P3, P4, P5, Handler).
-file("src/radiant.gleam", 494).
-spec patch5(
router(),
binary(),
param(PJN),
param(PJP),
param(PJR),
param(PJT),
param(PJV),
fun((req(), PJN, PJP, PJR, PJT, PJV) -> gleam@http@response:response(bitstring()))
) -> router().
patch5(Router, Pattern, P1, P2, P3, P4, P5, Handler) ->
typed5(Router, patch, Pattern, P1, P2, P3, P4, P5, Handler).
-file("src/radiant.gleam", 507).
-spec delete5(
router(),
binary(),
param(PJY),
param(PKA),
param(PKC),
param(PKE),
param(PKG),
fun((req(), PJY, PKA, PKC, PKE, PKG) -> gleam@http@response:response(bitstring()))
) -> router().
delete5(Router, Pattern, P1, P2, P3, P4, P5, Handler) ->
typed5(Router, delete, Pattern, P1, P2, P3, P4, P5, Handler).
-file("src/radiant.gleam", 1124).
-spec typed6(
router(),
gleam@http:method(),
binary(),
param(PRC),
param(PRE),
param(PRG),
param(PRI),
param(PRK),
param(PRM),
fun((req(), PRC, PRE, PRG, PRI, PRK, PRM) -> gleam@http@response:response(bitstring()))
) -> router().
typed6(Router, Method, Pattern, P1, P2, P3, P4, P5, P6, Handler) ->
Raw = radiant@internal@path:parse(Pattern),
validate_param(P1, Raw, Pattern),
validate_param(P2, Raw, Pattern),
validate_param(P3, Raw, Pattern),
validate_param(P4, Raw, Pattern),
validate_param(P5, Raw, Pattern),
validate_param(P6, Raw, Pattern),
Segments = begin
_pipe = Raw,
_pipe@1 = apply_param_type(_pipe, P1),
_pipe@2 = apply_param_type(_pipe@1, P2),
_pipe@3 = apply_param_type(_pipe@2, P3),
_pipe@4 = apply_param_type(_pipe@3, P4),
_pipe@5 = apply_param_type(_pipe@4, P5),
apply_param_type(_pipe@5, P6)
end,
Wrapped = fun(Req) ->
V1@1 = case begin
_pipe@6 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P1)
),
gleam@result:'try'(_pipe@6, erlang:element(3, P1))
end of
{ok, V1} -> V1;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed6"/utf8>>,
line => 1152,
value => _assert_fail,
start => 30138,
'end' => 30211,
pattern_start => 30149,
pattern_end => 30155})
end,
V2@1 = case begin
_pipe@7 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P2)
),
gleam@result:'try'(_pipe@7, erlang:element(3, P2))
end of
{ok, V2} -> V2;
_assert_fail@1 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed6"/utf8>>,
line => 1153,
value => _assert_fail@1,
start => 30216,
'end' => 30289,
pattern_start => 30227,
pattern_end => 30233})
end,
V3@1 = case begin
_pipe@8 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P3)
),
gleam@result:'try'(_pipe@8, erlang:element(3, P3))
end of
{ok, V3} -> V3;
_assert_fail@2 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed6"/utf8>>,
line => 1154,
value => _assert_fail@2,
start => 30294,
'end' => 30367,
pattern_start => 30305,
pattern_end => 30311})
end,
V4@1 = case begin
_pipe@9 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P4)
),
gleam@result:'try'(_pipe@9, erlang:element(3, P4))
end of
{ok, V4} -> V4;
_assert_fail@3 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed6"/utf8>>,
line => 1155,
value => _assert_fail@3,
start => 30372,
'end' => 30445,
pattern_start => 30383,
pattern_end => 30389})
end,
V5@1 = case begin
_pipe@10 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P5)
),
gleam@result:'try'(_pipe@10, erlang:element(3, P5))
end of
{ok, V5} -> V5;
_assert_fail@4 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed6"/utf8>>,
line => 1156,
value => _assert_fail@4,
start => 30450,
'end' => 30523,
pattern_start => 30461,
pattern_end => 30467})
end,
V6@1 = case begin
_pipe@11 = gleam_stdlib:map_get(
erlang:element(3, Req),
erlang:element(2, P6)
),
gleam@result:'try'(_pipe@11, erlang:element(3, P6))
end of
{ok, V6} -> V6;
_assert_fail@5 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"typed6"/utf8>>,
line => 1157,
value => _assert_fail@5,
start => 30528,
'end' => 30601,
pattern_start => 30539,
pattern_end => 30545})
end,
Handler(Req, V1@1, V2@1, V3@1, V4@1, V5@1, V6@1)
end,
add_route_raw(Router, Method, Segments, Wrapped).
-file("src/radiant.gleam", 521).
?DOC(" Register a GET route with six typed path parameters.\n").
-spec get6(
router(),
binary(),
param(PKJ),
param(PKL),
param(PKN),
param(PKP),
param(PKR),
param(PKT),
fun((req(), PKJ, PKL, PKN, PKP, PKR, PKT) -> gleam@http@response:response(bitstring()))
) -> router().
get6(Router, Pattern, P1, P2, P3, P4, P5, P6, Handler) ->
typed6(Router, get, Pattern, P1, P2, P3, P4, P5, P6, Handler).
-file("src/radiant.gleam", 535).
-spec post6(
router(),
binary(),
param(PKW),
param(PKY),
param(PLA),
param(PLC),
param(PLE),
param(PLG),
fun((req(), PKW, PKY, PLA, PLC, PLE, PLG) -> gleam@http@response:response(bitstring()))
) -> router().
post6(Router, Pattern, P1, P2, P3, P4, P5, P6, Handler) ->
typed6(Router, post, Pattern, P1, P2, P3, P4, P5, P6, Handler).
-file("src/radiant.gleam", 549).
-spec put6(
router(),
binary(),
param(PLJ),
param(PLL),
param(PLN),
param(PLP),
param(PLR),
param(PLT),
fun((req(), PLJ, PLL, PLN, PLP, PLR, PLT) -> gleam@http@response:response(bitstring()))
) -> router().
put6(Router, Pattern, P1, P2, P3, P4, P5, P6, Handler) ->
typed6(Router, put, Pattern, P1, P2, P3, P4, P5, P6, Handler).
-file("src/radiant.gleam", 563).
-spec patch6(
router(),
binary(),
param(PLW),
param(PLY),
param(PMA),
param(PMC),
param(PME),
param(PMG),
fun((req(), PLW, PLY, PMA, PMC, PME, PMG) -> gleam@http@response:response(bitstring()))
) -> router().
patch6(Router, Pattern, P1, P2, P3, P4, P5, P6, Handler) ->
typed6(Router, patch, Pattern, P1, P2, P3, P4, P5, P6, Handler).
-file("src/radiant.gleam", 577).
-spec delete6(
router(),
binary(),
param(PMJ),
param(PML),
param(PMN),
param(PMP),
param(PMR),
param(PMT),
fun((req(), PMJ, PML, PMN, PMP, PMR, PMT) -> gleam@http@response:response(bitstring()))
) -> router().
delete6(Router, Pattern, P1, P2, P3, P4, P5, P6, Handler) ->
typed6(Router, delete, Pattern, P1, P2, P3, P4, P5, P6, Handler).
-file("src/radiant.gleam", 1168).
?DOC(" The request HTTP method.\n").
-spec method(req()) -> gleam@http:method().
method(Req) ->
erlang:element(2, erlang:element(2, Req)).
-file("src/radiant.gleam", 1173).
?DOC(" The request path (e.g. \"/users/42\").\n").
-spec req_path(req()) -> binary().
req_path(Req) ->
erlang:element(8, erlang:element(2, Req)).
-file("src/radiant.gleam", 1178).
?DOC(" Get a request header by key (case-insensitive).\n").
-spec header(req(), binary()) -> {ok, binary()} | {error, nil}.
header(Req, Key) ->
gleam@http@request:get_header(erlang:element(2, Req), Key).
-file("src/radiant.gleam", 1183).
?DOC(" All request headers.\n").
-spec headers(req()) -> list({binary(), binary()}).
headers(Req) ->
erlang:element(3, erlang:element(2, Req)).
-file("src/radiant.gleam", 1188).
?DOC(" The raw request body as BitArray.\n").
-spec body(req()) -> bitstring().
body(Req) ->
erlang:element(4, erlang:element(2, Req)).
-file("src/radiant.gleam", 1193).
?DOC(" The request body decoded as UTF-8 text.\n").
-spec text_body(req()) -> {ok, binary()} | {error, nil}.
text_body(Req) ->
gleam@bit_array:to_string(erlang:element(4, erlang:element(2, Req))).
-file("src/radiant.gleam", 1203).
?DOC(
" Extract a path parameter as String.\n"
"\n"
" ```gleam\n"
" // pattern: \"/users/:name\"\n"
" radiant.str_param(req, \"name\") // Ok(\"alice\")\n"
" ```\n"
).
-spec str_param(req(), binary()) -> {ok, binary()} | {error, nil}.
str_param(Req, Name) ->
gleam_stdlib:map_get(erlang:element(3, Req), Name).
-file("src/radiant.gleam", 1213).
?DOC(
" Extract a path parameter and parse it as Int.\n"
"\n"
" ```gleam\n"
" // pattern: \"/users/:id\"\n"
" radiant.int_param(req, \"id\") // Ok(42)\n"
" ```\n"
).
-spec int_param(req(), binary()) -> {ok, integer()} | {error, nil}.
int_param(Req, Name) ->
_pipe = gleam_stdlib:map_get(erlang:element(3, Req), Name),
gleam@result:'try'(_pipe, fun gleam_stdlib:parse_int/1).
-file("src/radiant.gleam", 1225).
?DOC(" All query parameters as key-value pairs.\n").
-spec queries(req()) -> list({binary(), binary()}).
queries(Req) ->
case erlang:element(9, erlang:element(2, Req)) of
{some, Q} ->
case gleam_stdlib:parse_query(Q) of
{ok, Pairs} ->
Pairs;
{error, nil} ->
[]
end;
none ->
[]
end.
-file("src/radiant.gleam", 1219).
?DOC(" Get a single query parameter by key.\n").
-spec 'query'(req(), binary()) -> {ok, binary()} | {error, nil}.
'query'(Req, Key) ->
_pipe = queries(Req),
gleam@list:key_find(_pipe, Key).
-file("src/radiant.gleam", 1237).
?DOC(" Get a query parameter parsed as Int.\n").
-spec query_int(req(), binary()) -> {ok, integer()} | {error, nil}.
query_int(Req, Key) ->
_pipe = 'query'(Req, Key),
gleam@result:'try'(_pipe, fun gleam_stdlib:parse_int/1).
-file("src/radiant.gleam", 1242).
?DOC(" Get a query parameter parsed as Float.\n").
-spec query_float(req(), binary()) -> {ok, float()} | {error, nil}.
query_float(Req, Key) ->
_pipe = 'query'(Req, Key),
gleam@result:'try'(_pipe, fun gleam_stdlib:parse_float/1).
-file("src/radiant.gleam", 1248).
?DOC(
" Get a query parameter parsed as Bool.\n"
" Accepts `\"true\"`/`\"1\"` → `True`, `\"false\"`/`\"0\"` → `False`. Anything else returns `Error(Nil)`.\n"
).
-spec query_bool(req(), binary()) -> {ok, boolean()} | {error, nil}.
query_bool(Req, Key) ->
case 'query'(Req, Key) of
{ok, <<"true"/utf8>>} ->
{ok, true};
{ok, <<"1"/utf8>>} ->
{ok, true};
{ok, <<"false"/utf8>>} ->
{ok, false};
{ok, <<"0"/utf8>>} ->
{ok, false};
_ ->
{error, nil}
end.
-file("src/radiant.gleam", 1257).
?DOC(" Access the underlying `Request(BitArray)` for anything radiant doesn't wrap.\n").
-spec original(req()) -> gleam@http@request:request(bitstring()).
original(Req) ->
erlang:element(2, Req).
-file("src/radiant.gleam", 1269).
?DOC(
" Store a typed value in the request context.\n"
" Use a `Key(a)` constant to guarantee type-safe retrieval.\n"
"\n"
" ```gleam\n"
" pub const user_key: radiant.Key(User) = radiant.key(\"user\")\n"
"\n"
" radiant.set_context(req, user_key, User(name: \"Alice\"))\n"
" ```\n"
).
-spec set_context(req(), key(PSI), PSI) -> req().
set_context(Req, K, Value) ->
{key, Name} = K,
{req,
erlang:element(2, Req),
erlang:element(3, Req),
gleam@dict:insert(
erlang:element(4, Req),
Name,
gleam_stdlib:identity(Value)
)}.
-file("src/radiant.gleam", 1280).
?DOC(
" Retrieve a typed value from the request context.\n"
" Returns `Ok(a)` if the key was set, `Error(Nil)` otherwise.\n"
"\n"
" ```gleam\n"
" let assert Ok(user) = radiant.get_context(req, user_key)\n"
" ```\n"
).
-spec get_context(req(), key(PSK)) -> {ok, PSK} | {error, nil}.
get_context(Req, K) ->
{key, Name} = K,
case gleam_stdlib:map_get(erlang:element(4, Req), Name) of
{ok, Dyn} ->
{ok, gleam_stdlib:identity(Dyn)};
{error, _} ->
{error, nil}
end.
-file("src/radiant.gleam", 1299).
?DOC(" Build a response with the given status and UTF-8 text body.\n").
-spec response(integer(), binary()) -> gleam@http@response:response(bitstring()).
response(Status, Body_text) ->
{response, Status, [], <<Body_text/binary>>}.
-file("src/radiant.gleam", 1304).
?DOC(" 200 OK with text body.\n").
-spec ok(binary()) -> gleam@http@response:response(bitstring()).
ok(Body_text) ->
response(200, Body_text).
-file("src/radiant.gleam", 1309).
?DOC(" 201 Created with text body.\n").
-spec created(binary()) -> gleam@http@response:response(bitstring()).
created(Body_text) ->
response(201, Body_text).
-file("src/radiant.gleam", 1314).
?DOC(" 204 No Content (empty body).\n").
-spec no_content() -> gleam@http@response:response(bitstring()).
no_content() ->
response(204, <<""/utf8>>).
-file("src/radiant.gleam", 1319).
?DOC(" 404 Not Found (empty body).\n").
-spec not_found() -> gleam@http@response:response(bitstring()).
not_found() ->
response(404, <<""/utf8>>).
-file("src/radiant.gleam", 141).
?DOC(" Create an empty router with a default 404 fallback.\n").
-spec new() -> router().
new() ->
{router, radiant@internal@tree:new(), fun(_) -> not_found() end, []}.
-file("src/radiant.gleam", 601).
?DOC(
" Group routes under a common path prefix.\n"
"\n"
" ```gleam\n"
" radiant.new()\n"
" |> radiant.scope(\"/api/v1\", fn(r) {\n"
" r\n"
" |> radiant.get(\"/users\", list_users)\n"
" |> radiant.get(\"/users/:id\", show_user)\n"
" })\n"
" ```\n"
).
-spec scope(router(), binary(), fun((router()) -> router())) -> router().
scope(Router, Prefix, Builder) ->
Scoped = Builder(new()),
Prefix_segs = radiant@internal@path:parse(Prefix),
Sub_routes = radiant@internal@tree:to_routes(erlang:element(2, Scoped)),
gleam@list:fold(
Sub_routes,
Router,
fun(Acc_router, R) ->
{Method, Segments, Handler} = R,
Full_segments = lists:append(Prefix_segs, Segments),
New_tree = radiant@internal@tree:insert(
erlang:element(2, Acc_router),
Method,
Full_segments,
Handler
),
{router,
New_tree,
erlang:element(3, Acc_router),
erlang:element(4, Acc_router)}
end
).
-file("src/radiant.gleam", 1324).
?DOC(" 400 Bad Request (empty body).\n").
-spec bad_request() -> gleam@http@response:response(bitstring()).
bad_request() ->
response(400, <<""/utf8>>).
-file("src/radiant.gleam", 1330).
?DOC(
" 401 Unauthorized (empty body).\n"
" Set `www-authenticate` with `with_header` if needed.\n"
).
-spec unauthorized() -> gleam@http@response:response(bitstring()).
unauthorized() ->
response(401, <<""/utf8>>).
-file("src/radiant.gleam", 1335).
?DOC(" 403 Forbidden (empty body).\n").
-spec forbidden() -> gleam@http@response:response(bitstring()).
forbidden() ->
response(403, <<""/utf8>>).
-file("src/radiant.gleam", 1347).
?DOC(
" 422 Unprocessable Entity (empty body).\n"
" Standard response for semantic validation failures (e.g. invalid field values).\n"
).
-spec unprocessable_entity() -> gleam@http@response:response(bitstring()).
unprocessable_entity() ->
response(422, <<""/utf8>>).
-file("src/radiant.gleam", 1352).
?DOC(" 500 Internal Server Error (empty body).\n").
-spec internal_server_error() -> gleam@http@response:response(bitstring()).
internal_server_error() ->
response(500, <<""/utf8>>).
-file("src/radiant.gleam", 1357).
?DOC(" 400 Bad Request with a text body.\n").
-spec bad_request_with(binary()) -> gleam@http@response:response(bitstring()).
bad_request_with(Body_text) ->
response(400, Body_text).
-file("src/radiant.gleam", 1362).
?DOC(" 401 Unauthorized with a text body.\n").
-spec unauthorized_with(binary()) -> gleam@http@response:response(bitstring()).
unauthorized_with(Body_text) ->
response(401, Body_text).
-file("src/radiant.gleam", 1367).
?DOC(" 403 Forbidden with a text body.\n").
-spec forbidden_with(binary()) -> gleam@http@response:response(bitstring()).
forbidden_with(Body_text) ->
response(403, Body_text).
-file("src/radiant.gleam", 1372).
?DOC(" 404 Not Found with a text body.\n").
-spec not_found_with(binary()) -> gleam@http@response:response(bitstring()).
not_found_with(Body_text) ->
response(404, Body_text).
-file("src/radiant.gleam", 1377).
?DOC(" 422 Unprocessable Entity with a text body.\n").
-spec unprocessable_entity_with(binary()) -> gleam@http@response:response(bitstring()).
unprocessable_entity_with(Body_text) ->
response(422, Body_text).
-file("src/radiant.gleam", 1382).
?DOC(" 500 Internal Server Error with a text body.\n").
-spec internal_server_error_with(binary()) -> gleam@http@response:response(bitstring()).
internal_server_error_with(Body_text) ->
response(500, Body_text).
-file("src/radiant.gleam", 1399).
?DOC(" 303 See Other redirect.\n").
-spec redirect(binary()) -> gleam@http@response:response(bitstring()).
redirect(Uri) ->
{response, 303, [{<<"location"/utf8>>, Uri}], <<>>}.
-file("src/radiant.gleam", 1416).
?DOC(" Set a header on a response (key is lowercased automatically).\n").
-spec with_header(gleam@http@response:response(bitstring()), binary(), binary()) -> gleam@http@response:response(bitstring()).
with_header(Resp, Key, Value) ->
gleam@http@response:set_header(Resp, Key, Value).
-file("src/radiant.gleam", 1340).
?DOC(" 405 Method Not Allowed with an `allow` header.\n").
-spec method_not_allowed(binary()) -> gleam@http@response:response(bitstring()).
method_not_allowed(Allowed) ->
_pipe = response(405, <<""/utf8>>),
with_header(_pipe, <<"allow"/utf8>>, Allowed).
-file("src/radiant.gleam", 651).
?DOC(
" Dispatch a raw HTTP request through the router, returning a response.\n"
"\n"
" This is the main entry point connecting radiant to any HTTP server.\n"
" Middlewares are applied in registration order (first added = outermost).\n"
"\n"
" If the path matches a route but the method does not, returns 405 Method\n"
" Not Allowed with an `allow` header listing the accepted methods.\n"
).
-spec handle(router(), gleam@http@request:request(bitstring())) -> gleam@http@response:response(bitstring()).
handle(Router, Req) ->
Dispatch = fun(R) ->
Segments = radiant@internal@path:split(
erlang:element(8, erlang:element(2, R))
),
case radiant@internal@tree:match(
erlang:element(2, Router),
erlang:element(2, erlang:element(2, R)),
Segments
) of
{ok, {Handler, Params}} ->
Handler(
{req, erlang:element(2, R), Params, erlang:element(4, R)}
);
{error, nil} ->
Head_result = case erlang:element(2, erlang:element(2, R)) of
head ->
case radiant@internal@tree:match(
erlang:element(2, Router),
get,
Segments
) of
{ok, {Handler@1, Params@1}} ->
{ok,
Handler@1(
{req,
begin
_record = erlang:element(2, R),
{request,
get,
erlang:element(3, _record),
erlang:element(4, _record),
erlang:element(5, _record),
erlang:element(6, _record),
erlang:element(7, _record),
erlang:element(8, _record),
erlang:element(9, _record)}
end,
Params@1,
erlang:element(4, R)}
)};
{error, _} ->
{error, nil}
end;
_ ->
{error, nil}
end,
case Head_result of
{ok, Resp} ->
{response,
erlang:element(2, Resp),
erlang:element(3, Resp),
<<>>};
{error, _} ->
Allowed = radiant@internal@tree:allowed_methods(
erlang:element(2, Router),
Segments
),
case Allowed of
[] ->
(erlang:element(3, Router))(R);
_ ->
method_not_allowed(
begin
_pipe = Allowed,
_pipe@1 = gleam@list:map(
_pipe,
fun gleam@http:method_to_string/1
),
gleam@string:join(
_pipe@1,
<<", "/utf8>>
)
end
)
end
end
end
end,
Final_handler = gleam@list:fold(
erlang:element(4, Router),
Dispatch,
fun(Handler@2, Mw) -> Mw(Handler@2) end
),
Final_handler({req, Req, maps:new(), maps:new()}).
-file("src/radiant.gleam", 707).
?DOC(
" Like `handle`, but accepts a request with any body type plus a separately\n"
" read `BitArray` body. Useful for Wisp integration where the body is read\n"
" through `wisp.require_bit_array_body` before routing.\n"
"\n"
" ```gleam\n"
" use body <- wisp.require_bit_array_body(req)\n"
" radiant.handle_with(router, req, body)\n"
" ```\n"
).
-spec handle_with(router(), gleam@http@request:request(any()), bitstring()) -> gleam@http@response:response(bitstring()).
handle_with(Router, Req, Body) ->
handle(Router, gleam@http@request:set_body(Req, Body)).
-file("src/radiant.gleam", 1392).
?DOC(
" JSON error response: `{\"error\": \"message\"}` with `application/json` content-type.\n"
"\n"
" ```gleam\n"
" radiant.json_error(404, \"user not found\")\n"
" // → 404 {\"error\":\"user not found\"}\n"
" ```\n"
).
-spec json_error(integer(), binary()) -> gleam@http@response:response(bitstring()).
json_error(Status, Message) ->
Body = gleam@json:to_string(
gleam@json:object([{<<"error"/utf8>>, gleam@json:string(Message)}])
),
_pipe = response(Status, Body),
with_header(
_pipe,
<<"content-type"/utf8>>,
<<"application/json; charset=utf-8"/utf8>>
).
-file("src/radiant.gleam", 1404).
?DOC(" 200 OK with `content-type: application/json`.\n").
-spec json(binary()) -> gleam@http@response:response(bitstring()).
json(Body_text) ->
_pipe = response(200, Body_text),
with_header(
_pipe,
<<"content-type"/utf8>>,
<<"application/json; charset=utf-8"/utf8>>
).
-file("src/radiant.gleam", 1410).
?DOC(" 200 OK with `content-type: text/html`.\n").
-spec html(binary()) -> gleam@http@response:response(bitstring()).
html(Body_text) ->
_pipe = response(200, Body_text),
with_header(
_pipe,
<<"content-type"/utf8>>,
<<"text/html; charset=utf-8"/utf8>>
).
-file("src/radiant.gleam", 1449).
?DOC(
" Sensible default CORS config.\n"
"\n"
" - Origins: `[\"*\"]` (any)\n"
" - Methods: GET, POST, PUT, PATCH, DELETE\n"
" - Headers: `content-type`, `authorization`\n"
" - Max age: 86400 seconds (24 hours)\n"
).
-spec default_cors() -> cors_config().
default_cors() ->
{cors_config,
[<<"*"/utf8>>],
[get, post, put, patch, delete],
[<<"content-type"/utf8>>, <<"authorization"/utf8>>],
86400}.
-file("src/radiant.gleam", 1465).
?DOC(
" CORS middleware. Handles preflight `OPTIONS` requests automatically and\n"
" sets `access-control-allow-*` headers on all responses.\n"
"\n"
" ```gleam\n"
" radiant.new()\n"
" |> radiant.middleware(radiant.cors(radiant.default_cors()))\n"
" ```\n"
).
-spec cors(cors_config()) -> fun((fun((req()) -> gleam@http@response:response(bitstring()))) -> fun((req()) -> gleam@http@response:response(bitstring()))).
cors(Config) ->
fun(Next) ->
fun(Req) ->
Origin = begin
_pipe = header(Req, <<"origin"/utf8>>),
gleam@result:unwrap(_pipe, <<""/utf8>>)
end,
Allowed = (Origin /= <<""/utf8>>) andalso (gleam@list:contains(
erlang:element(2, Config),
<<"*"/utf8>>
)
orelse gleam@list:contains(erlang:element(2, Config), Origin)),
case method(Req) of
options ->
case Allowed of
true ->
_pipe@1 = no_content(),
_pipe@2 = with_header(
_pipe@1,
<<"access-control-allow-origin"/utf8>>,
Origin
),
_pipe@5 = with_header(
_pipe@2,
<<"access-control-allow-methods"/utf8>>,
begin
_pipe@3 = erlang:element(3, Config),
_pipe@4 = gleam@list:map(
_pipe@3,
fun gleam@http:method_to_string/1
),
gleam@string:join(_pipe@4, <<", "/utf8>>)
end
),
_pipe@6 = with_header(
_pipe@5,
<<"access-control-allow-headers"/utf8>>,
gleam@string:join(
erlang:element(4, Config),
<<", "/utf8>>
)
),
with_header(
_pipe@6,
<<"access-control-max-age"/utf8>>,
erlang:integer_to_binary(
erlang:element(5, Config)
)
);
false ->
no_content()
end;
_ ->
Resp = Next(Req),
case Allowed of
true ->
with_header(
Resp,
<<"access-control-allow-origin"/utf8>>,
Origin
);
false ->
Resp
end
end
end
end.
-file("src/radiant.gleam", 1521).
?DOC(
" Logging middleware. Takes a logging function and calls it before and after\n"
" each request with method, path, and status code.\n"
"\n"
" Works with any logger — woof, io.println, or your own:\n"
"\n"
" ```gleam\n"
" // With io.println:\n"
" radiant.log(io.println)\n"
"\n"
" // With woof:\n"
" radiant.log(fn(msg) { woof.log(logger, woof.Info, msg, []) })\n"
" ```\n"
).
-spec log(fun((binary()) -> any())) -> fun((fun((req()) -> gleam@http@response:response(bitstring()))) -> fun((req()) -> gleam@http@response:response(bitstring()))).
log(Logger) ->
fun(Next) ->
fun(Req) ->
M = gleam@http:method_to_string(method(Req)),
P = req_path(Req),
Logger(<<<<M/binary, " "/utf8>>/binary, P/binary>>),
Resp = Next(Req),
Logger(
<<<<<<<<M/binary, " "/utf8>>/binary, P/binary>>/binary,
" → "/utf8>>/binary,
(erlang:integer_to_binary(erlang:element(2, Resp)))/binary>>
),
Resp
end
end.
-file("src/radiant.gleam", 1546).
?DOC(
" Rescue middleware. Catches Erlang exceptions (panics) in handlers and\n"
" returns a 500 response instead of crashing the process.\n"
"\n"
" The callback receives the exception for logging or error reporting.\n"
"\n"
" ```gleam\n"
" radiant.new()\n"
" |> radiant.middleware(radiant.rescue(fn(err) {\n"
" io.debug(err)\n"
" radiant.response(500, \"Internal server error\")\n"
" }))\n"
" ```\n"
).
-spec rescue(
fun((exception:exception()) -> gleam@http@response:response(bitstring()))
) -> fun((fun((req()) -> gleam@http@response:response(bitstring()))) -> fun((req()) -> gleam@http@response:response(bitstring()))).
rescue(On_error) ->
fun(Next) ->
fun(Req) -> case exception_ffi:rescue(fun() -> Next(Req) end) of
{ok, Resp} ->
Resp;
{error, Err} ->
On_error(Err)
end end
end.
-file("src/radiant.gleam", 1580).
?DOC(
" A middleware that parses the request body as JSON and stores it in the\n"
" request context under the given typed key.\n"
"\n"
" If the body is not valid JSON or does not match the decoder,\n"
" returns `400 Bad Request` immediately.\n"
"\n"
" ```gleam\n"
" pub const user_key: radiant.Key(User) = radiant.key(\"user\")\n"
"\n"
" let user_decoder = {\n"
" use name <- decode.field(\"name\", decode.string)\n"
" decode.success(User(name))\n"
" }\n"
"\n"
" radiant.new()\n"
" |> radiant.middleware(radiant.json_body(user_key, user_decoder))\n"
" |> radiant.post(\"/users\", fn(req) {\n"
" let assert Ok(user) = radiant.get_context(req, user_key)\n"
" radiant.ok(\"Hello \" <> user.name)\n"
" })\n"
" ```\n"
).
-spec json_body(key(PTP), gleam@dynamic@decode:decoder(PTP)) -> fun((fun((req()) -> gleam@http@response:response(bitstring()))) -> fun((req()) -> gleam@http@response:response(bitstring()))).
json_body(Key, Decoder) ->
fun(Next) -> fun(Req) -> case body(Req) of
<<>> ->
Next(Req);
_ ->
case text_body(Req) of
{ok, B} ->
case gleam@json:parse(B, Decoder) of
{ok, Val} ->
Next(set_context(Req, Key, Val));
{error, _} ->
bad_request()
end;
{error, _} ->
bad_request()
end
end end end.
-file("src/radiant.gleam", 1655).
-spec mime_from_path(binary()) -> binary().
mime_from_path(Path) ->
Ext = begin
_pipe = Path,
_pipe@1 = gleam@string:split(_pipe, <<"."/utf8>>),
_pipe@2 = gleam@list:last(_pipe@1),
_pipe@3 = gleam@result:unwrap(_pipe@2, <<""/utf8>>),
string:lowercase(_pipe@3)
end,
case Ext of
<<"html"/utf8>> ->
<<"text/html"/utf8>>;
<<"htm"/utf8>> ->
<<"text/html"/utf8>>;
<<"css"/utf8>> ->
<<"text/css"/utf8>>;
<<"js"/utf8>> ->
<<"application/javascript"/utf8>>;
<<"json"/utf8>> ->
<<"application/json"/utf8>>;
<<"png"/utf8>> ->
<<"image/png"/utf8>>;
<<"jpg"/utf8>> ->
<<"image/jpeg"/utf8>>;
<<"jpeg"/utf8>> ->
<<"image/jpeg"/utf8>>;
<<"gif"/utf8>> ->
<<"image/gif"/utf8>>;
<<"svg"/utf8>> ->
<<"image/svg+xml"/utf8>>;
<<"txt"/utf8>> ->
<<"text/plain"/utf8>>;
_ ->
<<"application/octet-stream"/utf8>>
end.
-file("src/radiant.gleam", 1608).
?DOC(
" A middleware that serves static files from a directory.\n"
"\n"
" It strips the `prefix` from the request path and looks for the remaining\n"
" path inside the `directory`.\n"
"\n"
" If a file is found, it's served with a guessed Mime-Type.\n"
" Otherwise, it falls back to the next handler (usualy a 404 fallback).\n"
).
-spec serve_static(binary(), binary(), file_system()) -> fun((fun((req()) -> gleam@http@response:response(bitstring()))) -> fun((req()) -> gleam@http@response:response(bitstring()))).
serve_static(Prefix, Directory, Fs) ->
Prefix@1 = case gleam_stdlib:string_starts_with(Prefix, <<"/"/utf8>>) of
true ->
Prefix;
false ->
<<"/"/utf8, Prefix/binary>>
end,
fun(Next) ->
fun(Req) ->
Path = req_path(Req),
case gleam_stdlib:string_starts_with(Path, Prefix@1) of
true ->
Rel_path = begin
_pipe = gleam@string:drop_start(
Path,
string:length(Prefix@1)
),
_pipe@1 = gleam@string:split(_pipe, <<"/"/utf8>>),
_pipe@2 = gleam@list:filter(
_pipe@1,
fun(S) ->
(S /= <<""/utf8>>) andalso (S /= <<".."/utf8>>)
end
),
gleam@string:join(_pipe@2, <<"/"/utf8>>)
end,
Full_path = case Directory of
<<"."/utf8>> ->
Rel_path;
_ ->
<<<<Directory/binary, "/"/utf8>>/binary,
Rel_path/binary>>
end,
case (erlang:element(3, Fs))(Full_path) of
true ->
case (erlang:element(2, Fs))(Full_path) of
{ok, Bits} ->
Mime = mime_from_path(Full_path),
_pipe@3 = gleam@http@response:new(200),
_pipe@4 = gleam@http@response:set_body(
_pipe@3,
Bits
),
gleam@http@response:set_header(
_pipe@4,
<<"content-type"/utf8>>,
Mime
);
{error, _} ->
Next(Req)
end;
false ->
Next(Req)
end;
false ->
Next(Req)
end
end
end.
-file("src/radiant.gleam", 1685).
?DOC(
" Create a test request with the given method and path.\n"
" Supports query strings: `test_request(Get, \"/search?q=gleam\")`.\n"
"\n"
" Note: import `gleam/http.{Get, Post, ...}` for method constructors.\n"
).
-spec test_request(gleam@http:method(), binary()) -> gleam@http@request:request(bitstring()).
test_request(Method, Raw_path) ->
case gleam@string:split_once(Raw_path, <<"?"/utf8>>) of
{ok, {P, Q}} ->
_pipe = gleam@http@request:new(),
_pipe@1 = gleam@http@request:set_method(_pipe, Method),
_pipe@2 = gleam@http@request:set_path(_pipe@1, P),
_pipe@3 = (fun(R) ->
{request,
erlang:element(2, R),
erlang:element(3, R),
erlang:element(4, R),
erlang:element(5, R),
erlang:element(6, R),
erlang:element(7, R),
erlang:element(8, R),
{some, Q}}
end)(_pipe@2),
gleam@http@request:set_body(_pipe@3, <<>>);
{error, nil} ->
_pipe@4 = gleam@http@request:new(),
_pipe@5 = gleam@http@request:set_method(_pipe@4, Method),
_pipe@6 = gleam@http@request:set_path(_pipe@5, Raw_path),
gleam@http@request:set_body(_pipe@6, <<>>)
end.
-file("src/radiant.gleam", 1702).
?DOC(" Shortcut: create a GET test request.\n").
-spec test_get(binary()) -> gleam@http@request:request(bitstring()).
test_get(Raw_path) ->
test_request(get, Raw_path).
-file("src/radiant.gleam", 1707).
?DOC(" Shortcut: create a POST test request with a UTF-8 body.\n").
-spec test_post(binary(), binary()) -> gleam@http@request:request(bitstring()).
test_post(Raw_path, Body_text) ->
_pipe = test_request(post, Raw_path),
gleam@http@request:set_body(_pipe, <<Body_text/binary>>).
-file("src/radiant.gleam", 1713).
?DOC(" Shortcut: create a PUT test request with a UTF-8 body.\n").
-spec test_put(binary(), binary()) -> gleam@http@request:request(bitstring()).
test_put(Raw_path, Body_text) ->
_pipe = test_request(put, Raw_path),
gleam@http@request:set_body(_pipe, <<Body_text/binary>>).
-file("src/radiant.gleam", 1719).
?DOC(" Shortcut: create a PATCH test request with a UTF-8 body.\n").
-spec test_patch(binary(), binary()) -> gleam@http@request:request(bitstring()).
test_patch(Raw_path, Body_text) ->
_pipe = test_request(patch, Raw_path),
gleam@http@request:set_body(_pipe, <<Body_text/binary>>).
-file("src/radiant.gleam", 1725).
?DOC(" Shortcut: create a DELETE test request.\n").
-spec test_delete(binary()) -> gleam@http@request:request(bitstring()).
test_delete(Raw_path) ->
test_request(delete, Raw_path).
-file("src/radiant.gleam", 1730).
?DOC(" Shortcut: create a HEAD test request.\n").
-spec test_head(binary()) -> gleam@http@request:request(bitstring()).
test_head(Raw_path) ->
test_request(head, Raw_path).
-file("src/radiant.gleam", 1735).
?DOC(" Shortcut: create an OPTIONS test request.\n").
-spec test_options(binary()) -> gleam@http@request:request(bitstring()).
test_options(Raw_path) ->
test_request(options, Raw_path).
-file("src/radiant.gleam", 1745).
?DOC(
" Assert that a response has the expected status code.\n"
" Panics if the status doesn't match.\n"
).
-spec should_have_status(gleam@http@response:response(bitstring()), integer()) -> gleam@http@response:response(bitstring()).
should_have_status(Resp, Expected) ->
case erlang:element(2, Resp) =:= Expected of
true ->
Resp;
false ->
Msg = <<<<<<"Radiant Test: Expected status "/utf8,
(erlang:integer_to_binary(Expected))/binary>>/binary,
", got "/utf8>>/binary,
(erlang:integer_to_binary(erlang:element(2, Resp)))/binary>>,
erlang:error(#{gleam_error => panic,
message => Msg,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"should_have_status"/utf8>>,
line => 1757})
end.
-file("src/radiant.gleam", 1764).
?DOC(
" Assert that a response has the expected body.\n"
" Panics if the body doesn't match.\n"
).
-spec should_have_body(gleam@http@response:response(bitstring()), binary()) -> gleam@http@response:response(bitstring()).
should_have_body(Resp, Expected) ->
Expected_bits = <<Expected/binary>>,
case erlang:element(4, Resp) =:= Expected_bits of
true ->
Resp;
false ->
Actual = begin
_pipe = gleam@bit_array:to_string(erlang:element(4, Resp)),
gleam@result:unwrap(_pipe, <<"<non-utf8>"/utf8>>)
end,
erlang:error(#{gleam_error => panic,
message => (<<<<<<<<"Radiant Test: Expected body \""/utf8,
Expected/binary>>/binary,
"\", got \""/utf8>>/binary,
Actual/binary>>/binary,
"\""/utf8>>),
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"should_have_body"/utf8>>,
line => 1773})
end.
-file("src/radiant.gleam", 1786).
?DOC(
" Assert that a response has the expected header value.\n"
" Panics if the header is missing or doesn't match.\n"
).
-spec should_have_header(
gleam@http@response:response(bitstring()),
binary(),
binary()
) -> gleam@http@response:response(bitstring()).
should_have_header(Resp, Name, Expected) ->
case gleam@http@response:get_header(Resp, Name) of
{ok, Val} when Val =:= Expected ->
Resp;
{ok, Val@1} ->
erlang:error(#{gleam_error => panic,
message => (<<<<<<<<<<<<"Radiant Test: Expected header '"/utf8,
Name/binary>>/binary,
"' to be '"/utf8>>/binary,
Expected/binary>>/binary,
"', got '"/utf8>>/binary,
Val@1/binary>>/binary,
"'"/utf8>>),
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"should_have_header"/utf8>>,
line => 1794});
{error, nil} ->
erlang:error(#{gleam_error => panic,
message => (<<<<"Radiant Test: Missing expected header '"/utf8,
Name/binary>>/binary,
"'"/utf8>>),
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"should_have_header"/utf8>>,
line => 1805})
end.
-file("src/radiant.gleam", 1813).
?DOC(
" Parse the response body as JSON and verify it matches the decoder.\n"
" Returns the decoded value for further assertions.\n"
" Panics if parsing fails.\n"
).
-spec should_have_json_body(
gleam@http@response:response(bitstring()),
gleam@dynamic@decode:decoder(PUH)
) -> PUH.
should_have_json_body(Resp, Decoder) ->
Body = case gleam@bit_array:to_string(erlang:element(4, Resp)) of
{ok, S} ->
S;
{error, _} ->
erlang:error(#{gleam_error => panic,
message => <<"Radiant Test: Response body is not valid UTF-8"/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"should_have_json_body"/utf8>>,
line => 1819})
end,
case gleam@json:parse(Body, Decoder) of
{ok, Val} ->
Val;
{error, _} ->
erlang:error(#{gleam_error => panic,
message => <<"Radiant Test: Failed to decode JSON response body"/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"radiant"/utf8>>,
function => <<"should_have_json_body"/utf8>>,
line => 1824})
end.