@@ -1,29 +1,31 @@
1−{-# LANGUAGE CPP #-}
1+{-# LANGUAGE AllowAmbiguousTypes #-}
22{-# LANGUAGE ConstraintKinds #-}
3+{-# LANGUAGE CPP #-}
34{-# LANGUAGE DataKinds #-}
45{-# LANGUAGE DeriveDataTypeable #-}
56{-# LANGUAGE FlexibleContexts #-}
67{-# LANGUAGE FlexibleInstances #-}
8+{-# LANGUAGE InstanceSigs #-}
9+{-# LANGUAGE LambdaCase #-}
710{-# LANGUAGE MultiParamTypeClasses #-}
811{-# LANGUAGE OverloadedStrings #-}
912{-# LANGUAGE PolyKinds #-}
13+{-# LANGUAGE QuantifiedConstraints #-}
1014{-# LANGUAGE RankNTypes #-}
1115{-# LANGUAGE ScopedTypeVariables #-}
1216{-# LANGUAGE TupleSections #-}
17+{-# LANGUAGE TypeApplications #-}
1318{-# LANGUAGE TypeFamilies #-}
1419{-# LANGUAGE TypeOperators #-}
1520{-# LANGUAGE UndecidableInstances #-}
1621
17−#if MIN_VERSION_base(4,9,0) && __GLASGOW_HASKELL__ >= 802
18−#define HAS_TYPE_ERROR
19−#endif
20−
2122module Servant.Server.Internal
2223 ( module Servant.Server.Internal
2324 , module Servant.Server.Internal.BasicAuth
2425 , module Servant.Server.Internal.Context
2526 , module Servant.Server.Internal.Delayed
2627 , module Servant.Server.Internal.DelayedIO
28+ , module Servant.Server.Internal.ErrorFormatter
2729 , module Servant.Server.Internal.Handler
2830 , module Servant.Server.Internal.Router
2931 , module Servant.Server.Internal.RouteResult
@@ -34,19 +36,19 @@ module Servant.Server.Internal
3436import Control.Monad
3537 (join, when)
3638import Control.Monad.Trans
37− (liftIO)
39+ (liftIO, lift)
3840import Control.Monad.Trans.Resource
39− (runResourceT)
41+ (runResourceT, ReleaseKey)
42+import Data.Acquire
4043import qualified Data.ByteString as B
4144import qualified Data.ByteString.Builder as BB
4245import qualified Data.ByteString.Char8 as BC8
4346import qualified Data.ByteString.Lazy as BL
47+import Data.Constraint (Constraint, Dict(..))
4448import Data.Either
4549 (partitionEithers)
4650import Data.Maybe
4751 (fromMaybe, isNothing, mapMaybe, maybeToList)
48−import Data.Semigroup
49− ((<>))
5052import Data.String
5153 (IsString (..))
5254import Data.String.Conversions
@@ -55,58 +57,70 @@ import Data.Tagged
5557 (Tagged (..), retag, untag)
5658import qualified Data.Text as T
5759import Data.Typeable
60+import GHC.Generics
5861import GHC.TypeLits
59− (KnownNat, KnownSymbol, natVal, symbolVal)
62+ (KnownNat, KnownSymbol, TypeError, symbolVal)
6063import qualified Network.HTTP.Media as NHM
6164import Network.HTTP.Types hiding
6265 (Header, ResponseHeaders)
6366import Network.Socket
6467 (SockAddr)
6568import Network.Wai
66− (Application, Request, httpVersion, isSecure, lazyRequestBody,
67− rawQueryString, remoteHost, requestBody, requestHeaders,
69+ (Application, Request, Response, ResponseReceived, httpVersion, isSecure, lazyRequestBody,
70+ queryString, remoteHost, getRequestBodyChunk, requestHeaders,
6871 requestMethod, responseLBS, responseStream, vault)
6972import Prelude ()
7073import Prelude.Compat
7174import Servant.API
7275 ((:<|>) (..), (:>), Accept (..), BasicAuth, Capture',
73− CaptureAll, Description, EmptyAPI, FramingRender (..),
74− FramingUnrender (..), FromSourceIO (..), Header', If,
75− IsSecure (..), QueryFlag, QueryParam', QueryParams, Raw,
76− ReflectMethod (reflectMethod), RemoteHost, ReqBody',
77− SBool (..), SBoolI (..), SourceIO, Stream, StreamBody',
78− Summary, ToSourceIO (..), Vault, Verb, NoContentVerb,
79− WithNamedContext)
76+ CaptureAll, Description, EmptyAPI, Fragment,
77+ FramingRender (..), FramingUnrender (..), FromSourceIO (..),
78+ Header', If, IsSecure (..), NoContentVerb, QueryFlag,
79+ QueryParam', QueryParams, Raw, RawM, ReflectMethod (reflectMethod),
80+ RemoteHost, ReqBody', SBool (..), SBoolI (..), SourceIO,
81+ Stream, StreamBody', Summary, ToSourceIO (..), Vault, Verb,
82+ WithNamedContext, WithResource, NamedRoutes)
83+import Servant.API.Generic (GenericMode(..), ToServant, ToServantApi, GServantProduct, toServant, fromServant)
8084import Servant.API.ContentTypes
8185 (AcceptHeader (..), AllCTRender (..), AllCTUnrender (..),
82− AllMime, MimeRender (..), MimeUnrender (..), canHandleAcceptH,
83− NoContent (NoContent))
86+ AllMime, MimeRender (..), MimeUnrender (..), NoContent,
87+ canHandleAcceptH)
8488import Servant.API.Modifiers
8589 (FoldLenient, FoldRequired, RequestArgument,
8690 unfoldRequestArgument)
8791import Servant.API.ResponseHeaders
8892 (GetHeaders, Headers, getHeaders, getResponse)
93+import Servant.API.Status
94+ (statusFromNat)
8995import qualified Servant.Types.SourceT as S
96+import Servant.API.TypeErrors
9097import Web.HttpApiData
91− (FromHttpApiData, parseHeader, parseQueryParam,
92− parseUrlPieceMaybe, parseUrlPieces, parseUrlPiece)
98+ (FromHttpApiData, parseHeader, parseQueryParam, parseUrlPiece,
99+ parseUrlPieces)
100+import Data.Kind
101+ (Type)
93102
94103import Servant.Server.Internal.BasicAuth
95104import Servant.Server.Internal.Context
96105import Servant.Server.Internal.Delayed
97106import Servant.Server.Internal.DelayedIO
107+import Servant.Server.Internal.ErrorFormatter
98108import Servant.Server.Internal.Handler
99109import Servant.Server.Internal.Router
100110import Servant.Server.Internal.RouteResult
101111import Servant.Server.Internal.RoutingApplication
102112import Servant.Server.Internal.ServerError
103113
104−#ifdef HAS_TYPE_ERROR
105114import GHC.TypeLits
106115 (ErrorMessage (..), TypeError)
107−#endif
116+import Servant.API.TypeLevel
117+ (AtLeastOneFragment, FragmentUnique)
108118
109119class HasServer api context where
120+ -- | The type of a server for this API, given a monad to run effects in.
121+ --
122+ -- Note that the result kind is @*@, so it is /not/ a monad transformer, unlike
123+ -- what the @T@ in the name might suggest.
110124 type ServerT api (m :: * -> *) :: *
111125
112126 route ::
@@ -168,7 +182,10 @@ instance (HasServer a context, HasServer b context) => HasServer (a :<|> b) cont
168182-- > server = getBook
169183-- > where getBook :: Text -> Handler Book
170184-- > getBook isbn = ...
171−instance (KnownSymbol capture, FromHttpApiData a, HasServer api context, SBoolI (FoldLenient mods))
185+instance (KnownSymbol capture, FromHttpApiData a, Typeable a
186+ , HasServer api context, SBoolI (FoldLenient mods)
187+ , HasContextEntry (MkContextWithErrorFormatter context) ErrorFormatters
188+ )
172189 => HasServer (Capture' mods capture a :> api) context where
173190
174191 type ServerT (Capture' mods capture a :> api) m =
@@ -177,15 +194,19 @@ instance (KnownSymbol capture, FromHttpApiData a, HasServer api context, SBoolI
177194 hoistServerWithContext _ pc nt s = hoistServerWithContext (Proxy :: Proxy api) pc nt . s
178195
179196 route Proxy context d =
180− CaptureRouter $
197+ CaptureRouter [hint] $
181198 route (Proxy :: Proxy api)
182199 context
183− (addCapture d $ \ txt -> case ( sbool :: SBool (FoldLenient mods)
184− , parseUrlPiece txt :: Either T.Text a) of
185− (SFalse, Left e) -> delayedFail err400 { errBody = cs e }
186− (SFalse, Right v) -> return v
187− (STrue, piece) -> return $ (either (Left . cs) Right) piece
188− )
200+ (addCapture d $ \ txt -> withRequest $ \ request ->
201+ case ( sbool :: SBool (FoldLenient mods)
202+ , parseUrlPiece txt :: Either T.Text a) of
203+ (SFalse, Left e) -> delayedFail $ formatError rep request $ cs e
204+ (SFalse, Right v) -> return v
205+ (STrue, piece) -> return $ (either (Left . cs) Right) piece)
206+ where
207+ rep = typeRep (Proxy :: Proxy Capture')
208+ formatError = urlParseErrorFormatter $ getContextEntry (mkContextWithErrorFormatter context)
209+ hint = CaptureHint (T.pack $ symbolVal $ Proxy @capture) (typeRep (Proxy :: Proxy a))
189210
190211-- | If you use 'CaptureAll' in one of the endpoints for your API,
191212-- this automatically requires your server-side handler to be a
@@ -204,7 +225,10 @@ instance (KnownSymbol capture, FromHttpApiData a, HasServer api context, SBoolI
204225-- > server = getSourceFile
205226-- > where getSourceFile :: [Text] -> Handler Book
206227-- > getSourceFile pathSegments = ...
207−instance (KnownSymbol capture, FromHttpApiData a, HasServer api context)
228+instance (KnownSymbol capture, FromHttpApiData a, Typeable a
229+ , HasServer api context
230+ , HasContextEntry (MkContextWithErrorFormatter context) ErrorFormatters
231+ )
208232 => HasServer (CaptureAll capture a :> api) context where
209233
210234 type ServerT (CaptureAll capture a :> api) m =
@@ -213,13 +237,53 @@ instance (KnownSymbol capture, FromHttpApiData a, HasServer api context)
213237 hoistServerWithContext _ pc nt s = hoistServerWithContext (Proxy :: Proxy api) pc nt . s
214238
215239 route Proxy context d =
216− CaptureAllRouter $
240+ CaptureAllRouter [hint] $
217241 route (Proxy :: Proxy api)
218242 context
219− (addCapture d $ \ txts -> case parseUrlPieces txts of
220− Left _ -> delayedFail err400
221− Right v -> return v
243+ (addCapture d $ \ txts -> withRequest $ \ request ->
244+ case parseUrlPieces txts of
245+ Left e -> delayedFail $ formatError rep request $ cs e
246+ Right v -> return v
222247 )
248+ where
249+ rep = typeRep (Proxy :: Proxy CaptureAll)
250+ formatError = urlParseErrorFormatter $ getContextEntry (mkContextWithErrorFormatter context)
251+ hint = CaptureHint (T.pack $ symbolVal $ Proxy @capture) (typeRep (Proxy :: Proxy [a]))
252+
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.
258+
259+-- The creation and destruction are done using a 'Data.Acquire.Acquire'
260+-- provided via server 'Context'.
261+--
262+-- Example
263+--
264+-- > type MyApi = WithResource Handle :> "writeToFile" :> Post '[JSON] NoContent
265+-- >
266+-- > server :: Server MyApi
267+-- > server = writeToFile
268+-- > where writeToFile :: (ReleaseKey, Handle) -> Handler NoContent
269+-- > writeToFile (_, h) = hPutStrLn h "message"
270+--
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
273+-- if desired.
274+
275+instance (HasServer api ctx, HasContextEntry ctx (Acquire a))
276+ => HasServer (WithResource a :> api) ctx where
277+
278+ type ServerT (WithResource a :> api) m = (ReleaseKey, a) -> ServerT api m
279+
280+ hoistServerWithContext _ pc nt s = hoistServerWithContext (Proxy @api) pc nt . s
281+
282+ route Proxy context d = route (Proxy @api) context (d `addParameterCheck` allocateResource)
283+ where
284+ allocateResource :: DelayedIO (ReleaseKey, a)
285+ allocateResource = DelayedIO $ lift $ allocateAcquire (getContextEntry context)
286+
223287
224288
225289allowedMethodHead :: Method -> Request -> Bool
@@ -240,10 +304,10 @@ methodCheck method request
240304-- body check is no longer an option. However, we now run the accept
241305-- check before the body check and can therefore afford to make it
242306-- recoverable.
243−acceptCheck :: (AllMime list) => Proxy list -> B.ByteString -> DelayedIO ()
307+acceptCheck :: (AllMime list) => Proxy list -> AcceptHeader -> DelayedIO ()
244308acceptCheck proxy accH
245− | canHandleAcceptH proxy (AcceptHeader accH) = return ()
246− | otherwise = delayedFail err406
309+ | canHandleAcceptH proxy accH = return ()
310+ | otherwise = delayedFail err406
247311
248312methodRouter :: (AllCTRender ctypes a)
249313 => (b -> ([(HeaderName, B.ByteString)], a))
@@ -253,12 +317,12 @@ methodRouter :: (AllCTRender ctypes a)
253317methodRouter splitHeaders method proxy status action = leafRouter route'
254318 where
255319 route' env request respond =
256− let accH = fromMaybe ct_wildcard $ lookup hAccept $ requestHeaders request
320+ let accH = getAcceptHeader request
257321 in runAction (action `addMethodCheck` methodCheck method request
258322 `addAcceptCheck` acceptCheck proxy accH
259323 ) env request respond $ \ output -> do
260324 let (headers, b) = splitHeaders output
261− case handleAcceptH proxy (AcceptHeader accH) b of
325+ case handleAcceptH proxy accH b of
262326 Nothing -> FailFatal err406 -- this should not happen (checked before), so we make it fatal if it does
263327 Just (contentT, body) ->
264328 let bdy = if allowedMethodHead method request then "" else body
@@ -272,7 +336,7 @@ noContentRouter method status action = leafRouter route'
272336 where
273337 route' env request respond =
274338 runAction (action `addMethodCheck` methodCheck method request)
275− env request respond $ \ output ->
339+ env request respond $ \ _output ->
276340 Route $ responseLBS status [] ""
277341
278342instance {-# OVERLAPPABLE #-}
@@ -284,7 +348,7 @@ instance {-# OVERLAPPABLE #-}
284348
285349 route Proxy _ = methodRouter ([],) method (Proxy :: Proxy ctypes) status
286350 where method = reflectMethod (Proxy :: Proxy method)
287− status = toEnum . fromInteger $ natVal (Proxy :: Proxy status)
351+ status = statusFromNat (Proxy :: Proxy status)
288352
289353instance {-# OVERLAPPING #-}
290354 ( AllCTRender ctypes a, ReflectMethod method, KnownNat status
@@ -296,7 +360,7 @@ instance {-# OVERLAPPING #-}
296360
297361 route Proxy _ = methodRouter (\x -> (getHeaders x, getResponse x)) method (Proxy :: Proxy ctypes) status
298362 where method = reflectMethod (Proxy :: Proxy method)
299− status = toEnum . fromInteger $ natVal (Proxy :: Proxy status)
363+ status = statusFromNat (Proxy :: Proxy status)
300364
301365instance (ReflectMethod method) =>
302366 HasServer (NoContentVerb method) context where
@@ -317,7 +381,7 @@ instance {-# OVERLAPPABLE #-}
317381
318382 route Proxy _ = streamRouter ([],) method status (Proxy :: Proxy framing) (Proxy :: Proxy ctype)
319383 where method = reflectMethod (Proxy :: Proxy method)
320− status = toEnum . fromInteger $ natVal (Proxy :: Proxy status)
384+ status = statusFromNat (Proxy :: Proxy status)
321385
322386
323387instance {-# OVERLAPPING #-}
@@ -331,7 +395,7 @@ instance {-# OVERLAPPING #-}
331395
332396 route Proxy _ = streamRouter (\x -> (getHeaders x, getResponse x)) method status (Proxy :: Proxy framing) (Proxy :: Proxy ctype)
333397 where method = reflectMethod (Proxy :: Proxy method)
334− status = toEnum . fromInteger $ natVal (Proxy :: Proxy status)
398+ status = statusFromNat (Proxy :: Proxy status)
335399
336400
337401streamRouter :: forall ctype a c chunk env framing. (MimeRender ctype chunk, FramingRender framing, ToSourceIO chunk a) =>
@@ -343,7 +407,7 @@ streamRouter :: forall ctype a c chunk env framing. (MimeRender ctype chunk, Fra
343407 -> Delayed env (Handler c)
344408 -> Router env
345409streamRouter splitHeaders method status framingproxy ctypeproxy action = leafRouter $ \env request respond ->
346− let accH = fromMaybe ct_wildcard $ lookup hAccept $ requestHeaders request
410+ let AcceptHeader accH = getAcceptHeader request
347411 cmediatype = NHM.matchAccept [contentType ctypeproxy] accH
348412 accCheck = when (isNothing cmediatype) $ delayedFail err406
349413 contentHeader = (hContentType, NHM.renderHeader . maybeToList $ cmediatype)
@@ -388,6 +452,7 @@ streamRouter splitHeaders method status framingproxy ctypeproxy action = leafRou
388452instance
389453 (KnownSymbol sym, FromHttpApiData a, HasServer api context
390454 , SBoolI (FoldRequired mods), SBoolI (FoldLenient mods)
455+ , HasContextEntry (MkContextWithErrorFormatter context) ErrorFormatters
391456 )
392457 => HasServer (Header' mods sym a :> api) context where
393458------
@@ -399,6 +464,9 @@ instance
399464 route Proxy context subserver = route (Proxy :: Proxy api) context $
400465 subserver `addHeaderCheck` withRequest headerCheck
401466 where
467+ rep = typeRep (Proxy :: Proxy Header')
468+ formatError = headerParseErrorFormatter $ getContextEntry (mkContextWithErrorFormatter context)
469+
402470 headerName :: IsString n => n
403471 headerName = fromString $ symbolVal (Proxy :: Proxy sym)
404472
@@ -409,15 +477,13 @@ instance
409477 mev :: Maybe (Either T.Text a)
410478 mev = fmap parseHeader $ lookup headerName (requestHeaders req)
411479
412− errReq = delayedFailFatal err400
413− { errBody = "Header " <> headerName <> " is required"
414− }
480+ errReq = delayedFailFatal $ formatError rep req
481+ $ "Header " <> headerName <> " is required"
415482
416− errSt e = delayedFailFatal err400
417− { errBody = cs $ "Error parsing header "
418− <> headerName
419− <> " failed: " <> e
420− }
483+ errSt e = delayedFailFatal $ formatError rep req
484+ $ cs $ "Error parsing header "
485+ <> headerName
486+ <> " failed: " <> e
421487
422488-- | If you use @'QueryParam' "author" Text@ in one of the endpoints for your API,
423489-- this automatically requires your server-side handler to be a function
@@ -443,6 +509,7 @@ instance
443509instance
444510 ( KnownSymbol sym, FromHttpApiData a, HasServer api context
445511 , SBoolI (FoldRequired mods), SBoolI (FoldLenient mods)
512+ , HasContextEntry (MkContextWithErrorFormatter context) ErrorFormatters
446513 )
447514 => HasServer (QueryParam' mods sym a :> api) context where
448515------
@@ -452,9 +519,12 @@ instance
452519 hoistServerWithContext _ pc nt s = hoistServerWithContext (Proxy :: Proxy api) pc nt . s
453520
454521 route Proxy context subserver =
455− let querytext req = parseQueryText $ rawQueryString req
522+ let querytext = queryToQueryText . queryString
456523 paramname = cs $ symbolVal (Proxy :: Proxy sym)
457524
525+ rep = typeRep (Proxy :: Proxy QueryParam')
526+ formatError = urlParseErrorFormatter $ getContextEntry (mkContextWithErrorFormatter context)
527+
458528 parseParam :: Request -> DelayedIO (RequestArgument mods a)
459529 parseParam req =
460530 unfoldRequestArgument (Proxy :: Proxy mods) errReq errSt mev
@@ -462,14 +532,12 @@ instance
462532 mev :: Maybe (Either T.Text a)
463533 mev = fmap parseQueryParam $ join $ lookup paramname $ querytext req
464534
465− errReq = delayedFailFatal err400
466− { errBody = cs $ "Query parameter " <> paramname <> " is required"
467− }
535+ errReq = delayedFailFatal $ formatError rep req
536+ $ cs $ "Query parameter " <> paramname <> " is required"
468537
469− errSt e = delayedFailFatal err400
470− { errBody = cs $ "Error parsing query parameter "
471− <> paramname <> " failed: " <> e
472− }
538+ errSt e = delayedFailFatal $ formatError rep req
539+ $ cs $ "Error parsing query parameter "
540+ <> paramname <> " failed: " <> e
473541
474542 delayed = addParameterCheck subserver . withRequest $ \req ->
475543 parseParam req
@@ -495,7 +563,8 @@ instance
495563-- > server = getBooksBy
496564-- > where getBooksBy :: [Text] -> Handler [Book]
497565-- > getBooksBy authors = ...return all books by these authors...
498−instance (KnownSymbol sym, FromHttpApiData a, HasServer api context)
566+instance (KnownSymbol sym, FromHttpApiData a, HasServer api context
567+ , HasContextEntry (MkContextWithErrorFormatter context) ErrorFormatters)
499568 => HasServer (QueryParams sym a :> api) context where
500569
501570 type ServerT (QueryParams sym a :> api) m =
@@ -506,21 +575,23 @@ instance (KnownSymbol sym, FromHttpApiData a, HasServer api context)
506575 route Proxy context subserver = route (Proxy :: Proxy api) context $
507576 subserver `addParameterCheck` withRequest paramsCheck
508577 where
578+ rep = typeRep (Proxy :: Proxy QueryParams)
579+ formatError = urlParseErrorFormatter $ getContextEntry (mkContextWithErrorFormatter context)
580+
509581 paramname = cs $ symbolVal (Proxy :: Proxy sym)
510582 paramsCheck req =
511583 case partitionEithers $ fmap parseQueryParam params of
512584 ([], parsed) -> return parsed
513− (errs, _) -> delayedFailFatal err400
514− { errBody = cs $ "Error parsing query parameter(s) "
515− <> paramname <> " failed: "
516− <> T.intercalate ", " errs
517− }
585+ (errs, _) -> delayedFailFatal $ formatError rep req
586+ $ cs $ "Error parsing query parameter(s) "
587+ <> paramname <> " failed: "
588+ <> T.intercalate ", " errs
518589 where
519590 params :: [T.Text]
520591 params = mapMaybe snd
521592 . filter (looksLikeParam . fst)
522− . parseQueryText
523− . rawQueryString
593+ . queryToQueryText
594+ . queryString
524595 $ req
525596
526597 looksLikeParam name = name == paramname || name == (paramname <> "[]")
@@ -546,7 +617,7 @@ instance (KnownSymbol sym, HasServer api context)
546617 hoistServerWithContext _ pc nt s = hoistServerWithContext (Proxy :: Proxy api) pc nt . s
547618
548619 route Proxy context subserver =
549− let querytext r = parseQueryText $ rawQueryString r
620+ let querytext = queryToQueryText . queryString
550621 param r = case lookup paramname (querytext r) of
551622 Just Nothing -> True -- param is there, with no value
552623 Just (Just v) -> examine v -- param with a value
@@ -582,13 +653,42 @@ instance HasServer Raw context where
582653 Fail a -> respond $ Fail a
583654 FailFatal e -> respond $ FailFatal e
584655
656+-- | Just pass the request to the underlying application and serve its response.
657+--
658+-- Example:
659+--
660+-- > type MyApi = "images" :> Raw
661+-- >
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
666+
667+ route
668+ :: Proxy RawM
669+ -> Context context
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)) >>=
676+ \case
677+ Left e -> respond' $ FailFatal e
678+ Right a -> pure a
679+ Fail e -> respond' $ Fail e
680+ FailFatal e -> respond' $ FailFatal e
681+
682+ hoistServerWithContext _ _ f srvM = \req respond -> f (srvM req respond)
683+
684+
585685-- | If you use 'ReqBody' in one of the endpoints for your API,
586686-- this automatically requires your server-side handler to be a function
587687-- that takes an argument of the type specified by 'ReqBody'.
588688-- The @Content-Type@ header is inspected, and the list provided is used to
589689-- attempt deserialization. If the request does not have a @Content-Type@
590690-- header, it is treated as @application/octet-stream@ (as specified in
591−-- <http://tools.ietf.org/html/rfc7231#section-3.1.1.5 RFC7231>.
691+-- [RFC 7231 section 3.1.1.5](http://tools.ietf.org/html/rfc7231#section-3.1.1.5)).
592692-- This lets servant worry about extracting it from the request and turning
593693-- it into a value of the type you specify.
594694--
@@ -604,6 +704,7 @@ instance HasServer Raw context where
604704-- > where postBook :: Book -> Handler Book
605705-- > postBook book = ...insert into your db...
606706instance ( AllCTUnrender list a, HasServer api context, SBoolI (FoldLenient mods)
707+ , HasContextEntry (MkContextWithErrorFormatter context) ErrorFormatters
607708 ) => HasServer (ReqBody' mods list a :> api) context where
608709
609710 type ServerT (ReqBody' mods list a :> api) m =
@@ -615,6 +716,9 @@ instance ( AllCTUnrender list a, HasServer api context, SBoolI (FoldLenient mods
615716 = route (Proxy :: Proxy api) context $
616717 addBodyCheck subserver ctCheck bodyCheck
617718 where
719+ rep = typeRep (Proxy :: Proxy ReqBody')
720+ formatError = bodyParserErrorFormatter $ getContextEntry (mkContextWithErrorFormatter context)
721+
618722 -- Content-Type check, we only lookup we can try to parse the request body
619723 ctCheck = withRequest $ \ request -> do
620724 -- See HTTP RFC 2616, section 7.2.1
@@ -633,7 +737,7 @@ instance ( AllCTUnrender list a, HasServer api context, SBoolI (FoldLenient mods
633737 case sbool :: SBool (FoldLenient mods) of
634738 STrue -> return mrqbody
635739 SFalse -> case mrqbody of
636− Left e -> delayedFailFatal err400 { errBody = cs e }
740+ Left e -> delayedFailFatal $ formatError rep request e
637741 Right v -> return v
638742
639743instance
@@ -656,7 +760,7 @@ instance
656760 bodyCheck fromRS = withRequest $ \req -> do
657761 let mimeUnrender' = mimeUnrender (Proxy :: Proxy ctype) :: BL.ByteString -> Either String chunk
658762 let framingUnrender' = framingUnrender (Proxy :: Proxy framing) mimeUnrender' :: SourceIO B.ByteString -> SourceIO chunk
659− let body = requestBody req
763+ let body = getRequestBodyChunk req
660764 let rs = S.fromAction B.null body
661765 let rs' = fromRS $ framingUnrender' rs
662766 return rs'
@@ -725,12 +829,12 @@ data EmptyServer = EmptyServer deriving (Typeable, Eq, Show, Bounded, Enum)
725829emptyServer :: ServerT EmptyAPI m
726830emptyServer = Tagged EmptyServer
727831
728−-- | The server for an `EmptyAPI` is `emptyAPIServer`.
832+-- | The server for an `EmptyAPI` is `emptyServer`.
729833--
730834-- > type MyApi = "nothing" :> EmptyApi
731835-- >
732836-- > server :: Server MyApi
733−-- > server = emptyAPIServer
837+-- > server = emptyServer
734838instance HasServer EmptyAPI context where
735839 type ServerT EmptyAPI m = Tagged m EmptyServer
736840
@@ -759,7 +863,10 @@ instance ( KnownSymbol realm
759863-- * helpers
760864
761865ct_wildcard :: B.ByteString
762−ct_wildcard = "*" <> "/" <> "*" -- Because CPP
866+ct_wildcard = "*" <> "/" <> "*"
867+
868+getAcceptHeader :: Request -> AcceptHeader
869+getAcceptHeader = AcceptHeader . fromMaybe ct_wildcard . lookup hAccept . requestHeaders
763870
764871-- * General Authentication
765872
@@ -784,39 +891,19 @@ instance (HasContextEntry context (NamedContext name subContext), HasServer subA
784891 hoistServerWithContext _ _ nt s = hoistServerWithContext (Proxy :: Proxy subApi) (Proxy :: Proxy subContext) nt s
785892
786893-------------------------------------------------------------------------------
787−-- TypeError helpers
894+-- Custom type errors
788895-------------------------------------------------------------------------------
789896
790−#ifdef HAS_TYPE_ERROR
791−-- | This instance catches mistakes when there are non-saturated
792−-- type applications on LHS of ':>'.
793−--
794−-- >>> serve (Proxy :: Proxy (Capture "foo" :> Get '[JSON] Int)) (error "...")
795−-- ...
796−-- ...Expected something of kind Symbol or *, got: k -> l on the LHS of ':>'.
797−-- ...Maybe you haven't applied enough arguments to
798−-- ...Capture' '[] "foo"
799−-- ...
800−--
801−-- >>> undefined :: Server (Capture "foo" :> Get '[JSON] Int)
802−-- ...
803−-- ...Expected something of kind Symbol or *, got: k -> l on the LHS of ':>'.
804−-- ...Maybe you haven't applied enough arguments to
805−-- ...Capture' '[] "foo"
806−-- ...
807−--
808−instance TypeError (HasServerArrowKindError arr) => HasServer ((arr :: k -> l) :> api) context
897+-- Erroring instance for 'HasServer' when a combinator is not fully applied
898+instance TypeError (PartialApplication
899+#if __GLASGOW_HASKELL__ >= 904
900+ @(Type -> [Type] -> Constraint)
901+#endif
902+ HasServer arr) => HasServer ((arr :: a -> b) :> sub) context
809903 where
810− type ServerT (arr :> api) m = TypeError (HasServerArrowKindError arr)
811− -- it doens't really matter what sub route we peak
812− route _ _ _ = error "servant-server panic: impossible happened in HasServer (arr :> api)"
813− hoistServerWithContext _ _ _ = id
814−
815−-- Cannot have TypeError here, otherwise use of this symbol will error :)
816−type HasServerArrowKindError arr =
817− 'Text "Expected something of kind Symbol or *, got: k -> l on the LHS of ':>'."
818− ':$$: 'Text "Maybe you haven't applied enough arguments to"
819− ':$$: 'ShowType arr
904+ type ServerT (arr :> sub) _ = TypeError (PartialApplication (HasServer :: * -> [*] -> Constraint) arr)
905+ route = error "unreachable"
906+ hoistServerWithContext _ _ _ _ = error "unreachable"
820907
821908-- | This instance prevents from accidentally using '->' instead of ':>'
822909--
@@ -850,7 +937,107 @@ type HasServerArrowTypeError a b =
850937 ':$$: 'ShowType a
851938 ':$$: 'Text "and"
852939 ':$$: 'ShowType b
940+
941+-- Erroring instances for 'HasServer' for unknown API combinators
942+
943+-- XXX: This omits the @context@ parameter, e.g.:
944+--
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)
853949#endif
950+ HasServer ty) => HasServer (ty :> sub) context
951+
952+instance {-# OVERLAPPABLE #-} TypeError (NoInstanceFor (HasServer api context)) => HasServer api context
953+
954+-- | Ignore @'Fragment'@ in server handlers.
955+-- See <https://ietf.org/rfc/rfc2616.html#section-15.1.3> for more details.
956+--
957+-- Example:
958+--
959+-- > type MyApi = "books" :> Fragment Text :> Get '[JSON] [Book]
960+-- >
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
968+
969+ route _ = route (Proxy :: Proxy api)
970+
971+ hoistServerWithContext _ = hoistServerWithContext (Proxy :: Proxy api)
854972
855973-- $setup
856974-- >>> import Servant
975+
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
980+
981+type AsServer = AsServerT Handler
982+
983+
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)))
988+ )
989+
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.
993+--
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.
999+--
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.
1002+
1003+class GServer (api :: * -> *) (m :: * -> *) where
1004+ gServerProof :: Dict (GServerConstraints api m)
1005+
1006+instance
1007+ ( ToServant api (AsServerT m) ~ ServerT (ToServantApi api) m
1008+ , GServantProduct (Rep (api (AsServerT m)))
1009+ ) => GServer api m where
1010+ gServerProof = Dict
1011+
1012+instance
1013+ ( HasServer (ToServantApi api) context
1014+ , forall m. Generic (api (AsServerT m))
1015+ , forall m. GServer api m
1016+ ) => HasServer (NamedRoutes api) context where
1017+
1018+ type ServerT (NamedRoutes api) m = api (AsServerT m)
1019+
1020+ route
1021+ :: Proxy (NamedRoutes api)
1022+ -> Context context
1023+ -> Delayed env (api (AsServerT Handler))
1024+ -> Router env
1025+ route _ ctx delayed =
1026+ case gServerProof @api @Handler of
1027+ Dict -> route (Proxy @(ToServantApi api)) ctx (toServant <$> delayed)
1028+
1029+ hoistServerWithContext
1030+ :: forall m n. Proxy (NamedRoutes api)
1031+ -> Proxy context
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
1037+ (Dict, Dict) ->
1038+ fromServant servantSrvN
1039+ where
1040+ servantSrvM :: ServerT (ToServantApi api) m =
1041+ toServant server
1042+ servantSrvN :: ServerT (ToServantApi api) n =
1043+ hoistServerWithContext (Proxy @(ToServantApi api)) pctx nat servantSrvM