offstage - v0.7.0

offstage

Types

BadRequestResponse

</> 
pub type BadRequestResponse {
  BadRequestResponse(
    apply: fn(String) -> response.Response(wisp.Body),
    apply_when: fn(
      String,
      Bool,
      fn() -> response.Response(wisp.Body),
    ) -> response.Response(wisp.Body),
  )
}

Constructors

BearerAuth

</>

The type representing Bearer authentication in the system

pub type BearerAuth {
  BearerAuth(token: String)
}

Constructors 

  • BearerAuth(token: String)

ConflictResponse

</> 
pub type ConflictResponse {
  ConflictResponse(
    apply: fn(String) -> response.Response(wisp.Body),
    apply_when: fn(
      String,
      Bool,
      fn() -> response.Response(wisp.Body),
    ) -> response.Response(wisp.Body),
  )
}

Constructors

InternalServerErrorResponse

</> 
pub type InternalServerErrorResponse {
  InternalServerErrorResponse(
    apply: fn(String) -> response.Response(wisp.Body),
    apply_when: fn(
      String,
      Bool,
      fn() -> response.Response(wisp.Body),
    ) -> response.Response(wisp.Body),
  )
}

Constructors

JsonResponse

</>

The type representing a JSON response from the server

pub type JsonResponse(response) {
  JsonResponse(
    apply: fn(response) -> response.Response(wisp.Body),
    apply_when: fn(
      response,
      Bool,
      fn() -> response.Response(wisp.Body),
    ) -> response.Response(wisp.Body),
  )
}

Constructors

MistResponse

</>

The response type for Mist.

pub type MistResponse =
  offstage_core.MistResponse

NotFoundResponse

</> 
pub type NotFoundResponse {
  NotFoundResponse(
    apply: fn(String) -> response.Response(wisp.Body),
    apply_when: fn(
      String,
      Bool,
      fn() -> response.Response(wisp.Body),
    ) -> response.Response(wisp.Body),
  )
}

Constructors

OpenAPIScope

</> 
pub type OpenAPIScope =
  offstage_core.OpenAPIScope

Request

</>

The common request type that supports both Wisp and Mist.

pub type Request =
  request.Request(offstage_core.Connection)

RouteCapability

</> 
pub type RouteCapability(data, object) =
  offstage_core.RouteCapability(data, object)

RouteSpec

</> 
pub type RouteSpec =
  offstage_core.RouteSpec

RouteSpecBuilder

</> 
pub type RouteSpecBuilder =
  offstage_core.RouteSpecBuilder

ServiceUnavailableResponse

</> 
pub type ServiceUnavailableResponse {
  ServiceUnavailableResponse(
    apply: fn(String) -> response.Response(wisp.Body),
    apply_when: fn(
      String,
      Bool,
      fn() -> response.Response(wisp.Body),
    ) -> response.Response(wisp.Body),
  )
}

Constructors

TimeoutResponse

</> 
pub type TimeoutResponse {
  TimeoutResponse(
    apply: fn(String) -> response.Response(wisp.Body),
    apply_when: fn(
      String,
      Bool,
      fn() -> response.Response(wisp.Body),
    ) -> response.Response(wisp.Body),
  )
}

Constructors

UnauthorizedResponse

</> 
pub type UnauthorizedResponse {
  UnauthorizedResponse(
    apply: fn(String) -> response.Response(wisp.Body),
    apply_when: fn(
      String,
      Bool,
      fn() -> response.Response(wisp.Body),
    ) -> response.Response(wisp.Body),
  )
}

Constructors

WispResponse

</>

The response type for Wisp.

pub type WispResponse =
  response.Response(wisp.Body)

Values

bad_request

</> 
pub fn bad_request(
  spec: offstage_core.RouteSpecBuilder,
  next: fn(
    offstage_core.RouteSpecBuilder,
    offstage_core.RouteCapability(BadRequestResponse, object),
  ) -> offstage_core.RouteSpec,
) -> offstage_core.RouteSpec

bearer_auth

