This library lets you automatically derive Haskell functions that let you query each endpoint of a servant webservice.
Example
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeOperators #-}
import Data.Proxy
import Data.Text
import Network.HTTP.Client (newManager, defaultManagerSettings)
import Servant.API
import Servant.Client
type Book = Text
type MyApi = "books" :> Get '[JSON] [Book] -- GET /books
:<|> "books" :> ReqBody '[JSON] Book :> Post '[JSON] Book -- POST /books
myApi :: Proxy MyApi
myApi = Proxy
-- 'client' allows you to produce operations to query an API from a client.
postNewBook :: Book -> ClientM Book
getAllBooks :: ClientM [Book]
(getAllBooks :<|> postNewBook) = client myApi
main :: IO ()
main = do
manager' <- newManager defaultManagerSettings
res <- runClientM getAllBooks (mkClientEnv manager' (BaseUrl Http "localhost" 8081 ""))
case res of
Left err -> putStrLn $ "Error: " ++ show err
Right books -> print books
Add NamedRoutes combinator, making support for records first-class in Servant
(#1388).
Add custom type errors for partially applied combinators
(#1289,
#1486).
servant-client / servant-client-core / servant-http-streams: Fix
erroneous behavior, where only 2XX status codes would be considered
successful, irrelevant of the status parameter specified by the verb
combinator. (#1469)
servant-client / servant-client-core: Fix Show instance for
Servant.Client.Core.Request.
servant-client / servant-client-core: Allow passing arbitrary binary data
in Query parameters.
(#1432).
Other changes
Various version bumps.
0.18.3
Significant changes
Add response header support to UVerb (#1420)
Other changes
Support GHC-9.0.1.
Bump bytestring, hspec, http-client and QuickCheck dependencies.
:<|> "capture-lenient" :> Capture' '[Lenient] "foo" Int :> GET
which will make the capture always succeed. Handlers will be of the
type Either String CapturedType, where Left err represents
the possible parse failure.
servant-client Added a function to create Client.Request in ClientEnv #1213#1255
The new member makeClientRequest of ClientEnv is used to create
http-clientRequest from servant-client-coreRequest.
This functionality can be used for example to set
dynamic timeouts for each request.
Other changes
servant-clientservant-client-coreservant-http-streams Fix Verb with headers checking content type differently #1200#1204
For Verbs with response Headers, the implementation didn’t check
for the content-type of the response. Now it does.
servant-clientservant-http-streamsHasClient instance for Stream with Headers#1170#1197
servant-client Redact the authorization header in Show and exceptions #1238
0.16.0.1
Allow base-compat-0.11
0.16
Rename ServantError to ClientError, ServantErr to ServerError#1131
servant-client-core Rearrange modules. No more Internal modules, whole
API is versioned.
#1130
servant-client-core Keep structured exceptions in ConnectionError
constructor of ClientError#1115
-| ConnectionError Text
+| ConnectionError SomeException
servant-client-core Preserve failing request in FailureResponse
constructor of ClientError#1114
-FailureResponse Response
+-- | The server returned an error response including the
+-- failing request. 'requestPath' includes the 'BaseUrl' and the
+-- path of the request.
+FailureResponse (RequestF () (BaseUrl, BS.ByteString)) Response
The streaming functionality (Servant.API.Stream) is refactored to use
servant’s own SourceIO type (see Servant.Types.SourceT documentation),
which replaces both StreamGenerator and ResultStream types.
New conversion type-classes are ToSourceIO and FromSourceIO
(replacing ToStreamGenerator and BuildFromStream).
There are instances for conduit, pipes and machines in new packages:
servant-conduitservant-pipes and
servant-machines
respectively.
Writing new framing strategies is simpler. Check existing strategies for examples.
This change shouldn’t affect you, if you don’t use streaming endpoints.
Servant.Client.Streaming is used by CPSised
withClientM :: ClientM a -> ClientEnv -> (Either ServantError a -> IO b) -> IO b
To access Stream endpoints use Servant.Client.Streaming with
withClientM; otherwise you can continue using Servant.Client with runClientM.
You can use both too, ClientEnv and BaseUrl types are same for both.
Note:Servant.Client.Streaming doesn’t stream non-Stream endpoints.
Requesting ordinary Verb endpoints (e.g. Get) will block until
the whole response is received.
There is Servant.Client.Streaming.runClientM function, but it has
restricted type. NFData a constraint prevents using it with
SourceT, Conduit etc. response types.
runClientM :: NFData a => ClientM a -> ClientEnv -> IO (Either ServantError a)
This change shouldn’t affect you, if you don’t use streaming endpoints.
ToStreamGenerator definition changed, so it’s possible to write an instance
for conduits.
-class ToStreamGenerator f a where
- toStreamGenerator :: f a -> StreamGenerator a
+class ToStreamGenerator a b | a -> b where
+ toStreamGenerator :: a -> StreamGenerator b
servant-client-core Add hoistClient to HasClient.
Just like hoistServer allows us to change the monad in which request handlers
of a web application live, we also have hoistClient for changing the monad
in which client functions live.
Read tutorial section for more information.
(#936)
servant-client Add more constructors to RequestBody, including
RequestBodyStream.
Note: we are looking for http-library agnostic API,
so the might change again soon.
Tell us which constructors are useful for you!
(#913)
Add MonadThrow and MonadCatch instances for ClientM
0.9
BACKWARDS INCOMPATIBLE: client now returns a ClientM which is a Reader for
BasicEnv. BasicEnv comprises the HttpManager and BaseUrl that have had to be
passed to each method returned by client.
0.7.1
Support GHC 8.0
ServantError has an Eq instance now.
0.6
client no longer takes BaseUrl and Manager arguments. Instead, each function returned by client requires these two arguments.
0.5
Use the text package instead of String.
Support for the HttpVersion, IsSecure, RemoteHost and Vault combinators
Added support for path on BaseUrl.
client now takes an explicit Manager argument.
Use http-api-data instead of Servant.Common.Text
Client functions now consider any 2xx successful.
Remove matrix params.
Added support for Basic authentication
Add generalized authentication support via the AuthClientData type family and
AuthenticateReq data type
0.4.1
The HasClient instance for Delete cts () now does not care at all about content types provided.
0.4
Delete now is like Get, Post, Put, and Patch and returns a response body
Support content-type aware combinators and Accept/Content-type headers
Added a lot of tests
Support multiple concurrent threads
Use ServantError to report Errors instead of String
Make the clients for Raw endpoints return the whole Response value (to be able to access response headers for example)
Support for PATCH
Make () instances expect No Content status code, and not try to decode body.
