sttp.client3

package sttp.client3

Type members

Classlikes

abstract class AbstractFetchBackend[F[_], S <: Streams[S], P](options: FetchOptions, customizeRequest: Request => Request, monad: MonadError[F]) extends SttpBackend[F, P]

A backend that uses the fetch JavaScript api.

A backend that uses the fetch JavaScript api.

See also
sealed trait BasicRequestBody extends RequestBody[Any]
case class ByteArrayBody(b: Array[Byte], defaultContentType: MediaType) extends BasicRequestBody
case class ByteBufferBody(b: ByteBuffer, defaultContentType: MediaType) extends BasicRequestBody
case class ConditionalResponseAs[+T, R](condition: ResponseMetadata => Boolean, responseAs: ResponseAs[T, R])
abstract class DelegateSttpBackend[F[_], +P](delegate: SttpBackend[F, P]) extends SttpBackend[F, P]

A base class for delegate backends, which includes delegating implementations for close and responseMonad, so that only send needs to be defined.

A base class for delegate backends, which includes delegating implementations for close and responseMonad, so that only send needs to be defined.

case class DeserializationException[DE](body: String, error: DE)(`evidence$1`: ShowError[DE]) extends ResponseException[Nothing, DE]
class DigestAuthenticationBackend[F[_], P](delegate: SttpBackend[F, P], clientNonceGenerator: () => String) extends DelegateSttpBackend[F, P]
Companion
object
class EitherBackend[P](delegate: SttpBackend[Identity, P]) extends SttpBackend[[_] =>> Either[Throwable, _$1], P]

A synchronous backend that safely wraps SttpBackend exceptions in Either[Throwable, *]'s

A synchronous backend that safely wraps SttpBackend exceptions in Either[Throwable, *]'s

Type Params
P

TODO

Value Params
delegate

A synchronous SttpBackend which to which this backend forwards all requests

class FetchBackend extends AbstractFetchBackend[[T] =>> Future[T], Nothing, WebSockets]
Companion
object
object FetchBackend
Companion
class
object FetchOptions
Companion
class
final case class FetchOptions(credentials: Option[RequestCredentials], mode: Option[RequestMode])
Companion
object
case class FileBody(f: SttpFile, defaultContentType: MediaType) extends BasicRequestBody
class FollowRedirectsBackend[F[_], P](delegate: SttpBackend[F, P], contentHeaders: Set[String], sensitiveHeaders: Set[String]) extends DelegateSttpBackend[F, P]
Companion
object
case class HttpError[HE](body: HE, statusCode: StatusCode) extends ResponseException[HE, Nothing]
case object IgnoreResponse extends ResponseAs[Unit, Any]
case class InputStreamBody(b: InputStream, defaultContentType: MediaType) extends BasicRequestBody
case class MappedResponseAs[T, T2, R](raw: ResponseAs[T, R], g: (T, ResponseMetadata) => T2, showAs: Option[String]) extends ResponseAs[T2, R]
case class MultipartBody[R](parts: Seq[Part[RequestBody[R]]]) extends RequestBody[R]
case object NoBody extends RequestBody[Any]
sealed trait RequestBody[-R]
Companion
object
object RequestBody
Companion
class
case class RequestOptions(followRedirects: Boolean, readTimeout: Duration, maxRedirects: Int, redirectToGet: Boolean)
case class RequestT[U[_], T, -R](method: U[Method], uri: U[Uri], body: RequestBody[R], headers: Seq[Header], response: ResponseAs[T, R], options: RequestOptions, tags: Map[String, Any]) extends HasHeaders with RequestTExtensions[U, T, R]

Describes a HTTP request, along with a description of how the response body should be handled.

Describes a HTTP request, along with a description of how the response body should be handled.

The request can be sent using a SttpBackend, which provides a superset of the required capabilities.

Type Params
R

The backend capabilities required by the request or response description. This might be Any (no requirements), Effect (the backend must support the given effect type), Streams (the ability to send and receive streaming bodies) or sttp.capabilities.WebSockets (the ability to handle websocket requests).

T

The target type, to which the response body should be read.

U

Specifies if the method & uri are specified. By default can be either: * Empty, which is a type constructor which always resolves to None. This type of request is aliased to PartialRequest: there's no method and uri specified, and the request cannot be sent. * Identity, which is an identity type constructor. This type of request is aliased to Request: the method and uri are specified, and the request can be sent.

Value Params
response

