Servant.Client.Core.Internal.HasClient

Accessing APIs as a Client

clientIn :: HasClient m api => Proxy api -> Proxy m -> Client m api

clientIn allows you to produce operations to query an API from a client within a RunClient monad.

type MyApi = "books" :> Get '[JSON] [Book] -- GET /books
        :<|> "books" :> ReqBody '[JSON] Book :> Post '[JSON] Book -- POST /books

myApi :: Proxy MyApi
myApi = Proxy

clientM :: Proxy ClientM
clientM = Proxy

getAllBooks :: ClientM [Book]
postNewBook :: Book -> ClientM Book
(getAllBooks :<|> postNewBook) = myApi `clientIn` clientM

class RunClient m => HasClient m api where

This class lets us define how each API combinator influences the creation of an HTTP request.

Unless you are writing a new backend for servant-client-core or new combinators that you want to support client-generation, you can ignore this class.

Minimal complete definition

clientWithRoute

Associated Types

type Client (m :: * -> *) (api :: *) :: *

Methods

clientWithRoute :: Proxy m -> Proxy api -> Request -> Client m api

Instances

RunClient m => HasClient m Raw

Pick a Method and specify where the server you want to query is. You get back the full Response.

Associated Types

type Client (m :: * -> *) Raw :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * Raw -> Request -> Client m Raw

RunClient m => HasClient m EmptyAPI

The client for EmptyAPI is simply EmptyClient.

type MyAPI = "books" :> Get '[JSON] [Book] -- GET /books
        :<|> "nothing" :> EmptyAPI

myApi :: Proxy MyApi
myApi = Proxy

getAllBooks :: ClientM [Book]
(getAllBooks :<|> EmptyClient) = client myApi

Associated Types

type Client (m :: * -> *) EmptyAPI :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * EmptyAPI -> Request -> Client m EmptyAPI

(HasClient m a, HasClient m b) => HasClient m ((:<|>) a b)

A client querying function for a :<|> b will actually hand you one function for querying a and another one for querying b, stitching them together with :<|>, which really is just like a pair.

type MyApi = "books" :> Get '[JSON] [Book] -- GET /books
        :<|> "books" :> ReqBody '[JSON] Book :> Post Book -- POST /books

myApi :: Proxy MyApi
myApi = Proxy

getAllBooks :: ClientM [Book]
postNewBook :: Book -> ClientM Book
(getAllBooks :<|> postNewBook) = client myApi

Associated Types

type Client (m :: * -> *) ((:<|>) a b) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * (a :<|> b) -> Request -> Client m (a :<|> b)

HasClient m subapi => HasClient m (WithNamedContext name context subapi)

Associated Types

type Client (m :: * -> *) (WithNamedContext name context subapi) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * (WithNamedContext name context subapi) -> Request -> Client m (WithNamedContext name context subapi)

HasClient m api => HasClient m ((:>) * * (BasicAuth realm usr) api)

Associated Types

type Client (m :: * -> *) ((:>) * * (BasicAuth realm usr) api) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * ((* :> *) (BasicAuth realm usr) api) -> Request -> Client m ((* :> *) (BasicAuth realm usr) api)

HasClient m api => HasClient m ((:>) * * (AuthProtect k tag) api)

Associated Types

type Client (m :: * -> *) ((:>) * * (AuthProtect k tag) api) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * ((* :> *) (AuthProtect k tag) api) -> Request -> Client m ((* :> *) (AuthProtect k tag) api)

HasClient m api => HasClient m ((:>) * * IsSecure api)

Associated Types

type Client (m :: * -> *) ((:>) * * IsSecure api) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * ((* :> *) IsSecure api) -> Request -> Client m ((* :> *) IsSecure api)

HasClient m api => HasClient m ((:>) * * RemoteHost api)

Associated Types

