| Safe Haskell | Safe-Inferred |
|---|---|
| Language | GHC2021 |
Wire.API.Routes.MultiVerb
Contents
Synopsis
- data MultiVerb (method :: StdMethod) cs (as :: [Type]) (r :: Type)
- type MultiVerb1 m cs a = MultiVerb m cs '[a] (ResponseType a)
- data Respond (s :: Nat) (desc :: Symbol) (a :: Type)
- data RespondAs ct (s :: Nat) (desc :: Symbol) (a :: Type)
- type RespondEmpty s desc = RespondAs '() s desc ()
- data RespondStreaming (s :: Nat) (desc :: Symbol) (ct :: Type)
- data WithHeaders (hs :: [Type]) (a :: Type) (r :: Type)
- data DescHeader (name :: Symbol) (desc :: Symbol) (a :: Type)
- data OptHeader h
- class AsHeaders xs a b where
- class AsUnion (as :: [Type]) (r :: Type) where
- toUnion :: r -> Union (ResponseTypes as)
- fromUnion :: Union (ResponseTypes as) -> r
- eitherToUnion :: forall as bs a b. (InjectAfter as bs, InjectBefore as bs) => (a -> Union as) -> (b -> Union bs) -> Either a b -> Union (as .++ bs)
- eitherFromUnion :: EitherFromUnion as bs => (Union as -> a) -> (Union bs -> b) -> Union (as .++ bs) -> Either a b
- maybeToUnion :: forall as a. (InjectAfter as '[()], InjectBefore as '[()]) => (a -> Union as) -> Maybe a -> Union (as .++ '[()])
- maybeFromUnion :: forall as a. EitherFromUnion as '[()] => (Union as -> a) -> Union (as .++ '[()]) -> Maybe a
- class AsConstructor xs r where
- toConstructor :: ResponseType r -> NP I xs
- fromConstructor :: NP I xs -> ResponseType r
- newtype GenericAsConstructor r = GenericAsConstructor r
- newtype GenericAsUnion rs a = GenericAsUnion a
- type family ResponseType a :: Type
- class IsWaiBody (ResponseBody a) => IsResponse cs a where
- type ResponseStatus a :: Nat
- type ResponseBody a :: Type
- responseRender :: AcceptHeader -> ResponseType a -> Maybe (ResponseF (ResponseBody a))
- responseUnrender :: MediaType -> ResponseF (ResponseBody a) -> UnrenderResult (ResponseType a)
- class IsSwaggerResponse a where
- responseSwagger :: Declare Response
- class IsSwaggerResponseList as where
- responseListSwagger :: Declare (InsOrdHashMap HttpStatusCode Response)
- simpleResponseSwagger :: forall a cs desc. (ToSchema a, KnownSymbol desc, AllMime cs) => Declare Response
- combineResponseSwagger :: Response -> Response -> Response
- type family ResponseTypes (as :: [Type]) where ...
- class IsResponseList cs as where
- responseListRender :: AcceptHeader -> Union (ResponseTypes as) -> Maybe SomeResponse
- responseListUnrender :: MediaType -> SomeResponse -> UnrenderResult (Union (ResponseTypes as))
- responseListStatuses :: [Status]
- addContentType :: forall ct a. Accept ct => ResponseF a -> ResponseF a
MultiVerb types
data MultiVerb (method :: StdMethod) cs (as :: [Type]) (r :: Type) Source #
This type can be used in Servant to produce an endpoint which can return
multiple values with various content types and status codes. It is similar to
UVerb and behaves similarly, but it has some important differences:
- Descriptions and statuses can be attached to individual responses without using wrapper types and without affecting the handler return type.
- The return type of the handler can be decoupled from the types of the
individual responses. One can use a
Uniontype just like forUVerb, butMultiVerbalso supports using an arbitrary type with anAsUnioninstance. - Headers can be attached to individual responses, also without affecting the handler return type.
Instances
type MultiVerb1 m cs a = MultiVerb m cs '[a] (ResponseType a) Source #
A MultiVerb endpoint with a single response.
data Respond (s :: Nat) (desc :: Symbol) (a :: Type) Source #
A type to describe a MultiVerb response.
Includes status code, description, and return type. The content type of the
response is determined dynamically using the accept header and the list of
supported content types specified in the containing MultiVerb type.
Instances
data RespondAs ct (s :: Nat) (desc :: Symbol) (a :: Type) Source #
A type to describe a MultiVerb response with a fixed content type.
Similar to Respond, but hardcodes the content type to be used for
generating the response.
Instances
type RespondEmpty s desc = RespondAs '() s desc () Source #
A type to describe a MultiVerb response with an empty body.
Includes status code and description.
data RespondStreaming (s :: Nat) (desc :: Symbol) (ct :: Type) Source #
A type to describe a streaming MultiVerb response.
Includes status code, description and content type. Note that the handler return type is hardcoded to be 'SourceIO ByteString'.
Instances
data WithHeaders (hs :: [Type]) (a :: Type) (r :: Type) Source #
This type adds response headers to a MultiVerb response.
Type variables:
* hs: type-level list of headers
* a: return type (with headers)
* r: underlying response (without headers)
Instances
data DescHeader (name :: Symbol) (desc :: Symbol) (a :: Type) Source #
Instances
| (KnownSymbol name, KnownSymbol desc, ToParamSchema a) => ToResponseHeader (DescHeader name desc a :: Type) Source # | |
Defined in Wire.API.Routes.MultiVerb Methods toResponseHeader :: Proxy (DescHeader name desc a) -> (HeaderName, Header) Source # | |
A wrapper to turn a response header into an optional one.
Instances
| ToResponseHeader h => ToResponseHeader (OptHeader h :: Type) Source # | |
Defined in Wire.API.Routes.MultiVerb Methods toResponseHeader :: Proxy (OptHeader h) -> (HeaderName, Header) Source # | |
class AsHeaders xs a b where Source #
This is used to convert a response containing headers to a custom type including the information in the headers.
Instances
class AsUnion (as :: [Type]) (r :: Type) where Source #
This class is used to convert a handler return type to a union type
including all possible responses of a MultiVerb endpoint.
Any glue code necessary to convert application types to and from the
canonical Union type corresponding to a MultiVerb endpoint should be
packaged into an AsUnion instance.
Methods
toUnion :: r -> Union (ResponseTypes as) Source #
fromUnion :: Union (ResponseTypes as) -> r Source #
Instances
eitherToUnion :: forall as bs a b. (InjectAfter as bs, InjectBefore as bs) => (a -> Union as) -> (b -> Union bs) -> Either a b -> Union (as .++ bs) Source #
eitherFromUnion :: EitherFromUnion as bs => (Union as -> a) -> (Union bs -> b) -> Union (as .++ bs) -> Either a b Source #
maybeToUnion :: forall as a. (InjectAfter as '[()], InjectBefore as '[()]) => (a -> Union as) -> Maybe a -> Union (as .++ '[()]) Source #
maybeFromUnion :: forall as a. EitherFromUnion as '[()] => (Union as -> a) -> Union (as .++ '[()]) -> Maybe a Source #
class AsConstructor xs r where Source #
This class can be instantiated to get automatic derivation of AsUnion
instances via GenericAsUnion. The idea is that one has to make sure that for
each response r in a MultiVerb endpoint, there is an instance of
AsConstructor xs r for some xs, and that the list xss of all the
corresponding xs is equal to Code of the handler type. Then one can
write:
@
type Responses = ...
data Result = ...
deriving stock (Generic)
deriving (AsUnion Responses) via (GenericAsUnion Responses Result)
instance GSOP.Generic Result
@
and get an AsUnion instance for free.
There are a few predefined instances for constructors taking a single type
corresponding to a simple response, and for empty responses, but in more
general cases one either has to define an AsConstructor instance by hand,
or derive it via GenericAsConstructor.
Methods
toConstructor :: ResponseType r -> NP I xs Source #
fromConstructor :: NP I xs -> ResponseType r Source #
Instances
newtype GenericAsConstructor r Source #
Constructors
| GenericAsConstructor r |
Instances
| (Code (ResponseType r) ~ '[xs], Generic (ResponseType r)) => AsConstructor xs (GenericAsConstructor r) Source # | |
Defined in Wire.API.Routes.MultiVerb Methods toConstructor :: ResponseType (GenericAsConstructor r) -> NP I xs Source # fromConstructor :: NP I xs -> ResponseType (GenericAsConstructor r) Source # | |
| type ResponseType (GenericAsConstructor r) Source # | |
Defined in Wire.API.Routes.MultiVerb | |
newtype GenericAsUnion rs a Source #
This type is meant to be used with deriving via in order to automatically
generate an AsUnion instance using SOP.
See AsConstructor for more information and examples.
Constructors
| GenericAsUnion a |
Instances
| (Code a ~ xss, Generic a, AsConstructors xss rs) => AsUnion rs (GenericAsUnion rs a) Source # | |
Defined in Wire.API.Routes.MultiVerb Methods toUnion :: GenericAsUnion rs a -> Union (ResponseTypes rs) Source # fromUnion :: Union (ResponseTypes rs) -> GenericAsUnion rs a Source # | |
type family ResponseType a :: Type Source #
Instances
| type ResponseType RespondWithDeletionCodeTimeout Source # | |
| type ResponseType (GenericAsConstructor r) Source # | |
Defined in Wire.API.Routes.MultiVerb | |
| type ResponseType (ErrorResponse e) Source # | |
Defined in Wire.API.Error | |
| type ResponseType (Respond s desc a) Source # | |
Defined in Wire.API.Routes.MultiVerb | |
| type ResponseType (RespondStreaming s desc ct) Source # | |
Defined in Wire.API.Routes.MultiVerb | |
| type ResponseType (WithHeaders hs a r) Source # | |
Defined in Wire.API.Routes.MultiVerb | |
| type ResponseType (EmptyErrorForLegacyReasons s desc) Source # | |
Defined in Wire.API.Error.Empty | |
| type ResponseType (RespondAs ct s desc a) Source # | |
Defined in Wire.API.Routes.MultiVerb | |
| type ResponseType (VersionedRespond v s desc a) Source # | |
Defined in Wire.API.Routes.Versioned | |
class IsWaiBody (ResponseBody a) => IsResponse cs a where Source #
Methods
responseRender :: AcceptHeader -> ResponseType a -> Maybe (ResponseF (ResponseBody a)) Source #
responseUnrender :: MediaType -> ResponseF (ResponseBody a) -> UnrenderResult (ResponseType a) Source #
Instances
class IsSwaggerResponse a where Source #
Methods
responseSwagger :: Declare Response Source #
Instances
class IsSwaggerResponseList as where Source #
Methods
responseListSwagger :: Declare (InsOrdHashMap HttpStatusCode Response) Source #
Instances
| IsSwaggerResponseList ('[] :: [k]) Source # | |
Defined in Wire.API.Routes.MultiVerb Methods responseListSwagger :: Declare (InsOrdHashMap HttpStatusCode Response) Source # | |
| (IsSwaggerResponse a, KnownNat (ResponseStatus a), IsSwaggerResponseList as) => IsSwaggerResponseList (a ': as :: [Type]) Source # | |
Defined in Wire.API.Routes.MultiVerb Methods responseListSwagger :: Declare (InsOrdHashMap HttpStatusCode Response) Source # | |
simpleResponseSwagger :: forall a cs desc. (ToSchema a, KnownSymbol desc, AllMime cs) => Declare Response Source #
type family ResponseTypes (as :: [Type]) where ... Source #
Equations
| ResponseTypes '[] = '[] | |
| ResponseTypes (a ': as) = ResponseType a ': ResponseTypes as |
class IsResponseList cs as where Source #
Methods
responseListRender :: AcceptHeader -> Union (ResponseTypes as) -> Maybe SomeResponse Source #
responseListUnrender :: MediaType -> SomeResponse -> UnrenderResult (Union (ResponseTypes as)) Source #
Instances
| IsResponseList (cs :: k) ('[] :: [Type]) Source # | |
Defined in Wire.API.Routes.MultiVerb Methods responseListRender :: AcceptHeader -> Union (ResponseTypes '[]) -> Maybe SomeResponse Source # responseListUnrender :: MediaType -> SomeResponse -> UnrenderResult (Union (ResponseTypes '[])) Source # | |
| (IsResponse cs a, IsResponseList cs as, KnownStatus (ResponseStatus a)) => IsResponseList (cs :: k) (a ': as) Source # | |
Defined in Wire.API.Routes.MultiVerb Methods responseListRender :: AcceptHeader -> Union (ResponseTypes (a ': as)) -> Maybe SomeResponse Source # responseListUnrender :: MediaType -> SomeResponse -> UnrenderResult (Union (ResponseTypes (a ': as))) Source # | |