Description of how the response body should be handled. Needs to be specified upfront so that the response is always consumed and hence there are no requirements on client code to consume it. An exception to this are unsafe streaming and websocket responses, which need to be consumed/closed by the client.

tags

Request-specific tags which can be used by backends for logging, metrics, etc. Not used by default.

Companion
object
object RequestT
Companion
class
trait RequestTExtensions[U[_], T, -R]
class ResolveRelativeUrisBackend[F[_], +P](delegate: SttpBackend[F, P], resolve: Uri => F[Uri]) extends DelegateSttpBackend[F, P]
Companion
object
case class Response[T](body: T, code: StatusCode, statusText: String, headers: Seq[Header], history: List[Response[Unit]], request: RequestMetadata) extends ResponseMetadata
Value Params
history

If redirects are followed, and there were redirects, contains responses for the intermediate requests. The first response (oldest) comes first.

Companion
object
object Response
Companion
class
sealed trait ResponseAs[+T, -R]

Describes how response body should be handled.

Describes how response body should be handled.

Apart from the basic cases (ignoring, reading as a byte array or file), response body descriptions can be mapped over, to support custom types. The mapping can take into account the ResponseMetadata, that is the headers and status code. Responses can also be handled depending on the response metadata. Finally, two response body descriptions can be combined (with some restrictions).

A number of as[Type] helper methods are available as part of SttpApi and when importing sttp.client3._.

Type Params
R

The backend capabilities required by the response description. This might be Any (no requirements), Effect (the backend must support the given effect type), Streams (the ability to send and receive streaming bodies) or WebSockets (the ability to handle websocket requests).

T

Target type as which the response will be read.

Companion
object
object ResponseAs
Companion
class
case class ResponseAsBoth[A, B, R](l: ResponseAs[A, R], r: ResponseAs[B, Any]) extends ResponseAs[(A, Option[B]), R]
case object ResponseAsByteArray extends ResponseAs[Array[Byte], Any]
case class ResponseAsFile(output: SttpFile) extends ResponseAs[SttpFile, Any]
case class ResponseAsFromMetadata[T, R](conditions: List[ConditionalResponseAs[T, R]], default: ResponseAs[T, R]) extends ResponseAs[T, R]
case class ResponseAsStream[F[_], T, Stream, S] extends ResponseAs[T, Effect[F] & S]
Companion
object
Companion
class
case class ResponseAsStreamUnsafe[BinaryStream, S] extends ResponseAs[BinaryStream, S]
Companion
object
case class ResponseAsWebSocket[F[_], T](f: (WebSocket[F], ResponseMetadata) => F[T]) extends WebSocketResponseAs[T, Effect[F] & WebSockets]
case class ResponseAsWebSocketStream[S, Pipe[_, _]](s: Streams[S], p: Pipe[Data[_], WebSocketFrame]) extends WebSocketResponseAs[Unit, S & WebSockets]
case class ResponseAsWebSocketUnsafe[F[_]]() extends WebSocketResponseAs[WebSocket[F], Effect[F] & WebSockets]
sealed abstract class ResponseException[+HE, +DE](error: String) extends Exception
object RetryWhen
trait ShowError[-T]
Companion
object
object ShowError
Companion
class
class SpecifyAuthScheme[U[_], T, -R](hn: String, rt: RequestT[U, T, R], digestTag: String)
case class StreamBody[BinaryStream, S] extends RequestBody[S]
Companion
object
object StreamBody
Companion
class
case class StringBody(s: String, encoding: String, defaultContentType: MediaType) extends BasicRequestBody
trait SttpApi extends SttpExtensions with UriInterpolator
trait SttpBackend[F[_], +P]

A backend is used to send HTTP requests described by RequestT. Backends might wrap Java or Scala HTTP clients, or other backends.

A backend is used to send HTTP requests described by RequestT. Backends might wrap Java or Scala HTTP clients, or other backends.

Type Params
F

The effect type used when returning responses. E.g. Identity for synchronous backends, scala.concurrent.Future for asynchronous backends.

P

Capabilities supported by this backend, in addition to Effect. This might be Any (no special capabilities), Streams (the ability to send and receive streaming bodies) or WebSockets (the ability to handle websocket requests).

Note

Backends should try to classify exceptions into one of the categories specified by SttpClientException. Other exceptions should be thrown unchanged.

case class SttpBackendOptions(connectionTimeout: FiniteDuration, proxy: Option[Proxy])
Companion
object
Companion
class
abstract class SttpClientException(request: RequestT[Identity, _, _], cause: Exception) extends Exception

Known exceptions that might occur when using a backend. Currently this covers:

