Web.Scotty.Trans.Strict

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.

Get a parameter. First looks in captures, then form data, then query parameters.

• Raises an exception which can be caught by catch if parameter is not found.

• If parameter is found, but parseParam fails to parse to the correct type, next is called. This means captures are somewhat typed, in that a route won't match if a correctly typed capture cannot be parsed.

Get all parameters from path, form and query (in that order).

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 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 form parameters

Get query parameters

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.

Get list of uploaded files.

NB: Loads all file contents in memory with options defaultParseRequestBodyOptions

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.

Redirect to given URL. Like throwing an uncatchable exception. Any code after the call to redirect will not be run.

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

OR

redirect "/foo/bar"

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

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

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

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

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

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 a "500 Server Error" StatusError, which can be caught with catch.

Uncaught exceptions turn into HTTP 500 responses.

Throw a StatusError exception that has an associated HTTP error code and can be caught with catch.

Uncaught exceptions turn into HTTP responses corresponding to the given status.

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.

Catch an exception e.g. a StatusError or a user-defined exception.

raise JustKidding `catch` (\msg -> text msg)

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.

Catch any synchronous IO exceptions

E.g. when a parameter is not found in a query string (400 Bad Request) or when parsing a JSON body fails (422 Unprocessable Entity)

Thrown e.g. when a request is too large