type Client (m :: * -> *) ((:>) * * RemoteHost api) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * ((* :> *) RemoteHost api) -> Request -> Client m ((* :> *) RemoteHost api)

HasClient m api => HasClient m ((:>) * * Vault api)

Associated Types

type Client (m :: * -> *) ((:>) * * Vault api) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * ((* :> *) Vault api) -> Request -> Client m ((* :> *) Vault api)

(KnownSymbol path, HasClient m api) => HasClient m ((:>) * Symbol path api)

Make the querying function append path to the request path.

Associated Types

type Client (m :: * -> *) ((:>) * Symbol path api) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * ((* :> Symbol) path api) -> Request -> Client m ((* :> Symbol) path api)

(MimeRender * ct a, HasClient m api) => HasClient m ((:>) * * (ReqBody * ((:) * ct cts) a) api)

If you use a ReqBody in one of your endpoints in your API, the corresponding querying function will automatically take an additional argument of the type specified by your ReqBody. That function will take care of encoding this argument as JSON and of using it as the request body.

All you need is for your type to have a ToJSON instance.

Example:

type MyApi = "books" :> ReqBody '[JSON] Book :> Post '[JSON] Book

myApi :: Proxy MyApi
myApi = Proxy

addBook :: Book -> ClientM Book
addBook = client myApi
-- then you can just use "addBook" to query that endpoint

Associated Types

type Client (m :: * -> *) ((:>) * * (ReqBody * ((:) * ct cts) a) api) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * ((* :> *) (ReqBody * ((* ': ct) cts) a) api) -> Request -> Client m ((* :> *) (ReqBody * ((* ': ct) cts) a) api)

(KnownSymbol sym, HasClient m api) => HasClient m ((:>) * * (QueryFlag sym) api)

If you use a QueryFlag in one of your endpoints in your API, the corresponding querying function will automatically take an additional Bool argument.

If you give False, nothing will be added to the query string.

Otherwise, this function will insert a value-less query string parameter under the name associated to your QueryFlag.

Example:

type MyApi = "books" :> QueryFlag "published" :> Get '[JSON] [Book]

myApi :: Proxy MyApi
myApi = Proxy

getBooks :: Bool -> ClientM [Book]
getBooks = client myApi
-- then you can just use "getBooks" to query that endpoint.
-- 'getBooksBy False' for all books
-- 'getBooksBy True' to only get _already published_ books

Associated Types

type Client (m :: * -> *) ((:>) * * (QueryFlag sym) api) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * ((* :> *) (QueryFlag sym) api) -> Request -> Client m ((* :> *) (QueryFlag sym) api)

(KnownSymbol sym, ToHttpApiData a, HasClient m api) => HasClient m ((:>) * * (QueryParams * sym a) api)

If you use a QueryParams in one of your endpoints in your API, the corresponding querying function will automatically take an additional argument, a list of values of the type specified by your QueryParams.

If you give an empty list, nothing will be added to the query string.

Otherwise, this function will take care of inserting a textual representation of your values in the query string, under the same query string parameter name.

You can control how values for your type are turned into text by specifying a ToHttpApiData instance for your type.

Example:

type MyApi = "books" :> QueryParams "authors" Text :> Get '[JSON] [Book]

myApi :: Proxy MyApi
myApi = Proxy

getBooksBy :: [Text] -> ClientM [Book]
getBooksBy = client myApi
-- then you can just use "getBooksBy" to query that endpoint.
-- 'getBooksBy []' for all books
-- 'getBooksBy ["Isaac Asimov", "Robert A. Heinlein"]'
--   to get all books by Asimov and Heinlein

Associated Types

type Client (m :: * -> *) ((:>) * * (QueryParams * sym a) api) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * ((* :> *) (QueryParams * sym a) api) -> Request -> Client m ((* :> *) (QueryParams * sym a) api)

(KnownSymbol sym, ToHttpApiData a, HasClient m api) => HasClient m ((:>) * * (QueryParam * sym a) api)