Known exceptions that might occur when using a backend. Currently this covers:

  • connect exceptions: when a connection (tcp socket) can't be established to the target host
  • read exceptions: when a connection has been established, but there's any kind of problem receiving or handling the response (e.g. a broken socket or a deserialization error)

In general, it's safe to assume that the request hasn't been sent in case of connect exceptions. With read exceptions, the target host might or might have not received and processed the request.

The SttpBackend.send methods might also throw other exceptions, due to programming errors, bugs in the underlying implementations, bugs in sttp or an uncovered exception.

Value Params
cause

The original exception.

request

The request, which was being sent when the exception was thrown

Companion
object
Companion
class
case class TooManyRedirectsException(uri: Uri, redirects: Int) extends Exception
class TryBackend[P](delegate: SttpBackend[Identity, P]) extends SttpBackend[[T] =>> Try[T], P]

A synchronous backend that safely wraps SttpBackend exceptions in Try's

A synchronous backend that safely wraps SttpBackend exceptions in Try's

Type Params
P

TODO

Value Params
delegate

A synchronous SttpBackend which to which this backend forwards all requests

sealed trait WebSocketResponseAs[T, -R] extends ResponseAs[T, R]
object quick extends SttpApi

Inherited classlikes

class UriContext(val sc: StringContext)
Inherited from
UriInterpolator

Types

Provide an implicit value of this type to serialize arbitrary classes into a request body. Backends might also provide special logic for serializer instances which they define (e.g. to handle streaming).

Provide an implicit value of this type to serialize arbitrary classes into a request body. Backends might also provide special logic for serializer instances which they define (e.g. to handle streaming).

type Empty[X] = None
type Identity[X] = X
type PartialRequest[T, -R] = RequestT[Empty, T, R]

A RequestT without the method & uri specified (which cannot yet be sent).

A RequestT without the method & uri specified (which cannot yet be sent).

type Request[T, -R] = RequestT[Identity, T, R]

A RequestT with the method & uri specified. Such a request can be sent.

A RequestT with the method & uri specified. Such a request can be sent.

type RetryWhen = (RequestT[Identity, _, _], Either[Throwable, Response[_]]) => Boolean

Deprecated types

@deprecated(message = "use DeserializationException", since = "3.0.0")
Deprecated
[Since version 3.0.0] use DeserializationException
@deprecated(message = "use ResponseException", since = "3.0.0")
type ResponseError[+HE, +DE] = ResponseException[HE, DE]
Deprecated
[Since version 3.0.0] use ResponseException

Value members

Inherited methods

def asBoth[A, B](l: ResponseAs[A, Any], r: ResponseAs[B, Any]): ResponseAs[(A, B), Any]

Use both l and r to read the response body. Neither response specifications may use streaming or web sockets.

Use both l and r to read the response body. Neither response specifications may use streaming or web sockets.

Inherited from
SttpApi
def asBothOption[A, B, R](l: ResponseAs[A, R], r: ResponseAs[B, Any]): ResponseAs[(A, Option[B]), R]

Use l to read the response body. If the raw body value which is used by l is replayable (a file or byte array), also use r to read the response body. Otherwise ignore r (if the raw body is a stream or a web socket).

Use l to read the response body. If the raw body value which is used by l is replayable (a file or byte array), also use r to read the response body. Otherwise ignore r (if the raw body is a stream or a web socket).

Inherited from
SttpApi
def asByteArray: ResponseAs[Either[String, Array[Byte]], Any]
Inherited from
SttpApi
def asByteArrayAlways: ResponseAs[Array[Byte], Any]
Inherited from
SttpApi
def asEither[A, B, R](onError: ResponseAs[A, R], onSuccess: ResponseAs[B, R]): ResponseAs[Either[A, B], R]

Uses the onSuccess response specification for successful responses (2xx), and the onError specification otherwise.

Uses the onSuccess response specification for successful responses (2xx), and the onError specification otherwise.

Inherited from
SttpApi
def asFile(file: File): ResponseAs[Either[String, File], Any]
Inherited from
SttpExtensions
def asFileAlways(file: File): ResponseAs[File, Any]
Inherited from
SttpExtensions
def asParams(charset: String): ResponseAs[Either[String, Seq[(String, String)]], Any]

Use the given charset by default, unless specified otherwise in the response headers.

Use the given charset by default, unless specified otherwise in the response headers.

Inherited from
SttpApi
def asParams: ResponseAs[Either[String, Seq[(String, String)]], Any]

