Documentation

Pipe operator

Returns the request path, e.g. /Users or /CreateUser

Returns the request path and the query params, e.g. /ShowUser?userId=9bd6b37b-2e53-40a4-bb7b-fdba67d6af42

Returns a header value for a given header name. Returns Nothing if not found

The header is looked up in a case insensitive way.

>>> getHeader "Content-Type"
Just "text/html"

>>> getHeader "X-My-Custom-Header"
Nothing

Returns the current HTTP request.

See https://hackage.haskell.org/package/wai-3.2.2.1/docs/Network-Wai.html#t:Request

A list of headers (a pair of key and value) in an HTTP request.

A container storing useful data along the request lifecycle, such as the request, the current user, set current view layout, flash messages, ...

The controller context is usually accessed via the ?context variable. It's available inside the action and the view. Think of it as a key-value-map where the key is the type of the value.

You can store information inside the context using putContext:

>>> newtype CurrentLayout = CurrentLayout Html
>>> 
>>> ?context <- newControllerContext
>>> putContext (CurrentLayout layout)

Inside an action you can access the values using fromContext:

>>> (CurrentLayout layout) <- fromContext

You can freeze the context and then access values without being inside an IO context (like inside views which are pure):

Call freeze inside an IO part:

>>> ?context <- freeze ?context

(freeze is automatically called by IHP before rendering a view, so usually you don't need to call it manually)

Then use the frozen context from your pure code like this:

>>> let (CurrentLayout layout) = fromFrozenContext in ...

The context is initially created before a action is going to be executed. Its life cycle looks like this:

• newControllerContext: The new controller context is created
• The runActionWithNewContext fills in a few default values: The current ?application and also the Flash Messages to be rendered in the to-be-generated response.
• initContext: The initContext function of the InitControllerContext WebApplication (inside your FrontController.hs) is called. There application-specific context can be provided. Usually this is the current user and the default layout.
• beforeAction: Here the context could also be modified. E.g. the layout could be overriden here for the whole controller.
• action ..: The action itself.
• Freezing: Before rendering the response, the container is frozen. Frozen means that all previously mutable fields become immutable.
• View Rendering: The frozen container is now used inside the view and layout to display information such as the current user or flash messages

Sends a response to the client. Used by render functions.

This is the normal way to respond - it calls the WAI respond callback directly and returns the ResponseReceived.

Sends a response and exits the current action via early return. Sends the response via respondWith then throws EarlyReturnException so the action short-circuits.

Exit a request handler early after sending a response.

Use this when you want to conditionally exit a handler:

handler = do
    when someCondition do
        earlyReturn (sendErrorResponse ...)
    -- rest of the handler
    sendNormalResponse

The function runs the given IO action (which should send a response), then throws EarlyReturnException to exit. The middleware catches this exception so it doesn't propagate further.

Set a header value for a given header name.

>>> setHeader ("Content-Language", "en")

Returns a custom config parameter

>>> getAppConfig @StripePublicKey
StripePublicKey "pk_test_..."

Example:

First you need to define a custom config parameter in Config.hs:

-- Config/Config.hs
newtype StripePublicKey = StripePublicKey Text

config :: ConfigBuilder
config = do
    -- ...
    stripePublicKey <- StripePublicKey <$> env @Text "STRIPE_PUBLIC_KEY"
    option stripePublicKey

Then you can access it using getAppConfig:

action MyAction = do
    let (StripePublicKey stripePublicKey) = getAppConfig @StripePublicKey

    putStrLn ("Stripe public key: " <> stripePublicKey)

Type alias for WAI respond function

Information on the request sent by the client. This abstracts away the details of the underlying implementation.

Shared request context setup, specialized once per application type. Takes a pre-computed TypeRep to avoid per-controller-type code duplication. NOINLINE ensures GHC compiles one copy shared across all controllers.

Exceptions from initContext (including EarlyReturnException) propagate to the caller, which is expected to catch them.

A special datatype to indicate that the WAI handler has received the response. This is to avoid the need for Rank2Types in the definition of Application.

It is highly advised that only WAI handlers import and use the data constructor for this data type.

Since: wai-3.0.0