| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Solga
- serve :: Router r => r -> Application
- serveThrow :: Router r => r -> Application
- type (:>) f g = f g
- type (/>) seg g = Seg seg :> g
- type Get a = Endpoint "GET" (JSON a)
- type Post a = Endpoint "POST" (JSON a)
- newtype JSON a = JSON {
- jsonResponse :: a
- newtype Raw = Raw {}
- newtype RawResponse = RawResponse {}
- newtype End next = End {
- endNext :: next
- newtype WithIO next = WithIO {
- withIONext :: IO next
- newtype Seg seg next = Seg {
- segNext :: next
- data OneOfSegs segs next = OneOfSegs {
- oneOfSegsNext :: next
- class FromSegment a where
- newtype Capture a next = Capture {
- captureNext :: a -> next
- newtype Method method next = Method {
- methodNext :: next
- data ExtraHeaders next = ExtraHeaders {
- extraHeaders :: ResponseHeaders
- extraHeadersNext :: next
- newtype NoCache next = NoCache {
- noCacheNext :: next
- newtype ReqBodyJSON a next = ReqBodyJSON {
- reqBodyJSONNext :: a -> next
- type MultiPartData = ([Param], [File FilePath])
- data ReqBodyMultipart a next = ReqBodyMultipart {
- reqMultiPartParse :: MultiPartData -> Either String a
- reqMultiPartNext :: a -> next
- type Endpoint method a = End :> (NoCache :> (Method method :> (WithIO :> a)))
- data left :<|> right = (:<|>) {}
- class Abbreviated a where
- data SolgaError
- badRequest :: Text -> SolgaError
- notFound :: Text -> SolgaError
- class Router r where
- type Responder = (Response -> IO ResponseReceived) -> IO ResponseReceived
- tryRouteNext :: Router r' => (r -> r') -> Request -> Maybe (r -> Responder)
- tryRouteNextIO :: Router r' => (r -> IO r') -> Request -> Maybe (r -> Responder)
Serving APIs
serve :: Router r => r -> Application Source #
Serve a Router with Solga, returning SolgaErrors as HTTP responses and other errors as HTTP 500.
serveThrow :: Router r => r -> Application Source #
Serve a Router with Solga, throwing SolgaErrors.
Basic routers
type (:>) f g = f g infixr 2 Source #
Compose routers. This is just type application,
ie.: Foo :> Bar :> Baz == Foo (Bar Baz)
Return a given JSON object
Constructors
| JSON | |
Fields
| |
Serve a given WAI Application.
Constructors
| Raw | |
Fields | |
Only accept the end of a path.
Produce a response with IO.
Constructors
| WithIO | |
Fields
| |
data OneOfSegs segs next Source #
Match any of a set of path segments.
Constructors
| OneOfSegs | |
Fields
| |
class FromSegment a where Source #
The class of types that can be parsed from a path segment.
Minimal complete definition
Methods
fromSegment :: Text -> Maybe a Source #
Instances
newtype Capture a next Source #
Capture a path segment and pass it on.
Constructors
| Capture | |
Fields
| |
Instances
| Abbreviated next => Abbreviated (Capture a next) Source # | |
| (FromSegment a, Router next) => Router (Capture a next) Source # | |
| type Brief (Capture a next) Source # | |
newtype Method method next Source #
Accepts requests with a certain method.
Constructors
| Method | |
Fields
| |
Instances
| Eq next => Eq (Method method next) Source # | |
| Ord next => Ord (Method method next) Source # | |
| Show next => Show (Method method next) Source # | |
| Abbreviated next => Abbreviated (Method method next) Source # | |
| (KnownSymbol method, Router next) => Router (Method method next) Source # | |
| type Brief (Method method next) Source # | |
data ExtraHeaders next Source #
Set extra headers on responses. Existing headers will be overriden if specified here.
Constructors
| ExtraHeaders | |
Fields
| |
Instances
| Abbreviated (ExtraHeaders next) Source # | |
| Router next => Router (ExtraHeaders next) Source # | |
| type Brief (ExtraHeaders next) Source # | |
Prevent caching for sub-routers.
Constructors
| NoCache | |
Fields
| |
newtype ReqBodyJSON a next Source #
Parse a JSON request body.
Constructors
| ReqBodyJSON | |
Fields
| |
Instances
| Abbreviated next => Abbreviated (ReqBodyJSON a next) Source # | |
| (FromJSON a, Router next) => Router (ReqBodyJSON a next) Source # | |
| type Brief (ReqBodyJSON a next) Source # | |
data ReqBodyMultipart a next Source #
Accept a "multipart/form-data" request. Files will be stored in a temporary directory and will be deleted automatically after the request is processed.
Constructors
| ReqBodyMultipart | |
Fields
| |
Instances
| Abbreviated (ReqBodyMultipart a next) Source # | |
| Router next => Router (ReqBodyMultipart a next) Source # | |
| type Brief (ReqBodyMultipart a next) Source # | |
type Endpoint method a = End :> (NoCache :> (Method method :> (WithIO :> a))) Source #
Useful synonym for dynamic endpoints: accept requests with a given method, compute a JSON response in IO and don't cache.
data left :<|> right infixr 1 Source #
Try to route with left, or try to route with right.
Instances
| (Eq right, Eq left) => Eq ((:<|>) left right) Source # | |
| (Ord right, Ord left) => Ord ((:<|>) left right) Source # | |
| (Show right, Show left) => Show ((:<|>) left right) Source # | |
| (Abbreviated left, Abbreviated right) => Abbreviated ((:<|>) left right) Source # | |
| (Router left, Router right) => Router ((:<|>) left right) Source # | |
| type Brief ((:<|>) left right) Source # | |
Abbreviation
class Abbreviated a where Source #
Most Routers are really just newtypes. By using brief, you can
construct trees of Routers by providing only their inner types, much
like Servant.
Instances
| Abbreviated RawResponse Source # | |
| Abbreviated Raw Source # | |
| Abbreviated next => Abbreviated (WithIO next) Source # | |
| Abbreviated next => Abbreviated (NoCache next) Source # | |
| Abbreviated (ExtraHeaders next) Source # | |
| Abbreviated (JSON a) Source # | |
| Abbreviated next => Abbreviated (End next) Source # | |
| Abbreviated (ReqBodyMultipart a next) Source # | |
| Abbreviated next => Abbreviated (ReqBodyJSON a next) Source # | |
| Abbreviated next => Abbreviated (Method method next) Source # | |
| Abbreviated next => Abbreviated (Capture a next) Source # | |
| Abbreviated next => Abbreviated (OneOfSegs segs next) Source # | |
| (Abbreviated left, Abbreviated right) => Abbreviated ((:<|>) left right) Source # | |
| Abbreviated next => Abbreviated (Seg seg next) Source # | |
Error handling
badRequest :: Text -> SolgaError Source #
Create a 400 Bad Request error with a given message.
notFound :: Text -> SolgaError Source #
Create a 404 Not Found error with a given message.
Router implementation
Routers are the basic typeclass of Solga: their types describe what type of requests they accept, and their values describe how to handle them.
You can use Generic to get free instance of Router for any data type with one constructor
and Routers as fields. The fields will be considered alternatives, as if you wrote :<|> between them.
Methods
tryRoute :: Request -> Maybe (r -> Responder) Source #
Given a request, if the router supports the given request return a function that constructs a response with a concrete router.
tryRoute :: (Generic r, Router (Rep r ())) => Request -> Maybe (r -> Responder) Source #
Given a request, if the router supports the given request return a function that constructs a response with a concrete router.
Instances
type Responder = (Response -> IO ResponseReceived) -> IO ResponseReceived Source #
The right hand side of Application. Request is already known.
tryRouteNext :: Router r' => (r -> r') -> Request -> Maybe (r -> Responder) Source #
Try to route using a type r by providing a function to turn it into a Router r'.
Useful for passing routing on to the next step.
tryRouteNextIO :: Router r' => (r -> IO r') -> Request -> Maybe (r -> Responder) Source #
Like tryRouteNext but in IO.