Servant.API.ContentTypes

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:

1. Declare a new data type with no constructors (e.g. data HTML).
2. Make an instance of it for Accept.
3. If you want to be able to serialize data *into* that Content-Type, make an instance of it for MimeRender.
4. 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.

Provided Content-Types

data JSON

Instances

Accept * JSON

application/json

FromJSON a => MimeUnrender * JSON a

eitherDecode

ToJSON a => MimeRender * JSON a

encode

data PlainText

Instances

Accept * PlainText

text/plain;charset=utf-8

MimeUnrender * PlainText Text

left show . TextS.decodeUtf8' . toStrict

MimeUnrender * PlainText Text

left show . TextL.decodeUtf8'

MimeRender * PlainText Text

fromStrict . TextS.encodeUtf8

MimeRender * PlainText Text

encodeUtf8

data FormUrlEncoded

Instances

Accept * FormUrlEncoded

application/x-www-form-urlencoded

FromFormUrlEncoded a => MimeUnrender * FormUrlEncoded a

decodeFormUrlEncoded >=> fromFormUrlEncoded Note that the mimeUnrender p (mimeRender p x) == Right x law only holds if every element of x is non-null (i.e., not ("", ""))

ToFormUrlEncoded a => MimeRender * FormUrlEncoded a

encodeFormUrlEncoded . toFormUrlEncoded Note that the mimeUnrender p (mimeRender p x) == Right x law only holds if every element of x is non-null (i.e., not ("", ""))

data OctetStream

Instances

Accept * OctetStream

application/octet-stream

MimeUnrender * OctetStream ByteString

Right . toStrict

MimeUnrender * OctetStream ByteString

Right . id

MimeRender * OctetStream ByteString

fromStrict

MimeRender * OctetStream ByteString

id

Building your own Content-Type

class Accept ctype where

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")
:}

Methods

contentType :: Proxy ctype -> MediaType

Instances

Accept * OctetStream

application/octet-stream

Accept * FormUrlEncoded

application/x-www-form-urlencoded

Accept * PlainText

text/plain;charset=utf-8

Accept * JSON

application/json

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 where
   mimeRender _ val = pack ("This is MINE! " ++ show val)

type MyAPI = "path" :> Get '[MyContentType] Int

Methods

mimeRender :: Proxy ctype -> a -> ByteString

Instances

MimeRender * OctetStream ByteString

fromStrict

MimeRender * OctetStream ByteString

id

ToFormUrlEncoded a => MimeRender * FormUrlEncoded a

encodeFormUrlEncoded . toFormUrlEncoded Note that the mimeUnrender p (mimeRender p x) == Right x law only holds if every element of x is non-null (i.e., not ("", ""))

MimeRender * PlainText Text

fromStrict . TextS.encodeUtf8

MimeRender * PlainText Text

encodeUtf8

ToJSON a => MimeRender * JSON a

encode

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

Methods

mimeUnrender :: Proxy ctype -> ByteString -> Either String a

Instances

MimeUnrender * OctetStream ByteString

Right . toStrict

MimeUnrender * OctetStream ByteString

Right . id

FromFormUrlEncoded a => MimeUnrender * FormUrlEncoded a

decodeFormUrlEncoded >=> fromFormUrlEncoded Note that the mimeUnrender p (mimeRender p x) == Right x law only holds if every element of x is non-null (i.e., not ("", ""))

MimeUnrender * PlainText Text

left show . TextS.decodeUtf8' . toStrict

MimeUnrender * PlainText Text

left show . TextL.decodeUtf8'

FromJSON a => MimeUnrender * JSON a

eitherDecode

Internal

newtype AcceptHeader

Constructors

AcceptHeader ByteString

Instances

Eq AcceptHeader

Show AcceptHeader

class AllCTRender list a where

Methods

handleAcceptH :: Proxy list -> AcceptHeader -> a -> Maybe (ByteString, ByteString)

Instances

(AllMimeRender ctyps a, IsNonEmpty ctyps) => AllCTRender ctyps a

class IsNonEmpty list => AllCTUnrender list a where

Methods

handleCTypeH :: Proxy list -> ByteString -> ByteString -> Maybe (Either String a)

Instances

(AllMimeUnrender ctyps a, IsNonEmpty ctyps) => AllCTUnrender ctyps a

class AllMimeRender list a where

Methods

allMimeRender :: Proxy list -> a -> [(MediaType, ByteString)]

Instances

AllMimeRender ([] *) a

(MimeRender * ctyp a, AllMimeRender ((:) * ctyp' ctyps) a) => AllMimeRender ((:) * ctyp ((:) * ctyp' ctyps)) a

MimeRender * ctyp a => AllMimeRender ((:) * ctyp ([] *)) a

class AllMimeUnrender list a where

Methods

allMimeUnrender :: Proxy list -> ByteString -> [(MediaType, Either String a)]

Instances

AllMimeUnrender ([] *) a

(MimeUnrender * ctyp a, AllMimeUnrender ctyps a) => AllMimeUnrender ((:) * ctyp ctyps) a

class FromFormUrlEncoded a where

A type that can be converted from application/x-www-form-urlencoded, with the possibility of failure.

Methods

fromFormUrlEncoded :: [(Text, Text)] -> Either String a

Instances

FromFormUrlEncoded [(Text, Text)]

class ToFormUrlEncoded a where

A type that can be converted to application/x-www-form-urlencoded

Methods

toFormUrlEncoded :: a -> [(Text, Text)]

Instances

ToFormUrlEncoded [(Text, Text)]

type family IsNonEmpty list :: Constraint

Equations

IsNonEmpty (x : xs) = ()

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"