Servant.Foreign.Internal

Generalizes all the data needed to make code generation work with arbitrary programming languages.

Documentation

newtype FunctionName

Constructors

FunctionName

Fields

• unFunctionName :: [Text]

Instances

Eq FunctionName

Methods

(==) :: FunctionName -> FunctionName -> Bool

(/=) :: FunctionName -> FunctionName -> Bool

Show FunctionName

Methods

showsPrec :: Int -> FunctionName -> ShowS

show :: FunctionName -> String

showList :: [FunctionName] -> ShowS

Monoid FunctionName

Methods

mempty :: FunctionName

mappend :: FunctionName -> FunctionName -> FunctionName

mconcat :: [FunctionName] -> FunctionName

_FunctionName :: Iso' FunctionName [Text]

newtype PathSegment

Constructors

PathSegment

Fields

• unPathSegment :: Text

Instances

Eq PathSegment

Methods

(==) :: PathSegment -> PathSegment -> Bool

(/=) :: PathSegment -> PathSegment -> Bool

Show PathSegment

Methods

showsPrec :: Int -> PathSegment -> ShowS

show :: PathSegment -> String

showList :: [PathSegment] -> ShowS

IsString PathSegment

Methods

fromString :: String -> PathSegment

Monoid PathSegment

Methods

mempty :: PathSegment

mappend :: PathSegment -> PathSegment -> PathSegment

mconcat :: [PathSegment] -> PathSegment

_PathSegment :: Iso' PathSegment Text

data Arg f

Constructors

Arg

Fields

• _argName :: PathSegment
• _argType :: f

Instances

Eq f => Eq (Arg f)

Methods

(==) :: Arg f -> Arg f -> Bool

(/=) :: Arg f -> Arg f -> Bool

Show f => Show (Arg f)

Methods

showsPrec :: Int -> Arg f -> ShowS

show :: Arg f -> String

showList :: [Arg f] -> ShowS

argType :: forall f f. Lens (Arg f) (Arg f) f f

argName :: forall f. Lens' (Arg f) PathSegment

argPath :: Getter (Arg f) Text

data SegmentType f

Constructors

Static PathSegment

a static path segment. like "/foo"

Cap (Arg f)

a capture. like "/:userid"

Instances

Eq f => Eq (SegmentType f)

Methods

(==) :: SegmentType f -> SegmentType f -> Bool

(/=) :: SegmentType f -> SegmentType f -> Bool

Show f => Show (SegmentType f)

Methods

showsPrec :: Int -> SegmentType f -> ShowS

show :: SegmentType f -> String

showList :: [SegmentType f] -> ShowS

_Cap :: forall f f. Prism (SegmentType f) (SegmentType f) (Arg f) (Arg f)

_Static :: forall f. Prism' (SegmentType f) PathSegment

newtype Segment f

Constructors

Segment

Fields

• unSegment :: SegmentType f

Instances

Eq f => Eq (Segment f)

Methods

(==) :: Segment f -> Segment f -> Bool

(/=) :: Segment f -> Segment f -> Bool

Show f => Show (Segment f)

Methods

showsPrec :: Int -> Segment f -> ShowS

show :: Segment f -> String

showList :: [Segment f] -> ShowS

_Segment :: forall f f. Iso (Segment f) (Segment f) (SegmentType f) (SegmentType f)

isCapture :: Segment f -> Bool

captureArg :: Segment f -> Arg f

type Path f = [Segment f]

data ArgType

Constructors

Normal

Flag

List

Instances

Eq ArgType

Methods

(==) :: ArgType -> ArgType -> Bool

(/=) :: ArgType -> ArgType -> Bool

Show ArgType

Methods

showsPrec :: Int -> ArgType -> ShowS

show :: ArgType -> String

showList :: [ArgType] -> ShowS

_List :: Prism' ArgType ()

_Flag :: Prism' ArgType ()

_Normal :: Prism' ArgType ()

data QueryArg f

Constructors

QueryArg

Fields

• _queryArgName :: Arg f
• _queryArgType :: ArgType

Instances

Eq f => Eq (QueryArg f)

Methods

(==) :: QueryArg f -> QueryArg f -> Bool

(/=) :: QueryArg f -> QueryArg f -> Bool

Show f => Show (QueryArg f)

