Web.Spock.Simple

Spock's core

spock :: Int -> SessionCfg sess -> PoolOrConn conn -> st -> SpockM conn sess st () -> IO ()

Run a spock application using the warp server, 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.

type SpockM conn sess st a = SpockT (WebStateM conn sess st) a

type SpockAction conn sess st = ActionT (WebStateM conn sess st)

The SpockAction is the monad of all route-actions. You have access to the database, session and state of your application.

spockT :: MonadIO m => Port -> (forall a. m a -> IO a) -> SpockT m () -> IO ()

Run a raw spock application with custom underlying monad

data SpockT m a

Instances

MonadTrans SpockT

Monad m => Monad (SpockT m)

Functor m => Functor (SpockT m)

(Monad m, Functor m) => Applicative (SpockT m)

MonadIO m => MonadIO (SpockT m)

data ActionT m a

Instances

MonadTrans ActionT

Monad m => Monad (ActionT m)

Functor m => Functor (ActionT m)

(Monad m, Functor m) => Applicative (ActionT m)

MonadIO m => MonadIO (ActionT m)

spockApp :: MonadIO m => (forall a. m a -> IO a) -> SpockT m () -> IO Application

Convert a Spock-App to a wai-application

Defining routes

data SpockRoute

Instances

Eq SpockRoute

Ord SpockRoute

Read SpockRoute

Show SpockRoute

IsString SpockRoute

(<#>) :: SpockRoute -> SpockRoute -> SpockRoute

Combine two route components safely "foo" # "bar" ===> "foobar" "foo" # "bar" ===> "foobar" "foo # "bar" ===> "foo/bar"

Hooking routes

subcomponent :: Monad m => SpockRoute -> SpockT m () -> SpockT m ()

Define a subcomponent. Usage example:

subcomponent "/site" $
  do get "/home" homeHandler
     get "/misc/:param" $ -- ...
subcomponent "/admin" $
  do get "/home" adminHomeHandler

The request sitehome will be routed to homeHandler and the request adminhome will be routed to adminHomeHandler

get :: MonadIO m => SpockRoute -> ActionT m () -> SpockT m ()

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

post :: MonadIO m => SpockRoute -> ActionT m () -> SpockT m ()

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

head :: MonadIO m => SpockRoute -> ActionT m () -> SpockT m ()

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

put :: MonadIO m => SpockRoute -> ActionT m () -> SpockT m ()

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

delete :: MonadIO m => SpockRoute -> ActionT m () -> SpockT m ()

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

patch :: MonadIO m => SpockRoute -> ActionT m () -> SpockT m ()

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

hookRoute :: Monad m => StdMethod -> SpockRoute -> ActionT m () -> SpockT m ()

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

hookAny :: Monad m => StdMethod -> ([Text] -> ActionT m ()) -> SpockT m ()

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

data StdMethod :: *

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

Constructors

GET

POST

HEAD

PUT

DELETE

TRACE

CONNECT

OPTIONS

PATCH

Instances

Bounded StdMethod

Enum StdMethod

Eq StdMethod

Ord StdMethod

Read StdMethod

Show StdMethod

Ix StdMethod

Hashable StdMethod

Adding Wai.Middleware

middleware :: Monad m => Middleware -> SpockT m ()

Hook wai middleware into Spock

Using Spock as middleware

spockMiddleware :: MonadIO m => (forall a. m a -> IO a) -> SpockT m () -> IO Middleware

Convert a Spock-App to a wai-middleware

Safe actions

class (Hashable a, Eq a, Typeable a) => SafeAction conn sess st a where

SafeActions are actions that need to be protected from csrf attacks

Methods

runSafeAction :: a -> SpockAction conn sess st ()

The body of the safe action. Either GET or POST

safeActionPath :: forall conn sess st a. (SafeAction conn sess st a, HasSpock (SpockAction conn sess st), SpockConn (SpockAction conn sess st) ~ conn, SpockSession (SpockAction conn sess st) ~ sess, SpockState (SpockAction conn sess st) ~ st) => a -> SpockAction conn sess st Text

Wire up a safe action: Safe actions are actions that are protected from csrf attacks. Here's a usage example:

newtype DeleteUser = DeleteUser Int deriving (Hashable, Typeable, Eq)

instance SafeAction Connection () () DeleteUser where
   runSafeAction (DeleteUser i) =
      do runQuery $ deleteUserFromDb i
         redirect "/user-list"

get "/user-details/:userId" $
  do userId <- param' "userId"
     deleteUrl <- safeActionPath (DeleteUser userId)
     html $ "Click <a href='" <> deleteUrl <> "'>here</a> to delete user!"

Note that safeActions currently only support GET and POST requests.

module Web.Spock.Shared