module Control.Monad.Apiary.Filter (
method, stdMethod
, Control.Monad.Apiary.Filter.httpVersion
, http09, http10, http11
, root
, capture
, query
, (=:), (=!:), (=?:), (?:), (=*:), (=+:)
, hasQuery
, hasHeader
, eqHeader
, headers
, header
, header'
, ssl
, module Network.HTTP.Types
, module Control.Monad.Apiary.Filter.Internal.Strategy
) where
import Control.Monad
import Network.Wai as Wai
import qualified Network.HTTP.Types as HT
import Network.HTTP.Types (StdMethod(..))
import qualified Data.ByteString as S
import Data.Proxy
import Data.Reflection
import Data.Apiary.SList
import Data.Apiary.Param
import Control.Monad.Apiary.Action.Internal
import Control.Monad.Apiary.Filter.Internal
import qualified Control.Monad.Apiary.Filter.Internal.Strategy as Strategy
import Control.Monad.Apiary.Filter.Internal.Strategy (pFirst, pOne, pOption, pCheck, pMany, pSome)
import Control.Monad.Apiary.Filter.Internal.Capture.TH
import Control.Monad.Apiary.Internal
method :: (Functor n, Monad n) => HT.Method -> ApiaryT c n m a -> ApiaryT c n m a
method m = function_ ((m ==) . requestMethod)
stdMethod :: (Functor n, Monad n) => StdMethod -> ApiaryT c n m a -> ApiaryT c n m a
stdMethod = method . HT.renderStdMethod
ssl :: (Functor n, Monad n) => ApiaryT c n m a -> ApiaryT c n m a
ssl = function_ isSecure
httpVersion :: (Functor n, Monad n) => HT.HttpVersion
-> ApiaryT c n m b -> ApiaryT c n m b
httpVersion v = function_ $ (v ==) . Wai.httpVersion
http09 :: (Functor n, Monad n) => ApiaryT c n m b -> ApiaryT c n m b
http09 = Control.Monad.Apiary.Filter.httpVersion HT.http09
http10 :: (Functor n, Monad n) => ApiaryT c n m b -> ApiaryT c n m b
http10 = Control.Monad.Apiary.Filter.httpVersion HT.http10
http11 :: (Functor n, Monad n) => ApiaryT c n m b -> ApiaryT c n m b
http11 = Control.Monad.Apiary.Filter.httpVersion HT.http11
root :: (Functor n, Monad n) => ApiaryT c n m b -> ApiaryT c n m b
root m = do
rs <- rootPattern `liftM` apiaryConfig
function_ (\r -> rawPathInfo r `elem` rs) m
query :: (Query a, Strategy.Strategy w, Functor n, Monad n)
=> S.ByteString
-> Proxy (w a)
-> ApiaryT (Strategy.SNext w as a) n m b
-> ApiaryT as n m b
query k p = function $ \l r -> Strategy.readStrategy readQuery ((k ==) . fst) p (queryString r) l
(=:) :: (Functor n, Monad n, Query a) => S.ByteString -> Proxy a
-> ApiaryT (Snoc as a) n m b -> ApiaryT as n m b
k =: t = query k (pFirst t)
(=!:) :: (Functor n, Monad n, Query a) => S.ByteString -> Proxy a
-> ApiaryT (Snoc as a) n m b -> ApiaryT as n m b
k =!: t = query k (pOne t)
(=?:) :: (Functor n, Monad n, Query a) => S.ByteString -> Proxy a
-> ApiaryT (Snoc as (Maybe a)) n m b -> ApiaryT as n m b
k =?: t = query k (pOption t)
(?:) :: (Functor n, Monad n, Query a) => S.ByteString -> Proxy a
-> ApiaryT as n m b -> ApiaryT as n m b
k ?: t = query k (pCheck t)
(=*:) :: (Functor n, Monad n, Query a) => S.ByteString -> Proxy a
-> ApiaryT (Snoc as [a]) n m b -> ApiaryT as n m b
k =*: t = query k (pMany t)
(=+:) :: (Functor n, Monad n, Query a) => S.ByteString -> Proxy a
-> ApiaryT (Snoc as [a]) n m b -> ApiaryT as n m b
k =+: t = query k (pSome t)
hasQuery :: (Functor n, Monad n) => S.ByteString -> ApiaryT c n m a -> ApiaryT c n m a
hasQuery q = query q (Proxy :: Proxy (Strategy.Check ()))
hasHeader :: (Functor n, Monad n) => HT.HeaderName -> ApiaryT as n m b -> ApiaryT as n m b
hasHeader n = header' pCheck ((n ==) . fst)
eqHeader :: (Functor n, Monad n)
=> HT.HeaderName
-> S.ByteString
-> ApiaryT as n m b
-> ApiaryT as n m b
eqHeader k v = header' pCheck (\(k',v') -> k == k' && v == v')
header :: (Functor n, Monad n) => HT.HeaderName
-> ApiaryT (Snoc as S.ByteString) n m b -> ApiaryT as n m b
header n = header' pFirst ((n ==) . fst)
headers :: (Functor n, Monad n) => HT.HeaderName
-> ApiaryT (Snoc as [S.ByteString]) n m b -> ApiaryT as n m b
headers n = header' limit100 ((n ==) . fst)
where
limit100 :: Proxy x -> Proxy (Strategy.LimitSome $(int 100) x)
limit100 _ = Proxy
header' :: (Strategy.Strategy w, Functor n, Monad n)
=> (forall x. Proxy x -> Proxy (w x))
-> (HT.Header -> Bool)
-> ApiaryT (Strategy.SNext w as S.ByteString) n m b
-> ApiaryT as n m b
header' pf kf = function $ \l r ->
Strategy.readStrategy Just kf (pf pByteString) (requestHeaders r) l