Methods

showsPrec :: Int -> QueryArg f -> ShowS

show :: QueryArg f -> String

showList :: [QueryArg f] -> ShowS

queryArgType :: forall f. Lens' (QueryArg f) ArgType

queryArgName :: forall f f. Lens (QueryArg f) (QueryArg f) (Arg f) (Arg f)

data HeaderArg f

Constructors

HeaderArg

Fields

• _headerArg :: Arg f

ReplaceHeaderArg

Fields

• _headerArg :: Arg f
• _headerPattern :: Text

Instances

Eq f => Eq (HeaderArg f)

Methods

(==) :: HeaderArg f -> HeaderArg f -> Bool

(/=) :: HeaderArg f -> HeaderArg f -> Bool

Show f => Show (HeaderArg f)

Methods

showsPrec :: Int -> HeaderArg f -> ShowS

show :: HeaderArg f -> String

showList :: [HeaderArg f] -> ShowS

headerPattern :: forall f. Traversal' (HeaderArg f) Text

headerArg :: forall f f. Lens (HeaderArg f) (HeaderArg f) (Arg f) (Arg f)

_ReplaceHeaderArg :: forall f. Prism' (HeaderArg f) (Arg f, Text)

_HeaderArg :: forall f. Prism' (HeaderArg f) (Arg f)

data Url f

Constructors

Url

Fields

• _path :: Path f
• _queryStr :: [QueryArg f]

Instances

Eq f => Eq (Url f)

Methods

(==) :: Url f -> Url f -> Bool

(/=) :: Url f -> Url f -> Bool

Show f => Show (Url f)

Methods

showsPrec :: Int -> Url f -> ShowS

show :: Url f -> String

showList :: [Url f] -> ShowS

defUrl :: Url f

queryStr :: forall f. Lens' (Url f) [QueryArg f]

path :: forall f. Lens' (Url f) (Path f)

data Req f

Constructors

Req

Fields

• _reqUrl :: Url f
• _reqMethod :: Method
• _reqHeaders :: [HeaderArg f]
• _reqBody :: Maybe f
• _reqReturnType :: Maybe f
• _reqFuncName :: FunctionName

Instances

GenerateList ftype (Req ftype)

Methods

generateList :: Req ftype -> [Req ftype]

Eq f => Eq (Req f)

Methods

(==) :: Req f -> Req f -> Bool

(/=) :: Req f -> Req f -> Bool

Show f => Show (Req f)

Methods

showsPrec :: Int -> Req f -> ShowS

show :: Req f -> String

showList :: [Req f] -> ShowS

reqUrl :: forall f. Lens' (Req f) (Url f)

reqReturnType :: forall f. Lens' (Req f) (Maybe f)

reqMethod :: forall f. Lens' (Req f) Method

reqHeaders :: forall f. Lens' (Req f) [HeaderArg f]

reqFuncName :: forall f. Lens' (Req f) FunctionName

reqBody :: forall f. Lens' (Req f) (Maybe f)

defReq :: Req ftype

class NotFound

To be used exclusively as a "negative" return type/constraint by Elem type family.

type family Elem (a :: *) (ls :: [*]) :: Constraint where ...

Equations

Elem a '[] = NotFound