Use the utf-8 charset by default, unless specified otherwise in the response headers.

Use the utf-8 charset by default, unless specified otherwise in the response headers.

Inherited from
SttpApi
def asParamsAlways(charset: String): ResponseAs[Seq[(String, String)], Any]

Use the given charset by default, unless specified otherwise in the response headers.

Use the given charset by default, unless specified otherwise in the response headers.

Inherited from
SttpApi
def asParamsAlways: ResponseAs[Seq[(String, String)], Any]

Use the utf-8 charset by default, unless specified otherwise in the response headers.

Use the utf-8 charset by default, unless specified otherwise in the response headers.

Inherited from
SttpApi
def asStream[F[_], T, S](s: Streams[S])(f: BinaryStream => F[T]): ResponseAs[Either[String, T], Effect[F] & S]
Inherited from
SttpApi
def asStreamAlways[F[_], T, S](s: Streams[S])(f: BinaryStream => F[T]): ResponseAs[T, Effect[F] & S]
Inherited from
SttpApi
def asStreamAlwaysUnsafe[S](s: Streams[S]): ResponseAs[BinaryStream, S]
Inherited from
SttpApi
def asStreamAlwaysWithMetadata[F[_], T, S](s: Streams[S])(f: (BinaryStream, ResponseMetadata) => F[T]): ResponseAs[T, Effect[F] & S]
Inherited from
SttpApi
def asStreamUnsafe[S](s: Streams[S]): ResponseAs[Either[String, BinaryStream], S]
Inherited from
SttpApi
def asStreamWithMetadata[F[_], T, S](s: Streams[S])(f: (BinaryStream, ResponseMetadata) => F[T]): ResponseAs[Either[String, T], Effect[F] & S]
Inherited from
SttpApi
def asString(charset: String): ResponseAs[Either[String, String], Any]

Use the given charset by default, unless specified otherwise in the response headers.

Use the given charset by default, unless specified otherwise in the response headers.

Inherited from
SttpApi
def asString: ResponseAs[Either[String, String], Any]

Use the utf-8 charset by default, unless specified otherwise in the response headers.

Use the utf-8 charset by default, unless specified otherwise in the response headers.

Inherited from
SttpApi
def asStringAlways(charset: String): ResponseAs[String, Any]
Inherited from
SttpApi
def asStringAlways: ResponseAs[String, Any]

Use the utf-8 charset by default, unless specified otherwise in the response headers.

Use the utf-8 charset by default, unless specified otherwise in the response headers.

Inherited from
SttpApi
def asWebSocket[F[_], T](f: WebSocket[F] => F[T]): ResponseAs[Either[String, T], Effect[F] & WebSockets]
Inherited from
SttpApi
def asWebSocketAlways[F[_], T](f: WebSocket[F] => F[T]): ResponseAs[T, Effect[F] & WebSockets]
Inherited from
SttpApi
def asWebSocketAlwaysUnsafe[F[_]]: ResponseAs[WebSocket[F], Effect[F] & WebSockets]
Inherited from
SttpApi
def asWebSocketAlwaysWithMetadata[F[_], T](f: (WebSocket[F], ResponseMetadata) => F[T]): ResponseAs[T, Effect[F] & WebSockets]
Inherited from
SttpApi
def asWebSocketEither[A, B, R](onError: ResponseAs[A, R], onSuccess: ResponseAs[B, R]): ResponseAs[Either[A, B], R]

Uses the onSuccess response specification for 101 responses (switching protocols), and the onError specification otherwise.

Uses the onSuccess response specification for 101 responses (switching protocols), and the onError specification otherwise.

Inherited from
SttpApi
def asWebSocketStream[S](s: Streams[S])(p: Pipe[Data[_], WebSocketFrame]): ResponseAs[Either[String, Unit], S & WebSockets]
Inherited from
SttpApi
def asWebSocketStreamAlways[S](s: Streams[S])(p: Pipe[Data[_], WebSocketFrame]): ResponseAs[Unit, S & WebSockets]
Inherited from
SttpApi
def asWebSocketUnsafe[F[_]]: ResponseAs[Either[String, WebSocket[F]], Effect[F] & WebSockets]
Inherited from
SttpApi
def asWebSocketWithMetadata[F[_], T](f: (WebSocket[F], ResponseMetadata) => F[T]): ResponseAs[Either[String, T], Effect[F] & WebSockets]
Inherited from
SttpApi
def fromMetadata[T, R](default: ResponseAs[T, R], conditions: ConditionalResponseAs[T, R]*): ResponseAs[T, R]
Inherited from
SttpApi
def ignore: ResponseAs[Unit, Any]
Inherited from
SttpApi
def multipart[B](name: String, b: B)(`evidence$1`: () => B): Part[BasicRequestBody]

