git.iko.soy/typeable/req
on abe7b63 help sign in
9befc07
swap
0 ahead, 87 behind
.github/dependabot.ymldeleted−6
since splitsnapshots
unifiedsplit
@@ -1,6 +0,0 @@
1−version: 2
2−updates:
3− - package-ecosystem: "github-actions"
4− directory: "/"
5− schedule:
6− interval: "weekly"
.github/workflows/ci.yaml+13−20
@@ -8,28 +8,24 @@ on:
8 - opened
8 - opened
9 - synchronize
9 - synchronize
10jobs:
10jobs:
11− ormolu:
12− runs-on: ubuntu-latest
13− steps:
14− - uses: actions/checkout@v4
15− - uses: haskell-actions/run-ormolu@v17
16 build:
11 build:
17 runs-on: ubuntu-latest
12 runs-on: ubuntu-latest
18− needs: ormolu
19 strategy:
13 strategy:
20 matrix:
14 matrix:
21− cabal: ["3.12"]
15+ cabal: ["3.2"]
22− ghc: ["9.6.3", "9.8.2", "9.10.1"]
16+ ghc: ["8.6.5", "8.8.4", "8.10.2"]
17+ env:
18+ CONFIG: "--enable-tests --enable-benchmarks --flags=dev"
23 steps:
19 steps:
24− - uses: actions/checkout@v4
20+ - uses: actions/checkout@v2
25− - uses: haskell-actions/setup@v2
21+ - uses: actions/setup-haskell@v1.1.2
26 id: setup-haskell-cabal
22 id: setup-haskell-cabal
27 with:
23 with:
28 ghc-version: ${{ matrix.ghc }}
24 ghc-version: ${{ matrix.ghc }}
29 cabal-version: ${{ matrix.cabal }}
25 cabal-version: ${{ matrix.cabal }}
30− - run: cabal update
26+ - run: cabal v2-update
31− - run: cabal freeze
27+ - run: cabal v2-freeze $CONFIG
32− - uses: actions/cache@v4.2.3
28+ - uses: actions/cache@v2
33 with:
29 with:
34 path: |
30 path: |
35 ${{ steps.setup-haskell-cabal.outputs.cabal-store }}
31 ${{ steps.setup-haskell-cabal.outputs.cabal-store }}
@@ -38,10 +34,7 @@ jobs:
38 restore-keys: |
34 restore-keys: |
39 ${{ runner.os }}-${{ matrix.ghc }}-
35 ${{ runner.os }}-${{ matrix.ghc }}-
40 - run: cabal format && git diff --exit-code --color=always
36 - run: cabal format && git diff --exit-code --color=always
41− - run: cabal build
37+ - run: cabal v2-build $CONFIG
42− - run: |
43− docker pull kennethreitz/httpbin
44− docker run -p 1234:80 kennethreitz/httpbin &
45− cabal test
38+ - run: cabal v2-test $CONFIG
46− - run: cabal haddock
39+ - run: cabal v2-haddock $CONFIG
47− - run: cabal sdist
40+ - run: cabal v2-sdist
.gitignore−1
@@ -25,6 +25,5 @@ cabal.project.local
25cabal.sandbox.config
25cabal.sandbox.config
26dist-*/
26dist-*/
27dist/
27dist/
28−hie.yaml
29stack.yaml
28stack.yaml
30stack.yaml.lock
29stack.yaml.lock
CHANGELOG.md−65
@@ -1,68 +1,3 @@
1−## Req 3.13.4
2−
3−* Fixed empty ciphersuite list when compiling against `tls < 2.0.6`
4− (see [PR 175](https://github.com/mrkkrp/req/pull/175)). As a side effect, now
5− compatible with older versions of `crypton-connection` (>= 0.3).
6−
7−## Req 3.13.3
8−
9−* Works with `crypton-connection-0.4` and newer.
10−
11−## Req 3.13.2
12−
13−* Disable the problematic `httpbin-tests` test suite by default. Only enable
14− it when the `dev` flag is enabled. In that case it is expected that an
15− httpbin server is run locally at `localhost:1234`.
16−
17−## Req 3.13.1
18−
19−* Switched the non-pure test suite to use https://httpbun.org instead of
20− https://httpbin.org since the latter proved to be highly unreliable
21− lately.
22−
23−* Switched from `connection` to `crypton-connection`.
24−
25−* Builds with GHC 9.6.1.
26−
27−## Req 3.13.0
28−
29−* Add `headerRedacted` function to add header fields, which will be with
30− redacted values on print.
31−
32−## Req 3.12.0
33−
34−* Add `isStatusCodeException` function.
35−* Add `instance HttpResponse (Network.HTTP.Client.Response ())`.
36−
37−## Req 3.11.0
38−
39−* Add the `queryParamToList` method to the `QueryParam` type class.
40−* Add the `formToQuery` function. [Issue 126](https://github.com/mrkkrp/req/issues/126).
41−* Add `FromForm` instances (in the `Web.FormUrlEncoded` module) to the
42− `Option` and `FormUrlEncodedParam` types.
43−
44−## Req 3.10.0
45−
46−* Add `MonadHttp` instances for `transformers` types.
47−
48−## Req 3.9.2
49−
50−* The test suite works with `aeson-2.x.x.x`.
51−
52−## Req 3.9.1
53−
54−* Builds with GHC 9.0.
55−
56−## Req 3.9.0
57−
58−* The `useHttpURI` and `useHttpsURI` functions now preserve trailing
59− slashes.
60−
61−## Req 3.8.0
62−
63−* Adjusted the value of the `httpConfigRetryJudgeException` field of
64− `defaultHttpConfig` to retry on response timeouts and connection timeouts.
65−
66## Req 3.7.0
1## Req 3.7.0
67
2
68* Added `reqCb`, a function that allows you to modify the `Request` object
3* Added `reqCb`, a function that allows you to modify the `Request` object
Network/HTTP/Req.hs+170−314
@@ -1,9 +1,20 @@
1+{-# LANGUAGE BangPatterns #-}
2+{-# LANGUAGE CPP #-}
1{-# LANGUAGE DataKinds #-}
3{-# LANGUAGE DataKinds #-}
4+{-# LANGUAGE DeriveDataTypeable #-}
5+{-# LANGUAGE DeriveGeneric #-}
6+{-# LANGUAGE DeriveLift #-}
7+{-# LANGUAGE FlexibleInstances #-}
8+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
2{-# LANGUAGE LambdaCase #-}
9{-# LANGUAGE LambdaCase #-}
10+{-# LANGUAGE MultiParamTypeClasses #-}
3{-# LANGUAGE OverloadedStrings #-}
11{-# LANGUAGE OverloadedStrings #-}
4{-# LANGUAGE QuasiQuotes #-}
12{-# LANGUAGE QuasiQuotes #-}
13+{-# LANGUAGE RankNTypes #-}
5{-# LANGUAGE RecordWildCards #-}
14{-# LANGUAGE RecordWildCards #-}
6{-# LANGUAGE RoleAnnotations #-}
15{-# LANGUAGE RoleAnnotations #-}
16+{-# LANGUAGE ScopedTypeVariables #-}
17+{-# LANGUAGE StandaloneDeriving #-}
7{-# LANGUAGE TemplateHaskellQuotes #-}
18{-# LANGUAGE TemplateHaskellQuotes #-}
8{-# LANGUAGE TypeFamilies #-}
19{-# LANGUAGE TypeFamilies #-}
9{-# LANGUAGE UndecidableInstances #-}
20{-# LANGUAGE UndecidableInstances #-}
@@ -19,40 +30,61 @@
19--
30--
20-- The documentation below is structured in such a way that the most
31-- The documentation below is structured in such a way that the most
21-- important information is presented first: you learn how to do HTTP
32-- important information is presented first: you learn how to do HTTP
22−-- requests, how to embed them in the monad you have, and then it gives you
33+-- requests, how to embed them in any monad you have, and then it gives you
23-- details about less-common things you may want to know about. The
34-- details about less-common things you may want to know about. The
24-- documentation is written with sufficient coverage of details and
35-- documentation is written with sufficient coverage of details and
25-- examples, and it's designed to be a complete tutorial on its own.
36-- examples, and it's designed to be a complete tutorial on its own.
26--
37--
38+-- /(A modest intro goes here, click on 'req' to start making requests.)/
39+--
27-- === About the library
40-- === About the library
28--
41--
29−-- Req is an HTTP client library that attempts to be easy-to-use, type-safe,
42+-- Req is an easy-to-use, type-safe, expandable, high-level HTTP client
30−-- and expandable.
43+-- library that just works without any fooling around.
31−--
44+--
32−-- “Easy-to-use” means that the library is designed to be beginner-friendly
45+-- What does the phrase “easy-to-use” mean? It means that the library is
33−-- so it's simple to add to your monad stack, intuitive to work with,
46+-- designed to be beginner-friendly so it's simple to add to your monad
34−-- well-documented, and does not get in your way. Doing HTTP requests is a
47+-- stack, intuitive to work with, well-documented, and does not get in your
35−-- common task and a Haskell library for this should be approachable and
48+-- way. Doing HTTP requests is a common task and Haskell library for this
49+-- should be very approachable and clear to beginners, thus certain
36−-- clear to beginners, thus certain compromises were made. For example, one
50+-- compromises were made. For example, one cannot currently modify
37−-- cannot currently modify 'L.ManagerSettings' of the default manager
51+-- 'L.ManagerSettings' of the default manager because the library always
38−-- because the library always uses the same implicit global manager for
52+-- uses the same implicit global manager for simplicity and maximal
39−-- simplicity and maximal connection sharing. There is a way to use your own
53+-- connection sharing. There is a way to use your own manager with different
40−-- manager with different settings, but it requires more typing.
54+-- settings, but it requires a bit more typing.
41−--
55+--
42−-- “Type-safe” means that the library tries to eliminate certain classes of
56+-- “Type-safe” means that the library is protective and eliminates certain
43−-- errors. For example, we have correct-by-construction URLs; it is
57+-- classes of errors. For example, we have correct-by-construction 'Url's,
44−-- guaranteed that the user does not send the request body when using
58+-- it's guaranteed that the user does not send the request body when using
45−-- methods like GET or OPTIONS, and the amount of implicit assumptions is
59+-- methods like 'GET' or 'OPTIONS', and the amount of implicit assumptions
46−-- minimized by making the user specify their intentions in an explicit
60+-- is minimized by making the user specify his\/her intentions in an
47−-- form. For example, it's not possible to avoid specifying the body or the
61+-- explicit form (for example, it's not possible to avoid specifying the
48−-- method of a request. Authentication methods that assume HTTPS force the
62+-- body or method of request). Authentication methods that assume HTTPS
49−-- user to use HTTPS at the type level.
63+-- force the user to use HTTPS at the type level. The library also carefully
64+-- hides underlying types from the lower-level @http-client@ package because
65+-- those types are not safe enough (for example 'L.Request' is an instance
66+-- of 'Data.String.IsString' and, if it's malformed, it will blow up at
67+-- run-time).
50−--
68+--
51−-- “Expandable” refers to the ability to create new components without
69+-- “Expandable” refers to the ability of the library to be expanded without
52−-- having to resort to hacking. For example, it's possible to define your
70+-- having to resort to ugly hacking. For example, it's possible to define
53−-- own HTTP methods, create new ways to construct the body of a request,
71+-- your own HTTP methods, create new ways to construct the body of a
54−-- create new authorization options, perform a request in a different way,
72+-- request, create new authorization options, perform a request in a
55−-- and create your own methods to parse a response.
73+-- different way, and create your own methods to parse and represent a
74+-- response. As the user extends the library to satisfy his\/her special
75+-- needs, the new solutions will work just like the built-ins. However, all
76+-- of the common cases are also covered by the library out-of-the-box.
77+--
78+-- “High-level” means that there are less details to worry about. The
79+-- library is a result of my experiences as a Haskell consultant. Working
80+-- for several clients, who had very different projects, showed me that the
81+-- library should adapt easily to any particular style of writing Haskell
82+-- applications. For example, some people prefer throwing exceptions, while
83+-- others are concerned with purity. Just define 'handleHttpException'
84+-- accordingly when making your monad instance of 'MonadHttp' and it will
85+-- play together seamlessly. Finally, the library cuts down boilerplate
86+-- considerably, and helps you write concise, easy to read, and maintainable
87+-- code.
56--
88--
57-- === Using with other libraries
89-- === Using with other libraries
58--
90--
@@ -144,13 +176,11 @@ module Network.HTTP.Req
144 -- $query-parameters
176 -- $query-parameters
145 (=:),
177 (=:),
146 queryFlag,
178 queryFlag,
147− formToQuery,
148 QueryParam (..),
179 QueryParam (..),
149
180
150 -- *** Headers
181 -- *** Headers
151 header,
182 header,
152 attachHeader,
183 attachHeader,
153− headerRedacted,
154
184
155 -- *** Cookies
185 -- *** Cookies
156 -- $cookies
186 -- $cookies
@@ -197,78 +227,58 @@ module Network.HTTP.Req
197
227
198 -- * Other
228 -- * Other
199 HttpException (..),
229 HttpException (..),
200− isStatusCodeException,
201 CanHaveBody (..),
230 CanHaveBody (..),
202 Scheme (..),
231 Scheme (..),
203 )
232 )
204where
233where
205
234
206−import Blaze.ByteString.Builder qualified as BB
235+import qualified Blaze.ByteString.Builder as BB
207import Control.Applicative
236import Control.Applicative
208import Control.Arrow (first, second)
237import Control.Arrow (first, second)
209import Control.Exception hiding (Handler (..), TypeError)
238import Control.Exception hiding (Handler (..), TypeError)
210−import Control.Monad (guard, void, (>=>))
211import Control.Monad.Base
239import Control.Monad.Base
212import Control.Monad.Catch (Handler (..), MonadCatch, MonadMask, MonadThrow)
240import Control.Monad.Catch (Handler (..), MonadCatch, MonadMask, MonadThrow)
213import Control.Monad.IO.Class
241import Control.Monad.IO.Class
214import Control.Monad.IO.Unlift
242import Control.Monad.IO.Unlift
215−import Control.Monad.Reader (ReaderT (ReaderT), ask, lift, runReaderT)
243+import Control.Monad.Reader
216−import Control.Monad.Trans.Accum (AccumT)
217−import Control.Monad.Trans.Cont (ContT)
218import Control.Monad.Trans.Control
244import Control.Monad.Trans.Control
219−import Control.Monad.Trans.Except (ExceptT)
220−import Control.Monad.Trans.Identity (IdentityT)
221−import Control.Monad.Trans.Maybe (MaybeT)
222−import Control.Monad.Trans.RWS.CPS qualified as RWS.CPS
223−import Control.Monad.Trans.RWS.Lazy qualified as RWS.Lazy
224−import Control.Monad.Trans.RWS.Strict qualified as RWS.Strict
225−import Control.Monad.Trans.Select (SelectT)
226−import Control.Monad.Trans.State.Lazy qualified as State.Lazy
227−import Control.Monad.Trans.State.Strict qualified as State.Strict
228−import Control.Monad.Trans.Writer.CPS qualified as Writer.CPS
229−import Control.Monad.Trans.Writer.Lazy qualified as Writer.Lazy
230−import Control.Monad.Trans.Writer.Strict qualified as Writer.Strict
231import Control.Retry
245import Control.Retry
232import Data.Aeson (FromJSON (..), ToJSON (..))
246import Data.Aeson (FromJSON (..), ToJSON (..))
233−import Data.Aeson qualified as A
247+import qualified Data.Aeson as A
234import Data.ByteString (ByteString)
248import Data.ByteString (ByteString)
235−import Data.ByteString qualified as B
249+import qualified Data.ByteString as B
236−import Data.ByteString.Lazy qualified as BL
250+import qualified Data.ByteString.Lazy as BL
237−import Data.CaseInsensitive qualified as CI
251+import qualified Data.CaseInsensitive as CI
238import Data.Data (Data)
252import Data.Data (Data)
239−import Data.Default.Class (def)
240import Data.Function (on)
253import Data.Function (on)
241import Data.IORef
254import Data.IORef
242import Data.Kind (Constraint, Type)
255import Data.Kind (Constraint, Type)
243import Data.List (foldl', nubBy)
256import Data.List (foldl', nubBy)
244import Data.List.NonEmpty (NonEmpty (..))
257import Data.List.NonEmpty (NonEmpty (..))
245−import Data.List.NonEmpty qualified as NE
258+import qualified Data.List.NonEmpty as NE
246import Data.Maybe (fromMaybe)
259import Data.Maybe (fromMaybe)
247import Data.Proxy
260import Data.Proxy
248−import Data.Semigroup (Endo (..))
261+import Data.Semigroup hiding (Option, option)
249−import Data.Set qualified as S
250import Data.Text (Text)
262import Data.Text (Text)
251−import Data.Text qualified as T
263+import qualified Data.Text as T
252−import Data.Text.Encoding qualified as T
264+import qualified Data.Text.Encoding as T
253import Data.Typeable (Typeable, cast)
265import Data.Typeable (Typeable, cast)
254import GHC.Generics
266import GHC.Generics
255import GHC.TypeLits
267import GHC.TypeLits
256−import Language.Haskell.TH qualified as TH
268+import qualified Language.Haskell.TH as TH
257−import Language.Haskell.TH.Quote qualified as TH
269+import qualified Language.Haskell.TH.Quote as TH
258−import Language.Haskell.TH.Syntax qualified as TH
270+import qualified Language.Haskell.TH.Syntax as TH
259−import Network.Connection qualified as NC
271+import qualified Network.Connection as NC
260−import Network.HTTP.Client qualified as L
272+import qualified Network.HTTP.Client as L
261−import Network.HTTP.Client.Internal qualified as LI
273+import qualified Network.HTTP.Client.Internal as LI
262−import Network.HTTP.Client.MultipartFormData qualified as LM
274+import qualified Network.HTTP.Client.MultipartFormData as LM
263−import Network.HTTP.Client.TLS qualified as L
275+import qualified Network.HTTP.Client.TLS as L
264−import Network.HTTP.Types qualified as Y
276+import qualified Network.HTTP.Types as Y
265import System.IO.Unsafe (unsafePerformIO)
277import System.IO.Unsafe (unsafePerformIO)
266import Text.URI (URI)
278import Text.URI (URI)
267−import Text.URI qualified as URI
279+import qualified Text.URI as URI
268−import Text.URI.QQ qualified as QQ
280+import qualified Text.URI.QQ as QQ
269−import Web.Authenticate.OAuth qualified as OAuth
281+import qualified Web.Authenticate.OAuth as OAuth
270−import Web.FormUrlEncoded (FromForm (..), ToForm (..))
271−import Web.FormUrlEncoded qualified as Form
272import Web.HttpApiData (ToHttpApiData (..))
282import Web.HttpApiData (ToHttpApiData (..))
273
283
274----------------------------------------------------------------------------
284----------------------------------------------------------------------------
@@ -293,7 +303,7 @@ import Web.HttpApiData (ToHttpApiData (..))
293--
303--
294-- @body@ is a body option such as 'NoReqBody' or 'ReqBodyJson'. The
304-- @body@ is a body option such as 'NoReqBody' or 'ReqBodyJson'. The
295-- tutorial has a section about HTTP bodies, but usage is very
305-- tutorial has a section about HTTP bodies, but usage is very
296−-- straightforward and should be clear from the examples.
306+-- straightforward and should be clear from the examples below.
297--
307--
298-- @response@ is a type hint how to make and interpret response of an HTTP
308-- @response@ is a type hint how to make and interpret response of an HTTP
299-- request. Out-of-the-box it can be the following:
309-- request. Out-of-the-box it can be the following:
@@ -489,7 +499,7 @@ reqCb method url body responseProxy options adjustRequest =
489--
499--
490-- @since 3.7.0
500-- @since 3.7.0
491reqHandler ::
501reqHandler ::
492− (MonadHttp m) =>
502+ MonadHttp m =>
493 -- | How to get final result from a 'L.Response'
503 -- | How to get final result from a 'L.Response'
494 (L.Response L.BodyReader -> IO b) ->
504 (L.Response L.BodyReader -> IO b) ->
495 -- | 'L.Request' to perform
505 -- | 'L.Request' to perform
@@ -578,22 +588,22 @@ req' method url body options m = do
578 nubHeaders
588 nubHeaders
579 <> getRequestMod options
589 <> getRequestMod options
580 <> getRequestMod config
590 <> getRequestMod config
581− <> getRequestMod (Tagged body :: Tagged "body" body)
591+ <> getRequestMod (Womb body :: Womb "body" body)
582 <> getRequestMod url
592 <> getRequestMod url
583− <> getRequestMod (Tagged method :: Tagged "method" method)
593+ <> getRequestMod (Womb method :: Womb "method" method)
584 request <- finalizeRequest options request'
594 request <- finalizeRequest options request'
585 withReqManager (m request)
595 withReqManager (m request)
586
596
587-- | Perform an action using the global implicit 'L.Manager' that the rest
597-- | Perform an action using the global implicit 'L.Manager' that the rest
588−-- of the library uses. This allows us to reuse connections that the
598+-- of the library uses. This allows to reuse connections that the
589-- 'L.Manager' controls.
599-- 'L.Manager' controls.
590−withReqManager :: (MonadIO m) => (L.Manager -> m a) -> m a
600+withReqManager :: MonadIO m => (L.Manager -> m a) -> m a
591−withReqManager m = m globalManager
601+withReqManager m = liftIO (readIORef globalManager) >>= m
592
602
593−-- | The global 'L.Manager' that 'req' uses. Here we just go with the
603+-- | Global 'L.Manager' that 'req' uses. Here we just go with the default
594−-- default settings, so users don't need to deal with this manager stuff at
604+-- settings, so users don't need to deal with this manager stuff at all, but
595−-- all, but when we create a request, instance 'HttpConfig' can affect the
605+-- when we create a request, instance 'HttpConfig' can affect the default
596−-- default settings via 'getHttpConfig'.
606+-- settings via 'getHttpConfig'.
597--
607--
598-- A note about safety, in case 'unsafePerformIO' looks suspicious to you.
608-- A note about safety, in case 'unsafePerformIO' looks suspicious to you.
599-- The value of 'globalManager' is named and lives on top level. This means
609-- The value of 'globalManager' is named and lives on top level. This means
@@ -601,16 +611,16 @@ withReqManager m = m globalManager
601-- manager. From that moment on the 'IORef' will be just reused—exactly the
611-- manager. From that moment on the 'IORef' will be just reused—exactly the
602-- behavior we want here in order to maximize connection sharing. GHC could
612-- behavior we want here in order to maximize connection sharing. GHC could
603-- spoil the plan by inlining the definition, hence the @NOINLINE@ pragma.
613-- spoil the plan by inlining the definition, hence the @NOINLINE@ pragma.
604−globalManager :: L.Manager
614+globalManager :: IORef L.Manager
605globalManager = unsafePerformIO $ do
615globalManager = unsafePerformIO $ do
606 context <- NC.initConnectionContext
616 context <- NC.initConnectionContext
607 let settings =
617 let settings =
608 L.mkManagerSettingsContext
618 L.mkManagerSettingsContext
609 (Just context)
619 (Just context)
610− def
620+ (NC.TLSSettingsSimple False False False)
611 Nothing
621 Nothing
612 manager <- L.newManager settings
622 manager <- L.newManager settings
613− return manager
623+ newIORef manager
614{-# NOINLINE globalManager #-}
624{-# NOINLINE globalManager #-}
615
625
616----------------------------------------------------------------------------
626----------------------------------------------------------------------------
@@ -624,13 +634,13 @@ globalManager = unsafePerformIO $ do
624-- When writing a library, keep your API polymorphic in terms of
634-- When writing a library, keep your API polymorphic in terms of
625-- 'MonadHttp', only define instance of 'MonadHttp' in final application.
635-- 'MonadHttp', only define instance of 'MonadHttp' in final application.
626-- Another option is to use a @newtype@-wrapped monad stack and define
636-- Another option is to use a @newtype@-wrapped monad stack and define
627−-- 'MonadHttp' for it. As of the version /0.4.0/, the 'Req' monad that
637+-- 'MonadHttp' for it. As of version /0.4.0/, the 'Req' monad that follows
628−-- follows this strategy is provided out-of-the-box (see below).
638+-- this strategy is provided out-of-the-box (see below).
629
639
630-- | A type class for monads that support performing HTTP requests.
640-- | A type class for monads that support performing HTTP requests.
631-- Typically, you only need to define the 'handleHttpException' method
641-- Typically, you only need to define the 'handleHttpException' method
632-- unless you want to tweak 'HttpConfig'.
642-- unless you want to tweak 'HttpConfig'.
633−class (MonadIO m) => MonadHttp m where
643+class MonadIO m => MonadHttp m where
634 -- | This method describes how to deal with 'HttpException' that was
644 -- | This method describes how to deal with 'HttpException' that was
635 -- caught by the library. One option is to re-throw it if you are OK with
645 -- caught by the library. One option is to re-throw it if you are OK with
636 -- exceptions, but if you prefer working with something like
646 -- exceptions, but if you prefer working with something like
@@ -638,16 +648,17 @@ class (MonadIO m) => MonadHttp m where
638 -- 'Control.Monad.Except.throwError'.
648 -- 'Control.Monad.Except.throwError'.
639 handleHttpException :: HttpException -> m a
649 handleHttpException :: HttpException -> m a
640
650
641− -- | Return the 'HttpConfig' to be used when performing HTTP requests.
651+ -- | Return 'HttpConfig' to be used when performing HTTP requests. Default
642− -- Default implementation returns its 'def' value, which is described in
652+ -- implementation returns its 'def' value, which is described in the
643− -- the documentation for the type. Common usage pattern with manually
653+ -- documentation for the type. Common usage pattern with manually defined
644− -- defined 'getHttpConfig' is to return some hard-coded value, or a value
654+ -- 'getHttpConfig' is to return some hard-coded value, or a value
645 -- extracted from 'Control.Monad.Reader.MonadReader' if a more flexible
655 -- extracted from 'Control.Monad.Reader.MonadReader' if a more flexible
646 -- approach to configuration is desirable.
656 -- approach to configuration is desirable.
647 getHttpConfig :: m HttpConfig
657 getHttpConfig :: m HttpConfig
648 getHttpConfig = return defaultHttpConfig
658 getHttpConfig = return defaultHttpConfig
649
659
650−-- | 'HttpConfig' contains settings to be used when making HTTP requests.
660+-- | 'HttpConfig' contains general and default settings to be used when
661+-- making HTTP requests.
651data HttpConfig = HttpConfig
662data HttpConfig = HttpConfig
652 { -- | Proxy to use. By default values of @HTTP_PROXY@ and @HTTPS_PROXY@
663 { -- | Proxy to use. By default values of @HTTP_PROXY@ and @HTTPS_PROXY@
653 -- environment variables are respected, this setting overwrites them.
664 -- environment variables are respected, this setting overwrites them.
@@ -691,8 +702,8 @@ data HttpConfig = HttpConfig
691 -- | The retry policy to use for request retrying. By default 'def' is
702 -- | The retry policy to use for request retrying. By default 'def' is
692 -- used (see 'RetryPolicyM').
703 -- used (see 'RetryPolicyM').
693 --
704 --
694− -- __Note__: signature of this function was changed to disallow 'IO' in
705+ -- __Note__: signature of this function was changed in the version
695− -- version /1.0.0/ and then changed back to its current form in /3.1.0/.
706+ -- /1.0.0/.
696 --
707 --
697 -- @since 0.3.0
708 -- @since 0.3.0
698 httpConfigRetryPolicy :: RetryPolicyM IO,
709 httpConfigRetryPolicy :: RetryPolicyM IO,
@@ -705,19 +716,18 @@ data HttpConfig = HttpConfig
705 -- @since 0.3.0
716 -- @since 0.3.0
706 httpConfigRetryJudge :: forall b. RetryStatus -> L.Response b -> Bool,
717 httpConfigRetryJudge :: forall b. RetryStatus -> L.Response b -> Bool,
707 -- | Similar to 'httpConfigRetryJudge', but is used to decide when to
718 -- | Similar to 'httpConfigRetryJudge', but is used to decide when to
708− -- retry requests that resulted in an exception. By default it retries
719+ -- retry requests that resulted in an exception.
709− -- on response timeout and connection timeout (changed in version
710− -- /3.8.0/).
711 --
720 --
712 -- @since 3.4.0
721 -- @since 3.4.0
713 httpConfigRetryJudgeException :: RetryStatus -> SomeException -> Bool,
722 httpConfigRetryJudgeException :: RetryStatus -> SomeException -> Bool,
714 -- | Max length of preview fragment of response body.
723 -- | Max length of preview fragment of response body.
715 --
724 --
716 -- @since 3.6.0
725 -- @since 3.6.0
717− httpConfigBodyPreviewLength :: forall a. (Num a) => a
726+ httpConfigBodyPreviewLength :: forall a. Num a => a
718 }
727 }
728+ deriving (Typeable)
719
729
720−-- | The default value of 'HttpConfig'.
730+-- | Default value of 'HttpConfig'.
721--
731--
722-- @since 2.0.0
732-- @since 2.0.0
723defaultHttpConfig :: HttpConfig
733defaultHttpConfig :: HttpConfig
@@ -740,14 +750,7 @@ defaultHttpConfig =
740 598, -- (Informal convention) Network read timeout error
750 598, -- (Informal convention) Network read timeout error
741 599 -- (Informal convention) Network connect timeout error
751 599 -- (Informal convention) Network connect timeout error
742 ],
752 ],
743− httpConfigRetryJudgeException = \_ e ->
753+ httpConfigRetryJudgeException = \_ _ -> False,
744− case fromException e of
745− Just (L.HttpExceptionRequest _ c) ->
746− case c of
747− L.ResponseTimeout -> True
748− L.ConnectionTimeout -> True
749− _ -> False
750− _ -> False,
751 httpConfigBodyPreviewLength = 1024
754 httpConfigBodyPreviewLength = 1024
752 }
755 }
753 where
756 where
@@ -761,7 +764,7 @@ instance RequestComponent HttpConfig where
761 LI.requestManagerOverride = httpConfigAltManager
764 LI.requestManagerOverride = httpConfigAltManager
762 }
765 }
763
766
764−-- | A monad that allows us to run 'req' in any 'IO'-enabled monad without
767+-- | A monad that allows to run 'req' in any 'IO'-enabled monad without
765-- having to define new instances.
768-- having to define new instances.
766--
769--
767-- @since 0.4.0
770-- @since 0.4.0
@@ -797,87 +800,12 @@ instance MonadHttp Req where
797 handleHttpException = Req . lift . throwIO
800 handleHttpException = Req . lift . throwIO
798 getHttpConfig = Req ask
801 getHttpConfig = Req ask
799
802
800−-- | @since 3.10.0
801−instance (MonadHttp m, Monoid w) => MonadHttp (AccumT w m) where
802− handleHttpException = lift . handleHttpException
803− getHttpConfig = lift getHttpConfig
804−
805−-- | @since 3.10.0
806−instance (MonadHttp m) => MonadHttp (ContT r m) where
807− handleHttpException = lift . handleHttpException
808− getHttpConfig = lift getHttpConfig
809−
810−-- | @since 3.10.0
811−instance (MonadHttp m) => MonadHttp (ExceptT e m) where
812− handleHttpException = lift . handleHttpException
813− getHttpConfig = lift getHttpConfig
814−
815−-- | @since 3.10.0
816−instance (MonadHttp m) => MonadHttp (IdentityT m) where
817− handleHttpException = lift . handleHttpException
818− getHttpConfig = lift getHttpConfig
819−
820−-- | @since 3.10.0
821−instance (MonadHttp m) => MonadHttp (MaybeT m) where
822− handleHttpException = lift . handleHttpException
823− getHttpConfig = lift getHttpConfig
824−
825−-- | @since 3.10.0
826−instance (MonadHttp m) => MonadHttp (ReaderT r m) where
827− handleHttpException = lift . handleHttpException
828− getHttpConfig = lift getHttpConfig
829−
830−-- | @since 3.10.0
831−instance (MonadHttp m, Monoid w) => MonadHttp (RWS.CPS.RWST r w s m) where
832− handleHttpException = lift . handleHttpException
833− getHttpConfig = lift getHttpConfig
834−
835−-- | @since 3.10.0
836−instance (MonadHttp m, Monoid w) => MonadHttp (RWS.Lazy.RWST r w s m) where
837− handleHttpException = lift . handleHttpException
838− getHttpConfig = lift getHttpConfig
839−
840−-- | @since 3.10.0
841−instance (MonadHttp m, Monoid w) => MonadHttp (RWS.Strict.RWST r w s m) where
842− handleHttpException = lift . handleHttpException
843− getHttpConfig = lift getHttpConfig
844−
845−-- | @since 3.10.0
846−instance (MonadHttp m) => MonadHttp (SelectT r m) where
847− handleHttpException = lift . handleHttpException
848− getHttpConfig = lift getHttpConfig
849−
850−-- | @since 3.10.0
851−instance (MonadHttp m) => MonadHttp (State.Lazy.StateT s m) where
852− handleHttpException = lift . handleHttpException
853− getHttpConfig = lift getHttpConfig
854−
855−-- | @since 3.10.0
856−instance (MonadHttp m) => MonadHttp (State.Strict.StateT s m) where
857− handleHttpException = lift . handleHttpException
858− getHttpConfig = lift getHttpConfig
859−
860−-- | @since 3.10.0
861−instance (MonadHttp m, Monoid w) => MonadHttp (Writer.CPS.WriterT w m) where
862− handleHttpException = lift . handleHttpException
863− getHttpConfig = lift getHttpConfig
864−
865−-- | @since 3.10.0
866−instance (MonadHttp m, Monoid w) => MonadHttp (Writer.Lazy.WriterT w m) where
867− handleHttpException = lift . handleHttpException
868− getHttpConfig = lift getHttpConfig
869−
870−-- | @since 3.10.0
871−instance (MonadHttp m, Monoid w) => MonadHttp (Writer.Strict.WriterT w m) where
872− handleHttpException = lift . handleHttpException
873− getHttpConfig = lift getHttpConfig
874−
875-- | Run a computation in the 'Req' monad with the given 'HttpConfig'. In
803-- | Run a computation in the 'Req' monad with the given 'HttpConfig'. In
876−-- the case of an exceptional situation an 'HttpException' will be thrown.
804+-- case of exceptional situation an 'HttpException' will be thrown.
877--
805--
878-- @since 0.4.0
806-- @since 0.4.0
879runReq ::
807runReq ::
880− (MonadIO m) =>
808+ MonadIO m =>
881 -- | 'HttpConfig' to use
809 -- | 'HttpConfig' to use
882 HttpConfig ->
810 HttpConfig ->
883 -- | Computation to run
811 -- | Computation to run
@@ -982,7 +910,7 @@ class HttpMethod a where
982 -- | Return name of the method as a 'ByteString'.
910 -- | Return name of the method as a 'ByteString'.
983 httpMethodName :: Proxy a -> ByteString
911 httpMethodName :: Proxy a -> ByteString
984
912
985−instance (HttpMethod method) => RequestComponent (Tagged "method" method) where
913+instance HttpMethod method => RequestComponent (Womb "method" method) where
986 getRequestMod _ = Endo $ \x ->
914 getRequestMod _ = Endo $ \x ->
987 x {L.method = httpMethodName (Proxy :: Proxy method)}
915 x {L.method = httpMethodName (Proxy :: Proxy method)}
988
916
@@ -1024,20 +952,23 @@ instance (HttpMethod method) => RequestComponent (Tagged "method" method) where
1024-- > -- https://%D1%8E%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4.%D1%80%D1%84
952-- > -- https://%D1%8E%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4.%D1%80%D1%84
1025data Url (scheme :: Scheme) = Url Scheme (NonEmpty Text)
953data Url (scheme :: Scheme) = Url Scheme (NonEmpty Text)
1026 -- NOTE The second value is the path segments in reversed order.
954 -- NOTE The second value is the path segments in reversed order.
1027− deriving (Eq, Ord, Show, Data, Generic)
955+ deriving (Eq, Ord, Show, Data, Typeable, Generic)
1028
956
1029type role Url nominal
957type role Url nominal
1030
958
1031-- With template-haskell >=2.15 and text >=1.2.4 Lift can be derived, however
959-- With template-haskell >=2.15 and text >=1.2.4 Lift can be derived, however
1032−-- the derived lift forgets the type of the scheme.
960+-- the derived lift forgets the type of scheme.
1033−instance (Typeable scheme) => TH.Lift (Url scheme) where
961+instance Typeable scheme => TH.Lift (Url scheme) where
1034 lift url =
962 lift url =
1035 TH.dataToExpQ (fmap liftText . cast) url `TH.sigE` case url of
963 TH.dataToExpQ (fmap liftText . cast) url `TH.sigE` case url of
1036 Url Http _ -> [t|Url 'Http|]
964 Url Http _ -> [t|Url 'Http|]
1037 Url Https _ -> [t|Url 'Https|]
965 Url Https _ -> [t|Url 'Https|]
1038 where
966 where
1039 liftText t = TH.AppE (TH.VarE 'T.pack) <$> TH.lift (T.unpack t)
967 liftText t = TH.AppE (TH.VarE 'T.pack) <$> TH.lift (T.unpack t)
968+
969+#if MIN_VERSION_template_haskell(2,16,0)
1040− liftTyped = TH.Code . TH.unsafeTExpCoerce . TH.lift
970+ liftTyped url = TH.TExp <$> TH.lift url
971+#endif
1041
972
1042-- | Given host name, produce a 'Url' which has “http” as its scheme and
973-- | Given host name, produce a 'Url' which has “http” as its scheme and
1043-- empty path. This also sets port to @80@.
974-- empty path. This also sets port to @80@.
@@ -1049,14 +980,14 @@ http = Url Http . pure
1049https :: Text -> Url 'Https
980https :: Text -> Url 'Https
1050https = Url Https . pure
981https = Url Https . pure
1051
982
1052−-- | Grow a given 'Url' appending a single path segment to it. Note that the
983+-- | Grow given 'Url' appending a single path segment to it. Note that the
1053-- path segment can be of any type that is an instance of 'ToHttpApiData'.
984-- path segment can be of any type that is an instance of 'ToHttpApiData'.
1054infixl 5 /~
985infixl 5 /~
1055
986
1056−(/~) :: (ToHttpApiData a) => Url scheme -> a -> Url scheme
987+(/~) :: ToHttpApiData a => Url scheme -> a -> Url scheme
1057Url secure path /~ segment = Url secure (NE.cons (toUrlPiece segment) path)
988Url secure path /~ segment = Url secure (NE.cons (toUrlPiece segment) path)
1058
989
1059−-- | A type-constrained version of @('/~')@ to remove ambiguity in the cases
990+-- | Type-constrained version of @('/~')@ to remove ambiguity in the cases
1060-- when next URL piece is a 'Data.Text.Text' literal.
991-- when next URL piece is a 'Data.Text.Text' literal.
1061infixl 5 /:
992infixl 5 /:
1062
993
@@ -1089,7 +1020,8 @@ useHttpURI uri = do
1089 urlHead <- http <$> uriHost uri
1020 urlHead <- http <$> uriHost uri
1090 let url = case URI.uriPath uri of
1021 let url = case URI.uriPath uri of
1091 Nothing -> urlHead
1022 Nothing -> urlHead
1092− Just uriPath -> uriPathToUrl uriPath urlHead
1023+ Just (_, xs) ->
1024+ foldl' (/:) urlHead (URI.unRText <$> NE.toList xs)
1093 return (url, uriOptions uri)
1025 return (url, uriOptions uri)
1094
1026
1095-- | Just like 'useHttpURI', but expects the “https” scheme.
1027-- | Just like 'useHttpURI', but expects the “https” scheme.
@@ -1101,21 +1033,10 @@ useHttpsURI uri = do
1101 urlHead <- https <$> uriHost uri
1033 urlHead <- https <$> uriHost uri
1102 let url = case URI.uriPath uri of
1034 let url = case URI.uriPath uri of
1103 Nothing -> urlHead
1035 Nothing -> urlHead
1104− Just uriPath -> uriPathToUrl uriPath urlHead
1036+ Just (_, xs) ->
1037+ foldl' (/:) urlHead (URI.unRText <$> NE.toList xs)
1105 return (url, uriOptions uri)
1038 return (url, uriOptions uri)
1106
1039
1107−-- | Convert URI path to a 'Url'. Internal.
1108−--
1109−-- @since 3.9.0
1110−uriPathToUrl ::
1111− (Bool, NonEmpty (URI.RText 'URI.PathPiece)) ->
1112− Url scheme ->
1113− Url scheme
1114−uriPathToUrl (trailingSlash, xs) urlHead =
1115− if trailingSlash then path /: T.empty else path
1116− where
1117− path = foldl' (/:) urlHead (URI.unRText <$> NE.toList xs)
1118−
1119-- | A combination of 'useHttpURI' and 'useHttpsURI' for cases when scheme
1040-- | A combination of 'useHttpURI' and 'useHttpsURI' for cases when scheme
1120-- is not known in advance.
1041-- is not known in advance.
1121--
1042--
@@ -1232,21 +1153,21 @@ data NoReqBody = NoReqBody
1232instance HttpBody NoReqBody where
1153instance HttpBody NoReqBody where
1233 getRequestBody NoReqBody = L.RequestBodyBS B.empty
1154 getRequestBody NoReqBody = L.RequestBodyBS B.empty
1234
1155
1235−-- | This body option allows us to use a JSON object as the request
1156+-- | This body option allows to use a JSON object as request body—probably
1236−-- body—probably the most popular format right now. Just wrap a data type
1157+-- the most popular format right now. Just wrap a data type that is an
1237−-- that is an instance of 'ToJSON' type class and you are done: it will be
1158+-- instance of 'ToJSON' type class and you are done: it will be converted to
1238−-- converted to JSON and inserted as request body.
1159+-- JSON and inserted as request body.
1239--
1160--
1240-- This body option sets the @Content-Type@ header to @\"application/json;
1161-- This body option sets the @Content-Type@ header to @\"application/json;
1241-- charset=utf-8\"@ value.
1162-- charset=utf-8\"@ value.
1242newtype ReqBodyJson a = ReqBodyJson a
1163newtype ReqBodyJson a = ReqBodyJson a
1243
1164
1244−instance (ToJSON a) => HttpBody (ReqBodyJson a) where
1165+instance ToJSON a => HttpBody (ReqBodyJson a) where
1245 getRequestBody (ReqBodyJson a) = L.RequestBodyLBS (A.encode a)
1166 getRequestBody (ReqBodyJson a) = L.RequestBodyLBS (A.encode a)
1246 getRequestContentType _ = pure "application/json; charset=utf-8"
1167 getRequestContentType _ = pure "application/json; charset=utf-8"
1247
1168
1248-- | This body option streams request body from a file. It is expected that
1169-- | This body option streams request body from a file. It is expected that
1249−-- the file size does not change during streaming.
1170+-- the file size does not change during the streaming.
1250--
1171--
1251-- Using of this body option does not set the @Content-Type@ header.
1172-- Using of this body option does not set the @Content-Type@ header.
1252newtype ReqBodyFile = ReqBodyFile FilePath
1173newtype ReqBodyFile = ReqBodyFile FilePath
@@ -1271,11 +1192,12 @@ newtype ReqBodyLbs = ReqBodyLbs BL.ByteString
1271instance HttpBody ReqBodyLbs where
1192instance HttpBody ReqBodyLbs where
1272 getRequestBody (ReqBodyLbs bs) = L.RequestBodyLBS bs
1193 getRequestBody (ReqBodyLbs bs) = L.RequestBodyLBS bs
1273
1194
1274−-- | URL-encoded body. This can hold a collection of parameters which are
1195+-- | Form URL-encoded body. This can hold a collection of parameters which
1275−-- encoded similarly to query parameters at the end of query string, with
1196+-- are encoded similarly to query parameters at the end of query string,
1276−-- the only difference that they are stored in request body. The similarity
1197+-- with the only difference that they are stored in request body. The
1277−-- is reflected in the API as well, as you can use the same combinators you
1198+-- similarity is reflected in the API as well, as you can use the same
1278−-- would use to add query parameters: @('=:')@ and 'queryFlag'.
1199+-- combinators you would use to add query parameters: @('=:')@ and
1200+-- 'queryFlag'.
1279--
1201--
1280-- This body option sets the @Content-Type@ header to
1202-- This body option sets the @Content-Type@ header to
1281-- @\"application/x-www-form-urlencoded\"@ value.
1203-- @\"application/x-www-form-urlencoded\"@ value.
@@ -1294,13 +1216,6 @@ newtype FormUrlEncodedParam = FormUrlEncodedParam [(Text, Maybe Text)]
1294instance QueryParam FormUrlEncodedParam where
1216instance QueryParam FormUrlEncodedParam where
1295 queryParam name mvalue =
1217 queryParam name mvalue =
1296 FormUrlEncodedParam [(name, toQueryParam <$> mvalue)]
1218 FormUrlEncodedParam [(name, toQueryParam <$> mvalue)]
1297− queryParamToList (FormUrlEncodedParam p) = p
1298−
1299−-- | Use 'formToQuery'.
1300−--
1301−-- @since 3.11.0
1302−instance FromForm FormUrlEncodedParam where
1303− fromForm = Right . formToQuery
1304
1219
1305-- | Multipart form data. Please consult the
1220-- | Multipart form data. Please consult the
1306-- "Network.HTTP.Client.MultipartFormData" module for how to construct
1221-- "Network.HTTP.Client.MultipartFormData" module for how to construct
@@ -1340,7 +1255,7 @@ instance HttpBody ReqBodyMultipart where
1340-- | Create 'ReqBodyMultipart' request body from a collection of 'LM.Part's.
1255-- | Create 'ReqBodyMultipart' request body from a collection of 'LM.Part's.
1341--
1256--
1342-- @since 0.2.0
1257-- @since 0.2.0
1343−reqBodyMultipart :: (MonadIO m) => [LM.Part] -> m ReqBodyMultipart
1258+reqBodyMultipart :: MonadIO m => [LM.Part] -> m ReqBodyMultipart
1344reqBodyMultipart parts = liftIO $ do
1259reqBodyMultipart parts = liftIO $ do
1345 boundary <- LM.webkitBoundary
1260 boundary <- LM.webkitBoundary
1346 body <- LM.renderParts boundary parts
1261 body <- LM.renderParts boundary parts
@@ -1368,6 +1283,9 @@ type family ProvidesBody body :: CanHaveBody where
1368-- | This type function allows any HTTP body if method says it
1283-- | This type function allows any HTTP body if method says it
1369-- 'CanHaveBody'. When the method says it should have 'NoBody', the only
1284-- 'CanHaveBody'. When the method says it should have 'NoBody', the only
1370-- body option to use is 'NoReqBody'.
1285-- body option to use is 'NoReqBody'.
1286+--
1287+-- __Note__: users of GHC 8.0.1 and later will see a slightly more friendly
1288+-- error message when method does not allow a body and body is provided.
1371type family
1289type family
1372 HttpBodyAllowed
1290 HttpBodyAllowed
1373 (allowsBody :: CanHaveBody)
1291 (allowsBody :: CanHaveBody)
@@ -1380,8 +1298,8 @@ type family
1380 TypeError
1298 TypeError
1381 ('Text "This HTTP method does not allow attaching a request body.")
1299 ('Text "This HTTP method does not allow attaching a request body.")
1382
1300
1383−instance (HttpBody body) => RequestComponent (Tagged "body" body) where
1301+instance HttpBody body => RequestComponent (Womb "body" body) where
1384− getRequestMod (Tagged body) = Endo $ \x ->
1302+ getRequestMod (Womb body) = Endo $ \x ->
1385 x
1303 x
1386 { L.requestBody = getRequestBody body,
1304 { L.requestBody = getRequestBody body,
1387 L.requestHeaders =
1305 L.requestHeaders =
@@ -1410,8 +1328,8 @@ data Option (scheme :: Scheme)
1410 = Option (Endo (Y.QueryText, L.Request)) (Maybe (L.Request -> IO L.Request))
1328 = Option (Endo (Y.QueryText, L.Request)) (Maybe (L.Request -> IO L.Request))
1411
1329
1412-- NOTE 'QueryText' is just [(Text, Maybe Text)], we keep it along with
1330-- NOTE 'QueryText' is just [(Text, Maybe Text)], we keep it along with
1413−-- Request to avoid appending to an existing query string in request every
1331+-- Request to avoid appending to existing query string in request every
1414−-- time new parameter is added. The additional Maybe (L.Request -> IO
1332+-- time new parameter is added. Additional Maybe (L.Request -> IO
1415-- L.Request) is a finalizer that will be applied after all other
1333-- L.Request) is a finalizer that will be applied after all other
1416-- transformations. This is for authentication methods that sign requests
1334-- transformations. This is for authentication methods that sign requests
1417-- based on data in Request.
1335-- based on data in Request.
@@ -1426,12 +1344,6 @@ instance Monoid (Option scheme) where
1426 mempty = Option mempty Nothing
1344 mempty = Option mempty Nothing
1427 mappend = (<>)
1345 mappend = (<>)
1428
1346
1429−-- | Use 'formToQuery'.
1430−--
1431−-- @since 3.11.0
1432−instance FromForm (Option scheme) where
1433− fromForm = Right . formToQuery
1434−
1435-- | A helper to create an 'Option' that modifies only collection of query
1347-- | A helper to create an 'Option' that modifies only collection of query
1436-- parameters. This helper is not a part of the public API.
1348-- parameters. This helper is not a part of the public API.
1437withQueryParams :: (Y.QueryText -> Y.QueryText) -> Option scheme
1349withQueryParams :: (Y.QueryText -> Y.QueryText) -> Option scheme
@@ -1450,7 +1362,7 @@ instance RequestComponent (Option scheme) where
1450
1362
1451-- | Finalize given 'L.Request' by applying a finalizer from the given
1363-- | Finalize given 'L.Request' by applying a finalizer from the given
1452-- 'Option' (if it has any).
1364-- 'Option' (if it has any).
1453−finalizeRequest :: (MonadIO m) => Option scheme -> L.Request -> m L.Request
1365+finalizeRequest :: MonadIO m => Option scheme -> L.Request -> m L.Request
1454finalizeRequest (Option _ mfinalizer) = liftIO . fromMaybe pure mfinalizer
1366finalizeRequest (Option _ mfinalizer) = liftIO . fromMaybe pure mfinalizer
1455
1367
1456----------------------------------------------------------------------------
1368----------------------------------------------------------------------------
@@ -1474,7 +1386,7 @@ infix 7 =:
1474(=:) :: (QueryParam param, ToHttpApiData a) => Text -> a -> param
1386(=:) :: (QueryParam param, ToHttpApiData a) => Text -> a -> param
1475name =: value = queryParam name (pure value)
1387name =: value = queryParam name (pure value)
1476
1388
1477−-- | Construct a flag, that is, a valueless query parameter. For example, in
1389+-- | Construct a flag, that is, valueless query parameter. For example, in
1478-- the following URL @\"a\"@ is a flag, while @\"b\"@ is a query parameter
1390-- the following URL @\"a\"@ is a flag, while @\"b\"@ is a query parameter
1479-- with a value:
1391-- with a value:
1480--
1392--
@@ -1483,27 +1395,9 @@ name =: value = queryParam name (pure value)
1483-- This operator is defined in terms of 'queryParam':
1395-- This operator is defined in terms of 'queryParam':
1484--
1396--
1485-- > queryFlag name = queryParam name (Nothing :: Maybe ())
1397-- > queryFlag name = queryParam name (Nothing :: Maybe ())
1486−queryFlag :: (QueryParam param) => Text -> param
1398+queryFlag :: QueryParam param => Text -> param
1487queryFlag name = queryParam name (Nothing :: Maybe ())
1399queryFlag name = queryParam name (Nothing :: Maybe ())
1488
1400
1489−-- | Construct query parameters from a 'ToForm' instance. This function
1490−-- produces the same query params as 'Form.urlEncodeAsFormStable'.
1491−--
1492−-- Note that 'Form.Form' doesn't have the concept of parameters with the
1493−-- empty value (i.e. what you can get by @key =: ""@). If the value is
1494−-- empty, it will be encoded as a valueless parameter (i.e. what you can get
1495−-- by @queryFlag key@).
1496−--
1497−-- @since 3.11.0
1498−formToQuery :: (QueryParam param, Monoid param, ToForm f) => f -> param
1499−formToQuery f = mconcat . fmap toParam . Form.toListStable $ toForm f
1500− where
1501− toParam (key, val) =
1502− queryParam key $
1503− if val == ""
1504− then Nothing
1505− else Just val
1506−
1507-- | A type class for query-parameter-like things. The reason to have an
1401-- | A type class for query-parameter-like things. The reason to have an
1508-- overloaded 'queryParam' is to be able to use it as an 'Option' and as a
1402-- overloaded 'queryParam' is to be able to use it as an 'Option' and as a
1509-- 'FormUrlEncodedParam' when constructing form URL encoded request bodies.
1403-- 'FormUrlEncodedParam' when constructing form URL encoded request bodies.
@@ -1513,17 +1407,11 @@ class QueryParam param where
1513 -- 'Nothing', it won't be included at all (i.e. you create a flag this
1407 -- 'Nothing', it won't be included at all (i.e. you create a flag this
1514 -- way). It's recommended to use @('=:')@ and 'queryFlag' instead of this
1408 -- way). It's recommended to use @('=:')@ and 'queryFlag' instead of this
1515 -- method, because they are easier to read.
1409 -- method, because they are easier to read.
1516− queryParam :: (ToHttpApiData a) => Text -> Maybe a -> param
1410+ queryParam :: ToHttpApiData a => Text -> Maybe a -> param
1517−
1518− -- | Get the query parameter names and values set by 'queryParam'.
1519− --
1520− -- @since 3.11.0
1521− queryParamToList :: param -> [(Text, Maybe Text)]
1522
1411
1523instance QueryParam (Option scheme) where
1412instance QueryParam (Option scheme) where
1524 queryParam name mvalue =
1413 queryParam name mvalue =
1525 withQueryParams ((:) (name, toQueryParam <$> mvalue))
1414 withQueryParams ((:) (name, toQueryParam <$> mvalue))
1526− queryParamToList (Option f _) = fst $ appEndo f ([], L.defaultRequest)
1527
1415
1528----------------------------------------------------------------------------
1416----------------------------------------------------------------------------
1529-- Request—Optional parameters—Headers
1417-- Request—Optional parameters—Headers
@@ -1547,14 +1435,6 @@ attachHeader :: ByteString -> ByteString -> L.Request -> L.Request
1547attachHeader name value x =
1435attachHeader name value x =
1548 x {L.requestHeaders = (CI.mk name, value) : L.requestHeaders x}
1436 x {L.requestHeaders = (CI.mk name, value) : L.requestHeaders x}
1549
1437
1550−-- | Same as 'header', but with redacted values on print.
1551−--
1552−-- @since 3.13.0
1553−headerRedacted :: ByteString -> ByteString -> Option scheme
1554−headerRedacted name value = withRequest $ \x ->
1555− let y = attachHeader name value x
1556− in y {L.redactHeaders = CI.mk name `S.insert` L.redactHeaders y}
1557−
1558----------------------------------------------------------------------------
1438----------------------------------------------------------------------------
1559-- Request—Optional parameters—Cookies
1439-- Request—Optional parameters—Cookies
1560
1440
@@ -1696,7 +1576,7 @@ customAuth = Option mempty . pure
1696
1576
1697-- | Specify the port to connect to explicitly. Normally, 'Url' you use
1577-- | Specify the port to connect to explicitly. Normally, 'Url' you use
1698-- determines the default port: @80@ for HTTP and @443@ for HTTPS. This
1578-- determines the default port: @80@ for HTTP and @443@ for HTTPS. This
1699−-- 'Option' allows us to choose an arbitrary port overwriting the defaults.
1579+-- 'Option' allows to choose an arbitrary port overwriting the defaults.
1700port :: Int -> Option scheme
1580port :: Int -> Option scheme
1701port n = withRequest $ \x ->
1581port n = withRequest $ \x ->
1702 x {L.port = n}
1582 x {L.port = n}
@@ -1711,8 +1591,8 @@ port n = withRequest $ \x ->
1711--
1591--
1712-- > decompress (const True)
1592-- > decompress (const True)
1713decompress ::
1593decompress ::
1714− -- | Predicate that is given MIME type, it returns 'True' when content
1594+ -- | Predicate that is given MIME type, it
1715− -- should be decompressed on the fly.
1595+ -- returns 'True' when content should be decompressed on the fly.
1716 (ByteString -> Bool) ->
1596 (ByteString -> Bool) ->
1717 Option scheme
1597 Option scheme
1718decompress f = withRequest $ \x ->
1598decompress f = withRequest $ \x ->
@@ -1762,7 +1642,7 @@ ignoreResponse = Proxy
1762newtype JsonResponse a = JsonResponse (L.Response a)
1642newtype JsonResponse a = JsonResponse (L.Response a)
1763 deriving (Show)
1643 deriving (Show)
1764
1644
1765−instance (FromJSON a) => HttpResponse (JsonResponse a) where
1645+instance FromJSON a => HttpResponse (JsonResponse a) where
1766 type HttpResponseBody (JsonResponse a) = a
1646 type HttpResponseBody (JsonResponse a) = a
1767 toVanillaResponse (JsonResponse r) = r
1647 toVanillaResponse (JsonResponse r) = r
1768 getHttpResponse r = do
1648 getHttpResponse r = do
@@ -1814,7 +1694,7 @@ lbsResponse = Proxy
1814----------------------------------------------------------------------------
1694----------------------------------------------------------------------------
1815-- Helpers for response interpretations
1695-- Helpers for response interpretations
1816
1696
1817−-- | Fetch beginning of the response and return it together with a new
1697+-- | Fetch beginning of response and return it together with new
1818-- @'L.Response' 'L.BodyReader'@ that can be passed to 'getHttpResponse' and
1698-- @'L.Response' 'L.BodyReader'@ that can be passed to 'getHttpResponse' and
1819-- such.
1699-- such.
1820grabPreview ::
1700grabPreview ::
@@ -1878,14 +1758,14 @@ brReadN br n = go 0 id id
1878
1758
1879-- | Get the response body.
1759-- | Get the response body.
1880responseBody ::
1760responseBody ::
1881− (HttpResponse response) =>
1761+ HttpResponse response =>
1882 response ->
1762 response ->
1883 HttpResponseBody response
1763 HttpResponseBody response
1884responseBody = L.responseBody . toVanillaResponse
1764responseBody = L.responseBody . toVanillaResponse
1885
1765
1886-- | Get the response status code.
1766-- | Get the response status code.
1887responseStatusCode ::
1767responseStatusCode ::
1888− (HttpResponse response) =>
1768+ HttpResponse response =>
1889 response ->
1769 response ->
1890 Int
1770 Int
1891responseStatusCode =
1771responseStatusCode =
@@ -1893,7 +1773,7 @@ responseStatusCode =
1893
1773
1894-- | Get the response status message.
1774-- | Get the response status message.
1895responseStatusMessage ::
1775responseStatusMessage ::
1896− (HttpResponse response) =>
1776+ HttpResponse response =>
1897 response ->
1777 response ->
1898 ByteString
1778 ByteString
1899responseStatusMessage =
1779responseStatusMessage =
@@ -1901,7 +1781,7 @@ responseStatusMessage =
1901
1781
1902-- | Lookup a particular header from a response.
1782-- | Lookup a particular header from a response.
1903responseHeader ::
1783responseHeader ::
1904− (HttpResponse response) =>
1784+ HttpResponse response =>
1905 -- | Response interpretation
1785 -- | Response interpretation
1906 response ->
1786 response ->
1907 -- | Header to lookup
1787 -- | Header to lookup
@@ -1913,7 +1793,7 @@ responseHeader r h =
1913
1793
1914-- | Get the response 'L.CookieJar'.
1794-- | Get the response 'L.CookieJar'.
1915responseCookieJar ::
1795responseCookieJar ::
1916− (HttpResponse response) =>
1796+ HttpResponse response =>
1917 response ->
1797 response ->
1918 L.CookieJar
1798 L.CookieJar
1919responseCookieJar = L.responseCookieJar . toVanillaResponse
1799responseCookieJar = L.responseCookieJar . toVanillaResponse
@@ -1926,9 +1806,9 @@ responseCookieJar = L.responseCookieJar . toVanillaResponse
1926-- To create a new response interpretation you just need to make your data
1806-- To create a new response interpretation you just need to make your data
1927-- type an instance of the 'HttpResponse' type class.
1807-- type an instance of the 'HttpResponse' type class.
1928
1808
1929−-- | A type class for response interpretations. It allows us to describe how
1809+-- | A type class for response interpretations. It allows to describe how to
1930−-- to consume the response from a @'L.Response' 'L.BodyReader'@ and produce
1810+-- consume response from a @'L.Response' 'L.BodyReader'@ and produce the
1931−-- the final result that is to be returned to the user.
1811+-- final result that is to be returned to the user.
1932class HttpResponse response where
1812class HttpResponse response where
1933 -- | The associated type is the type of body that can be extracted from an
1813 -- | The associated type is the type of body that can be extracted from an
1934 -- instance of 'HttpResponse'.
1814 -- instance of 'HttpResponse'.
@@ -1967,16 +1847,6 @@ class HttpResponse response where
1967 acceptHeader :: Proxy response -> Maybe ByteString
1847 acceptHeader :: Proxy response -> Maybe ByteString
1968 acceptHeader Proxy = Nothing
1848 acceptHeader Proxy = Nothing
1969
1849
1970−-- | This instance has been added to make it easier to inspect 'L.Response'
1971−-- using Req's functions like 'responseStatusCode', 'responseStatusMessage',
1972−-- etc.
1973−--
1974−-- @since 3.12.0
1975−instance HttpResponse (L.Response ()) where
1976− type HttpResponseBody (L.Response ()) = ()
1977− toVanillaResponse = id
1978− getHttpResponse = return . void
1979−
1980----------------------------------------------------------------------------
1850----------------------------------------------------------------------------
1981-- Other
1851-- Other
1982
1852
@@ -2002,7 +1872,7 @@ class RequestComponent a where
2002-- method@ and @'HttpBody' body => 'RequestComponent' body@ when it decides
1872-- method@ and @'HttpBody' body => 'RequestComponent' body@ when it decides
2003-- which instance to use (i.e. the constraints are taken into account later,
1873-- which instance to use (i.e. the constraints are taken into account later,
2004-- when instance is already chosen).
1874-- when instance is already chosen).
2005−newtype Tagged (tag :: Symbol) a = Tagged a
1875+newtype Womb (tag :: Symbol) a = Womb a
2006
1876
2007-- | Exceptions that this library throws.
1877-- | Exceptions that this library throws.
2008data HttpException
1878data HttpException
@@ -2011,24 +1881,10 @@ data HttpException
2011 | -- | A wrapper with Aeson-produced 'String' describing why decoding
1881 | -- | A wrapper with Aeson-produced 'String' describing why decoding
2012 -- failed
1882 -- failed
2013 JsonHttpException String
1883 JsonHttpException String
2014− deriving (Show, Generic)
1884+ deriving (Show, Typeable, Generic)
2015
1885
2016instance Exception HttpException
1886instance Exception HttpException
2017
1887
2018−-- | Return 'Just' if the given 'HttpException' is wrapping a http-client's
2019−-- 'L.StatusCodeException'. Otherwise, return 'Nothing'.
2020−--
2021−-- @since 3.12.0
2022−isStatusCodeException :: HttpException -> Maybe (L.Response ())
2023−isStatusCodeException
2024− ( VanillaHttpException
2025− ( L.HttpExceptionRequest
2026− _
2027− (L.StatusCodeException r _)
2028− )
2029− ) = Just r
2030−isStatusCodeException _ = Nothing
2031−
2032-- | A simple type isomorphic to 'Bool' that we only have for better error
1888-- | A simple type isomorphic to 'Bool' that we only have for better error
2033-- messages. We use it as a kind and its data constructors as type-level
1889-- messages. We use it as a kind and its data constructors as type-level
2034-- tags.
1890-- tags.
@@ -2048,4 +1904,4 @@ data Scheme
2048 Http
1904 Http
2049 | -- | HTTPS
1905 | -- | HTTPS
2050 Https
1906 Https
2051− deriving (Eq, Ord, Show, Data, Generic, TH.Lift)
1907+ deriving (Eq, Ord, Show, Data, Typeable, Generic, TH.Lift)
README.md+124−28
@@ -4,8 +4,10 @@
4[![Hackage](https://img.shields.io/hackage/v/req.svg?style=flat)](https://hackage.haskell.org/package/req)
4[![Hackage](https://img.shields.io/hackage/v/req.svg?style=flat)](https://hackage.haskell.org/package/req)
5[![Stackage Nightly](http://stackage.org/package/req/badge/nightly)](http://stackage.org/nightly/package/req)
5[![Stackage Nightly](http://stackage.org/package/req/badge/nightly)](http://stackage.org/nightly/package/req)
6[![Stackage LTS](http://stackage.org/package/req/badge/lts)](http://stackage.org/lts/package/req)
6[![Stackage LTS](http://stackage.org/package/req/badge/lts)](http://stackage.org/lts/package/req)
7−[![CI](https://github.com/mrkkrp/req/actions/workflows/ci.yaml/badge.svg)](https://github.com/mrkkrp/req/actions/workflows/ci.yaml)
7+![CI](https://github.com/mrkkrp/req/workflows/CI/badge.svg?branch=master)
8
8
9+* [Motivation and Req vs other libraries](#motivation-and-req-vs-other-libraries)
10+* [Unsolved problems](#unsolved-problems)
9* [Related packages](#related-packages)
11* [Related packages](#related-packages)
10* [Blog posts](#blog-posts)
12* [Blog posts](#blog-posts)
11* [Contribution](#contribution)
13* [Contribution](#contribution)
@@ -41,33 +43,49 @@ main = runReq defaultHttpConfig $ do
41 liftIO $ print (responseBody r :: Value)
43 liftIO $ print (responseBody r :: Value)
42```
44```
43
45
44−Req is an HTTP client library that attempts to be easy-to-use, type-safe,
46+Req is an easy-to-use, type-safe, expandable, high-level HTTP client library
45−and expandable.
47+that just works without any fooling around.
46−
48+
47−“Easy-to-use” means that the library is designed to be beginner-friendly so
49+What does the phrase “easy-to-use” mean? It means that the library is
48−it's simple to add to your monad stack, intuitive to work with,
50+designed to be beginner-friendly so it's simple to add to your monad stack,
49−well-documented, and does not get in your way. Doing HTTP requests is a
51+intuitive to work with, well-documented, and does not get in your way. Doing
50−common task and a Haskell library for this should be approachable and clear
52+HTTP requests is a common task and Haskell library for this should be very
51−to beginners, thus certain compromises were made. For example, one cannot
53+approachable and clear to beginners, thus certain compromises were made. For
52−currently modify `ManagerSettings` of the default manager because the
54+example, one cannot currently modify `ManagerSettings` of the default
53−library always uses the same implicit global manager for simplicity and
55+manager because the library always uses the same implicit global manager for
54−maximal connection sharing. There is a way to use your own manager with
56+simplicity and maximal connection sharing. There is a way to use your own
55−different settings, but it requires more typing.
57+manager with different settings, but it requires a bit more typing.
56−
58+
57−“Type-safe” means that the library tries to eliminate certain classes of
59+“Type-safe” means that the library is protective and eliminates certain
58−errors. For example, we have correct-by-construction URLs; it is guaranteed
60+classes of errors. For example, we have correct-by-construction URLs, it's
59−that the user does not send the request body when using methods like GET or
61+guaranteed that the user does not send the request body when using methods
60−OPTIONS, and the amount of implicit assumptions is minimized by making the
62+like GET or OPTIONS, and the amount of implicit assumptions is minimized by
61−user specify their intentions in an explicit form. For example, it's not
63+making the user specify his/her intentions in an explicit form (for example,
62−possible to avoid specifying the body or the method of a request.
64+it's not possible to avoid specifying the body or method of request).
63Authentication methods that assume HTTPS force the user to use HTTPS at the
65Authentication methods that assume HTTPS force the user to use HTTPS at the
64−type level.
66+type level. The library also carefully hides underlying types from the
65−
67+lower-level `http-client` package because those types are not safe enough
68+(for example `Request` is an instance of `IsString` and, if it's malformed,
69+it will blow up at run-time).
70+
66−“Expandable” refers to the ability to create new components without having
71+“Expandable” refers to the ability to create new components for dealing with
67−to resort to hacking. For example, it's possible to define your own HTTP
72+HTTP without having to resort to ugly hacking. For example, it's possible to
68−methods, create new ways to construct the body of a request, create new
73+define your own HTTP methods, create new ways to construct the body of a
69−authorization options, perform a request in a different way, and create your
74+request, create new authorization options, perform a request in a different
70−own methods to parse a response.
75+way, and create your own methods to parse and represent a response. As the
76+user extends the library to satisfy his/her special needs, the new solutions
77+will work just like the built-ins. However, all of the common cases are also
78+covered by the library out-of-the-box.
79+
80+“High-level” means that there are less details to worry about. The library
81+is a result of my experiences as a Haskell consultant. Working for several
82+clients, who had very different projects, showed me that the library should
83+adapt easily to any particular style of writing Haskell applications. For
84+example, some people prefer throwing exceptions, while others are concerned
85+with purity. Just define `handleHttpException` accordingly when making your
86+monad instance of `MonadHttp` and it will play together seamlessly. Finally,
87+the library cuts down boilerplate considerably, and helps you write concise,
88+easy to read, and maintainable code.
71
89
72The library uses the following mature packages under the hood to guarantee
90The library uses the following mature packages under the hood to guarantee
73you the best experience:
91you the best experience:
@@ -77,11 +95,89 @@ you the best experience:
77* [`http-client-tls`](https://hackage.haskell.org/package/http-client-tls)—TLS
95* [`http-client-tls`](https://hackage.haskell.org/package/http-client-tls)—TLS
78 (HTTPS) support for `http-client`.
96 (HTTPS) support for `http-client`.
79
97
80−It is important to note that since we leverage well-known libraries that the
98+It's important to note that since we leverage well-known libraries that the
81whole Haskell ecosystem uses, there is no risk in using Req. The machinery
99whole Haskell ecosystem uses, there is no risk in using Req. The machinery
82for performing requests is the same as with `http-conduit` and Wreq. The
100for performing requests is the same as with `http-conduit` and Wreq. The
83only difference is the API.
101only difference is the API.
84
102
103+## Motivation and Req vs other libraries
104+
105+*This section is my opinion and it contains criticisms of other well-known
106+libraries. If you're a user/fan of one of these libraries, please remember
107+not to react aggressively and respect the fact that I may have different
108+views on API design from yours.*
109+
110+I have spent time to write the library because sending HTTP requests is a
111+common need, but there is no high-level library for that in Haskell that I
112+could use with pleasure. I'll explain why.
113+
114+First of all, there is `http-client` and `http-client-tls`. They just work.
115+I have no issues with the libraries except that they are too low-level for
116+my taste. Indeed, even the docs say that they are low-level and “intended as
117+a base layer for more user-friendly packages”. This is exactly how I use
118+them in Req, as base level. Req is nothing but a different API to
119+`http-client`, so it only works because of the hard work put into
120+`http-client`.
121+
122+`http-conduit` definitely has its place. For one thing it allows you to
123+stream request and response bodies in constant memory, what other library
124+allows you to do that? On the other hand if you take a look at
125+`Network.HTTP.Simple`, then although it's said that it's a “higher level
126+API”, it's mostly the same as vanilla `http-client` in spirit/approach and
127+just adds `conduit`-powered functions to perform requests and allows to use
128+global implicit `Manager` (Req does the same). If I tried to frame what
129+exactly I don't like about `http-conduit` in words, then it would be “the
130+way requests are constructed”. You *set* parameters instead of *being
131+forced* to declare necessary bits and *being allowed* to declare optional
132+bits in a way that their combination is valid. Also, with `http-conduit` you
133+parse request from a string without the protection of TH that otherwise
134+saves the day as in Yesod.
135+
136+Then there is Wreq. `wreq` [doesn't see much development
137+lately](https://github.com/bos/wreq/issues/93). `wreq` is by itself a weird
138+library, IMO. You have functions per method—not very good, as there may be
139+new methods, like PATCH which is not new but still missing (well, you have
140+`customMethod`, but what is the point of having per-method functions if you
141+have a more general way to use any method? you should be able to just insert
142+methods in the “argument slot” of `customMethod` and end up with a more
143+general solution). Now, every method function has a companion that takes
144+`Options` (like you have `get` and `getWith`). Why the duplication? Where is
145+generality and flexibility? This is not all though, because you cannot
146+really use `get` you see in the main module, because you want to have
147+connection sharing. Wreq's author does not take the gift of automatic
148+connection re-use `Manager` from `http-client` provides, he invents the
149+whole new thing of “sessions”. Only inside a session your connections will
150+be shared and re-used. However with the session stuff you have yet another
151+set of per-method functions like `get` and `getWith`—these are different
152+ones, to be used with sessions! Now if you have a multi-threaded app, here
153+is a surprise for you: you can't share connections between threads as
154+connections are shared only inside of the `withSession` friend and “session
155+will no longer be valid after that function returns”. There are valid uses
156+for sessions, but the point is that they are just too inconvenient for
157+common tasks.
158+
159+I used `servant-client` a couple of times but the amount of boilerplate it
160+requires is frightening. If you have several query parameters, and you use
161+just one of them, you'll have to pass lots of `Nothing`s.
162+
163+## Unsolved problems
164+
165+AWS request signing is problematic because request body can be in the form
166+of an action to execute (and all that “popper” stuff for streaming), not
167+just a `ByteString` and so getting its digest (hash) is not trivial without
168+running the action and consuming body in its entirety before the request in
169+made. In Wreq the author chose to just use `error` when body is not a
170+(strict or lazy) `ByteString`. Maybe it's OK for Wreq, but I don't consider
171+this a proper solution for Req as we support full variety of body options.
172+For example, what if I want to upload 1 Gb file to S3? I want to stream it
173+in constant memory but at the same time I need to calculate its hash before
174+I start streaming. One solution to the problem seems to be in taking the
175+hash explicitly (as an argument of the hypothetical `awsAuth`) and making it
176+a responsibility of the user to calculate the hash correctly. I don't like
177+this because it's not user-friendly. So the question stays open, for now
178+there is no AWS signing functionality provided out-of-the-box. The best
179+solution for talking to AWS is the `amazonka` package so far.
180+
85## Related packages
181## Related packages
86
182
87The following packages are designed to be used with Req:
183The following packages are designed to be used with Req:
Setup.hsnew file+6
@@ -0,0 +1,6 @@
1+module Main (main) where
2+
3+import Distribution.Simple
4+
5+main :: IO ()
6+main = defaultMain
cabal.projectdeleted−4
@@ -1,4 +0,0 @@
1−packages: .
2−tests: True
3−benchmarks: True
4−constraints: req +dev
httpbin-tests/Network/HTTP/ReqSpec.hs+70−107
@@ -1,6 +1,6 @@
1+{-# LANGUAGE CPP #-}
1{-# LANGUAGE DataKinds #-}
2{-# LANGUAGE DataKinds #-}
2{-# LANGUAGE FlexibleInstances #-}
3{-# LANGUAGE FlexibleInstances #-}
3−{-# LANGUAGE LambdaCase #-}
4{-# LANGUAGE OverloadedStrings #-}
4{-# LANGUAGE OverloadedStrings #-}
5{-# LANGUAGE RankNTypes #-}
5{-# LANGUAGE RankNTypes #-}
6{-# OPTIONS_GHC -fno-warn-orphans #-}
6{-# OPTIONS_GHC -fno-warn-orphans #-}
@@ -8,28 +8,29 @@
8module Network.HTTP.ReqSpec (spec) where
8module Network.HTTP.ReqSpec (spec) where
9
9
10import Control.Exception
10import Control.Exception
11−import Control.Monad (forM_)
11+import Control.Monad.Reader
12import Control.Monad.Trans.Control
12import Control.Monad.Trans.Control
13import Data.Aeson (ToJSON (..), Value (..), object, (.=))
13import Data.Aeson (ToJSON (..), Value (..), object, (.=))
14−import Data.Aeson qualified as A
14+import qualified Data.Aeson as A
15−import Data.Aeson.KeyMap qualified as Aeson.KeyMap
16−import Data.ByteString qualified as B
15+import qualified Data.ByteString as B
17−import Data.ByteString.Lazy qualified as BL
16+import qualified Data.ByteString.Lazy as BL
18−import Data.Functor.Identity (runIdentity)
17+import qualified Data.HashMap.Strict as HM
19−import Data.Maybe (fromJust)
20import Data.Proxy
18import Data.Proxy
21import Data.Text (Text)
19import Data.Text (Text)
22−import Data.Text qualified as T
20+import qualified Data.Text as T
23−import Data.Text.Encoding qualified as T
21+import qualified Data.Text.Encoding as T
24−import Data.Text.IO qualified as TIO
22+import qualified Data.Text.IO as TIO
25−import Network.HTTP.Client qualified as L
23+import qualified Network.HTTP.Client as L
26−import Network.HTTP.Client.MultipartFormData qualified as LM
24+import qualified Network.HTTP.Client.MultipartFormData as LM
27−import Network.HTTP.Req hiding (req)
25+import Network.HTTP.Req
28−import Network.HTTP.Req qualified as Req
29−import Network.HTTP.Types qualified as Y
26+import qualified Network.HTTP.Types as Y
30import Test.Hspec
27import Test.Hspec
31import Test.QuickCheck
28import Test.QuickCheck
32
29
30+#if !MIN_VERSION_base(4,13,0)
31+import Data.Semigroup ((<>))
32+#endif
33+
33spec :: Spec
34spec :: Spec
34spec = do
35spec = do
35 describe "exception throwing on non-2xx status codes" $
36 describe "exception throwing on non-2xx status codes" $
@@ -50,11 +51,6 @@ spec = do
50 blindlyThrowing (req GET httpbin NoReqBody ignoreResponse mempty)
51 blindlyThrowing (req GET httpbin NoReqBody ignoreResponse mempty)
51 `shouldThrow` anyException
52 `shouldThrow` anyException
52
53
53− describe "isStatusCodeException" $
54− it "extracts non-2xx response" $
55− req GET (httpbin /: "foo") NoReqBody ignoreResponse mempty
56− `shouldThrow` selector404ByStatusCodeException
57−
58 describe "receiving user-agent header back" $
54 describe "receiving user-agent header back" $
59 it "works" $ do
55 it "works" $ do
60 r <-
56 r <-
@@ -85,7 +81,8 @@ spec = do
85 .= object
81 .= object
86 [ "Accept-Encoding" .= ("gzip" :: Text),
82 [ "Accept-Encoding" .= ("gzip" :: Text),
87 "Foo" .= ("bar" :: Text),
83 "Foo" .= ("bar" :: Text),
88− "Baz" .= ("quux" :: Text)
84+ "Baz" .= ("quux" :: Text),
85+ "Host" .= ("httpbin.org" :: Text)
89 ]
86 ]
90 ]
87 ]
91 responseStatusCode r `shouldBe` 200
88 responseStatusCode r `shouldBe` 200
@@ -97,10 +94,11 @@ spec = do
97 (stripFunnyHeaders . stripOrigin) (responseBody r)
94 (stripFunnyHeaders . stripOrigin) (responseBody r)
98 `shouldBe` object
95 `shouldBe` object
99 [ "args" .= emptyObject,
96 [ "args" .= emptyObject,
100− "url" .= ("http://localhost:1234/get" :: Text),
97+ "url" .= ("https://httpbin.org/get" :: Text),
101 "headers"
98 "headers"
102 .= object
99 .= object
103− [ "Accept-Encoding" .= ("gzip" :: Text)
100+ [ "Accept-Encoding" .= ("gzip" :: Text),
101+ "Host" .= ("httpbin.org" :: Text)
104 ]
102 ]
105 ]
103 ]
106 responseHeader r "Content-Type" `shouldBe` return "application/json"
104 responseHeader r "Content-Type" `shouldBe` return "application/json"
@@ -117,11 +115,12 @@ spec = do
117 [ "args" .= emptyObject,
115 [ "args" .= emptyObject,
118 "json" .= text,
116 "json" .= text,
119 "data" .= reflected,
117 "data" .= reflected,
120− "url" .= ("http://localhost:1234/post" :: Text),
118+ "url" .= ("https://httpbin.org/post" :: Text),
121 "headers"
119 "headers"
122 .= object
120 .= object
123 [ "Content-Type" .= ("application/json; charset=utf-8" :: Text),
121 [ "Content-Type" .= ("application/json; charset=utf-8" :: Text),
124 "Accept-Encoding" .= ("gzip" :: Text),
122 "Accept-Encoding" .= ("gzip" :: Text),
123+ "Host" .= ("httpbin.org" :: Text),
125 "Content-Length" .= show (T.length reflected)
124 "Content-Length" .= show (T.length reflected)
126 ],
125 ],
127 "files" .= emptyObject,
126 "files" .= emptyObject,
@@ -139,17 +138,18 @@ spec = do
139 LM.partBS "bar" "bar data!"
138 LM.partBS "bar" "bar data!"
140 ]
139 ]
141 r <- req POST (httpbin /: "post") body jsonResponse mempty
140 r <- req POST (httpbin /: "post") body jsonResponse mempty
142− let contentType = fromJust (getRequestContentType body)
141+ let Just contentType = getRequestContentType body
143 (stripFunnyHeaders . stripOrigin) (responseBody r)
142 (stripFunnyHeaders . stripOrigin) (responseBody r)
144 `shouldBe` object
143 `shouldBe` object
145 [ "args" .= emptyObject,
144 [ "args" .= emptyObject,
146 "json" .= Null,
145 "json" .= Null,
147 "data" .= ("" :: Text),
146 "data" .= ("" :: Text),
148− "url" .= ("http://localhost:1234/post" :: Text),
147+ "url" .= ("https://httpbin.org/post" :: Text),
149 "headers"
148 "headers"
150 .= object
149 .= object
151 [ "Content-Type" .= T.decodeUtf8 contentType,
150 [ "Content-Type" .= T.decodeUtf8 contentType,
152 "Accept-Encoding" .= ("gzip" :: Text),
151 "Accept-Encoding" .= ("gzip" :: Text),
152+ "Host" .= ("httpbin.org" :: Text),
153 "Content-Length" .= ("242" :: Text)
153 "Content-Length" .= ("242" :: Text)
154 ],
154 ],
155 "files" .= emptyObject,
155 "files" .= emptyObject,
@@ -174,10 +174,11 @@ spec = do
174 [ "args" .= emptyObject,
174 [ "args" .= emptyObject,
175 "json" .= Null,
175 "json" .= Null,
176 "data" .= contents,
176 "data" .= contents,
177− "url" .= ("http://localhost:1234/patch" :: Text),
177+ "url" .= ("https://httpbin.org/patch" :: Text),
178 "headers"
178 "headers"
179 .= object
179 .= object
180 [ "Accept-Encoding" .= ("gzip" :: Text),
180 [ "Accept-Encoding" .= ("gzip" :: Text),
181+ "Host" .= ("httpbin.org" :: Text),
181 "Content-Length" .= show (T.length contents)
182 "Content-Length" .= show (T.length contents)
182 ],
183 ],
183 "files" .= emptyObject,
184 "files" .= emptyObject,
@@ -199,11 +200,12 @@ spec = do
199 [ "args" .= emptyObject,
200 [ "args" .= emptyObject,
200 "json" .= Null,
201 "json" .= Null,
201 "data" .= ("" :: Text),
202 "data" .= ("" :: Text),
202− "url" .= ("http://localhost:1234/put" :: Text),
203+ "url" .= ("https://httpbin.org/put" :: Text),
203 "headers"
204 "headers"
204 .= object
205 .= object
205 [ "Content-Type" .= ("application/x-www-form-urlencoded" :: Text),
206 [ "Content-Type" .= ("application/x-www-form-urlencoded" :: Text),
206 "Accept-Encoding" .= ("gzip" :: Text),
207 "Accept-Encoding" .= ("gzip" :: Text),
208+ "Host" .= ("httpbin.org" :: Text),
207 "Content-Length" .= ("18" :: Text)
209 "Content-Length" .= ("18" :: Text)
208 ],
210 ],
209 "files" .= emptyObject,
211 "files" .= emptyObject,
@@ -261,17 +263,21 @@ spec = do
261 -- TODO /response-headers
263 -- TODO /response-headers
262 -- TODO /redirect
264 -- TODO /redirect
263
265
266+ -- FIXME Redirects test is temporarily disabled due to
267+ --
268+ -- https://github.com/postmanlabs/httpbin/issues/617
269+
264− describe "redirects" $
270+ -- describe "redirects" $
265− it "follows redirects" $ do
271+ -- it "follows redirects" $ do
266− r <-
272+ -- r <-
267− req
273+ -- req
268− GET
274+ -- GET
269− (httpbin /: "redirect-to")
275+ -- (httpbin /: "redirect-to")
270− NoReqBody
276+ -- NoReqBody
271− ignoreResponse
277+ -- ignoreResponse
272− ("url" =: ("https://httpbin.org" :: Text))
278+ -- ("url" =: ("https://httpbin.org" :: Text))
273− responseStatusCode r `shouldBe` 200
279+ -- responseStatusCode r `shouldBe` 200
274− responseStatusMessage r `shouldBe` "OK"
280+ -- responseStatusMessage r `shouldBe` "OK"
275
281
276 -- TODO /relative-redicet
282 -- TODO /relative-redicet
277 -- TODO /absolute-redirect
283 -- TODO /absolute-redirect
@@ -301,7 +307,7 @@ spec = do
301 (httpbin /: "basic-auth" /~ user /~ password)
307 (httpbin /: "basic-auth" /~ user /~ password)
302 NoReqBody
308 NoReqBody
303 ignoreResponse
309 ignoreResponse
304− (basicAuthUnsafe (T.encodeUtf8 user) (T.encodeUtf8 password))
310+ (basicAuth (T.encodeUtf8 user) (T.encodeUtf8 password))
305 responseStatusCode r `shouldBe` 200
311 responseStatusCode r `shouldBe` 200
306 responseStatusMessage r `shouldBe` "OK"
312 responseStatusMessage r `shouldBe` "OK"
307
313
@@ -388,80 +394,44 @@ instance MonadHttp IO where
388----------------------------------------------------------------------------
394----------------------------------------------------------------------------
389-- Helpers
395-- Helpers
390
396
391−-- | Run a request with such settings that it does not signal errors.
397+-- | Run request with such settings that it does not signal error on adverse
398+-- response status codes.
392prepareForShit :: Req a -> IO a
399prepareForShit :: Req a -> IO a
393prepareForShit = runReq defaultHttpConfig {httpConfigCheckResponse = noNoise}
400prepareForShit = runReq defaultHttpConfig {httpConfigCheckResponse = noNoise}
394 where
401 where
395 noNoise _ _ _ = Nothing
402 noNoise _ _ _ = Nothing
396
403
397−-- | Run a request with such settings that it throws on any response.
404+-- | Run request with such settings that it throws on any response.
398blindlyThrowing :: Req a -> IO a
405blindlyThrowing :: Req a -> IO a
399blindlyThrowing = runReq defaultHttpConfig {httpConfigCheckResponse = doit}
406blindlyThrowing = runReq defaultHttpConfig {httpConfigCheckResponse = doit}
400 where
407 where
401 doit _ _ = error "Oops!"
408 doit _ _ = error "Oops!"
402
409
403-- | 'Url' representing <https://httpbin.org>.
410-- | 'Url' representing <https://httpbin.org>.
404−httpbin :: Url 'Http
411+httpbin :: Url 'Https
405−httpbin = http "localhost"
412+httpbin = https "httpbin.org"
406−
407−req ::
408− ( MonadHttp m,
409− HttpMethod method,
410− HttpBody body,
411− HttpResponse response,
412− HttpBodyAllowed (AllowsBody method) (ProvidesBody body)
413− ) =>
414− method ->
415− Url scheme ->
416− body ->
417− Proxy response ->
418− Option scheme ->
419− m response
420−req method url body responseProxy options =
421− Req.req method url body responseProxy (options <> defaultOptions)
422−
423−-- | Options to apply by default.
424−defaultOptions :: Option scheme
425−defaultOptions = port 1234
426
413
427-- | Remove “origin” field from JSON value. Origin may change, we don't want
414-- | Remove “origin” field from JSON value. Origin may change, we don't want
428-- to depend on that.
415-- to depend on that.
429stripOrigin :: Value -> Value
416stripOrigin :: Value -> Value
430−stripOrigin (Object m) = Object (Aeson.KeyMap.delete "origin" m)
417+stripOrigin (Object m) = Object (HM.delete "origin" m)
431stripOrigin value = value
418stripOrigin value = value
432
419
433-- | Remove funny headers that might break the tests.
420-- | Remove funny headers that might break the tests.
434stripFunnyHeaders :: Value -> Value
421stripFunnyHeaders :: Value -> Value
435−stripFunnyHeaders = \case
422+stripFunnyHeaders (Object m) =
436− Object m ->
423+ let f (Object p) = Object $ HM.filterWithKey (\k _ -> k `elem` hs) p
437− Object
438− ( runIdentity
439− ( Aeson.KeyMap.alterF
440− (pure . fmap stripFunnyHeaders')
441− "headers"
442− m
443− )
444− )
445− value -> value
446−
447−-- | Similar to 'stripFunnyHeaders', but acts directly on the argument
448−-- without trying to access its "headers" field.
449−stripFunnyHeaders' :: Value -> Value
450−stripFunnyHeaders' = \case
451− Object p ->
452− Object $
453− Aeson.KeyMap.filterWithKey
454− (\k _ -> k `elem` whitelistedHeaders)
455− p
456− value -> value
424+ f value = value
457− where
425+ hs =
458− whitelistedHeaders =
459− [ "Content-Type",
426+ [ "Content-Type",
460− "Accept-Encoding",
427+ "Accept-Encoding",
428+ "Host",
461− "Content-Length",
429+ "Content-Length",
462− "Foo",
430+ "Foo",
463− "Baz"
431+ "Baz"
464− ]
432+ ]
433+ in Object (HM.adjust f "headers" m)
434+stripFunnyHeaders value = value
465
435
466-- | This is a complete test case that makes use of <https://httpbin.org> to
436-- | This is a complete test case that makes use of <https://httpbin.org> to
467-- get various response status codes.
437-- get various response status codes.
@@ -491,19 +461,12 @@ selector404
491 L.responseStatus response == Y.status404 && not (B.null chunk)
461 L.responseStatus response == Y.status404 && not (B.null chunk)
492selector404 _ = False
462selector404 _ = False
493
463
494−-- | Same as 'selector404' except that it uses 'isStatusCodeException'.
495−selector404ByStatusCodeException :: HttpException -> Bool
496−selector404ByStatusCodeException e =
497− case isStatusCodeException e of
498− Nothing -> False
499− Just r -> responseStatusCode r == 404
500−
501−-- | The empty JSON 'Object'.
464+-- | Empty JSON 'Object'.
502emptyObject :: Value
465emptyObject :: Value
503−emptyObject = Object Aeson.KeyMap.empty
466+emptyObject = Object HM.empty
504
467
505−-- | Get a rendered JSON value as 'Text'.
468+-- | Get rendered JSON value as 'Text'.
506−reflectJSON :: (ToJSON a) => a -> Text
469+reflectJSON :: ToJSON a => a -> Text
507reflectJSON = T.decodeUtf8 . BL.toStrict . A.encode
470reflectJSON = T.decodeUtf8 . BL.toStrict . A.encode
508
471
509-- | Clarify to the type checker that the inner computation is in the 'IO'
472-- | Clarify to the type checker that the inner computation is in the 'IO'
pure-tests/Network/HTTP/ReqSpec.hsmode 100644 → 100755+34−58
@@ -1,3 +1,4 @@
1+{-# LANGUAGE CPP #-}
1{-# LANGUAGE DataKinds #-}
2{-# LANGUAGE DataKinds #-}
2{-# LANGUAGE DeriveGeneric #-}
3{-# LANGUAGE DeriveGeneric #-}
3{-# LANGUAGE FlexibleInstances #-}
4{-# LANGUAGE FlexibleInstances #-}
@@ -13,41 +14,43 @@
13
14
14module Network.HTTP.ReqSpec (spec) where
15module Network.HTTP.ReqSpec (spec) where
15
16
16−import Blaze.ByteString.Builder qualified as BB
17+import qualified Blaze.ByteString.Builder as BB
17import Control.Exception (throwIO)
18import Control.Exception (throwIO)
18import Control.Monad
19import Control.Monad
19import Control.Retry
20import Control.Retry
20import Data.Aeson (ToJSON (..))
21import Data.Aeson (ToJSON (..))
21−import Data.Aeson qualified as A
22+import qualified Data.Aeson as A
22import Data.ByteString (ByteString)
23import Data.ByteString (ByteString)
23−import Data.ByteString qualified as B
24+import qualified Data.ByteString as B
24−import Data.ByteString.Char8 qualified as B8
25+import qualified Data.ByteString.Char8 as B8
25−import Data.ByteString.Lazy qualified as BL
26+import qualified Data.ByteString.Lazy as BL
26−import Data.CaseInsensitive qualified as CI
27+import qualified Data.CaseInsensitive as CI
27import Data.Either (isRight)
28import Data.Either (isRight)
28−import Data.List.NonEmpty qualified as NE
29+import qualified Data.List.NonEmpty as NE
29import Data.Maybe (fromJust, fromMaybe, isJust, isNothing)
30import Data.Maybe (fromJust, fromMaybe, isJust, isNothing)
30import Data.Proxy
31import Data.Proxy
31import Data.Text (Text)
32import Data.Text (Text)
32−import Data.Text qualified as T
33+import qualified Data.Text as T
33−import Data.Text.Encoding qualified as T
34+import qualified Data.Text.Encoding as T
34import Data.Time
35import Data.Time
35import Data.Typeable (Typeable, eqT)
36import Data.Typeable (Typeable, eqT)
36−import GHC.Exts (IsList (..))
37import GHC.Generics
37import GHC.Generics
38−import Language.Haskell.TH qualified as TH
38+import qualified Language.Haskell.TH as TH
39−import Language.Haskell.TH.Quote qualified as TH
39+import qualified Language.Haskell.TH.Quote as TH
40−import Network.HTTP.Client qualified as L
40+import qualified Network.HTTP.Client as L
41import Network.HTTP.Req
41import Network.HTTP.Req
42−import Network.HTTP.Types qualified as Y
42+import qualified Network.HTTP.Types as Y
43−import Network.HTTP.Types.Header qualified as Y
43+import qualified Network.HTTP.Types.Header as Y
44import Test.Hspec
44import Test.Hspec
45import Test.Hspec.Core.Spec (SpecM)
45import Test.Hspec.Core.Spec (SpecM)
46import Test.QuickCheck
46import Test.QuickCheck
47import Text.URI (URI)
47import Text.URI (URI)
48−import Text.URI qualified as URI
48+import qualified Text.URI as URI
49−import Text.URI.QQ qualified as QQ
49+import qualified Text.URI.QQ as QQ
50−import Web.FormUrlEncoded qualified as F
50+
51+#if !MIN_VERSION_base(4,13,0)
52+import Data.Semigroup ((<>))
53+#endif
51
54
52spec :: Spec
55spec :: Spec
53spec = do
56spec = do
@@ -161,13 +164,11 @@ spec = do
161 let uriHttp = uri' {URI.uriScheme = Just [QQ.scheme|http|]}
164 let uriHttp = uri' {URI.uriScheme = Just [QQ.scheme|http|]}
162 uriHttps = uri' {URI.uriScheme = Just [QQ.scheme|https|]}
165 uriHttps = uri' {URI.uriScheme = Just [QQ.scheme|https|]}
163 requestHttp <-
166 requestHttp <-
164− case fromJust (useURI uriHttp) of
167+ let Left (url', options) = fromJust (useURI uriHttp)
165− Left (url', options) -> req_ GET url' NoReqBody options
168+ in req_ GET url' NoReqBody options
166− _ -> error "(useURI uriHttp) should have returned Left"
167 requestHttps <-
169 requestHttps <-
168− case fromJust (useURI uriHttps) of
170+ let Right (url', options) = fromJust (useURI uriHttps)
169− Right (url', options) -> req_ GET url' NoReqBody options
171+ in req_ GET url' NoReqBody options
170− _ -> error "(useURI uriHttps) should have returned Right"
171 L.host requestHttp `shouldBe` uriHost uriHttp
172 L.host requestHttp `shouldBe` uriHost uriHttp
172 L.host requestHttps `shouldBe` uriHost uriHttps
173 L.host requestHttps `shouldBe` uriHost uriHttps
173 L.port requestHttp `shouldBe` uriPort 80 uriHttp
174 L.port requestHttp `shouldBe` uriPort 80 uriHttp
@@ -237,19 +238,6 @@ spec = do
237 L.RequestBodyLBS x -> x `shouldBe` renderQuery params
238 L.RequestBodyLBS x -> x `shouldBe` renderQuery params
238 _ -> expectationFailure "Wrong request body constructor."
239 _ -> expectationFailure "Wrong request body constructor."
239
240
240− describe "query params" $ do
241− describe "FormUrlEncodedParam" $ do
242− describe "formToQuery" $ do
243− it "should produce the same parameters as F.urlEncodeFormStable" $
244− property $ \form -> do
245− request <- req_ POST url (ReqBodyUrlEnc $ formToQuery form) mempty
246− case L.requestBody request of
247− L.RequestBodyLBS x -> x `shouldBe` F.urlEncodeFormStable form
248− _ -> expectationFailure "Wrong request body constructor"
249− specParamToList (Proxy :: Proxy FormUrlEncodedParam)
250− describe "Option" $ do
251− specParamToList (Proxy :: Proxy (Option 'Http))
252−
253 describe "optional parameters" $ do
241 describe "optional parameters" $ do
254 describe "header" $ do
242 describe "header" $ do
255 it "sets specified header value" $
243 it "sets specified header value" $
@@ -278,7 +266,11 @@ spec = do
278 it "cookie jar is set without modifications" $
266 it "cookie jar is set without modifications" $
279 property $ \cjar -> do
267 property $ \cjar -> do
280 request <- req_ GET url NoReqBody (cookieJar cjar)
268 request <- req_ GET url NoReqBody (cookieJar cjar)
269+#if MIN_VERSION_http_client(0,7,0)
281 L.cookieJar request `shouldSatisfy` (maybe False (L.equalCookieJar cjar))
270 L.cookieJar request `shouldSatisfy` (maybe False (L.equalCookieJar cjar))
271+#else
272+ L.cookieJar request `shouldBe` Just cjar
273+#endif
282 describe "basicAuth" $ do
274 describe "basicAuth" $ do
283 it "sets Authorization header to correct value" $
275 it "sets Authorization header to correct value" $
284 property $ \username password -> do
276 property $ \username password -> do
@@ -413,7 +405,7 @@ spec = do
413 -- 'Https, Option _) type checks, so we can catch if the type of scheme
405 -- 'Https, Option _) type checks, so we can catch if the type of scheme
414 -- is unspecified.
406 -- is unspecified.
415 let testTypeOfQuoterResult ::
407 let testTypeOfQuoterResult ::
416− forall a s. (Typeable a) => (a, Option s) -> Bool
408+ forall a s. Typeable a => (a, Option s) -> Bool
417 testTypeOfQuoterResult _ = isJust $ eqT @a @(Url 'Https)
409 testTypeOfQuoterResult _ = isJust $ eqT @a @(Url 'Https)
418 in property $ testTypeOfQuoterResult [urlQ|https://example.org/|]
410 in property $ testTypeOfQuoterResult [urlQ|https://example.org/|]
419 it "doesn't work for invalid urls" $
411 it "doesn't work for invalid urls" $
@@ -503,9 +495,6 @@ instance Arbitrary Day where
503instance Arbitrary DiffTime where
495instance Arbitrary DiffTime where
504 arbitrary = secondsToDiffTime <$> arbitrary
496 arbitrary = secondsToDiffTime <$> arbitrary
505
497
506−instance Arbitrary F.Form where
507− arbitrary = (F.Form . fromList) <$> arbitrary
508−
509----------------------------------------------------------------------------
498----------------------------------------------------------------------------
510-- Helper types
499-- Helper types
511
500
@@ -573,14 +562,13 @@ uriPort def uri =
573 maybe def (fromIntegral) $
562 maybe def (fromIntegral) $
574 either (const Nothing) Just (URI.uriAuthority uri) >>= URI.authPort
563 either (const Nothing) Just (URI.uriAuthority uri) >>= URI.authPort
575
564
576−-- | Get the path from a 'URI'.
565+-- | Get path from 'URI'.
577uriPath :: URI -> ByteString
566uriPath :: URI -> ByteString
578uriPath uri = fromMaybe "" $ do
567uriPath uri = fromMaybe "" $ do
579− (trailingSlash, xs) <- URI.uriPath uri
568+ (_, xs) <- URI.uriPath uri
580− let pref = (encodePathPieces . fmap URI.unRText . NE.toList) xs
569+ (return . encodePathPieces . fmap URI.unRText . NE.toList) xs
581− return $ if trailingSlash then pref <> "/" else pref
582
570
583−-- | Get the query string from a 'URI'.
571+-- | Get query string from 'URI'.
584uriQuery :: URI -> ByteString
572uriQuery :: URI -> ByteString
585uriQuery uri = do
573uriQuery uri = do
586 let liftQueryParam = \case
574 let liftQueryParam = \case
@@ -618,15 +606,3 @@ basicProxyAuthHeader :: ByteString -> ByteString -> ByteString
618basicProxyAuthHeader username password =
606basicProxyAuthHeader username password =
619 fromJust . lookup Y.hProxyAuthorization . L.requestHeaders $
607 fromJust . lookup Y.hProxyAuthorization . L.requestHeaders $
620 L.applyBasicProxyAuth username password L.defaultRequest
608 L.applyBasicProxyAuth username password L.defaultRequest
621−
622−-- | Spec about 'paramToList' for the type @p@.
623−specParamToList :: (QueryParam p, Monoid p) => Proxy p -> Spec
624−specParamToList typeProxy = do
625− describe "paramToList" $ do
626− it "should reproduce the parameters given by queryParam" $
627− property $ \(QueryParams params) -> do
628− let queryParam0 =
629− (mconcat $ fmap (uncurry queryParam) params)
630− `asProxyTypeOf` typeProxy
631− got = queryParamToList queryParam0
632− got `shouldBe` params
req.cabal+70−66
@@ -1,15 +1,19 @@
1−cabal-version: 2.4
1+cabal-version: 1.18
2name: req
2name: req
3−version: 3.13.4
3+version: 3.7.0
4−license: BSD-3-Clause
4+license: BSD3
5license-file: LICENSE.md
5license-file: LICENSE.md
6maintainer: Mark Karpov <markkarpov92@gmail.com>
6maintainer: Mark Karpov <markkarpov92@gmail.com>
7author: Mark Karpov <markkarpov92@gmail.com>
7author: Mark Karpov <markkarpov92@gmail.com>
8−tested-with: ghc ==9.6.3 ghc ==9.8.2 ghc ==9.10.1
8+tested-with: ghc ==8.6.5 ghc ==8.8.4 ghc ==8.10.2
9homepage: https://github.com/mrkkrp/req
9homepage: https://github.com/mrkkrp/req
10bug-reports: https://github.com/mrkkrp/req/issues
10bug-reports: https://github.com/mrkkrp/req/issues
11−synopsis: HTTP client library
11+synopsis:
12+ Easy-to-use, type-safe, expandable, high-level HTTP client library
13+
12−description: HTTP client library.
14+description:
15+ Easy-to-use, type-safe, expandable, high-level HTTP client library.
16+
13category: Network, Web
17category: Network, Web
14build-type: Simple
18build-type: Simple
15data-files:
19data-files:
@@ -31,97 +35,97 @@ flag dev
31
35
32library
36library
33 exposed-modules: Network.HTTP.Req
37 exposed-modules: Network.HTTP.Req
34− default-language: GHC2021
38+ default-language: Haskell2010
35 build-depends:
39 build-depends:
36− aeson >=0.9 && <3,
40+ aeson >=0.9 && <1.6,
37− authenticate-oauth >=1.5 && <1.8,
41+ authenticate-oauth >=1.5 && <1.7,
38− base >=4.15 && <5,
42+ base >=4.12 && <5.0,
39 blaze-builder >=0.3 && <0.5,
43 blaze-builder >=0.3 && <0.5,
40− bytestring >=0.10.8 && <0.13,
44+ bytestring >=0.10.8 && <0.11,
41 case-insensitive >=0.2 && <1.3,
45 case-insensitive >=0.2 && <1.3,
42− containers >=0.5 && <0.8,
43− crypton-connection >=0.4.2 && <0.5,
46+ connection >=0.2.2 && <0.4,
44− data-default-class >=0.2.0.0,
45 exceptions >=0.6 && <0.11,
47 exceptions >=0.6 && <0.11,
46− http-api-data >=0.2 && <0.7,
48+ http-api-data >=0.2 && <0.5,
47− http-client >=0.7.13.1 && <0.8,
49+ http-client >=0.5 && <0.8,
48 http-client-tls >=0.3.2 && <0.4,
50 http-client-tls >=0.3.2 && <0.4,
49− http-types >=0.8 && <10,
51+ http-types >=0.8 && <10.0,
50 modern-uri >=0.3 && <0.4,
52 modern-uri >=0.3 && <0.4,
51 monad-control >=1.0 && <1.1,
53 monad-control >=1.0 && <1.1,
52 mtl >=2.0 && <3.0,
54 mtl >=2.0 && <3.0,
53− retry >=0.8 && <0.10,
55+ retry >=0.8 && <0.9,
54− template-haskell >=2.19 && <2.23,
56+ template-haskell >=2.14 && <2.17,
55− text >=0.2 && <2.2,
57+ text >=0.2 && <1.3,
56− transformers >=0.5.3.0 && <0.7,
58+ time >=1.2 && <1.10,
59+ transformers >=0.4 && <0.6,
57− transformers-base,
60+ transformers-base -any,
58 unliftio-core >=0.1.1 && <0.3
61 unliftio-core >=0.1.1 && <0.3
59
62
60 if flag(dev)
63 if flag(dev)
61− ghc-options:
64+ ghc-options: -O0 -Wall -Werror
62− -Wall -Werror -Wpartial-fields -Wunused-packages
63− -Wno-unused-imports
64
65
65 else
66 else
66 ghc-options: -O2 -Wall
67 ghc-options: -O2 -Wall
67
68
69+ if flag(dev)
70+ ghc-options:
71+ -Wcompat -Wincomplete-record-updates -Wincomplete-uni-patterns
72+ -Wnoncanonical-monad-instances
73+
68test-suite pure-tests
74test-suite pure-tests
69− type: exitcode-stdio-1.0
75+ type: exitcode-stdio-1.0
70− main-is: Spec.hs
76+ main-is: Spec.hs
71− build-tool-depends: hspec-discover:hspec-discover >=2 && <3
77+ build-tools: hspec-discover >=2.0 && <3.0
72− hs-source-dirs: pure-tests
78+ hs-source-dirs: pure-tests
73− other-modules: Network.HTTP.ReqSpec
79+ other-modules: Network.HTTP.ReqSpec
74− default-language: GHC2021
80+ default-language: Haskell2010
75 build-depends:
81 build-depends:
76− QuickCheck >=2.7 && <3,
82+ QuickCheck >=2.7 && <3.0,
77− aeson >=0.9 && <3,
83+ aeson >=0.9 && <1.6,
78− base >=4.15 && <5.0,
84+ base >=4.12 && <5.0,
79 blaze-builder >=0.3 && <0.5,
85 blaze-builder >=0.3 && <0.5,
80− bytestring >=0.10.8 && <0.13,
86+ bytestring >=0.10.8 && <0.11,
81 case-insensitive >=0.2 && <1.3,
87 case-insensitive >=0.2 && <1.3,
82− hspec >=2.0 && <3,
88+ hspec >=2.0 && <3.0,
83− hspec-core >=2.0 && <3,
89+ hspec-core >=2.0 && <3.0,
84− http-api-data >=0.2 && <0.7,
85− http-client >=0.7 && <0.8,
90+ http-client >=0.5 && <0.8,
86− http-types >=0.8 && <10,
91+ http-types >=0.8 && <10.0,
87 modern-uri >=0.3 && <0.4,
92 modern-uri >=0.3 && <0.4,
93+ mtl >=2.0 && <3.0,
88− req,
94+ req -any,
89− retry >=0.8 && <0.10,
95+ retry >=0.8 && <0.9,
90− template-haskell >=2.19 && <2.23,
96+ template-haskell >=2.14 && <2.17,
91− text >=0.2 && <2.2,
97+ text >=0.2 && <1.3,
92− time >=1.2 && <1.15
98+ time >=1.2 && <1.10
93
99
94 if flag(dev)
100 if flag(dev)
95− ghc-options:
101+ ghc-options: -O0 -Wall -Werror
96− -Wall -Werror -Wredundant-constraints -Wpartial-fields
97− -Wunused-packages
98
102
99 else
103 else
100 ghc-options: -O2 -Wall
104 ghc-options: -O2 -Wall
101
105
102test-suite httpbin-tests
106test-suite httpbin-tests
103− type: exitcode-stdio-1.0
107+ type: exitcode-stdio-1.0
104− main-is: Spec.hs
108+ main-is: Spec.hs
105− build-tool-depends: hspec-discover:hspec-discover >=2 && <3
109+ build-tools: hspec-discover >=2.0 && <3.0
106− hs-source-dirs: httpbin-tests
110+ hs-source-dirs: httpbin-tests
107− other-modules: Network.HTTP.ReqSpec
111+ other-modules: Network.HTTP.ReqSpec
108− default-language: GHC2021
112+ default-language: Haskell2010
109 build-depends:
113 build-depends:
110− QuickCheck >=2.7 && <3,
114+ QuickCheck >=2.7 && <3.0,
111− aeson >=2 && <3,
115+ aeson >=0.9 && <1.6,
112− base >=4.15 && <5,
116+ base >=4.12 && <5.0,
113− bytestring >=0.10.8 && <0.13,
117+ bytestring >=0.10.8 && <0.11,
114 hspec >=2.0 && <3.0,
118 hspec >=2.0 && <3.0,
115− http-client >=0.7 && <0.8,
119+ http-client >=0.5 && <0.8,
116− http-types >=0.8 && <10,
120+ http-types >=0.8 && <10.0,
117 monad-control >=1.0 && <1.1,
121 monad-control >=1.0 && <1.1,
122+ mtl >=2.0 && <3.0,
118− req,
123+ req -any,
119− text >=0.2 && <2.2
124+ text >=0.2 && <1.3,
125+ unordered-containers >=0.2.5 && <0.3
120
126
121 if flag(dev)
127 if flag(dev)
122− ghc-options:
128+ ghc-options: -O0 -Wall -Werror
123− -Wall -Werror -Wredundant-constraints -Wpartial-fields
124− -Wunused-packages
125
129
126 else
130 else
127− buildable: False
131+ ghc-options: -O2 -Wall