dream - v2.3.2

dream/http

Convenience module for HTTP utilities

This module re-exports all HTTP-related types and functions from the dream/http submodules, allowing you to use a single import in your controllers.

Instead of importing from multiple modules:

import dream/http/request.{type Request}
import dream/http/response.{json_response}
import dream/http/status
import dream/http/params.{require_int}

You can just import one:

import dream/http

pub fn show(request: http.Request, context, services) -> http.Response {
  use id <- result.try(http.require_int(request, "id"))
  let user = get_user(services.db, id)
  http.json_response(http.ok, user_to_json(user))
}

What’s Re-exported

This module re-exports:

Types:

Functions:

When to Use This

Use dream/http in controllers for convenience. For more specific imports or when you only need one or two functions, import the specific submodule:

import dream/http/status  // Just status codes
import dream/http/error.{type Error}  // Just error type

Types

</> 
pub type Cookie =
  cookie.Cookie

Error

</> 
pub type Error =
  error.Error
</> 
pub type Header =
  header.Header

Method

</> 
pub type Method =
  request.Method

PathParam

</> 
pub type PathParam =
  request.PathParam

Protocol

</> 
pub type Protocol =
  request.Protocol

Request

</> 
pub type Request =
  request.Request

Response

</> 
pub type Response =
  response.Response

ResponseBody

</> 
pub type ResponseBody =
  response.ResponseBody

SameSite

</> 
pub type SameSite =
  cookie.SameSite

ValidationError

</> 
pub type ValidationError =
  validation.ValidationError

Version

</> 
pub type Version =
  request.Version

Values

accepted

</> 
pub const accepted: Int

bad_request

</> 
pub const bad_request: Int

binary_response

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

conflict

</> 
pub const conflict: Int
</> 
pub const cookie_name: fn(cookie.Cookie) -> String
</> 
pub const cookie_value: fn(cookie.Cookie) -> String

created

</> 
pub const created: Int

empty_response

</> 
pub const empty_response: fn(Int) -> response.Response

field_optional

</> 
pub const field_optional: fn(List(#(String, String)), String) -> option.Option(
  String,
)

forbidden

</> 
pub const forbidden: Int

found

</> 
pub const found: Int
</> 
pub const get_cookie: fn(List(cookie.Cookie), String) -> option.Option(
  cookie.Cookie,
)
</> 
pub const get_cookie_value: fn(List(cookie.Cookie), String) -> option.Option(
  String,
)

get_header

</> 
pub const get_header: fn(List(header.Header), String) -> option.Option(
  String,
)

get_int_param

</> 
pub const get_int_param: fn(request.Request, String) -> Result(
  Int,
  String,
)

get_param

</> 
pub const get_param: fn(request.Request, String) -> Result(
  request.PathParam,
  String,
)

get_query_param

</> 
pub const get_query_param: fn(String, String) -> option.Option(
  String,
)

get_string_param

</> 
pub const get_string_param: fn(request.Request, String) -> Result(
  String,
  String,
)

has_content_type

</> 
pub const has_content_type: fn(request.Request, String) -> Bool

header_name

</> 
pub const header_name: fn(header.Header) -> String

header_value

</> 
pub const header_value: fn(header.Header) -> String

html_response

</> 
pub const html_response: fn(Int, String) -> response.Response

internal_server_error

</> 
pub const internal_server_error: Int

is_method

</> 
pub const is_method: fn(request.Request, request.Method) -> Bool

json_response

</> 
pub const json_response: fn(Int, String) -> response.Response

method_not_allowed

</> 
pub const method_not_allowed: Int

method_to_string

</> 
pub const method_to_string: fn(request.Method) -> String

moved_permanently

</> 
pub const moved_permanently: Int

no_content

</> 
pub const no_content: Int

not_found

</> 
pub const not_found: Int

not_implemented

</> 
pub const not_implemented: Int

ok

</> 
pub const ok: Int

parse_method

</> 
pub const parse_method: fn(String) -> option.Option(
  request.Method,
)

redirect_response

</> 
pub const redirect_response: fn(Int, String) -> response.Response

require_field

</> 
pub const require_field: fn(List(#(String, String)), String) -> Result(
  String,
  error.Error,
)

require_field_int

</> 
pub const require_field_int: fn(List(#(String, String)), String) -> Result(
  Int,
  error.Error,
)

require_form

</> 
pub const require_form: fn(request.Request) -> Result(
  List(#(String, String)),
  error.Error,
)

require_int

</> 
pub const require_int: fn(request.Request, String) -> Result(
  Int,
  error.Error,
)

require_string

</> 
pub const require_string: fn(request.Request, String) -> Result(
  String,
  error.Error,
)
</> 
pub const secure_cookie: fn(String, String) -> cookie.Cookie

see_other

</> 
pub const see_other: Int

service_unavailable

</> 
pub const service_unavailable: Int

set_params

</> 
pub const set_params: fn(request.Request, List(#(String, String))) -> request.Request
</> 
pub const simple_cookie: fn(String, String) -> cookie.Cookie

stream_response

</> 
pub const stream_response: fn(
  Int,
  yielder.Yielder(BitArray),
  String,
) -> response.Response

temporary_redirect

</> 
pub const temporary_redirect: Int

text_response

</> 
pub const text_response: fn(Int, String) -> response.Response

too_many_requests

</> 
pub const too_many_requests: Int

unauthorized

</> 
pub const unauthorized: Int

unprocessable_content

</> 
pub const unprocessable_content: Int

validate_json

</> 
pub const validate_json: fn(String, decode.Decoder(a)) -> Result(
  a,
  validation.ValidationError,
)
✨ Search Document