Elem a (a ': list) = ()

Elem a (b ': list) = Elem a list

class HasForeignType lang ftype a where

HasForeignType maps Haskell types with types in the target language of your backend. For example, let's say you're implementing a backend to some language X, and you want a Text representation of each input/output type mentioned in the API:

-- First you need to create a dummy type to parametrize your
-- instances.
data LangX

-- Otherwise you define instances for the types you need
instance HasForeignType LangX Text Int where
   typeFor _ _ _ = "intX"

-- Or for example in case of lists
instance HasForeignType LangX Text a => HasForeignType LangX Text [a] where
   typeFor lang type _ = "listX of " <> typeFor lang ftype (Proxy :: Proxy a)

Finally to generate list of information about all the endpoints for an API you create a function of a form:

getEndpoints :: (HasForeign LangX Text api, GenerateList Text (Foreign Text api))
             => Proxy api -> [Req Text]
getEndpoints api = listFromAPI (Proxy :: Proxy LangX) (Proxy :: Proxy Text) api

-- If language __X__ is dynamically typed then you can use
-- a predefined NoTypes parameter with the NoContent output type:

getEndpoints :: (HasForeign NoTypes NoContent api, GenerateList Text (Foreign NoContent api))
             => Proxy api -> [Req NoContent]
getEndpoints api = listFromAPI (Proxy :: Proxy NoTypes) (Proxy :: Proxy NoContent) api

Minimal complete definition

typeFor

Methods

typeFor :: Proxy lang -> Proxy ftype -> Proxy a -> ftype

Instances

HasForeignType k * NoTypes NoContent ftype

Methods

typeFor :: Proxy NoContent ftype -> Proxy * ftype -> Proxy NoTypes a -> ftype

data NoTypes

Instances

HasForeignType k * NoTypes NoContent ftype

Methods

typeFor :: Proxy NoContent ftype -> Proxy * ftype -> Proxy NoTypes a -> ftype

class HasForeign lang ftype api where

Minimal complete definition

foreignFor

Associated Types

type Foreign ftype api :: *

Methods

foreignFor :: Proxy lang -> Proxy ftype -> Proxy api -> Req ftype -> Foreign ftype api

Instances

HasForeign k lang ftype Raw

Associated Types

type Foreign Raw api :: *

Methods

foreignFor :: Proxy lang ftype -> Proxy * Raw -> Proxy * api -> Req Raw -> Foreign Raw api

(HasForeign k lang ftype a, HasForeign k lang ftype b) => HasForeign k lang ftype ((:<|>) a b)

Associated Types

type Foreign ((:<|>) a b) api :: *

Methods

foreignFor :: Proxy lang ftype -> Proxy * (a :<|> b) -> Proxy * api -> Req (a :<|> b) -> Foreign (a :<|> b) api

HasForeign k lang ftype api => HasForeign k lang ftype (WithNamedContext name context api)

Associated Types

type Foreign (WithNamedContext name context api) api :: *

Methods

foreignFor :: Proxy lang ftype -> Proxy * (WithNamedContext name context api) -> Proxy * api -> Req (WithNamedContext name context api) -> Foreign (WithNamedContext name context api) api

HasForeign k lang ftype api => HasForeign k lang ftype ((:>) * * HttpVersion api)

Associated Types

type Foreign ((:>) * * HttpVersion api) api :: *

Methods

foreignFor :: Proxy lang ftype -> Proxy * ((* :> *) HttpVersion api) -> Proxy * api -> Req ((* :> *) HttpVersion api) -> Foreign ((* :> *) HttpVersion api) api

HasForeign k lang ftype api => HasForeign k lang ftype ((:>) * * Vault api)

Associated Types

type Foreign ((:>) * * Vault api) api :: *

Methods

foreignFor :: Proxy lang ftype -> Proxy * ((* :> *) Vault api) -> Proxy * api -> Req ((* :> *) Vault api) -> Foreign ((* :> *) Vault api) api

HasForeign k lang ftype api => HasForeign k lang ftype ((:>) * * IsSecure api)

Associated Types

type Foreign ((:>) * * IsSecure api) api :: *

Methods

foreignFor :: Proxy lang ftype -> Proxy * ((* :> *) IsSecure api) -> Proxy * api -> Req ((* :> *) IsSecure api) -> Foreign ((* :> *) IsSecure api) api

HasForeign k lang ftype api => HasForeign k lang ftype ((:>) * * RemoteHost api)

Associated Types

type Foreign ((:>) * * RemoteHost api) api :: *

Methods

foreignFor :: Proxy lang ftype -> Proxy * ((* :> *) RemoteHost api) -> Proxy * api -> Req ((* :> *) RemoteHost api) -> Foreign ((* :> *) RemoteHost api) api

(KnownSymbol path, HasForeign k lang ftype api) => HasForeign k lang ftype ((:>) * Symbol path api)

Associated Types

type Foreign ((:>) * Symbol path api) api :: *

Methods

foreignFor :: Proxy lang ftype -> Proxy * ((* :> Symbol) path api) -> Proxy * api -> Req ((* :> Symbol) path api) -> Foreign ((* :> Symbol) path api) api

(Elem JSON list, HasForeignType k k1 lang ftype a, HasForeign k1 lang ftype api) => HasForeign k1 lang ftype ((:>) * * (ReqBody k list a) api)

Associated Types

type Foreign ((:>) * * (ReqBody k list a) api) api :: *

Methods

foreignFor :: Proxy lang ftype -> Proxy * ((* :> *) (ReqBody k list a) api) -> Proxy * api -> Req ((* :> *) (ReqBody k list a) api) -> Foreign ((* :> *) (ReqBody k list a) api) api

(KnownSymbol sym, HasForeignType * k lang ftype Bool, HasForeign k lang ftype api) => HasForeign k lang ftype ((:>) * * (QueryFlag sym) api)

Associated Types

type Foreign ((:>) * * (QueryFlag sym) api) api :: *

Methods

foreignFor :: Proxy lang ftype -> Proxy * ((* :> *) (QueryFlag sym) api) -> Proxy * api -> Req ((* :> *) (QueryFlag sym) api) -> Foreign ((* :> *) (QueryFlag sym) api) api

(KnownSymbol sym, HasForeignType * k lang ftype [a], HasForeign k lang ftype api) => HasForeign k lang ftype ((:>) * * (QueryParams * sym a) api)

Associated Types

type Foreign ((:>) * * (QueryParams * sym a) api) api :: *

Methods

foreignFor :: Proxy lang ftype -> Proxy * ((* :> *) (QueryParams * sym a) api) -> Proxy * api -> Req ((* :> *) (QueryParams * sym a) api) -> Foreign ((* :> *) (QueryParams * sym a) api) api

(KnownSymbol sym, HasForeignType k k1 lang ftype a, HasForeign k1 lang ftype api) => HasForeign k1 lang ftype ((:>) * * (QueryParam k sym a) api)

Associated Types

type Foreign ((:>) * * (QueryParam k sym a) api) api :: *

Methods

foreignFor :: Proxy lang ftype -> Proxy * ((* :> *) (QueryParam k sym a) api) -> Proxy * api -> Req ((* :> *) (QueryParam k sym a) api) -> Foreign ((* :> *) (QueryParam k sym a) api) api

(KnownSymbol sym, HasForeignType * k lang ftype a, HasForeign k lang ftype api) => HasForeign k lang ftype ((:>) * * (Header sym a) api)

Associated Types

type Foreign ((:>) * * (Header sym a) api) api :: *

Methods

foreignFor :: Proxy lang ftype -> Proxy * ((* :> *) (Header sym a) api) -> Proxy * api -> Req ((* :> *) (Header sym a) api) -> Foreign ((* :> *) (Header sym a) api) api

(KnownSymbol sym, HasForeignType k k1 lang ftype t, HasForeign k1 lang ftype api) => HasForeign k1 lang ftype ((:>) * * (Capture k sym t) api)

Associated Types

type Foreign ((:>) * * (Capture k sym t) api) api :: *

Methods

foreignFor :: Proxy lang ftype -> Proxy * ((* :> *) (Capture k sym t) api) -> Proxy * api -> Req ((* :> *) (Capture k sym t) api) -> Foreign ((* :> *) (Capture k sym t) api) api

(Elem JSON list, HasForeignType k k2 lang ftype a, ReflectMethod k1 method) => HasForeign k2 lang ftype (Verb k k1 method status list a)

Associated Types

type Foreign (Verb k k1 method status list a) api :: *

Methods

foreignFor :: Proxy lang ftype -> Proxy * (Verb k k1 method status list a) -> Proxy * api -> Req (Verb k k1 method status list a) -> Foreign (Verb k k1 method status list a) api

class GenerateList ftype reqs where

Utility class used by listFromAPI which computes the data needed to generate a function for each endpoint and hands it all back in a list.

Minimal complete definition

generateList

Methods

generateList :: reqs -> [Req ftype]

Instances

GenerateList ftype (Req ftype)

Methods

generateList :: Req ftype -> [Req ftype]

(GenerateList ftype start, GenerateList ftype rest) => GenerateList ftype ((:<|>) start rest)

Methods

generateList :: (start :<|> rest) -> [Req ftype]

listFromAPI :: (HasForeign lang ftype api, GenerateList ftype (Foreign ftype api)) => Proxy lang -> Proxy ftype -> Proxy api -> [Req ftype]

Generate the necessary data for codegen as a list, each Req describing one endpoint from your API type.