</> 
pub fn bearer_auth(
  spec: offstage_core.RouteSpecBuilder,
  name: String,
  next: fn(
    offstage_core.RouteSpecBuilder,
    offstage_core.RouteCapability(BearerAuth, object),
  ) -> offstage_core.RouteSpec,
) -> offstage_core.RouteSpec

Add bearer authentication to the route.

build

</> 
pub fn build(
  spec: offstage_core.RouteSpecBuilder,
  builder: fn(request.Request(offstage_core.Connection)) -> Result(
    object,
    response.Response(wisp.Body),
  ),
  route: fn(request.Request(offstage_core.Connection), object) -> response.Response(
    wisp.Body,
  ),
) -> offstage_core.RouteSpec

Build a route specification from the given builder functions.

conflict

</> 
pub fn conflict(
  spec: offstage_core.RouteSpecBuilder,
  next: fn(
    offstage_core.RouteSpecBuilder,
    offstage_core.RouteCapability(ConflictResponse, object),
  ) -> offstage_core.RouteSpec,
) -> offstage_core.RouteSpec

delete

</> 
pub fn delete(route: String) -> offstage_core.RouteSpecBuilder

Create a DELETE route with the given [route] path.

description

</> 
pub fn description(
  spec: offstage_core.RouteSpecBuilder,
  description: String,
) -> offstage_core.RouteSpecBuilder

Set the [summary] of the route.

doc

</> 
pub fn doc(
  spec: offstage_core.RouteSpec,
  openapi: openapi.OpenAPI,
) -> openapi.OpenAPI

Get the OpenAPI document from the given route definition

get

</> 
pub fn get(route: String) -> offstage_core.RouteSpecBuilder

Create a GET route with the given [route] path.

internal_server_error

</> 
pub fn internal_server_error(
  spec: offstage_core.RouteSpecBuilder,
  next: fn(
    offstage_core.RouteSpecBuilder,
    offstage_core.RouteCapability(
      InternalServerErrorResponse,
      object,
    ),
  ) -> offstage_core.RouteSpec,
) -> offstage_core.RouteSpec

json_body

</> 
pub fn json_body(
  spec: offstage_core.RouteSpecBuilder,
  decoder: serialize.Decoder(body),
  next: fn(
    offstage_core.RouteSpecBuilder,
    offstage_core.RouteCapability(body, object),
  ) -> offstage_core.RouteSpec,
) -> offstage_core.RouteSpec

Add a json body with the given decoder to the route

json_path_parameter

</> 
pub fn json_path_parameter(
  spec: offstage_core.RouteSpecBuilder,
  name: String,
  decoder: serialize.Decoder(a),
  next: fn(
    offstage_core.RouteSpecBuilder,
    offstage_core.RouteCapability(a, object),
  ) -> offstage_core.RouteSpec,
) -> offstage_core.RouteSpec

json_query_parameter

</> 
pub fn json_query_parameter(
  spec: offstage_core.RouteSpecBuilder,
  name: String,
  serializer: serialize.Serializer(a),
  default: option.Option(a),
  next: fn(
    offstage_core.RouteSpecBuilder,
    offstage_core.RouteCapability(a, object),
  ) -> offstage_core.RouteSpec,
) -> offstage_core.RouteSpec

json_response

</> 
pub fn json_response(
  spec: offstage_core.RouteSpecBuilder,
  code: Int,
  summary: String,
  encoder: serialize.Encoder(response),
  next: fn(
    offstage_core.RouteSpecBuilder,
    offstage_core.RouteCapability(JsonResponse(response), object),
  ) -> offstage_core.RouteSpec,
) -> offstage_core.RouteSpec

match_path_segment

</> 
pub fn match_path_segment(
  request_segments: List(String),
  route_segments: List(String),
) -> Bool

Verify if the given request segments match the route’s segments. Parameters like ‘{id}’ will be treated as wildcards.

multipart_body

</> 
pub fn multipart_body(
  spec: offstage_core.RouteSpecBuilder,
  decoder: serialize.Decoder(body),
  next: fn(
    offstage_core.RouteSpecBuilder,
    offstage_core.RouteCapability(body, object),
  ) -> offstage_core.RouteSpec,
) -> offstage_core.RouteSpec

