servant-0.11: A family of combinators for defining webservices APIs

Safe HaskellNone
LanguageHaskell2010

Servant.API.ContentTypes

Contents

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:

  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.

Synopsis

Provided Content-Types

data JSON #

data FormUrlEncoded #

Instances

Accept * FormUrlEncoded #
application/x-www-form-urlencoded
FromForm a => MimeUnrender * FormUrlEncoded a #

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

ToForm a => MimeRender * FormUrlEncoded a #

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

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

Minimal complete definition

contentType | contentTypes

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

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

Minimal complete definition

mimeRender

Methods

mimeRender :: Proxy ctype -> a -> ByteString #

Instances

MimeRender * OctetStream ByteString #

fromStrict

MimeRender * OctetStream ByteString #
id
ToForm a => MimeRender * FormUrlEncoded a #

urlEncodeAsForm 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 String #
BC.pack
MimeRender * PlainText Text #
fromStrict . TextS.encodeUtf8
MimeRender * PlainText Text #

encodeUtf8

ToJSON a => MimeRender * JSON a #

encode

Methods

mimeRender :: Proxy JSON a -> a -> ByteString #

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

mimeUnrender | mimeUnrenderWithType

Methods

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

mimeUnrenderWithType :: Proxy ctype -> MediaType -> ByteString -> Either String a #

Variant which is given the actual MediaType provided by the other party.

In the most cases you don't want to branch based on the MediaType. See pr552 for a motivating example.

Instances

MimeUnrender * OctetStream ByteString #
Right . toStrict
MimeUnrender * OctetStream ByteString #
Right . id
FromForm a => MimeUnrender * FormUrlEncoded a #

urlDecodeAsForm 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 String #
Right . BC.unpack
MimeUnrender * PlainText Text #
left show . TextS.decodeUtf8' . toStrict
MimeUnrender * PlainText Text #
left show . TextL.decodeUtf8'
FromJSON a => MimeUnrender * JSON a #

eitherDecode

NoContent

data NoContent #

A type for responses without content-body.

Constructors

NoContent 

Instances

Eq NoContent # 
Read NoContent # 
Show NoContent # 
Generic NoContent # 

Associated Types

type Rep NoContent :: * -> * #

AllMime ((:) * ctyp ((:) * ctyp' ctyps)) => AllMimeRender ((:) * ctyp ((:) * ctyp' ctyps)) NoContent # 

Methods

allMimeRender :: Proxy [*] ((* ': ctyp) ((* ': ctyp') ctyps)) -> NoContent -> [(MediaType, ByteString)] #

Accept * ctyp => AllMimeRender ((:) * ctyp ([] *)) NoContent # 

Methods

allMimeRender :: Proxy [*] ((* ': ctyp) [*]) -> NoContent -> [(MediaType, ByteString)] #

type Rep NoContent # 
type Rep NoContent = D1 (MetaData "NoContent" "Servant.API.ContentTypes" "servant-0.11-fCWv59w22jEhv7YLGePVV" False) (C1 (MetaCons "NoContent" PrefixI False) U1)

Internal

class AllMime list => AllCTRender list a where #

Minimal complete definition

handleAcceptH

Instances

TypeError Constraint (Text "No instance for (), use NoContent instead.") => AllCTRender ([] *) () # 
(Accept * ct, AllMime cts, AllMimeRender ((:) * ct cts) a) => AllCTRender ((:) * ct cts) a # 

Methods

handleAcceptH :: Proxy [*] ((* ': ct) cts) -> AcceptHeader -> a -> Maybe (ByteString, ByteString) #

class AllCTUnrender list a where #

Minimal complete definition

canHandleCTypeH

Instances

class AllMime list where #

Minimal complete definition

allMime

Methods

allMime :: Proxy list -> [MediaType] #

Instances

AllMime ([] *) # 

Methods

allMime :: Proxy [*] [*] -> [MediaType] #

(Accept * ctyp, AllMime ctyps) => AllMime ((:) * ctyp ctyps) # 

Methods

allMime :: Proxy [*] ((* ': ctyp) ctyps) -> [MediaType] #

class AllMime list => AllMimeRender list a where #

Minimal complete definition

allMimeRender

Methods

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

Instances

AllMime ((:) * ctyp ((:) * ctyp' ctyps)) => AllMimeRender ((:) * ctyp ((:) * ctyp' ctyps)) NoContent # 

Methods

allMimeRender :: Proxy [*] ((* ': ctyp) ((* ': ctyp') ctyps)) -> NoContent -> [(MediaType, ByteString)] #

Accept * ctyp => AllMimeRender ((:) * ctyp ([] *)) NoContent # 

Methods

allMimeRender :: Proxy [*] ((* ': ctyp) [*]) -> NoContent -> [(MediaType, ByteString)] #

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

Methods

allMimeRender :: Proxy [*] ((* ': ctyp) ((* ': ctyp') ctyps)) -> a -> [(MediaType, ByteString)] #

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

Methods

allMimeRender :: Proxy [*] ((* ': ctyp) [*]) -> a -> [(MediaType, ByteString)] #

class AllMime list => AllMimeUnrender list a where #

Minimal complete definition

allMimeUnrender

Instances

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

Methods

allMimeUnrender :: Proxy [*] ((* ': ctyp) ctyps) -> [(MediaType, ByteString -> Either String 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"