Run a Spock application using run from Network.Wai.Handler.Warp.

Like runSpock, but does not display the banner "Spock is running on port XXX" on stdout.

Convert a middleware to an application. All failing requests will result in a 404 page

Create a spock application using a given db storageLayer and an initial state. Spock works with database libraries that already implement connection pooling and with those that don't come with it out of the box. For more see the PoolOrConn type. Use runSpock to run the app or spockAsApp to create a Wai.Application

Register routes and middleware when the application starts. The handler passed to a route runs later, once per matching request, in SpockAction.

conn is a database connection, sess is one visitor's session value, and st is application-wide state. The final result parameter is usually (). This is SpockCtxM with an empty request context. Use SpockCtxM inside a prehook that supplies a typed context.

Route registration with handlers that receive context ctx. A prehook produces this context per request; getContext reads it in the handler. Context belongs to the selected request and hook scope, while st is shared by the entire application and sess belongs to a visitor's session.

The underlying monad is WebStateM: lift helper runs a shared-state or database helper during registration. Inside a handler, the same expression runs it for that request. Use liftIO for an ordinary IO operation.

The root of a path piece. Use to define a handler for "/"

A variant of Either with a FromHttpApiData definition that tries both branches without a prefix. Useful to define routes with vars that should work with different types.

A route parameter

A static route piece. One leading slash is optional. Empty internal and trailing pieces are retained for strict routing; compatibility routing and renderRoute ignore them. Use renderRouteWith with the application's policy.

Require a trailing slash in strict routing, including after a capture. Root remains root, and a path already ending in a slash is unchanged.

Combine two path components

Join the last segment on the left and the first on the right with a dot. Both sides may contain typed captures: var . "txt" or var . var. Matching tries the rightmost dot first and accepts the first split whose typed parsers and literals succeed. Use a custom capture type to restrict extensions; a Text capture accepts any text, including an empty extension. Static routes take precedence over extensions, then plain captures and wildcards. More literal characters give an extension pattern priority.

Matches the rest of the route. Should be the last part of the path.

Render a route applying path pieces

Render with the application's slash policy. Use StrictSlashes or RedirectTrailingSlashes to preserve trailing and repeated literal slashes.

Render a URL with each complete path segment percent-encoded.

Percent-encoded rendering with the application's slash policy.

Specify an action that will be run before all subroutes. It can modify the requests current context

Specify an action that will be run when the HTTP verb GET and the given route match

Specify an action that will be run when the HTTP verb POST and the given route match

Specify an action that will be run when the HTTP verb GET/POST and the given route match

Specify an action that will be run when the HTTP verb HEAD and the given route match

Specify an action that will be run when the HTTP verb PUT and the given route match

Specify an action that will be run when the HTTP verb DELETE and the given route match

Specify an action that will be run when the HTTP verb PATCH and the given route match

Specify an action that will be run when a standard HTTP verb and the given route match

Specify an action that will be run when a custom HTTP verb and the given route match

Specify an action that will be run when a standard HTTP verb matches but no defined route matches. The full path is passed as an argument

Specify an action that will be run when a custom HTTP verb matches but no defined route matches. The full path is passed as an argument

Specify an action that will be run regardless of the HTTP verb

Specify an action that will be run regardless of the HTTP verb and no defined route matches. The full path is passed as an argument

HTTP standard method (as defined by RFC 2616, and PATCH which is defined by RFC 5789).

Since: http-types-0.2.0

Hook wai middleware into Spock

A per-request SpockActionCtx with context (). This is the usual handler type outside a prehook. Its conn, sess, and st parameters have the same meanings as in the application's route-registration type.

A per-request action with typed context ctx, database connection conn, session value sess, and shared application state st. The final type parameter is the action's result. Use getContext for the value supplied by a prehook, getState for shared state, and session actions for this visitor.

This is ActionCtxT over WebStateM. lift helper enters WebStateM; liftIO operation runs IO. Sending a response finishes the action even though response helpers have a polymorphic result type.

Access application services in WebStateM and Spock's registration/action layers. Helpers polymorphic in this class can use getState and runQuery without committing to either of those layers.

Get the CSRF token for the current user. This token must be sent on all non GET requests via a post parameter or HTTP-Header if spc_csrfProtection is turned on. See configuration SpockCfg documentation for more information

Get the CSRF token sent by the client. You should not need to call this manually if spc_csrfProtection is turned on.

Check that the client sent a valid CSRF token. You should not need to call this manually in non GET requests if spc_csrfProtection is turned on.

Shared application services over ResourceT IO. This is the base monad underneath both route registration and request actions in full Spock. Helpers here can use getState and runQuery, but have no request body, response, hook context, or current visitor's session. Those require the action layer. Lift such a helper into an action or registration block with lift; use runSpockIO with an existing environment to run it from IO.

Add the application's WebState environment to an underlying monad m. conn, sess, and st select the connection, session value, and shared state types; a is the computation's result. This is a reader of an existing environment, not a mutable state transformer. Put an IORef or TVar in st when shared state needs to change, with suitable synchronization.

Applications normally use WebStateM, the resource-managed IO specialization.

The application environment: connection pool, session manager, configuration, and shared state. It does not contain a particular request.

Read the heart of Spock. This is useful if you want to construct your own monads that work with runQuery and getState using runSpockIO

Run an action inside of Spocks core monad. This allows you to use runQuery and getState

Read the connection pool of Spock. This is useful if you want to construct your own monads that work with runQuery and getState using runSpockIO