{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
-- | Optics for @http-client@ types
module Network.HTTP.Client.Lens
  ( -- * 'Request' lenses
    method
  , secure
  , host
  , port
  , path
  , queryString
  , requestBody
  , requestHeaders
  , proxy
  , hostAddress
  , rawBody
  , decompress
  , redirectCount
  , checkResponse
  , responseTimeout
  , cookieJar
  , requestVersion
  , onRequestBodyException
  , requestManagerOverride
  ) where

import           Control.Exception (SomeException)
import           Data.ByteString (ByteString)
import qualified Network.HTTP.Client as H
import qualified Network.HTTP.Client.Internal as H
import qualified Network.HTTP.Types as H
import           Network.Socket (HostAddress)

import           Network.HTTP.Client.Lens.Internal


-- | 'H.method' lens
method :: Lens' H.Request H.Method
method :: Lens' Request Method
method Method -> f Method
f Request
req = Method -> f Method
f (Request -> Method
H.method Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Method
m' -> Request
req { method :: Method
H.method = Method
m' }
{-# INLINE method #-}

-- | 'H.secure' lens
secure :: Lens' H.Request Bool
secure :: Lens' Request Bool
secure Bool -> f Bool
f Request
req = Bool -> f Bool
f (Request -> Bool
H.secure Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Bool
s' -> Request
req { secure :: Bool
H.secure = Bool
s' }
{-# INLINE secure #-}

-- | 'H.host' lens
host :: Lens' H.Request ByteString
host :: Lens' Request Method
host Method -> f Method
f Request
req = Method -> f Method
f (Request -> Method
H.host Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Method
h' -> Request
req { host :: Method
H.host = Method
h' }
{-# INLINE host #-}

-- | 'H.port' lens
port :: Lens' H.Request Int
port :: Lens' Request Int
port Int -> f Int
f Request
req = Int -> f Int
f (Request -> Int
H.port Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Int
p' -> Request
req { port :: Int
H.port = Int
p' }
{-# INLINE port #-}

-- | 'H.path' lens
path :: Lens' H.Request ByteString
path :: Lens' Request Method
path Method -> f Method
f Request
req = Method -> f Method
f (Request -> Method
H.path Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Method
p' -> Request
req { path :: Method
H.path = Method
p' }
{-# INLINE path #-}

-- | 'H.queryString' lens
queryString :: Lens' H.Request ByteString
queryString :: Lens' Request Method
queryString Method -> f Method
f Request
req = Method -> f Method
f (Request -> Method
H.queryString Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Method
qs' -> Request
req { queryString :: Method
H.queryString = Method
qs' }
{-# INLINE queryString #-}

-- | 'H.requestHeaders' lens
requestHeaders :: Lens' H.Request H.RequestHeaders
requestHeaders :: Lens' Request RequestHeaders
requestHeaders RequestHeaders -> f RequestHeaders
f Request
req = RequestHeaders -> f RequestHeaders
f (Request -> RequestHeaders
H.requestHeaders Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \RequestHeaders
rh' -> Request
req { requestHeaders :: RequestHeaders
H.requestHeaders = RequestHeaders
rh' }
{-# INLINE requestHeaders #-}

-- | 'H.requestBody' lens
requestBody :: Lens' H.Request H.RequestBody
requestBody :: Lens' Request RequestBody
requestBody RequestBody -> f RequestBody
f Request
req = RequestBody -> f RequestBody
f (Request -> RequestBody
H.requestBody Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \RequestBody
rb' -> Request
req { requestBody :: RequestBody
H.requestBody = RequestBody
rb' }
{-# INLINE requestBody #-}

-- | 'H.proxy'
proxy :: Lens' H.Request (Maybe H.Proxy)
proxy :: Lens' Request (Maybe Proxy)
proxy Maybe Proxy -> f (Maybe Proxy)
f Request
req = Maybe Proxy -> f (Maybe Proxy)
f (Request -> Maybe Proxy
H.proxy Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Maybe Proxy
mp' -> Request
req { proxy :: Maybe Proxy
H.proxy = Maybe Proxy
mp' }
{-# INLINE proxy #-}

-- | 'H.hostAddress'
hostAddress :: Lens' H.Request (Maybe HostAddress)
hostAddress :: Lens' Request (Maybe HostAddress)
hostAddress Maybe HostAddress -> f (Maybe HostAddress)
f Request
req = Maybe HostAddress -> f (Maybe HostAddress)
f (Request -> Maybe HostAddress
H.hostAddress Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Maybe HostAddress
ha' -> Request
req { hostAddress :: Maybe HostAddress
H.hostAddress = Maybe HostAddress
ha' }
{-# INLINE hostAddress #-}

-- | 'H.rawBody'
rawBody :: Lens' H.Request Bool
rawBody :: Lens' Request Bool
rawBody Bool -> f Bool
f Request
req = Bool -> f Bool
f (Request -> Bool
H.rawBody Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Bool
b' -> Request
req { rawBody :: Bool
H.rawBody = Bool
b' }
{-# INLINE rawBody #-}

-- | 'H.decompress'
decompress :: Lens' H.Request (ByteString -> Bool)
decompress :: Lens' Request (Method -> Bool)
decompress (Method -> Bool) -> f (Method -> Bool)
f Request
req = (Method -> Bool) -> f (Method -> Bool)
f (Request -> Method -> Bool
H.decompress Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Method -> Bool
btb' -> Request
req { decompress :: Method -> Bool
H.decompress = Method -> Bool
btb' }
{-# INLINE decompress #-}

-- | 'H.redirectCount' lens
redirectCount :: Lens' H.Request Int
redirectCount :: Lens' Request Int
redirectCount Int -> f Int
f Request
req = Int -> f Int
f (Request -> Int
H.redirectCount Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Int
rc' -> Request
req { redirectCount :: Int
H.redirectCount = Int
rc' }
{-# INLINE redirectCount #-}

-- | 'H.checkResponse' lens
checkResponse :: Lens' H.Request (H.Request -> H.Response H.BodyReader -> IO ())
checkResponse :: Lens' Request (Request -> Response BodyReader -> IO ())
checkResponse (Request -> Response BodyReader -> IO ())
-> f (Request -> Response BodyReader -> IO ())
f Request
req = (Request -> Response BodyReader -> IO ())
-> f (Request -> Response BodyReader -> IO ())
f (Request -> Request -> Response BodyReader -> IO ()
H.checkResponse Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Request -> Response BodyReader -> IO ()
cr' -> Request
req { checkResponse :: Request -> Response BodyReader -> IO ()
H.checkResponse = Request -> Response BodyReader -> IO ()
cr' }
{-# INLINE checkResponse #-}

-- | 'H.responseTimeout' lens
responseTimeout :: Lens' H.Request H.ResponseTimeout
responseTimeout :: Lens' Request ResponseTimeout
responseTimeout ResponseTimeout -> f ResponseTimeout
f Request
req = ResponseTimeout -> f ResponseTimeout
f (Request -> ResponseTimeout
H.responseTimeout Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \ResponseTimeout
rt' -> Request
req { responseTimeout :: ResponseTimeout
H.responseTimeout = ResponseTimeout
rt' }
{-# INLINE responseTimeout #-}

-- | 'H.cookieJar'
cookieJar :: Lens' H.Request (Maybe H.CookieJar)
cookieJar :: Lens' Request (Maybe CookieJar)
cookieJar Maybe CookieJar -> f (Maybe CookieJar)
f Request
req = Maybe CookieJar -> f (Maybe CookieJar)
f (Request -> Maybe CookieJar
H.cookieJar Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Maybe CookieJar
mcj' -> Request
req { cookieJar :: Maybe CookieJar
H.cookieJar = Maybe CookieJar
mcj' }
{-# INLINE cookieJar #-}

-- | 'H.requestVersion' lens
requestVersion :: Lens' H.Request H.HttpVersion
requestVersion :: Lens' Request HttpVersion
requestVersion HttpVersion -> f HttpVersion
f Request
req = HttpVersion -> f HttpVersion
f (Request -> HttpVersion
H.requestVersion Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \HttpVersion
rv' -> Request
req { requestVersion :: HttpVersion
H.requestVersion = HttpVersion
rv' }
{-# INLINE requestVersion #-}

-- | 'H.onRequestBodyException' lens
onRequestBodyException :: Lens' H.Request (SomeException -> IO ())
onRequestBodyException :: Lens' Request (SomeException -> IO ())
onRequestBodyException (SomeException -> IO ()) -> f (SomeException -> IO ())
f Request
req = (SomeException -> IO ()) -> f (SomeException -> IO ())
f (Request -> SomeException -> IO ()
H.onRequestBodyException Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \SomeException -> IO ()
cb -> Request
req { onRequestBodyException :: SomeException -> IO ()
H.onRequestBodyException = SomeException -> IO ()
cb }
{-# INLINE onRequestBodyException #-}

-- | 'H.requestManagerOverride' lens
requestManagerOverride :: Lens' H.Request (Maybe H.Manager)
requestManagerOverride :: Lens' Request (Maybe Manager)
requestManagerOverride Maybe Manager -> f (Maybe Manager)
f Request
req = Maybe Manager -> f (Maybe Manager)
f (Request -> Maybe Manager
H.requestManagerOverride Request
req) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Maybe Manager
m' -> Request
req { requestManagerOverride :: Maybe Manager
H.requestManagerOverride = Maybe Manager
m' }
{-# INLINE requestManagerOverride #-}