Run a scotty application using the warp server. NB: scotty p === scottyT p id

Run a scotty application using the warp server, passing extra options. NB: scottyOpts opts === scottyOptsT opts id

Run a scotty application using the warp server, passing extra options, and listening on the provided socket. NB: scottySocket opts sock === scottySocketT opts sock id

Turn a scotty application into a WAI Application, which can be run with any WAI handler. NB: scottyApp === scottyAppT id

Use given middleware. Middleware is nested such that the first declared is the outermost middleware (it has first dibs on the request and last action on the response). Every middleware is run on each request.

get = addroute GET

post = addroute POST

put = addroute PUT

delete = addroute DELETE

patch = addroute PATCH

options = addroute OPTIONS

Define a route with a StdMethod, a route pattern representing the path spec, and an Action which may modify the response.

get "/" $ text "beam me up!"

The path spec can include values starting with a colon, which are interpreted as captures. These are parameters that can be looked up with pathParam.

>>> :{
let server = S.get "/foo/:bar" (S.pathParam "bar" >>= S.text)
 in do
      withScotty server $ curl "http://localhost:3000/foo/something"
:}
"something"

Add a route that matches regardless of the HTTP verb.

Specify an action to take if nothing else is found. Note: this _always_ matches, so should generally be the last route specified.

Set global size limit for the request body. Requests with body size exceeding the limit will not be processed and an HTTP response 413 will be returned to the client. Size limit needs to be greater than 0, otherwise the application will terminate on start.

Standard Sinatra-style route. Named captures are prepended with colons. This is the default route type generated by OverloadedString routes. i.e.

get (capture "/foo/:bar") $ ...

and

