Type Members

1.  class Bootstrap[ES <: HList, CTS <: HList] extends AnyRef

   Bootstraps a Finagle HTTP service out of the collection of Finch endpoints.

   Bootstraps a Finagle HTTP service out of the collection of Finch endpoints.

   val api: Service[Request, Response] = Bootstrap
    .serve[Application.Json](getUser :+: postUser)
    .serve[Text.Plain](healthcheck)
    .toService

   Note

   This API is experimental/unstable. Use with caution.

2.  trait Decode[A] extends AnyRef

   Decodes an HTTP payload represented as Buf (encoded with Charset) into an arbitrary type A.

3.  trait DecodeEntity[A] extends AnyRef

   Decodes an HTTP entity (eg: header, query-string param) represented as UTF-8 String into an arbitrary type A.

4.  trait DecodePath[A] extends AnyRef

   Decodes an HTTP path (eg: /foo/bar/baz) represented as UTF-8 String into an arbitrary type A.

5.  trait Encode[A] extends AnyRef

   Encodes an HTTP payload (represented as an arbitrary type A) with a given Charset.

6.  trait Endpoint[A] extends AnyRef

   An Endpoint represents the HTTP endpoint.

   An Endpoint represents the HTTP endpoint.

   It is well known and widely adopted in Finagle that "Your Server is a Function" (i.e., Request => Future[Response]). In a REST/HTTP API setting this function may be viewed as Request =1=> (A =2=> Future[B]) =3=> Future[Response], where transformation 1 is a request decoding (deserialization), transformation 2 - is a business logic and transformation 3 is - a response encoding (serialization). The only interesting part here is transformation 2 (i.e., A => Future[B]), which represents an application business.

   An Endpoint transformation (map, mapAsync, etc.) encodes the business logic, while the rest of Finch ecosystem takes care about both serialization and deserialization.

   A typical way to transform (or map) the Endpoint is to use io.finch.syntax.Mapper:

   import io.finch._
   
   case class Foo(i: Int)
   case class Bar(s: String)
   
   val foo: Endpoint[Foo] = get("foo") { Ok(Foo(42)) }
   val bar: Endpoint[Bar] = get("bar" :: path[String]) { s: String => Ok(Bar(s)) }

   Endpoints are also composable in terms of or-else combinator (known as a "space invader" operator :+:) that takes two Endpoints and returns a coproduct Endpoint.

   import io.finch._
   
   val foobar: Endpoint[Foo :+: Bar :+: CNil] = foo :+: bar

   An Endpoint might be converted into a Finagle Service with Endpoint.toService method so it can be served within Finagle HTTP.

   import com.twitter.finagle.Http
   
   Http.server.serve(foobar.toService)

7.  sealed abstract class EndpointResult[+A] extends AnyRef

   A result returned from an Endpoint.

   A result returned from an Endpoint. This models Option[(Input, Future[Output])] and represents two cases:

   • Endpoint is matched so both remainder and output is returned.
   • Endpoint is skipped so None is returned.

   API methods exposed on this type are mostly introduced for testing.

   This class also provides various of awaitX methods useful for testing and experimenting.

8.  trait Endpoints extends Bodies with Paths with Headers with ParamAndParams with Cookies with FileUploadsAndAttributes

   A collection of Endpoint combinators.

9.  sealed abstract class Error extends Exception with NoStackTrace

   A single error from an Endpoint.

   A single error from an Endpoint.

   This indicates that one of the Finch's built-in components failed. This includes, but not limited by:

   - reading a required param, body, header, etc. - parsing a string-based endpoint with .as[T] combinator - validating an endpoint with .should or shouldNot combinators

10.  case class Errors(errors: NonEmptyList[Error]) extends Exception with NoStackTrace with Product with Serializable

    Multiple errors from an Endpoint.

    Multiple errors from an Endpoint.

    This type of error indicates that an endpoint is able to accumulate multiple Errors into a single instance of Errors that embeds a non-empty list.

    Error accumulation happens as part of the .product (or adjoin, ::) combinator.

11.  trait HighPriorityDecode extends LowPriorityDecode
12.  trait HighPriorityEncodeInstances extends LowPriorityEncodeInstances
13.  trait HighPriorityToResponseInstances extends LowPriorityToResponseInstances
14.  final case class Input(request: Request, route: Seq[String]) extends Product with Serializable

    An input for Endpoint that glues two individual pieces together:

    An input for Endpoint that glues two individual pieces together:

    - Finagle's Request needed for evaluating (e.g., body, param) - Finch's route (represented as Seq[String]) needed for matching (e.g., path)

15.  trait LowPriorityDecode extends AnyRef
16.  trait LowPriorityEncodeInstances extends AnyRef
17.  trait LowPriorityToResponseInstances extends AnyRef
18.  sealed trait Output[+A] extends AnyRef

    An output of Endpoint.

19.  trait Outputs extends AnyRef
20.  trait ToResponse[A] extends AnyRef

    Represents a conversion from A to Response.

21.  trait ToService[ES <: HList, CTS <: HList] extends AnyRef

    Wraps a given list of Endpoints and their content-types with a Finagle Service.

    Wraps a given list of Endpoints and their content-types with a Finagle Service.

    Guarantees to:

    - handle Finch's own errors (i.e., Error and Error) as 400s - copy requests's HTTP version onto a response - respond with 404 when en endpoint is not matched

    - include the date header on each response (unless disabled) - include the server header on each response (unless disabled)

    Annotations

    @implicitNotFound( ... )

22.  trait ValidationRule[A] extends AnyRef

    A ValidationRule enables a reusable way of defining a validation rules in the application domain.

    A ValidationRule enables a reusable way of defining a validation rules in the application domain. It might be composed with Endpoints using either should or shouldNot methods and with other ValidationRules using logical methods and and or.

    case class User(name: String, age: Int)
    val user: Endpoint[User] = (
      param("name").should(beLongerThan(3)) ::
      param("age").as[Int].should(beGreaterThan(0) and beLessThan(120))
    ).as[User]

23.  trait ValidationRules extends AnyRef