Content type will be set to application/octet-stream, can be overridden later using the contentType method.

Content type will be set to application/octet-stream, can be overridden later using the contentType method.

Inherited from
SttpApi
def multipart(name: String, fs: Seq[(String, String)], encoding: String): Part[BasicRequestBody]

Encodes the given parameters as form data.

Encodes the given parameters as form data.

Content type will be set to application/x-www-form-urlencoded, can be overridden later using the contentType method.

Inherited from
SttpApi
def multipart(name: String, fs: Seq[(String, String)]): Part[BasicRequestBody]

Encodes the given parameters as form data using utf-8.

Encodes the given parameters as form data using utf-8.

Content type will be set to application/x-www-form-urlencoded, can be overridden later using the contentType method.

Inherited from
SttpApi
def multipart(name: String, fs: Map[String, String], encoding: String): Part[BasicRequestBody]

Encodes the given parameters as form data.

Encodes the given parameters as form data.

Content type will be set to application/x-www-form-urlencoded, can be overridden later using the contentType method.

Inherited from
SttpApi
def multipart(name: String, fs: Map[String, String]): Part[BasicRequestBody]

Encodes the given parameters as form data using utf-8.

Encodes the given parameters as form data using utf-8.

Content type will be set to application/x-www-form-urlencoded, can be overridden later using the contentType method.

Inherited from
SttpApi
def multipart(name: String, data: InputStream): Part[BasicRequestBody]

Content type will be set to application/octet-stream, can be overridden later using the contentType method.

Content type will be set to application/octet-stream, can be overridden later using the contentType method.

Inherited from
SttpApi
def multipart(name: String, data: ByteBuffer): Part[BasicRequestBody]

Content type will be set to application/octet-stream, can be overridden later using the contentType method.

Content type will be set to application/octet-stream, can be overridden later using the contentType method.

Inherited from
SttpApi
def multipart(name: String, data: Array[Byte]): Part[BasicRequestBody]

Content type will be set to application/octet-stream, can be overridden later using the contentType method.

Content type will be set to application/octet-stream, can be overridden later using the contentType method.

Inherited from
SttpApi
def multipart(name: String, data: String, encoding: String): Part[BasicRequestBody]

Content type will be set to text/plain with given encoding, can be overridden later using the contentType method.

Content type will be set to text/plain with given encoding, can be overridden later using the contentType method.

Inherited from
SttpApi
def multipart(name: String, data: String): Part[BasicRequestBody]

Content type will be set to text/plain with utf-8 encoding, can be overridden later using the contentType method.

Content type will be set to text/plain with utf-8 encoding, can be overridden later using the contentType method.

Inherited from
SttpApi
def multipartFile(name: String, file: File): Part[BasicRequestBody]

Content type will be set to application/octet-stream, can be overridden later using the contentType method.

Content type will be set to application/octet-stream, can be overridden later using the contentType method.

File name will be set to the name of the file.

Inherited from
SttpExtensions
def multipartStream[S](s: Streams[S])(name: String, b: BinaryStream): Part[RequestBody[S]]

Content type will be set to application/octet-stream, can be overridden later using the contentType method.

Content type will be set to application/octet-stream, can be overridden later using the contentType method.

Inherited from
SttpApi

Inherited fields

val DefaultReadTimeout: Duration
Inherited from
SttpApi
val basicRequest: RequestT[Empty, Either[String, String], Any]

A starting request, with the following modification comparing to emptyRequest: Accept-Encoding is set to gzip, deflate (compression/decompression is handled automatically by the library).

A starting request, with the following modification comparing to emptyRequest: Accept-Encoding is set to gzip, deflate (compression/decompression is handled automatically by the library).

Reads the response body as an Either[String, String], where Left is used if the status code is non-2xx, and Right otherwise.

Inherited from
SttpApi
val emptyRequest: RequestT[Empty, Either[String, String], Any]

An empty request with no headers.

An empty request with no headers.

Reads the response body as an Either[String, String], where Left is used if the status code is non-2xx, and Right otherwise.

Inherited from
SttpApi
val quickRequest: RequestT[Empty, String, Any]

A starting request which always reads the response body as a string, regardless of the status code.

A starting request which always reads the response body as a string, regardless of the status code.

Inherited from
SttpApi