falcon/core

Types

Config

pub type Config {
  Body(OpaqueBody)
  Headers(Pairs)
  Queries(Pairs)
  ClientOptions(hackney.Options)
}

Constructors

```
Body(OpaqueBody)
```
A string to use as the body of the request - not meant to be used directly, use post, put, or patch instead, or if necessary, to_body
```
Headers(Pairs)
```
A list of headers to prepend to the request
```
Queries(Pairs)
```
A list of query parameters to append to the URL
```
ClientOptions(hackney.Options)
```
A list of options to pass to the underlying HTTP client to control things like timeouts and redirects

FalconError

</>

pub type FalconError {
  URLParseError
  InvalidUtf8Response
  HackneyError(Dynamic)
  RawDecodingError(dynamic.DecodeErrors)
  JsonDecodingError(json.DecodeError)
}

Constructors

```
URLParseError
```
```
InvalidUtf8Response
```
```
HackneyError(Dynamic)
```
```
RawDecodingError(dynamic.DecodeErrors)
```
```
JsonDecodingError(json.DecodeError)
```

FalconResponse

</>

pub type FalconResponse(a) {
  FalconResponse(status: Int, headers: Pairs, body: a)
}

Constructors

FalconResponse(status: Int, headers: Pairs, body: a)

This exists to prevent the body from being added manually to requests like Get and Delete which don’t support bodies. Since a user cannot create an OpaqueBody, they cannot add a body to a request that doesn’t support it

pub opaque type OpaqueBody

Opts

</>

pub type Opts =
  List(Config)

Pairs

</>

pub type Pairs =
  List(#(String, String))

ResultResponse

</>

pub type ResultResponse(a) =
  Result(FalconResponse(a), FalconError)

Target

</>

pub type Target(a) {
  Json(Decoder(a))
  Raw(Decoder(a))
}

Constructors

```
Json(Decoder(a))
```
```
Raw(Decoder(a))
```

Url

</>

pub type Url {
  Url(String)
  SplitUrl(
    scheme: Scheme,
    host: String,
    path: String,
    port: Option(Int),
  )
}

Constructors

```
Url(String)
```

SplitUrl(
  scheme: Scheme,
  host: String,
  path: String,
  port: Option(Int),
)

Functions

append_path

</>

pub fn append_path(url: Url, path: String) -> Url

delete

</>

pub fn delete(
  to url: Url,
  expecting target: Target(a),
  options opts: List(Config),
) -> Result(FalconResponse(a), FalconError)

error_to_string

</>

pub fn error_to_string(err: FalconError) -> String

Convert a FalconError to a string for display - some errors like HackneyError are not very helpful to the end user and are logged instead

extract_body

</>

pub fn extract_body(response: FalconResponse(a)) -> a

extract_headers

</>

pub fn extract_headers(
  response: FalconResponse(a),
) -> List(#(String, String))

extract_params

</>

pub fn extract_params(
  opts: List(Config),
  state: #(Request(String), List(HackneyOption)),
) -> #(Request(String), List(HackneyOption))

extract_status_code

</>

pub fn extract_status_code(response: FalconResponse(a)) -> Int

get

</>

pub fn get(
  to url: Url,
  expecting target: Target(a),
  options opts: List(Config),
) -> Result(FalconResponse(a), FalconError)

patch

</>

pub fn patch(
  to url: Url,
  body body: String,
  expecting target: Target(a),
  options opts: List(Config),
) -> Result(FalconResponse(a), FalconError)

post

</>

pub fn post(
  to url: Url,
  body body: String,
  expecting target: Target(a),
  options opts: List(Config),
) -> Result(FalconResponse(a), FalconError)

put

</>

pub fn put(
  to url: Url,
  body body: String,
  expecting target: Target(a),
  options opts: List(Config),
) -> Result(FalconResponse(a), FalconError)

send

</>

pub fn send(
  method method: Method,
  url url: Url,
  expecting decode: Target(a),
  options opts: List(Config),
) -> Result(FalconResponse(a), FalconError)

Core function for sending requests, you would normally use the get, post, put, patch, or delete functions instead

to_body

</>

pub fn to_body(body: String) -> Config

Convert a string to an OpaqueBody - only use this if you are using the send function directly

url_to_string

</>

pub fn url_to_string(url: Url) -> String