sttp.client3

package sttp.client3

Type members

Classlikes

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)(implicit 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 parameters:
P

TODO

Value parameters:
delegate

A synchronous SttpBackend which to which this backend forwards all requests

case class FileBody(f: SttpFile, defaultContentType: MediaType) extends BasicRequestBody
class FollowRedirectsBackend[F[_], P](delegate: SttpBackend[F, P], contentHeaders: Set[String], sensitiveHeaders: Set[String], transformUri: Uri => Uri) extends DelegateSttpBackend[F, P]
Value parameters:
transformUri

Defines if and how Uri s from the Location header should be transformed. For example, this enables changing the encoding of host, path, query and fragment segments to be more strict or relaxed.

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
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 parameters:
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 parameters:
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 parameters:
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 parameters:
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 parameters:
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 parameters:
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[Try, P]

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

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

Type parameters:
P

TODO

Value parameters:
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

implicit implicit 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
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 asPath(path: Path): ResponseAs[Either[String, Path], Any]
Inherited from:
SttpExtensions
def asPathAlways(path: Path): ResponseAs[Path, Any]
Inherited from:
SttpExtensions
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 : BodySerializer](name: String, b: 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, data: Path): Part[RequestBody[Any]]

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 multipartFile(name: String, data: File): Part[RequestBody[Any]]

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

Implicits

Inherited implicits

final implicit def UriContext(sc: StringContext): UriContext
Inherited from:
UriInterpolator