@@ -1,31 +1,29 @@
1−{-# LANGUAGE AllowAmbiguousTypes #-}
2−{-# LANGUAGE ConstraintKinds #-}
3{-# LANGUAGE CPP #-}
1{-# LANGUAGE CPP #-}
2+{-# LANGUAGE ConstraintKinds #-}
4{-# LANGUAGE DataKinds #-}
3{-# LANGUAGE DataKinds #-}
5{-# LANGUAGE DeriveDataTypeable #-}
4{-# LANGUAGE DeriveDataTypeable #-}
6{-# LANGUAGE FlexibleContexts #-}
5{-# LANGUAGE FlexibleContexts #-}
7{-# LANGUAGE FlexibleInstances #-}
6{-# LANGUAGE FlexibleInstances #-}
8−{-# LANGUAGE InstanceSigs #-}
9−{-# LANGUAGE LambdaCase #-}
10{-# LANGUAGE MultiParamTypeClasses #-}
7{-# LANGUAGE MultiParamTypeClasses #-}
11{-# LANGUAGE OverloadedStrings #-}
8{-# LANGUAGE OverloadedStrings #-}
12{-# LANGUAGE PolyKinds #-}
9{-# LANGUAGE PolyKinds #-}
13−{-# LANGUAGE QuantifiedConstraints #-}
14{-# LANGUAGE RankNTypes #-}
10{-# LANGUAGE RankNTypes #-}
15{-# LANGUAGE ScopedTypeVariables #-}
11{-# LANGUAGE ScopedTypeVariables #-}
16{-# LANGUAGE TupleSections #-}
12{-# LANGUAGE TupleSections #-}
17−{-# LANGUAGE TypeApplications #-}
18{-# LANGUAGE TypeFamilies #-}
13{-# LANGUAGE TypeFamilies #-}
19{-# LANGUAGE TypeOperators #-}
14{-# LANGUAGE TypeOperators #-}
20{-# LANGUAGE UndecidableInstances #-}
15{-# LANGUAGE UndecidableInstances #-}
17+#if MIN_VERSION_base(4,9,0) && __GLASGOW_HASKELL__ >= 802
18+#define HAS_TYPE_ERROR
22module Servant.Server.Internal
21module Servant.Server.Internal
23 ( module Servant.Server.Internal
22 ( module Servant.Server.Internal
24 , module Servant.Server.Internal.BasicAuth
23 , module Servant.Server.Internal.BasicAuth
25 , module Servant.Server.Internal.Context
24 , module Servant.Server.Internal.Context
26 , module Servant.Server.Internal.Delayed
25 , module Servant.Server.Internal.Delayed
27 , module Servant.Server.Internal.DelayedIO
26 , module Servant.Server.Internal.DelayedIO
28− , module Servant.Server.Internal.ErrorFormatter
29 , module Servant.Server.Internal.Handler
27 , module Servant.Server.Internal.Handler
30 , module Servant.Server.Internal.Router
28 , module Servant.Server.Internal.Router
31 , module Servant.Server.Internal.RouteResult
29 , module Servant.Server.Internal.RouteResult
@@ -36,19 +34,19 @@ module Servant.Server.Internal
36import Control.Monad
34import Control.Monad
37 (join, when)
35 (join, when)
38import Control.Monad.Trans
36import Control.Monad.Trans
39− (liftIO, lift)
37+ (liftIO)
40import Control.Monad.Trans.Resource
38import Control.Monad.Trans.Resource
41− (runResourceT, ReleaseKey)
39+ (runResourceT)
43import qualified Data.ByteString as B
40import qualified Data.ByteString as B
44import qualified Data.ByteString.Builder as BB
41import qualified Data.ByteString.Builder as BB
45import qualified Data.ByteString.Char8 as BC8
42import qualified Data.ByteString.Char8 as BC8
46import qualified Data.ByteString.Lazy as BL
43import qualified Data.ByteString.Lazy as BL
47−import Data.Constraint (Constraint, Dict(..))
48import Data.Either
44import Data.Either
49 (partitionEithers)
45 (partitionEithers)
50import Data.Maybe
46import Data.Maybe
51 (fromMaybe, isNothing, mapMaybe, maybeToList)
47 (fromMaybe, isNothing, mapMaybe, maybeToList)
52import Data.String
50import Data.String
53 (IsString (..))
51 (IsString (..))
54import Data.String.Conversions
52import Data.String.Conversions
@@ -57,70 +55,56 @@ import Data.Tagged
57 (Tagged (..), retag, untag)
55 (Tagged (..), retag, untag)
58import qualified Data.Text as T
56import qualified Data.Text as T
59import Data.Typeable
57import Data.Typeable
61import GHC.TypeLits
58import GHC.TypeLits
62− (KnownNat, KnownSymbol, TypeError, symbolVal)
59+ (KnownNat, KnownSymbol, natVal, symbolVal)
63import qualified Network.HTTP.Media as NHM
60import qualified Network.HTTP.Media as NHM
64import Network.HTTP.Types hiding
61import Network.HTTP.Types hiding
65 (Header, ResponseHeaders)
62 (Header, ResponseHeaders)
66import Network.Socket
63import Network.Socket
67 (SockAddr)
64 (SockAddr)
68import Network.Wai
65import Network.Wai
69− (Application, Request, Response, ResponseReceived, httpVersion, isSecure, lazyRequestBody,
66+ (Application, Request, httpVersion, isSecure, lazyRequestBody,
70− queryString, remoteHost, getRequestBodyChunk, requestHeaders,
67+ rawQueryString, remoteHost, requestBody, requestHeaders,
71 requestMethod, responseLBS, responseStream, vault)
68 requestMethod, responseLBS, responseStream, vault)
72import Prelude ()
69import Prelude ()
73import Prelude.Compat
70import Prelude.Compat
74import Servant.API
71import Servant.API
75 ((:<|>) (..), (:>), Accept (..), BasicAuth, Capture',
72 ((:<|>) (..), (:>), Accept (..), BasicAuth, Capture',
76− CaptureAll, Description, EmptyAPI, Fragment,
73+ CaptureAll, Description, EmptyAPI, FramingRender (..),
77− FramingRender (..), FramingUnrender (..), FromSourceIO (..),
74+ FramingUnrender (..), FromSourceIO (..), Header', If,
78− Header', If, IsSecure (..), NoContentVerb, QueryFlag,
75+ IsSecure (..), QueryFlag, QueryParam', QueryParams, Raw,
79− QueryParam', QueryParams, Raw, RawM, ReflectMethod (reflectMethod),
76+ ReflectMethod (reflectMethod), RemoteHost, ReqBody',
80− RemoteHost, ReqBody', SBool (..), SBoolI (..), SourceIO,
77+ SBool (..), SBoolI (..), SourceIO, Stream, StreamBody',
81− Stream, StreamBody', Summary, ToSourceIO (..), Vault, Verb,
78+ Summary, ToSourceIO (..), Vault, Verb, WithNamedContext)
82− WithNamedContext, WithResource, NamedRoutes)
83−import Servant.API.Generic (GenericMode(..), ToServant, ToServantApi, GServantProduct, toServant, fromServant)
84import Servant.API.ContentTypes
79import Servant.API.ContentTypes
85 (AcceptHeader (..), AllCTRender (..), AllCTUnrender (..),
80 (AcceptHeader (..), AllCTRender (..), AllCTUnrender (..),
86− AllMime, MimeRender (..), MimeUnrender (..), NoContent,
81+ AllMime, MimeRender (..), MimeUnrender (..), canHandleAcceptH)
88import Servant.API.Modifiers
82import Servant.API.Modifiers
89 (FoldLenient, FoldRequired, RequestArgument,
83 (FoldLenient, FoldRequired, RequestArgument,
90 unfoldRequestArgument)
84 unfoldRequestArgument)
91import Servant.API.ResponseHeaders
85import Servant.API.ResponseHeaders
92 (GetHeaders, Headers, getHeaders, getResponse)
86 (GetHeaders, Headers, getHeaders, getResponse)
93−import Servant.API.Status
95import qualified Servant.Types.SourceT as S
87import qualified Servant.Types.SourceT as S
96−import Servant.API.TypeErrors
97import Web.HttpApiData
88import Web.HttpApiData
98− (FromHttpApiData, parseHeader, parseQueryParam, parseUrlPiece,
89+ (FromHttpApiData, parseHeader, parseQueryParam,
99− parseUrlPieces)
90+ parseUrlPieceMaybe, parseUrlPieces, parseUrlPiece)
103import Servant.Server.Internal.BasicAuth
92import Servant.Server.Internal.BasicAuth
104import Servant.Server.Internal.Context
93import Servant.Server.Internal.Context
105import Servant.Server.Internal.Delayed
94import Servant.Server.Internal.Delayed
106import Servant.Server.Internal.DelayedIO
95import Servant.Server.Internal.DelayedIO
107−import Servant.Server.Internal.ErrorFormatter
108import Servant.Server.Internal.Handler
96import Servant.Server.Internal.Handler
109import Servant.Server.Internal.Router
97import Servant.Server.Internal.Router
110import Servant.Server.Internal.RouteResult
98import Servant.Server.Internal.RouteResult
111import Servant.Server.Internal.RoutingApplication
99import Servant.Server.Internal.RoutingApplication
112import Servant.Server.Internal.ServerError
100import Servant.Server.Internal.ServerError
102+#ifdef HAS_TYPE_ERROR
114import GHC.TypeLits
103import GHC.TypeLits
115 (ErrorMessage (..), TypeError)
104 (ErrorMessage (..), TypeError)
116−import Servant.API.TypeLevel
105+#endif
117− (AtLeastOneFragment, FragmentUnique)
119class HasServer api context where
107class HasServer api context where
120− -- | The type of a server for this API, given a monad to run effects in.
122− -- Note that the result kind is @*@, so it is /not/ a monad transformer, unlike
123− -- what the @T@ in the name might suggest.
124 type ServerT api (m :: * -> *) :: *
108 type ServerT api (m :: * -> *) :: *
@@ -182,10 +166,7 @@ instance (HasServer a context, HasServer b context) => HasServer (a :<|> b) cont
182-- > server = getBook
166-- > server = getBook
183-- > where getBook :: Text -> Handler Book
167-- > where getBook :: Text -> Handler Book
184-- > getBook isbn = ...
168-- > getBook isbn = ...
185−instance (KnownSymbol capture, FromHttpApiData a, Typeable a
186− , HasServer api context, SBoolI (FoldLenient mods)
169+instance (KnownSymbol capture, FromHttpApiData a, HasServer api context, SBoolI (FoldLenient mods))
187− , HasContextEntry (MkContextWithErrorFormatter context) ErrorFormatters
189 => HasServer (Capture' mods capture a :> api) context where
170 => HasServer (Capture' mods capture a :> api) context where
191 type ServerT (Capture' mods capture a :> api) m =
172 type ServerT (Capture' mods capture a :> api) m =
@@ -194,19 +175,15 @@ instance (KnownSymbol capture, FromHttpApiData a, Typeable a
194 hoistServerWithContext _ pc nt s = hoistServerWithContext (Proxy :: Proxy api) pc nt . s
175 hoistServerWithContext _ pc nt s = hoistServerWithContext (Proxy :: Proxy api) pc nt . s
196 route Proxy context d =
177 route Proxy context d =
197− CaptureRouter [hint] $
178+ CaptureRouter $
198 route (Proxy :: Proxy api)
179 route (Proxy :: Proxy api)
200− (addCapture d $ \ txt -> withRequest $ \ request ->
201− case ( sbool :: SBool (FoldLenient mods)
181+ (addCapture d $ \ txt -> case ( sbool :: SBool (FoldLenient mods)
202− , parseUrlPiece txt :: Either T.Text a) of
182+ , parseUrlPiece txt :: Either T.Text a) of
203− (SFalse, Left e) -> delayedFail $ formatError rep request $ cs e
183+ (SFalse, Left e) -> delayedFail err400 { errBody = cs e }
204− (SFalse, Right v) -> return v
184+ (SFalse, Right v) -> return v
205− (STrue, piece) -> return $ (either (Left . cs) Right) piece)
185+ (STrue, piece) -> return $ (either (Left . cs) Right) piece
207− rep = typeRep (Proxy :: Proxy Capture')
208− formatError = urlParseErrorFormatter $ getContextEntry (mkContextWithErrorFormatter context)
209− hint = CaptureHint (T.pack $ symbolVal $ Proxy @capture) (typeRep (Proxy :: Proxy a))
211-- | If you use 'CaptureAll' in one of the endpoints for your API,
188-- | If you use 'CaptureAll' in one of the endpoints for your API,
212-- this automatically requires your server-side handler to be a
189-- this automatically requires your server-side handler to be a
@@ -225,10 +202,7 @@ instance (KnownSymbol capture, FromHttpApiData a, Typeable a
225-- > server = getSourceFile
202-- > server = getSourceFile
226-- > where getSourceFile :: [Text] -> Handler Book
203-- > where getSourceFile :: [Text] -> Handler Book
227-- > getSourceFile pathSegments = ...
204-- > getSourceFile pathSegments = ...
228−instance (KnownSymbol capture, FromHttpApiData a, Typeable a
205+instance (KnownSymbol capture, FromHttpApiData a, HasServer api context)
229− , HasServer api context
230− , HasContextEntry (MkContextWithErrorFormatter context) ErrorFormatters
232 => HasServer (CaptureAll capture a :> api) context where
206 => HasServer (CaptureAll capture a :> api) context where
234 type ServerT (CaptureAll capture a :> api) m =
208 type ServerT (CaptureAll capture a :> api) m =
@@ -237,53 +211,13 @@ instance (KnownSymbol capture, FromHttpApiData a, Typeable a
237 hoistServerWithContext _ pc nt s = hoistServerWithContext (Proxy :: Proxy api) pc nt . s
211 hoistServerWithContext _ pc nt s = hoistServerWithContext (Proxy :: Proxy api) pc nt . s
239 route Proxy context d =
213 route Proxy context d =
240− CaptureAllRouter [hint] $
214+ CaptureAllRouter $
241 route (Proxy :: Proxy api)
215 route (Proxy :: Proxy api)
243− (addCapture d $ \ txts -> withRequest $ \ request ->
244− case parseUrlPieces txts of
217+ (addCapture d $ \ txts -> case parseUrlPieces txts of
245− Left e -> delayedFail $ formatError rep request $ cs e
218+ Left _ -> delayedFail err400
246− Right v -> return v
219+ Right v -> return v
249− rep = typeRep (Proxy :: Proxy CaptureAll)
250− formatError = urlParseErrorFormatter $ getContextEntry (mkContextWithErrorFormatter context)
251− hint = CaptureHint (T.pack $ symbolVal $ Proxy @capture) (typeRep (Proxy :: Proxy [a]))
253−-- | If you use 'WithResource' in one of the endpoints for your API Servant
254−-- will provide the handler for this endpoint an argument of the specified type.
255−-- The lifespan of this resource will be automatically managed by Servant. This
256−-- resource will be created before the handler starts and it will be destoyed
257−-- after it ends. A new resource is created for each request to the endpoint.
259−-- The creation and destruction are done using a 'Data.Acquire.Acquire'
260−-- provided via server 'Context'.
264−-- > type MyApi = WithResource Handle :> "writeToFile" :> Post '[JSON] NoContent
266−-- > server :: Server MyApi
267−-- > server = writeToFile
268−-- > where writeToFile :: (ReleaseKey, Handle) -> Handler NoContent
269−-- > writeToFile (_, h) = hPutStrLn h "message"
271−-- In addition to the resource, the handler will also receive a 'ReleaseKey'
272−-- which can be used to deallocate the resource before the end of the request
275−instance (HasServer api ctx, HasContextEntry ctx (Acquire a))
276− => HasServer (WithResource a :> api) ctx where
278− type ServerT (WithResource a :> api) m = (ReleaseKey, a) -> ServerT api m
280− hoistServerWithContext _ pc nt s = hoistServerWithContext (Proxy @api) pc nt . s
282− route Proxy context d = route (Proxy @api) context (d `addParameterCheck` allocateResource)
284− allocateResource :: DelayedIO (ReleaseKey, a)
285− allocateResource = DelayedIO $ lift $ allocateAcquire (getContextEntry context)
289allowedMethodHead :: Method -> Request -> Bool
223allowedMethodHead :: Method -> Request -> Bool
@@ -304,10 +238,10 @@ methodCheck method request
304-- body check is no longer an option. However, we now run the accept
238-- body check is no longer an option. However, we now run the accept
305-- check before the body check and can therefore afford to make it
239-- check before the body check and can therefore afford to make it
306-- recoverable.
240-- recoverable.
307−acceptCheck :: (AllMime list) => Proxy list -> AcceptHeader -> DelayedIO ()
241+acceptCheck :: (AllMime list) => Proxy list -> B.ByteString -> DelayedIO ()
308acceptCheck proxy accH
242acceptCheck proxy accH
309− | canHandleAcceptH proxy accH = return ()
243+ | canHandleAcceptH proxy (AcceptHeader accH) = return ()
310− | otherwise = delayedFail err406
244+ | otherwise = delayedFail err406
312methodRouter :: (AllCTRender ctypes a)
246methodRouter :: (AllCTRender ctypes a)
313 => (b -> ([(HeaderName, B.ByteString)], a))
247 => (b -> ([(HeaderName, B.ByteString)], a))
@@ -317,28 +251,17 @@ methodRouter :: (AllCTRender ctypes a)
317methodRouter splitHeaders method proxy status action = leafRouter route'
251methodRouter splitHeaders method proxy status action = leafRouter route'
319 route' env request respond =
253 route' env request respond =
320− let accH = getAcceptHeader request
254+ let accH = fromMaybe ct_wildcard $ lookup hAccept $ requestHeaders request
321 in runAction (action `addMethodCheck` methodCheck method request
255 in runAction (action `addMethodCheck` methodCheck method request
322 `addAcceptCheck` acceptCheck proxy accH
256 `addAcceptCheck` acceptCheck proxy accH
323 ) env request respond $ \ output -> do
257 ) env request respond $ \ output -> do
324 let (headers, b) = splitHeaders output
258 let (headers, b) = splitHeaders output
325− case handleAcceptH proxy accH b of
259+ case handleAcceptH proxy (AcceptHeader accH) b of
326 Nothing -> FailFatal err406 -- this should not happen (checked before), so we make it fatal if it does
260 Nothing -> FailFatal err406 -- this should not happen (checked before), so we make it fatal if it does
327 Just (contentT, body) ->
261 Just (contentT, body) ->
328 let bdy = if allowedMethodHead method request then "" else body
262 let bdy = if allowedMethodHead method request then "" else body
329 in Route $ responseLBS status ((hContentType, cs contentT) : headers) bdy
263 in Route $ responseLBS status ((hContentType, cs contentT) : headers) bdy
331−noContentRouter :: Method
333− -> Delayed env (Handler b)
335−noContentRouter method status action = leafRouter route'
337− route' env request respond =
338− runAction (action `addMethodCheck` methodCheck method request)
339− env request respond $ \ _output ->
340− Route $ responseLBS status [] ""
342instance {-# OVERLAPPABLE #-}
265instance {-# OVERLAPPABLE #-}
343 ( AllCTRender ctypes a, ReflectMethod method, KnownNat status
266 ( AllCTRender ctypes a, ReflectMethod method, KnownNat status
344 ) => HasServer (Verb method status ctypes a) context where
267 ) => HasServer (Verb method status ctypes a) context where
@@ -348,7 +271,7 @@ instance {-# OVERLAPPABLE #-}
349 route Proxy _ = methodRouter ([],) method (Proxy :: Proxy ctypes) status
272 route Proxy _ = methodRouter ([],) method (Proxy :: Proxy ctypes) status
350 where method = reflectMethod (Proxy :: Proxy method)
273 where method = reflectMethod (Proxy :: Proxy method)
351− status = statusFromNat (Proxy :: Proxy status)
274+ status = toEnum . fromInteger $ natVal (Proxy :: Proxy status)
353instance {-# OVERLAPPING #-}
276instance {-# OVERLAPPING #-}
354 ( AllCTRender ctypes a, ReflectMethod method, KnownNat status
277 ( AllCTRender ctypes a, ReflectMethod method, KnownNat status
@@ -360,16 +283,8 @@ instance {-# OVERLAPPING #-}
361 route Proxy _ = methodRouter (\x -> (getHeaders x, getResponse x)) method (Proxy :: Proxy ctypes) status
284 route Proxy _ = methodRouter (\x -> (getHeaders x, getResponse x)) method (Proxy :: Proxy ctypes) status
362 where method = reflectMethod (Proxy :: Proxy method)
285 where method = reflectMethod (Proxy :: Proxy method)
363− status = statusFromNat (Proxy :: Proxy status)
286+ status = toEnum . fromInteger $ natVal (Proxy :: Proxy status)
365−instance (ReflectMethod method) =>
366− HasServer (NoContentVerb method) context where
368− type ServerT (NoContentVerb method) m = m NoContent
369− hoistServerWithContext _ _ nt s = nt s
371− route Proxy _ = noContentRouter method status204
372− where method = reflectMethod (Proxy :: Proxy method)
374instance {-# OVERLAPPABLE #-}
289instance {-# OVERLAPPABLE #-}
375 ( MimeRender ctype chunk, ReflectMethod method, KnownNat status,
290 ( MimeRender ctype chunk, ReflectMethod method, KnownNat status,
@@ -381,7 +296,7 @@ instance {-# OVERLAPPABLE #-}
382 route Proxy _ = streamRouter ([],) method status (Proxy :: Proxy framing) (Proxy :: Proxy ctype)
297 route Proxy _ = streamRouter ([],) method status (Proxy :: Proxy framing) (Proxy :: Proxy ctype)
383 where method = reflectMethod (Proxy :: Proxy method)
298 where method = reflectMethod (Proxy :: Proxy method)
384− status = statusFromNat (Proxy :: Proxy status)
299+ status = toEnum . fromInteger $ natVal (Proxy :: Proxy status)
387instance {-# OVERLAPPING #-}
302instance {-# OVERLAPPING #-}
@@ -395,7 +310,7 @@ instance {-# OVERLAPPING #-}
396 route Proxy _ = streamRouter (\x -> (getHeaders x, getResponse x)) method status (Proxy :: Proxy framing) (Proxy :: Proxy ctype)
311 route Proxy _ = streamRouter (\x -> (getHeaders x, getResponse x)) method status (Proxy :: Proxy framing) (Proxy :: Proxy ctype)
397 where method = reflectMethod (Proxy :: Proxy method)
312 where method = reflectMethod (Proxy :: Proxy method)
398− status = statusFromNat (Proxy :: Proxy status)
313+ status = toEnum . fromInteger $ natVal (Proxy :: Proxy status)
401streamRouter :: forall ctype a c chunk env framing. (MimeRender ctype chunk, FramingRender framing, ToSourceIO chunk a) =>
316streamRouter :: forall ctype a c chunk env framing. (MimeRender ctype chunk, FramingRender framing, ToSourceIO chunk a) =>
@@ -407,7 +322,7 @@ streamRouter :: forall ctype a c chunk env framing. (MimeRender ctype chunk, Fra
407 -> Delayed env (Handler c)
322 -> Delayed env (Handler c)
408 -> Router env
323 -> Router env
409streamRouter splitHeaders method status framingproxy ctypeproxy action = leafRouter $ \env request respond ->
324streamRouter splitHeaders method status framingproxy ctypeproxy action = leafRouter $ \env request respond ->
410− let AcceptHeader accH = getAcceptHeader request
325+ let accH = fromMaybe ct_wildcard $ lookup hAccept $ requestHeaders request
411 cmediatype = NHM.matchAccept [contentType ctypeproxy] accH
326 cmediatype = NHM.matchAccept [contentType ctypeproxy] accH
412 accCheck = when (isNothing cmediatype) $ delayedFail err406
327 accCheck = when (isNothing cmediatype) $ delayedFail err406
413 contentHeader = (hContentType, NHM.renderHeader . maybeToList $ cmediatype)
328 contentHeader = (hContentType, NHM.renderHeader . maybeToList $ cmediatype)
@@ -452,7 +367,6 @@ streamRouter splitHeaders method status framingproxy ctypeproxy action = leafRou
453 (KnownSymbol sym, FromHttpApiData a, HasServer api context
368 (KnownSymbol sym, FromHttpApiData a, HasServer api context
454 , SBoolI (FoldRequired mods), SBoolI (FoldLenient mods)
369 , SBoolI (FoldRequired mods), SBoolI (FoldLenient mods)
455− , HasContextEntry (MkContextWithErrorFormatter context) ErrorFormatters
457 => HasServer (Header' mods sym a :> api) context where
371 => HasServer (Header' mods sym a :> api) context where
@@ -464,9 +378,6 @@ instance
464 route Proxy context subserver = route (Proxy :: Proxy api) context $
378 route Proxy context subserver = route (Proxy :: Proxy api) context $
465 subserver `addHeaderCheck` withRequest headerCheck
379 subserver `addHeaderCheck` withRequest headerCheck
467− rep = typeRep (Proxy :: Proxy Header')
468− formatError = headerParseErrorFormatter $ getContextEntry (mkContextWithErrorFormatter context)
470 headerName :: IsString n => n
381 headerName :: IsString n => n
471 headerName = fromString $ symbolVal (Proxy :: Proxy sym)
382 headerName = fromString $ symbolVal (Proxy :: Proxy sym)
@@ -477,13 +388,15 @@ instance
477 mev :: Maybe (Either T.Text a)
388 mev :: Maybe (Either T.Text a)
478 mev = fmap parseHeader $ lookup headerName (requestHeaders req)
389 mev = fmap parseHeader $ lookup headerName (requestHeaders req)
480− errReq = delayedFailFatal $ formatError rep req
391+ errReq = delayedFailFatal err400
481− $ "Header " <> headerName <> " is required"
392+ { errBody = "Header " <> headerName <> " is required"
483− errSt e = delayedFailFatal $ formatError rep req
395+ errSt e = delayedFailFatal err400
484− $ cs $ "Error parsing header "
396+ { errBody = cs $ "Error parsing header "
485− <> headerName
397+ <> headerName
486− <> " failed: " <> e
398+ <> " failed: " <> e
488-- | If you use @'QueryParam' "author" Text@ in one of the endpoints for your API,
401-- | If you use @'QueryParam' "author" Text@ in one of the endpoints for your API,
489-- this automatically requires your server-side handler to be a function
402-- this automatically requires your server-side handler to be a function
@@ -509,7 +422,6 @@ instance
510 ( KnownSymbol sym, FromHttpApiData a, HasServer api context
423 ( KnownSymbol sym, FromHttpApiData a, HasServer api context
511 , SBoolI (FoldRequired mods), SBoolI (FoldLenient mods)
424 , SBoolI (FoldRequired mods), SBoolI (FoldLenient mods)
512− , HasContextEntry (MkContextWithErrorFormatter context) ErrorFormatters
514 => HasServer (QueryParam' mods sym a :> api) context where
426 => HasServer (QueryParam' mods sym a :> api) context where
@@ -519,12 +431,9 @@ instance
519 hoistServerWithContext _ pc nt s = hoistServerWithContext (Proxy :: Proxy api) pc nt . s
431 hoistServerWithContext _ pc nt s = hoistServerWithContext (Proxy :: Proxy api) pc nt . s
521 route Proxy context subserver =
433 route Proxy context subserver =
522− let querytext = queryToQueryText . queryString
434+ let querytext req = parseQueryText $ rawQueryString req
523 paramname = cs $ symbolVal (Proxy :: Proxy sym)
435 paramname = cs $ symbolVal (Proxy :: Proxy sym)
525− rep = typeRep (Proxy :: Proxy QueryParam')
526− formatError = urlParseErrorFormatter $ getContextEntry (mkContextWithErrorFormatter context)
528 parseParam :: Request -> DelayedIO (RequestArgument mods a)
437 parseParam :: Request -> DelayedIO (RequestArgument mods a)
529 parseParam req =
438 parseParam req =
530 unfoldRequestArgument (Proxy :: Proxy mods) errReq errSt mev
439 unfoldRequestArgument (Proxy :: Proxy mods) errReq errSt mev
@@ -532,12 +441,14 @@ instance
532 mev :: Maybe (Either T.Text a)
441 mev :: Maybe (Either T.Text a)
533 mev = fmap parseQueryParam $ join $ lookup paramname $ querytext req
442 mev = fmap parseQueryParam $ join $ lookup paramname $ querytext req
535− errReq = delayedFailFatal $ formatError rep req
444+ errReq = delayedFailFatal err400
536− $ cs $ "Query parameter " <> paramname <> " is required"
445+ { errBody = cs $ "Query parameter " <> paramname <> " is required"
538− errSt e = delayedFailFatal $ formatError rep req
448+ errSt e = delayedFailFatal err400
539− $ cs $ "Error parsing query parameter "
449+ { errBody = cs $ "Error parsing query parameter "
540− <> paramname <> " failed: " <> e
450+ <> paramname <> " failed: " <> e
542 delayed = addParameterCheck subserver . withRequest $ \req ->
453 delayed = addParameterCheck subserver . withRequest $ \req ->
543 parseParam req
454 parseParam req
@@ -563,8 +474,7 @@ instance
563-- > server = getBooksBy
474-- > server = getBooksBy
564-- > where getBooksBy :: [Text] -> Handler [Book]
475-- > where getBooksBy :: [Text] -> Handler [Book]
565-- > getBooksBy authors = ...return all books by these authors...
476-- > getBooksBy authors = ...return all books by these authors...
566−instance (KnownSymbol sym, FromHttpApiData a, HasServer api context
477+instance (KnownSymbol sym, FromHttpApiData a, HasServer api context)
567− , HasContextEntry (MkContextWithErrorFormatter context) ErrorFormatters)
568 => HasServer (QueryParams sym a :> api) context where
478 => HasServer (QueryParams sym a :> api) context where
570 type ServerT (QueryParams sym a :> api) m =
480 type ServerT (QueryParams sym a :> api) m =
@@ -575,23 +485,21 @@ instance (KnownSymbol sym, FromHttpApiData a, HasServer api context
575 route Proxy context subserver = route (Proxy :: Proxy api) context $
485 route Proxy context subserver = route (Proxy :: Proxy api) context $
576 subserver `addParameterCheck` withRequest paramsCheck
486 subserver `addParameterCheck` withRequest paramsCheck
578− rep = typeRep (Proxy :: Proxy QueryParams)
579− formatError = urlParseErrorFormatter $ getContextEntry (mkContextWithErrorFormatter context)
581 paramname = cs $ symbolVal (Proxy :: Proxy sym)
488 paramname = cs $ symbolVal (Proxy :: Proxy sym)
582 paramsCheck req =
489 paramsCheck req =
583 case partitionEithers $ fmap parseQueryParam params of
490 case partitionEithers $ fmap parseQueryParam params of
584 ([], parsed) -> return parsed
491 ([], parsed) -> return parsed
585− (errs, _) -> delayedFailFatal $ formatError rep req
492+ (errs, _) -> delayedFailFatal err400
586− $ cs $ "Error parsing query parameter(s) "
493+ { errBody = cs $ "Error parsing query parameter(s) "
587− <> paramname <> " failed: "
494+ <> paramname <> " failed: "
588− <> T.intercalate ", " errs
495+ <> T.intercalate ", " errs
590 params :: [T.Text]
498 params :: [T.Text]
591 params = mapMaybe snd
499 params = mapMaybe snd
592 . filter (looksLikeParam . fst)
500 . filter (looksLikeParam . fst)
593− . queryToQueryText
501+ . parseQueryText
594− . queryString
502+ . rawQueryString
597 looksLikeParam name = name == paramname || name == (paramname <> "[]")
505 looksLikeParam name = name == paramname || name == (paramname <> "[]")
@@ -617,7 +525,7 @@ instance (KnownSymbol sym, HasServer api context)
617 hoistServerWithContext _ pc nt s = hoistServerWithContext (Proxy :: Proxy api) pc nt . s
525 hoistServerWithContext _ pc nt s = hoistServerWithContext (Proxy :: Proxy api) pc nt . s
619 route Proxy context subserver =
527 route Proxy context subserver =
620− let querytext = queryToQueryText . queryString
528+ let querytext r = parseQueryText $ rawQueryString r
621 param r = case lookup paramname (querytext r) of
529 param r = case lookup paramname (querytext r) of
622 Just Nothing -> True -- param is there, with no value
530 Just Nothing -> True -- param is there, with no value
623 Just (Just v) -> examine v -- param with a value
531 Just (Just v) -> examine v -- param with a value
@@ -653,42 +561,13 @@ instance HasServer Raw context where
653 Fail a -> respond $ Fail a
561 Fail a -> respond $ Fail a
654 FailFatal e -> respond $ FailFatal e
562 FailFatal e -> respond $ FailFatal e
656−-- | Just pass the request to the underlying application and serve its response.
660−-- > type MyApi = "images" :> Raw
662−-- > server :: Server MyApi
663−-- > server = serveDirectory "/var/www/images"
664−instance HasServer RawM context where
665− type ServerT RawM m = Request -> (Response -> IO ResponseReceived) -> m ResponseReceived
670− -> Delayed env (Request -> (Response -> IO ResponseReceived) -> Handler ResponseReceived) -> Router env
671− route _ _ handleDelayed = RawRouter $ \env request respond -> runResourceT $ do
672− routeResult <- runDelayed handleDelayed env request
673− let respond' = liftIO . respond
674− liftIO $ case routeResult of
675− Route handler -> runHandler (handler request (respond . Route)) >>=
677− Left e -> respond' $ FailFatal e
679− Fail e -> respond' $ Fail e
680− FailFatal e -> respond' $ FailFatal e
682− hoistServerWithContext _ _ f srvM = \req respond -> f (srvM req respond)
685-- | If you use 'ReqBody' in one of the endpoints for your API,
564-- | If you use 'ReqBody' in one of the endpoints for your API,
686-- this automatically requires your server-side handler to be a function
565-- this automatically requires your server-side handler to be a function
687-- that takes an argument of the type specified by 'ReqBody'.
566-- that takes an argument of the type specified by 'ReqBody'.
688-- The @Content-Type@ header is inspected, and the list provided is used to
567-- The @Content-Type@ header is inspected, and the list provided is used to
689-- attempt deserialization. If the request does not have a @Content-Type@
568-- attempt deserialization. If the request does not have a @Content-Type@
690-- header, it is treated as @application/octet-stream@ (as specified in
569-- header, it is treated as @application/octet-stream@ (as specified in
691−-- [RFC 7231 section 3.1.1.5](http://tools.ietf.org/html/rfc7231#section-3.1.1.5)).
570+-- <http://tools.ietf.org/html/rfc7231#section-3.1.1.5 RFC7231>.
692-- This lets servant worry about extracting it from the request and turning
571-- This lets servant worry about extracting it from the request and turning
693-- it into a value of the type you specify.
572-- it into a value of the type you specify.
@@ -704,7 +583,6 @@ instance HasServer RawM context where
704-- > where postBook :: Book -> Handler Book
583-- > where postBook :: Book -> Handler Book
705-- > postBook book = ...insert into your db...
584-- > postBook book = ...insert into your db...
706instance ( AllCTUnrender list a, HasServer api context, SBoolI (FoldLenient mods)
585instance ( AllCTUnrender list a, HasServer api context, SBoolI (FoldLenient mods)
707− , HasContextEntry (MkContextWithErrorFormatter context) ErrorFormatters
708 ) => HasServer (ReqBody' mods list a :> api) context where
586 ) => HasServer (ReqBody' mods list a :> api) context where
710 type ServerT (ReqBody' mods list a :> api) m =
588 type ServerT (ReqBody' mods list a :> api) m =
@@ -716,9 +594,6 @@ instance ( AllCTUnrender list a, HasServer api context, SBoolI (FoldLenient mods
716 = route (Proxy :: Proxy api) context $
594 = route (Proxy :: Proxy api) context $
717 addBodyCheck subserver ctCheck bodyCheck
595 addBodyCheck subserver ctCheck bodyCheck
719− rep = typeRep (Proxy :: Proxy ReqBody')
720− formatError = bodyParserErrorFormatter $ getContextEntry (mkContextWithErrorFormatter context)
722 -- Content-Type check, we only lookup we can try to parse the request body
597 -- Content-Type check, we only lookup we can try to parse the request body
723 ctCheck = withRequest $ \ request -> do
598 ctCheck = withRequest $ \ request -> do
724 -- See HTTP RFC 2616, section 7.2.1
599 -- See HTTP RFC 2616, section 7.2.1
@@ -737,7 +612,7 @@ instance ( AllCTUnrender list a, HasServer api context, SBoolI (FoldLenient mods
737 case sbool :: SBool (FoldLenient mods) of
612 case sbool :: SBool (FoldLenient mods) of
738 STrue -> return mrqbody
613 STrue -> return mrqbody
739 SFalse -> case mrqbody of
614 SFalse -> case mrqbody of
740− Left e -> delayedFailFatal $ formatError rep request e
615+ Left e -> delayedFailFatal err400 { errBody = cs e }
741 Right v -> return v
616 Right v -> return v
@@ -760,7 +635,7 @@ instance
760 bodyCheck fromRS = withRequest $ \req -> do
635 bodyCheck fromRS = withRequest $ \req -> do
761 let mimeUnrender' = mimeUnrender (Proxy :: Proxy ctype) :: BL.ByteString -> Either String chunk
636 let mimeUnrender' = mimeUnrender (Proxy :: Proxy ctype) :: BL.ByteString -> Either String chunk
762 let framingUnrender' = framingUnrender (Proxy :: Proxy framing) mimeUnrender' :: SourceIO B.ByteString -> SourceIO chunk
637 let framingUnrender' = framingUnrender (Proxy :: Proxy framing) mimeUnrender' :: SourceIO B.ByteString -> SourceIO chunk
763− let body = getRequestBodyChunk req
638+ let body = requestBody req
764 let rs = S.fromAction B.null body
639 let rs = S.fromAction B.null body
765 let rs' = fromRS $ framingUnrender' rs
640 let rs' = fromRS $ framingUnrender' rs
766 return rs'
641 return rs'
@@ -829,12 +704,12 @@ data EmptyServer = EmptyServer deriving (Typeable, Eq, Show, Bounded, Enum)
829emptyServer :: ServerT EmptyAPI m
704emptyServer :: ServerT EmptyAPI m
830emptyServer = Tagged EmptyServer
705emptyServer = Tagged EmptyServer
832−-- | The server for an `EmptyAPI` is `emptyServer`.
707+-- | The server for an `EmptyAPI` is `emptyAPIServer`.
834-- > type MyApi = "nothing" :> EmptyApi
709-- > type MyApi = "nothing" :> EmptyApi
836-- > server :: Server MyApi
711-- > server :: Server MyApi
837−-- > server = emptyServer
712+-- > server = emptyAPIServer
838instance HasServer EmptyAPI context where
713instance HasServer EmptyAPI context where
839 type ServerT EmptyAPI m = Tagged m EmptyServer
714 type ServerT EmptyAPI m = Tagged m EmptyServer
@@ -863,10 +738,7 @@ instance ( KnownSymbol realm
863-- * helpers
738-- * helpers
865ct_wildcard :: B.ByteString
740ct_wildcard :: B.ByteString
866−ct_wildcard = "*" <> "/" <> "*"
741+ct_wildcard = "*" <> "/" <> "*" -- Because CPP
868−getAcceptHeader :: Request -> AcceptHeader
869−getAcceptHeader = AcceptHeader . fromMaybe ct_wildcard . lookup hAccept . requestHeaders
871-- * General Authentication
743-- * General Authentication
@@ -891,19 +763,39 @@ instance (HasContextEntry context (NamedContext name subContext), HasServer subA
891 hoistServerWithContext _ _ nt s = hoistServerWithContext (Proxy :: Proxy subApi) (Proxy :: Proxy subContext) nt s
763 hoistServerWithContext _ _ nt s = hoistServerWithContext (Proxy :: Proxy subApi) (Proxy :: Proxy subContext) nt s
893-------------------------------------------------------------------------------
765-------------------------------------------------------------------------------
894−-- Custom type errors
766+-- TypeError helpers
895-------------------------------------------------------------------------------
767-------------------------------------------------------------------------------
897−-- Erroring instance for 'HasServer' when a combinator is not fully applied
769+#ifdef HAS_TYPE_ERROR
898−instance TypeError (PartialApplication
770+-- | This instance catches mistakes when there are non-saturated
899−#if __GLASGOW_HASKELL__ >= 904
771+-- type applications on LHS of ':>'.
900− @(Type -> [Type] -> Constraint)
772+--
901−#endif
773+-- >>> serve (Proxy :: Proxy (Capture "foo" :> Get '[JSON] Int)) (error "...")
775+-- ...Expected something of kind Symbol or *, got: k -> l on the LHS of ':>'.
776+-- ...Maybe you haven't applied enough arguments to
777+-- ...Capture' '[] "foo"
780+-- >>> undefined :: Server (Capture "foo" :> Get '[JSON] Int)
782+-- ...Expected something of kind Symbol or *, got: k -> l on the LHS of ':>'.
783+-- ...Maybe you haven't applied enough arguments to
784+-- ...Capture' '[] "foo"
902− HasServer arr) => HasServer ((arr :: a -> b) :> sub) context
787+instance TypeError (HasServerArrowKindError arr) => HasServer ((arr :: k -> l) :> api) context
904− type ServerT (arr :> sub) _ = TypeError (PartialApplication (HasServer :: * -> [*] -> Constraint) arr)
789+ type ServerT (arr :> api) m = TypeError (HasServerArrowKindError arr)
905− route = error "unreachable"
790+ -- it doens't really matter what sub route we peak
791+ route _ _ _ = error "servant-server panic: impossible happened in HasServer (arr :> api)"
906− hoistServerWithContext _ _ _ _ = error "unreachable"
792+ hoistServerWithContext _ _ _ = id
794+-- Cannot have TypeError here, otherwise use of this symbol will error :)
795+type HasServerArrowKindError arr =
796+ 'Text "Expected something of kind Symbol or *, got: k -> l on the LHS of ':>'."
797+ ':$$: 'Text "Maybe you haven't applied enough arguments to"
908-- | This instance prevents from accidentally using '->' instead of ':>'
800-- | This instance prevents from accidentally using '->' instead of ':>'
@@ -937,107 +829,7 @@ type HasServerArrowTypeError a b =
937 ':$$: 'ShowType a
829 ':$$: 'ShowType a
938 ':$$: 'Text "and"
830 ':$$: 'Text "and"
939 ':$$: 'ShowType b
831 ':$$: 'ShowType b
941−-- Erroring instances for 'HasServer' for unknown API combinators
943−-- XXX: This omits the @context@ parameter, e.g.:
945−-- "There is no instance for HasServer (Bool :> …)". Do we care ?
946−instance {-# OVERLAPPABLE #-} TypeError (NoInstanceForSub
947−#if __GLASGOW_HASKELL__ >= 904
948− @(Type -> [Type] -> Constraint)
950− HasServer ty) => HasServer (ty :> sub) context
952−instance {-# OVERLAPPABLE #-} TypeError (NoInstanceFor (HasServer api context)) => HasServer api context
954−-- | Ignore @'Fragment'@ in server handlers.
955−-- See <https://ietf.org/rfc/rfc2616.html#section-15.1.3> for more details.
959−-- > type MyApi = "books" :> Fragment Text :> Get '[JSON] [Book]
961−-- > server :: Server MyApi
962−-- > server = getBooks
963−-- > where getBooks :: Handler [Book]
964−-- > getBooks = ...return all books...
965−instance (AtLeastOneFragment api, FragmentUnique (Fragment a1 :> api), HasServer api context)
966− => HasServer (Fragment a1 :> api) context where
967− type ServerT (Fragment a1 :> api) m = ServerT api m
969− route _ = route (Proxy :: Proxy api)
971− hoistServerWithContext _ = hoistServerWithContext (Proxy :: Proxy api)
974-- >>> import Servant
835-- >>> import Servant
976−-- | A type that specifies that an API record contains a server implementation.
977−data AsServerT (m :: * -> *)
978−instance GenericMode (AsServerT m) where
979− type AsServerT m :- api = ServerT api m
981−type AsServer = AsServerT Handler
984−-- | Set of constraints required to convert to / from vanilla server types.
985−type GServerConstraints api m =
986− ( ToServant api (AsServerT m) ~ ServerT (ToServantApi api) m
987− , GServantProduct (Rep (api (AsServerT m)))
990−-- | This class is a necessary evil: in the implementation of 'HasServer' for
991−-- @'NamedRoutes' api@, we essentially need the quantified constraint @forall
992−-- m. 'GServerConstraints' m@ to hold.
994−-- We cannot require do that directly as the definition of 'GServerConstraints'
995−-- contains type family applications ('Rep' and 'ServerT'). The trick is to hide
996−-- those type family applications behind a typeclass providing evidence for
997−-- @'GServerConstraints' api m@ in the form of a dictionary, and require that
998−-- @forall m. 'GServer' api m@ instead.
1000−-- Users shouldn't have to worry about this class, as the only possible instance
1001−-- is provided in this module for all record APIs.
1003−class GServer (api :: * -> *) (m :: * -> *) where
1004− gServerProof :: Dict (GServerConstraints api m)
1007− ( ToServant api (AsServerT m) ~ ServerT (ToServantApi api) m
1008− , GServantProduct (Rep (api (AsServerT m)))
1009− ) => GServer api m where
1010− gServerProof = Dict
1013− ( HasServer (ToServantApi api) context
1014− , forall m. Generic (api (AsServerT m))
1015− , forall m. GServer api m
1016− ) => HasServer (NamedRoutes api) context where
1018− type ServerT (NamedRoutes api) m = api (AsServerT m)
1021− :: Proxy (NamedRoutes api)
1023− -> Delayed env (api (AsServerT Handler))
1025− route _ ctx delayed =
1026− case gServerProof @api @Handler of
1027− Dict -> route (Proxy @(ToServantApi api)) ctx (toServant <$> delayed)
1029− hoistServerWithContext
1030− :: forall m n. Proxy (NamedRoutes api)
1032− -> (forall x. m x -> n x)
1033− -> api (AsServerT m)
1034− -> api (AsServerT n)
1035− hoistServerWithContext _ pctx nat server =
1036− case (gServerProof @api @m, gServerProof @api @n) of
1038− fromServant servantSrvN
1040− servantSrvM :: ServerT (ToServantApi api) m =
1042− servantSrvN :: ServerT (ToServantApi api) n =
1043− hoistServerWithContext (Proxy @(ToServantApi api)) pctx nat servantSrvM