{-# LANGUAGE OverloadedStrings #-}
...
get "/foo/:bar" $ ...

are equivalent.

Match requests using a regular expression. Named captures are not yet supported.

>>> :{
let server = S.get (S.regex "^/f(.*)r$") $ do
                cap <- S.pathParam "1"
                S.text cap
 in do
      withScotty server $ curl "http://localhost:3000/foo/bar"
:}
"oo/ba"

Build a route based on a function which can match using the entire Request object. Nothing indicates the route does not match. A Just value indicates a successful match, optionally returning a list of key-value pairs accessible by param.

>>> :{
let server = S.get (function $ \req -> Just [("version", T.pack $ show $ W.httpVersion req)]) $ do
                v <- S.pathParam "version"
                S.text v
 in do
      withScotty server $ curl "http://localhost:3000/"
:}
"HTTP/1.1"

Build a route that requires the requested path match exactly, without captures.

Get the Request object.

Get a request header. Header name is case-insensitive.

Get all the request headers. Header names are case-insensitive.

Get the request body.

NB This loads the whole request body in memory at once.

Get an IO action that reads body chunks

• This is incompatible with body since body consumes all chunks.

Parse the request body as a JSON object and return it.

If the JSON object is malformed, this sets the status to 400 Bad Request, and throws an exception.

If the JSON fails to parse, this sets the status to 422 Unprocessable Entity.

These status codes are as per https://www.restapitutorial.com/httpstatuscodes.html.

NB : Internally this uses body.

Parse the request body as x-www-form-urlencoded form data and return it.

The form is parsed using urlDecodeAsForm. If that returns Left, the status is set to 400 and an exception is thrown.

Look up a path parameter.

• Raises an exception which can be caught by catch if parameter is not found. If the exception is not caught, scotty will return a HTTP error code 500 ("Internal Server Error") to the client.
• If the parameter is found, but parseParam fails to parse to the correct type, next is called.

Since: 0.20

Synonym for pathParam

Look up a form parameter.

• Raises an exception which can be caught by catch if parameter is not found. If the exception is not caught, scotty will return a HTTP error code 400 ("Bad Request") to the client.
• This function raises a code 400 also if the parameter is found, but parseParam fails to parse to the correct type.

Since: 0.20

Look up a query parameter.

• Raises an exception which can be caught by catch if parameter is not found. If the exception is not caught, scotty will return a HTTP error code 400 ("Bad Request") to the client.
• This function raises a code 400 also if the parameter is found, but parseParam fails to parse to the correct type.

Since: 0.20

Look up a path parameter. Returns Nothing if the parameter is not found or cannot be parsed at the right type.

NB : Doesn't throw exceptions. In particular, route pattern matching will not continue, so developers must raiseStatus or throw to signal something went wrong.

Since: 0.21

Look up a capture parameter. Returns Nothing if the parameter is not found or cannot be parsed at the right type.

NB : Doesn't throw exceptions. In particular, route pattern matching will not continue, so developers must raiseStatus or throw to signal something went wrong.

Since: 0.21

Look up a form parameter. Returns Nothing if the parameter is not found or cannot be parsed at the right type.

NB : Doesn't throw exceptions, so developers must raiseStatus or throw to signal something went wrong.

Since: 0.21

Look up a query parameter. Returns Nothing if the parameter is not found or cannot be parsed at the right type.

NB : Doesn't throw exceptions, so developers must raiseStatus or throw to signal something went wrong.

Since: 0.21

Get path parameters

Get path parameters

Get form parameters

Get query parameters

Get list of uploaded files.

NB: Loads all file contents in memory with options defaultParseRequestBodyOptions

Get list of uploaded temp files and form parameters decoded from multipart payloads.

NB the temp files are deleted when the continuation exits.

Set the HTTP response status.

Add to the response headers. Header names are case-insensitive.

Set one of the response headers. Will override any previously set value for that header. Header names are case-insensitive.

Synonym for redirect302. If you are unsure which redirect to use, you probably want this one.

redirect "http://www.google.com"

OR

redirect "/foo/bar"

Redirect to given URL with status 300 (Multiple Choices). Like throwing an uncatchable exception. Any code after the call to redirect will not be run.

Redirect to given URL with status 301 (Moved Permanently). Like throwing an uncatchable exception. Any code after the call to redirect will not be run.

Redirect to given URL with status 302 (Found). Like throwing an uncatchable exception. Any code after the call to redirect will not be run.

Redirect to given URL with status 303 (See Other). Like throwing an uncatchable exception. Any code after the call to redirect will not be run.

Redirect to given URL with status 304 (Not Modified). Like throwing an uncatchable exception. Any code after the call to redirect will not be run.

Redirect to given URL with status 307 (Temporary Redirect). Like throwing an uncatchable exception. Any code after the call to redirect will not be run.

Redirect to given URL with status 308 (Permanent Redirect). Like throwing an uncatchable exception. Any code after the call to redirect will not be run.

Send a file as the response. Doesn't set the "Content-Type" header, so you probably want to do that on your own with setHeader. Setting a status code will have no effect because Warp will overwrite that to 200 (see sendResponse).

Set the body of the response to the JSON encoding of the given value. Also sets "Content-Type" header to "application/json; charset=utf-8" if it has not already been set.

Set the body of the response to a Source. Doesn't set the "Content-Type" header, so you probably want to do that on your own with setHeader.

Set the body of the response to the given ByteString value. Doesn't set the "Content-Type" header, so you probably want to do that on your own with setHeader.

Nest a whole WAI application inside a Scotty handler. See Web.Scotty for further documentation

Access the HTTP headers of the Response

SINCE 0.21

Access the HTTP Status of the Response

SINCE 0.21

Access the content of the Response

SINCE 0.21

Throw an exception which can be caught within the scope of the current Action with catch.

If the exception is not caught locally, another option is to implement a global Handler (with defaultHandler) that defines its interpretation and a translation to HTTP error codes.

Uncaught exceptions turn into HTTP 500 responses.

Abort execution of this action and continue pattern matching routes. Like an exception, any code after next is not executed.

NB : Internally, this is implemented with an exception that can only be caught by the library, but not by the user.

As an example, these two routes overlap. The only way the second one will ever run is if the first one calls next.

get "/foo/:bar" $ do
  w :: Text <- pathParam "bar"
  unless (w == "special") next
  text "You made a request to /foo/special"

get "/foo/:baz" $ do
  w <- pathParam "baz"
  text $ "You made a request to: " <> w

Finish the execution of the current action. Like throwing an uncatchable exception. Any code after the call to finish will not be run.

Since: 0.10.3

Global handler for user-defined exceptions.

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

Catch a synchronous (but not asynchronous) exception and recover from it.

This is parameterized on the exception type. To catch all synchronous exceptions, use catchAny.

Since: unliftio-0.1.0.0

Thrown e.g. when a request is too large

Minimum implemention: parseParam

Useful for creating Parsable instances for things that already implement Read. Ex:

instance Parsable Int where parseParam = readEither

Type parameter t is the file content. Could be () when not needed or a FilePath for temp files instead.

Specializes a Handler to the ActionT monad

Generalized version of Handler

makeSimpleCookie and setCookie combined.

Lookup one cookie name

Returns all cookies

Browsers don't directly delete a cookie, but setting its expiry to a past date (e.g. the UNIX epoch) ensures that the cookie will be invalidated (whether and when it will be actually deleted by the browser seems to be browser-dependent).

Construct a simple cookie (an UTF-8 string pair with default cookie options)

Represents a session containing an ID, expiration time, and content.

Type alias for session identifiers.

Type for session storage, a transactional variable containing a map of session IDs to sessions.

Creates a new session jar and starts a background thread to maintain it.

Creates a new session for a user, storing the content and setting a cookie.

Creates a new session with a generated ID, sets its expiration, | and adds it to the session jar.

Reads the content of the current user's session.

Reads the content of a session by its ID.

Retrieves the current user's session based on the "sess_id" cookie. | Returns `Left SessionStatus` if the session is expired or does not exist.

Retrieves a session by its ID from the session jar.

Adds or overwrites a new session to the session jar.

Deletes a session by its ID from the session jar.

Continuously removes expired sessions from the session jar.