If you use a QueryParam in one of your endpoints in your API, the corresponding querying function will automatically take an additional argument of the type specified by your QueryParam, enclosed in Maybe.

If you give Nothing, nothing will be added to the query string.

If you give a non-Nothing value, this function will take care of inserting a textual representation of this value in the query string.

You can control how values for your type are turned into text by specifying a ToHttpApiData instance for your type.

Example:

type MyApi = "books" :> QueryParam "author" Text :> Get '[JSON] [Book]

myApi :: Proxy MyApi
myApi = Proxy

getBooksBy :: Maybe Text -> ClientM [Book]
getBooksBy = client myApi
-- then you can just use "getBooksBy" to query that endpoint.
-- 'getBooksBy Nothing' for all books
-- 'getBooksBy (Just "Isaac Asimov")' to get all books by Isaac Asimov

Associated Types

type Client (m :: * -> *) ((:>) * * (QueryParam * sym a) api) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * ((* :> *) (QueryParam * sym a) api) -> Request -> Client m ((* :> *) (QueryParam * sym a) api)

HasClient m api => HasClient m ((:>) * * (Description desc) api)

Ignore Description in client functions.

Associated Types

type Client (m :: * -> *) ((:>) * * (Description desc) api) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * ((* :> *) (Description desc) api) -> Request -> Client m ((* :> *) (Description desc) api)

HasClient m api => HasClient m ((:>) * * (Summary desc) api)

Ignore Summary in client functions.

Associated Types

type Client (m :: * -> *) ((:>) * * (Summary desc) api) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * ((* :> *) (Summary desc) api) -> Request -> Client m ((* :> *) (Summary desc) api)

HasClient m api => HasClient m ((:>) * * HttpVersion api)

Using a HttpVersion combinator in your API doesn't affect the client functions.

Associated Types

type Client (m :: * -> *) ((:>) * * HttpVersion api) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * ((* :> *) HttpVersion api) -> Request -> Client m ((* :> *) HttpVersion api)

(KnownSymbol sym, ToHttpApiData a, HasClient m api) => HasClient m ((:>) * * (Header sym a) api)

If you use a Header in one of your endpoints in your API, the corresponding querying function will automatically take an additional argument of the type specified by your Header, wrapped in Maybe.

That function will take care of encoding this argument as Text in the request headers.

All you need is for your type to have a ToHttpApiData instance.

Example:

newtype Referer = Referer { referrer :: Text }
  deriving (Eq, Show, Generic, ToHttpApiData)

           -- GET /view-my-referer
type MyApi = "view-my-referer" :> Header "Referer" Referer :> Get '[JSON] Referer

myApi :: Proxy MyApi
myApi = Proxy

viewReferer :: Maybe Referer -> ClientM Book
viewReferer = client myApi
-- then you can just use "viewRefer" to query that endpoint
-- specifying Nothing or e.g Just "http://haskell.org/" as arguments

Associated Types

type Client (m :: * -> *) ((:>) * * (Header sym a) api) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * ((* :> *) (Header sym a) api) -> Request -> Client m ((* :> *) (Header sym a) api)

(KnownSymbol capture, ToHttpApiData a, HasClient m sublayout) => HasClient m ((:>) * * (CaptureAll * capture a) sublayout)

If you use a CaptureAll in one of your endpoints in your API, the corresponding querying function will automatically take an additional argument of a list of the type specified by your CaptureAll. That function will take care of inserting a textual representation of this value at the right place in the request path.

You can control how these values are turned into text by specifying a ToHttpApiData instance of your type.

Example:

type MyAPI = "src" :> CaptureAll Text -> Get '[JSON] SourceFile

myApi :: Proxy
myApi = Proxy

getSourceFile :: [Text] -> ClientM SourceFile
getSourceFile = client myApi
-- then you can use "getSourceFile" to query that endpoint

Associated Types

