{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
-- | This module just exports orphan instances to make named-servant
-- work with clients
module Servant.Client.Named () where
import Servant.API
import Servant.Client.Core.HasClient
import Servant.Named
import Servant.API.Modifiers
import Data.Proxy
import GHC.TypeLits
import Data.Maybe
import Data.Functor.Identity
import Named

unarg :: NamedF f a name -> f a
unarg :: NamedF f a name -> f a
unarg (ArgF f a
a) = f a
a

instance (KnownSymbol sym, ToHttpApiData a, HasClient m api)
      => HasClient m (NamedQueryParams sym a :> api) where

  type Client m (NamedQueryParams sym a :> api) =
    sym :? [a] -> Client m api

  clientWithRoute :: Proxy m
-> Proxy (NamedQueryParams sym a :> api)
-> Request
-> Client m (NamedQueryParams sym a :> api)
clientWithRoute Proxy m
pm Proxy (NamedQueryParams sym a :> api)
Proxy Request
req (ArgF Maybe [a]
paramlist) =
    Proxy m
-> Proxy (QueryParams sym a :> api)
-> Request
-> Client m (QueryParams sym a :> api)
forall (m :: * -> *) api.
HasClient m api =>
Proxy m -> Proxy api -> Request -> Client m api
clientWithRoute Proxy m
pm (Proxy (QueryParams sym a :> api)
forall k (t :: k). Proxy t
Proxy :: Proxy (QueryParams sym a :> api)) Request
req ([a] -> Client m api) -> [a] -> Client m api
forall a b. (a -> b) -> a -> b
$
                    [a] -> Maybe [a] -> [a]
forall a. a -> Maybe a -> a
fromMaybe [] Maybe [a]
paramlist
                    
  hoistClientMonad :: Proxy m
-> Proxy (NamedQueryParams sym a :> api)
-> (forall x. mon x -> mon' x)
-> Client mon (NamedQueryParams sym a :> api)
-> Client mon' (NamedQueryParams sym a :> api)
hoistClientMonad Proxy m
pm Proxy (NamedQueryParams sym a :> api)
_ forall x. mon x -> mon' x
f Client mon (NamedQueryParams sym a :> api)
cl NamedF Maybe [a] sym
as =
    Proxy m
-> Proxy api
-> (forall x. mon x -> mon' x)
-> Client mon api
-> Client mon' api
forall (m :: * -> *) api (mon :: * -> *) (mon' :: * -> *).
HasClient m api =>
Proxy m
-> Proxy api
-> (forall x. mon x -> mon' x)
-> Client mon api
-> Client mon' api
hoistClientMonad Proxy m
pm (Proxy api
forall k (t :: k). Proxy t
Proxy :: Proxy api) forall x. mon x -> mon' x
f (Client mon (NamedQueryParams sym a :> api)
NamedF Maybe [a] sym -> Client mon api
cl NamedF Maybe [a] sym
as)

instance (KnownSymbol sym, ToHttpApiData a, HasClient m sub,
          SBoolI (FoldRequired mods))
      => HasClient m (NamedQueryParam' mods sym a :> sub) where

  type Client m (NamedQueryParam' mods sym a :> sub) =
    If (FoldRequired mods) (sym :! a) (sym :? a) -> Client m sub

  -- if mparam = Nothing, we don't add it to the query string
  clientWithRoute :: Proxy m
-> Proxy (NamedQueryParam' mods sym a :> sub)
-> Request
-> Client m (NamedQueryParam' mods sym a :> sub)
clientWithRoute Proxy m
pm Proxy (NamedQueryParam' mods sym a :> sub)
Proxy Request
req If (FoldRequired mods) (sym :! a) (sym :? a)
mparam =
    Proxy m
-> Proxy (QueryParam' mods sym a :> sub)
-> Request
-> Client m (QueryParam' mods sym a :> sub)
forall (m :: * -> *) api.
HasClient m api =>
Proxy m -> Proxy api -> Request -> Client m api
clientWithRoute Proxy m
pm (Proxy (QueryParam' mods sym a :> sub)
forall k (t :: k). Proxy t
Proxy :: Proxy (QueryParam' mods sym a :> sub)) Request
req (If (FoldRequired mods) a (Maybe a) -> Client m sub)
-> If (FoldRequired mods) a (Maybe a) -> Client m sub
forall a b. (a -> b) -> a -> b
$
      case SBool (FoldRequired mods)
forall (b :: Bool). SBoolI b => SBool b
sbool :: SBool (FoldRequired mods) of
        SBool (FoldRequired mods)
STrue  -> Identity a -> a
forall a. Identity a -> a
runIdentity ((sym :! a) -> Identity a
forall (f :: * -> *) a (name :: Symbol). NamedF f a name -> f a
unarg If (FoldRequired mods) (sym :! a) (sym :? a)
sym :! a
mparam)
        SBool (FoldRequired mods)
SFalse -> (sym :? a) -> Maybe a
forall (f :: * -> *) a (name :: Symbol). NamedF f a name -> f a
unarg If (FoldRequired mods) (sym :! a) (sym :? a)
sym :? a
mparam

  hoistClientMonad :: Proxy m
-> Proxy (NamedQueryParam' mods sym a :> sub)
-> (forall x. mon x -> mon' x)
-> Client mon (NamedQueryParam' mods sym a :> sub)
-> Client mon' (NamedQueryParam' mods sym a :> sub)
hoistClientMonad Proxy m
pm Proxy (NamedQueryParam' mods sym a :> sub)
_ forall x. mon x -> mon' x
f Client mon (NamedQueryParam' mods sym a :> sub)
cl If (FoldRequired mods) (sym :! a) (sym :? a)
arg' =
    Proxy m
-> Proxy sub
-> (forall x. mon x -> mon' x)
-> Client mon sub
-> Client mon' sub
forall (m :: * -> *) api (mon :: * -> *) (mon' :: * -> *).
HasClient m api =>
Proxy m
-> Proxy api
-> (forall x. mon x -> mon' x)
-> Client mon api
-> Client mon' api
hoistClientMonad Proxy m
pm (Proxy sub
forall k (t :: k). Proxy t
Proxy :: Proxy sub) forall x. mon x -> mon' x
f (Client mon (NamedQueryParam' mods sym a :> sub)
If (FoldRequired mods) (sym :! a) (sym :? a) -> Client mon sub
cl If (FoldRequired mods) (sym :! a) (sym :? a)
arg')

instance (KnownSymbol sym, HasClient m api)
      => HasClient m (NamedQueryFlag sym :> api) where

  type Client m (NamedQueryFlag sym :> api) =
    sym :? Bool -> Client m api

  clientWithRoute :: Proxy m
-> Proxy (NamedQueryFlag sym :> api)
-> Request
-> Client m (NamedQueryFlag sym :> api)
clientWithRoute Proxy m
pm Proxy (NamedQueryFlag sym :> api)
Proxy Request
req (ArgF Maybe Bool
flag) =
    Proxy m
-> Proxy (QueryFlag sym :> api)
-> Request
-> Client m (QueryFlag sym :> api)
forall (m :: * -> *) api.
HasClient m api =>
Proxy m -> Proxy api -> Request -> Client m api
clientWithRoute Proxy m
pm (Proxy (QueryFlag sym :> api)
forall k (t :: k). Proxy t
Proxy :: Proxy (QueryFlag sym :> api)) Request
req (Bool -> Client m api) -> Bool -> Client m api
forall a b. (a -> b) -> a -> b
$
                    Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe Bool
False Maybe Bool
flag
                    
  hoistClientMonad :: Proxy m
-> Proxy (NamedQueryFlag sym :> api)
-> (forall x. mon x -> mon' x)
-> Client mon (NamedQueryFlag sym :> api)
-> Client mon' (NamedQueryFlag sym :> api)
hoistClientMonad Proxy m
pm Proxy (NamedQueryFlag sym :> api)
_ forall x. mon x -> mon' x
f Client mon (NamedQueryFlag sym :> api)
cl NamedF Maybe Bool sym
as =
    Proxy m
-> Proxy api
-> (forall x. mon x -> mon' x)
-> Client mon api
-> Client mon' api
forall (m :: * -> *) api (mon :: * -> *) (mon' :: * -> *).
HasClient m api =>
Proxy m
-> Proxy api
-> (forall x. mon x -> mon' x)
-> Client mon api
-> Client mon' api
hoistClientMonad Proxy m
pm (Proxy api
forall k (t :: k). Proxy t
Proxy :: Proxy api) forall x. mon x -> mon' x
f (Client mon (NamedQueryFlag sym :> api)
NamedF Maybe Bool sym -> Client mon api
cl NamedF Maybe Bool sym
as)