Add a multipart body with the given decoder to the route

not_found

</> 
pub fn not_found(
  spec: offstage_core.RouteSpecBuilder,
  next: fn(
    offstage_core.RouteSpecBuilder,
    offstage_core.RouteCapability(NotFoundResponse, object),
  ) -> offstage_core.RouteSpec,
) -> offstage_core.RouteSpec

pagination

</> 
pub fn pagination(
  spec: offstage_core.RouteSpecBuilder,
  config: pagination.PaginationConfig(
    a,
    b,
    offstage_core.Connection,
  ),
  next: fn(
    offstage_core.RouteSpecBuilder,
    offstage_core.RouteCapability(a, object),
  ) -> offstage_core.RouteSpec,
) -> offstage_core.RouteSpec

patch

</> 
pub fn patch(route: String) -> offstage_core.RouteSpecBuilder

Create a PATCH route with the given [route] path.

path_parameter

</> 
pub fn path_parameter(
  spec: offstage_core.RouteSpecBuilder,
  name: String,
  decoder: serialize.Decoder(a),
  next: fn(
    offstage_core.RouteSpecBuilder,
    offstage_core.RouteCapability(a, object),
  ) -> offstage_core.RouteSpec,
) -> offstage_core.RouteSpec

post

</> 
pub fn post(route: String) -> offstage_core.RouteSpecBuilder

Create a POST route with the given [route] path.

put

</> 
pub fn put(route: String) -> offstage_core.RouteSpecBuilder

Create a PUT route with the given [route] path.

query_parameter

</> 
pub fn query_parameter(
  spec: offstage_core.RouteSpecBuilder,
  name: String,
  serializer: serialize.Serializer(a),
  default: option.Option(a),
  next: fn(
    offstage_core.RouteSpecBuilder,
    offstage_core.RouteCapability(a, object),
  ) -> offstage_core.RouteSpec,
) -> offstage_core.RouteSpec

require_authorization

</> 
pub fn require_authorization(
  req: request.Request(offstage_core.Connection),
  unauthorized: UnauthorizedResponse,
) -> Result(String, response.Response(wisp.Body))

Require the given token from the request headers and execute the given function accordingly

router

</> 
pub fn router(
  openapi: openapi.OpenAPI,
  specs: List(offstage_core.RouteSpec),
  request: request.Request(offstage_core.Connection),
) -> response.Response(wisp.Body)

Route the request to the corresponding route based on the given specs.

service_unavailable

</> 
pub fn service_unavailable(
  spec: offstage_core.RouteSpecBuilder,
  next: fn(
    offstage_core.RouteSpecBuilder,
    offstage_core.RouteCapability(
      ServiceUnavailableResponse,
      object,
    ),
  ) -> offstage_core.RouteSpec,
) -> offstage_core.RouteSpec

summary

</> 
pub fn summary(
  spec: offstage_core.RouteSpecBuilder,
  summary: String,
) -> offstage_core.RouteSpecBuilder

Set the [summary] of the route.

tag

</> 
pub fn tag(
  spec: offstage_core.RouteSpecBuilder,
  tag: String,
) -> offstage_core.RouteSpecBuilder

Set the [tag] of the route.

timeout

</> 
pub fn timeout(
  spec: offstage_core.RouteSpecBuilder,
  next: fn(
    offstage_core.RouteSpecBuilder,
    offstage_core.RouteCapability(TimeoutResponse, object),
  ) -> offstage_core.RouteSpec,
) -> offstage_core.RouteSpec

try

</> 
pub const try: fn(Result(a, b), fn(a) -> b) -> b

Attempt to execute the given function with the value inside the Result. This function is similar to the result.try function, returning the

unauthorized

</> 
pub fn unauthorized(
  spec: offstage_core.RouteSpecBuilder,
  next: fn(
    offstage_core.RouteSpecBuilder,
    offstage_core.RouteCapability(UnauthorizedResponse, object),
  ) -> offstage_core.RouteSpec,
) -> offstage_core.RouteSpec
✨ Search Document