type Client (m :: * -> *) ((:>) * * (CaptureAll * capture a) sublayout) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * ((* :> *) (CaptureAll * capture a) sublayout) -> Request -> Client m ((* :> *) (CaptureAll * capture a) sublayout)

(KnownSymbol capture, ToHttpApiData a, HasClient m api) => HasClient m ((:>) * * (Capture * capture a) api)

If you use a Capture in one of your endpoints in your API, the corresponding querying function will automatically take an additional argument of the type specified by your Capture. That function will take care of inserting a textual representation of this value at the right place in the request path.

You can control how values for this type are turned into text by specifying a ToHttpApiData instance for your type.

Example:

type MyApi = "books" :> Capture "isbn" Text :> Get '[JSON] Book

myApi :: Proxy MyApi
myApi = Proxy

getBook :: Text -> ClientM Book
getBook = client myApi
-- then you can just use "getBook" to query that endpoint

Associated Types

type Client (m :: * -> *) ((:>) * * (Capture * capture a) api) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * ((* :> *) (Capture * capture a) api) -> Request -> Client m ((* :> *) (Capture * capture a) api)

(RunClient m, BuildHeadersTo ls, ReflectMethod k1 method) => HasClient m (Verb * k1 method status cts (Headers ls NoContent))

Associated Types

type Client (m :: * -> *) (Verb * k1 method status cts (Headers ls NoContent)) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * (Verb * k1 method status cts (Headers ls NoContent)) -> Request -> Client m (Verb * k1 method status cts (Headers ls NoContent))

(RunClient m, MimeUnrender * ct a, BuildHeadersTo ls, ReflectMethod k1 method, (~) [*] cts' ((:) * ct cts)) => HasClient m (Verb * k1 method status cts' (Headers ls a))

Associated Types

type Client (m :: * -> *) (Verb * k1 method status cts' (Headers ls a)) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * (Verb * k1 method status cts' (Headers ls a)) -> Request -> Client m (Verb * k1 method status cts' (Headers ls a))

(RunClient m, ReflectMethod k1 method) => HasClient m (Verb * k1 method status cts NoContent)

Associated Types

type Client (m :: * -> *) (Verb * k1 method status cts NoContent) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * (Verb * k1 method status cts NoContent) -> Request -> Client m (Verb * k1 method status cts NoContent)

(RunClient m, MimeUnrender * ct a, ReflectMethod k1 method, (~) [*] cts' ((:) * ct cts)) => HasClient m (Verb * k1 method status cts' a)

Associated Types

type Client (m :: * -> *) (Verb * k1 method status cts' a) :: *

Methods

clientWithRoute :: Proxy (* -> *) m -> Proxy * (Verb * k1 method status cts' a) -> Request -> Client m (Verb * k1 method status cts' a)

data EmptyClient

Singleton type representing a client for an empty API.

Constructors

EmptyClient

Instances

Bounded EmptyClient

Methods

minBound :: EmptyClient

maxBound :: EmptyClient

Enum EmptyClient

Methods

succ :: EmptyClient -> EmptyClient

pred :: EmptyClient -> EmptyClient

toEnum :: Int -> EmptyClient

fromEnum :: EmptyClient -> Int

enumFrom :: EmptyClient -> [EmptyClient]

enumFromThen :: EmptyClient -> EmptyClient -> [EmptyClient]

enumFromTo :: EmptyClient -> EmptyClient -> [EmptyClient]

enumFromThenTo :: EmptyClient -> EmptyClient -> EmptyClient -> [EmptyClient]

Eq EmptyClient

Methods

(==) :: EmptyClient -> EmptyClient -> Bool

(/=) :: EmptyClient -> EmptyClient -> Bool

Show EmptyClient

Methods

showsPrec :: Int -> EmptyClient -> ShowS

show :: EmptyClient -> String

showList :: [EmptyClient] -> ShowS

Basic Authentication