Return the non-empty segments of a request path.

ℹ️ This function is re-exported from gleam_http.

Examples

case glen.path_segments(req) {
  [] -> index_page()
  ["about"] -> about_page()
  ["greet", name] -> greet_page(name)
  _ -> not_found_page()
}

Set the body of a response.

ℹ️ This function is re-exported from gleam_http.

Set the header with the given value under the given header key.

If the response already has that key, it is replaced.

ℹ️ This function is re-exported from gleam_http.

Set the body of a response to a BitArray.

Convert a JavaScript request into a Glen request.

Convert a Glen response into a JavaScript response.

Escape a string so it can be included inside of HTML safely. You should run this function on all user input being included in HTML to prevent possible XSS attacks.

Create a response with a file stream as the body. The content-type header will be automatically set based on the file’s extension.

Set the body of a response to a file stream. The content-type header will be automatically set based on the file’s extension.

Get the query parameters from a request. Parameters are not predictably ordered, so you should not pattern match on them. Instead, use the key_find function from gleam/list to access parameters.

Create a response with an HTML body.

Set the body of a response to HTML.

Create a response with a JSON body.

Set the body of a response to JSON.

Middleware function for logging requests and responses.

Examples

fn handle_req(req) {
  use <- glen.log(req)
  // ...requests and responses are now logged...
}

Create a response with a status of 405 (method not allowed). The allowed header will be set to the given allowed methods.

Read a request body as a BitArray.

Read a request body as FormData.

Read a request body as JSON.

Read a request body as text.

Redirect the client to a URL with the given status. The status should be in the 3xx range (such as 303: See Other or 307: Temporary Redirect).

Middleware function that reads a request body as a BitArray.

Examples

fn handle_req(req) {
  use bits <- glen.require_bit_array_body(req)

  "Look at all the bits! " <> string.inspect(bits)
  |> glen.html(status.ok)
  |> promise.resolve
}

Middleware function for requiring the request to have a content-type header with a specific content type. Returns the same as unsupported_media_type if the header is missing or does not meet the requirement.

Examples

fn handle_req(req) {
  use <- glen.require_content_type(req, "text/html")
  // ...the request's content-type must be text/html...
}

Middleware for requiring the request body to be a form with a content-type of either application/x-www-form-urlencoded or multipart/form-data.

Formdata values are sorted alphabetically so they can be pattern matched on.

Examples

fn handle_req(req) {
  use formdata <- glen.require_form(req)

  case formdata.values {
    [#("name", name)] -> greet(name)
    _ -> glen.response(status.bad_request)
  }
  |> promise.resolve
}

Middleware function for requiring the request body to be JSON with a content-type of application/json.

Examples

fn handle_req(req) {
  use json <- glen.require_json(req)

  case my_decoder(json) {
    Ok(decoded) -> decoded.foo |> glen.text(status.ok)
    Error(_) -> glen.response(status.bad_request)
  }
  |> promise.resolve
}

Middleware function for requiring the request to be of a certain HTTP method. Returns the same as method_not_allowed if the method does not meet the requirement.

Examples

fn handle_req(req) {
  use <- glen.require_method(req, http.Get)
  // ...only GET requests are allowed...
}

Middleware function that reads a request body as a string.

Examples

fn handle_req(req) {
  use string_body <- glen.require_string_body(req)

  "You gave me: " <> glen.escape_html(string_body)
  |> glen.html(status.ok)
  |> promise.resolve
}

Middleware function that rescues any crashes with an empty response and a status of 500 (internal server error).

Gleam code should never crash under normal circumstances, but it’s always good to be prepared.

Examples

fn handle_req(req) {
  use <- glen.rescue_crashes
  // ...crashes are now handled gracefully...
}

Create a response with the given status code and an empty body.

Start a server using Deno.serve.

ℹ️ Only works when using the deno runtime. See the readme for more info.

Examples

glen.serve(8000, fn(_req) {
  "Hello, world!"
  |> glen.text(status.ok)
  |> promise.resolve
})

Middleware for serving up static files from a directory under a path prefix.

Examples

fn handle_req(req) {
  use <- glen.static(req, "static", "./somedir/static")

  "<img src='/static/image.png'/>" |> glen.html(status.ok) |> promise.resolve
}

Create a response with a text body.

Set the body of a response to text.

Create a response with a status of 415 (unsupported media type). The accept header will be set to the given supported content types.

Upgrade a request to become a websocket. If the request does not have an upgrade header set to websocket, a response of 426 (upgrade required) will be returned.

• on_open gets called when a client starts a websocket connection.
• on_close is called when the connection in closed.
• on_event gets called when the websocket recieves an event or message.

ℹ️ Websockets are currently only supported when using the deno runtime.

Examples

See this for a more detailed example of websockets.

fn handle_req(req) {
  use _conn <- glen.websocket(
    req,
    on_open: on_open,
    on_close: on_close,
    on_event: on_event,
  )
  Nil
}

fn on_open(conn) {
  // ...
}

fn on_close(state) {
  // ...
}

fn on_event(conn, state, msg) {
  // ...
}