Safe Haskell | None |
---|---|
Language | Haskell2010 |
Servant.API.ContentTypes
Description
A collection of basic Content-Types (also known as Internet Media Types, or MIME types). Additionally, this module provides classes that encapsulate how to serialize or deserialize values to or from a particular Content-Type.
Content-Types are used in ReqBody
and the method combinators:
>>>
type MyEndpoint = ReqBody '[JSON, PlainText] Book :> Get '[JSON, PlainText] Book
Meaning the endpoint accepts requests of Content-Type application/json
or text/plain;charset-utf8
, and returns data in either one of those
formats (depending on the Accept
header).
If you would like to support Content-Types beyond those provided here, then:
- Declare a new data type with no constructors (e.g.
data HTML
). - Make an instance of it for
Accept
. - If you want to be able to serialize data *into* that
Content-Type, make an instance of it for
MimeRender
. - If you want to be able to deserialize data *from* that
Content-Type, make an instance of it for
MimeUnrender
.
Note that roles are reversed in servant-server
and servant-client
:
to be able to serve (or even typecheck) a Get '[JSON, XML] MyData
,
you'll need to have the appropriate MimeRender
instances in scope,
whereas to query that endpoint with servant-client
, you'll need
a MimeUnrender
instance in scope.
- data JSON
- data PlainText
- data FormUrlEncoded
- data OctetStream
- class Accept ctype where
- class Accept ctype => MimeRender ctype a where
- class Accept ctype => MimeUnrender ctype a where
- data NoContent = NoContent
- newtype AcceptHeader = AcceptHeader ByteString
- class AllMime list => AllCTRender list a where
- class AllCTUnrender list a where
- class AllMime list where
- class AllMime list => AllMimeRender list a where
- class AllMime list => AllMimeUnrender list a where
- eitherDecodeLenient :: FromJSON a => ByteString -> Either String a
- canHandleAcceptH :: AllMime list => Proxy list -> AcceptHeader -> Bool
Provided Content-Types
Instances
Accept * PlainText # | text/plain;charset=utf-8 |
MimeUnrender * PlainText String # | Right . BC.unpack |
MimeUnrender * PlainText Text # | left show . TextS.decodeUtf8' . toStrict |
MimeUnrender * PlainText Text # | left show . TextL.decodeUtf8' |
MimeRender * PlainText String # | BC.pack |
MimeRender * PlainText Text # | fromStrict . TextS.encodeUtf8 |
MimeRender * PlainText Text # | |
data FormUrlEncoded #
Instances
Accept * FormUrlEncoded # | application/x-www-form-urlencoded |
FromForm a => MimeUnrender * FormUrlEncoded a # |
|
ToForm a => MimeRender * FormUrlEncoded a # |
|
data OctetStream #
Instances
Accept * OctetStream # | application/octet-stream |
MimeUnrender * OctetStream ByteString # | Right . toStrict |
MimeUnrender * OctetStream ByteString # | Right . id |
MimeRender * OctetStream ByteString # | |
MimeRender * OctetStream ByteString # | id |
Building your own Content-Type
Instances of Accept
represent mimetypes. They are used for matching
against the Accept
HTTP header of the request, and for setting the
Content-Type
header of the response
Example:
>>>
import Network.HTTP.Media ((//), (/:))
>>>
data HTML
>>>
:{
instance Accept HTML where contentType _ = "text" // "html" /: ("charset", "utf-8") :}
Minimal complete definition
class Accept ctype => MimeRender ctype a where #
Instantiate this class to register a way of serializing a type based
on the Accept
header.
Example:
data MyContentType instance Accept MyContentType where contentType _ = "example" // "prs.me.mine" /: ("charset", "utf-8") instance Show a => MimeRender MyContentType a where mimeRender _ val = pack ("This is MINE! " ++ show val) type MyAPI = "path" :> Get '[MyContentType] Int
Minimal complete definition
Methods
mimeRender :: Proxy ctype -> a -> ByteString #
Instances
MimeRender * OctetStream ByteString # | |
MimeRender * OctetStream ByteString # | id |
ToForm a => MimeRender * FormUrlEncoded a # |
|
MimeRender * PlainText String # | BC.pack |
MimeRender * PlainText Text # | fromStrict . TextS.encodeUtf8 |
MimeRender * PlainText Text # | |
ToJSON a => MimeRender * JSON a # | |
class Accept ctype => MimeUnrender ctype a where #
Instantiate this class to register a way of deserializing a type based
on the request's Content-Type
header.
>>>
import Network.HTTP.Media hiding (Accept)
>>>
import qualified Data.ByteString.Lazy.Char8 as BSC
>>>
data MyContentType = MyContentType String
>>>
:{
instance Accept MyContentType where contentType _ = "example" // "prs.me.mine" /: ("charset", "utf-8") :}
>>>
:{
instance Read a => MimeUnrender MyContentType a where mimeUnrender _ bs = case BSC.take 12 bs of "MyContentType" -> return . read . BSC.unpack $ BSC.drop 12 bs _ -> Left "didn't start with the magic incantation" :}
>>>
type MyAPI = "path" :> ReqBody '[MyContentType] Int :> Get '[JSON] Int
Minimal complete definition
Methods
mimeUnrender :: Proxy ctype -> ByteString -> Either String a #
mimeUnrenderWithType :: Proxy ctype -> MediaType -> ByteString -> Either String a #
Instances
MimeUnrender * OctetStream ByteString # | Right . toStrict |
MimeUnrender * OctetStream ByteString # | Right . id |
FromForm a => MimeUnrender * FormUrlEncoded a # |
|
MimeUnrender * PlainText String # | Right . BC.unpack |
MimeUnrender * PlainText Text # | left show . TextS.decodeUtf8' . toStrict |
MimeUnrender * PlainText Text # | left show . TextL.decodeUtf8' |
FromJSON a => MimeUnrender * JSON a # |
|
NoContent
A type for responses without content-body.
Constructors
NoContent |
Internal
class AllMime list => AllCTRender list a where #
Minimal complete definition
Methods
handleAcceptH :: Proxy list -> AcceptHeader -> a -> Maybe (ByteString, ByteString) #
Instances
TypeError Constraint (Text "No instance for (), use NoContent instead.") => AllCTRender ([] *) () # | |
(Accept * ct, AllMime cts, AllMimeRender ((:) * ct cts) a) => AllCTRender ((:) * ct cts) a # | |
class AllCTUnrender list a where #
Minimal complete definition
Methods
canHandleCTypeH :: Proxy list -> ByteString -> Maybe (ByteString -> Either String a) #
handleCTypeH :: Proxy list -> ByteString -> ByteString -> Maybe (Either String a) #
Instances
AllMimeUnrender ctyps a => AllCTUnrender ctyps a # | |
Minimal complete definition
class AllMime list => AllMimeRender list a where #
Minimal complete definition
Methods
allMimeRender :: Proxy list -> a -> [(MediaType, ByteString)] #
Instances
AllMime ((:) * ctyp ((:) * ctyp' ctyps)) => AllMimeRender ((:) * ctyp ((:) * ctyp' ctyps)) NoContent # | |
Accept * ctyp => AllMimeRender ((:) * ctyp ([] *)) NoContent # | |
(MimeRender * ctyp a, AllMimeRender ((:) * ctyp' ctyps) a) => AllMimeRender ((:) * ctyp ((:) * ctyp' ctyps)) a # | |
MimeRender * ctyp a => AllMimeRender ((:) * ctyp ([] *)) a # | |
class AllMime list => AllMimeUnrender list a where #
Minimal complete definition
Methods
allMimeUnrender :: Proxy list -> [(MediaType, ByteString -> Either String a)] #
Instances
AllMimeUnrender ([] *) a # | |
(MimeUnrender * ctyp a, AllMimeUnrender ctyps a) => AllMimeUnrender ((:) * ctyp ctyps) a # | |
eitherDecodeLenient :: FromJSON a => ByteString -> Either String a #
Like eitherDecode
but allows all JSON values instead of just
objects and arrays.
Will handle trailing whitespace, but not trailing junk. ie.
>>>
eitherDecodeLenient "1 " :: Either String Int
Right 1
>>>
eitherDecodeLenient "1 junk" :: Either String Int
Left "trailing junk after valid JSON: endOfInput"
canHandleAcceptH :: AllMime list => Proxy list -> AcceptHeader -> Bool #