Web.Wheb

This module reexports Wheb modules. It should be the only thing you need to import to get started.

import           Web.Wheb
import           Data.Text.Lazy (pack)

main :: IO ()
main = do
  opts <- generateOptions $ addGET (pack ".") rootPat $ (text (pack "Hi!"))
  runWhebServer opts

Handlers

ReaderT and StateT Functionality

ReaderT

getApp :: Monad m => WhebT g s m g

Get the g in WhebT g s m g. This is a read-only state so only thread-safe resources such as DB connections should go in here.

getWithApp :: Monad m => (g -> a) -> WhebT g s m a

StateT

getHandlerState :: Monad m => WhebT g s m s

Get the s in WhebT g s m g. This is a read and writable state so you can get and put information in your state. Each request gets its own fresh state duplicated from our options startingState

putHandlerState :: Monad m => s -> WhebT g s m ()

modifyHandlerState :: Monad m => (s -> s) -> WhebT g s m s

modifyHandlerState' :: Monad m => (s -> s) -> WhebT g s m ()

Dealing with responses

Creating a HandlerResponse

html :: Monad m => Text -> WhebHandlerT g s m

Return simple HTML from Text

text :: Monad m => Text -> WhebHandlerT g s m

Return simple Text

file :: Monad m => Text -> Text -> WhebHandlerT g s m

Give filepath and content type to serve a file from disk.

builder :: Monad m => Text -> Builder -> WhebHandlerT g s m

Give content type and Blaze Builder

redirect :: Monad m => Text -> WhebHandlerT g s m

Redirect to a given URL

Setting a header

setHeader :: Monad m => Text -> Text -> WhebT g s m ()

Set a header for the response

setRawHeader :: Monad m => Header -> WhebT g s m ()

Set a Strict ByteString header for the response

Settings

getSetting :: Monad m => Text -> WhebT g s m (Maybe Text)

Help prevent monomorphism errors for simple settings.

getSetting' :: (Monad m, Typeable a) => Text -> WhebT g s m (Maybe a)

Open up underlying support for polymorphic global settings

getSetting'' :: (Monad m, Typeable a) => Text -> a -> WhebT g s m a

Get a setting or a default

getSettings :: Monad m => WhebT g s m CSettings

Get all settings.

Routes

getRouteParams :: Monad m => WhebT g s m RouteParamList

Get all route params.

getRouteParam :: (Typeable a, Monad m) => Text -> WhebT g s m a

Cast a route param into its type.

getRoute :: Monad m => Text -> RouteParamList -> WhebT g s m Text

Convert Either from getRoute' into an error in the Monad

getRoute' :: Monad m => Text -> RouteParamList -> WhebT g s m (Either UrlBuildError Text)

Generate a route from a name and param list.

Request reading

getRequest :: Monad m => WhebT g s m Request

Access the request

getRequestHeader :: Monad m => Text -> WhebT g s m (Maybe Text)

Get a request header

getWithRequest :: Monad m => (Request -> a) -> WhebT g s m a

getQueryParams :: Monad m => WhebT g s m Query

Get params from URL (e.g. from '/foo/?q=4')

getPOSTParam :: MonadIO m => Text -> WhebT g s m (Maybe Text)

Maybe get one param if it exists.

getPOSTParams :: MonadIO m => WhebT g s m [(Text, Text)]

Get POST params as Text

getRawPOST :: MonadIO m => WhebT g s m ([Param], [File ByteString])

Get the raw parsed POST data including files.

Running Wheb

runWhebServer :: WhebOptions g s IO -> IO ()

Convenience wrapper for runWhebServerT function in IO

runWhebServerT :: (forall a. m a -> IO a) -> WhebOptions g s m -> IO ()

Run a server with a function to run your inner Transformer to IO and generated options

runRawHandler :: WhebOptions g s IO -> WhebT g s IO a -> IO (Either WhebError a)

Convenience wrapper for runRawHandlerT function in IO

runRawHandlerT :: WhebOptions g s m -> (m (Either WhebError a) -> IO (Either WhebError a)) -> Request -> WhebT g s m a -> IO (Either WhebError a)

Running a Handler with a custom Transformer

Initialize

Routes

Named routes convenience functions

addGET :: Text -> UrlPat -> WhebHandlerT g s m -> InitM g s m ()

addPOST :: Text -> UrlPat -> WhebHandlerT g s m -> InitM g s m ()

addPUT :: Text -> UrlPat -> WhebHandlerT g s m -> InitM g s m ()

addDELETE :: Text -> UrlPat -> WhebHandlerT g s m -> InitM g s m ()

Add raw routes

addRoute :: Route g s m -> InitM g s m ()

addRoutes :: [Route g s m] -> InitM g s m ()

catchAll :: WhebHandlerT g s m -> InitM g s m ()

Catch all requests regardless of method or path

Sockets

addWhebSocket :: UrlPat -> WhebSocket g s m -> InitM g s m ()

Sites

addSite :: Text -> Site url (WhebHandlerT g s m) -> InitM g s m ()

Middlewares

addWAIMiddleware :: Middleware -> InitM g s m ()

Add generic WAI middleware

addWhebMiddleware :: WhebMiddleware g s m -> InitM g s m ()

Add Wheb specific middleware

Settings

addSetting :: Text -> Text -> InitM g s m ()

Wrapped addSetting' to help prevent monomorphism errors for simple settings.

addSetting' :: Typeable a => Text -> a -> InitM g s m ()

Adds a setting value, replacing it if its key already exists.

addSettings :: CSettings -> InitM g s m ()

readSettingsFile :: FilePath -> InitM g s m ()

Reads a file line by line and splits keys and values by ":". Uses default Text.Read to try to match Int, Bool or Float and will add specific typed settings for those.

Cleanup

addCleanupHook :: IO () -> InitM g s m ()

IO Actions to run after server has been stopped.

Running

generateOptions :: MonadIO m => InitM g s m (g, s) -> IO (WhebOptions g s m)

Generate WhebOptions from InitM in IO

genMinOpts :: InitM () () IO () -> IO MinOpts

Generate options for an application without a context or state

Routes

URL Patterns

compilePat :: UrlPat -> UrlParser

Convert a UrlPat to a UrlParser

rootPat :: UrlPat

Represents root path /

URL building

(</>) :: UrlPat -> UrlPat -> UrlPat

Allows for easier building of URL patterns This should be the primary URL constructor.

(\"blog\" '</>' ('grabInt' \"pk\") '</>' \"edit\" '</>' ('grabText' \"verb\"))

grabInt :: Text -> UrlPat

Parses URL parameter and matches on Int

grabText :: Text -> UrlPat

Parses URL parameter and matches on Text

pT :: Text -> UrlPat

Constructors to use w/o OverloadedStrings

pS :: String -> UrlPat

Utilities

spack :: Show a => a -> Text

Show and pack into Text

class Monad m => MonadIO m where

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

• liftIO . return = return

• liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Methods

liftIO :: IO a -> m a

Lift a computation from the IO monad.

Instances

MonadIO IO

MonadIO m => MonadIO (ListT m)

MonadIO m => MonadIO (ResourceT m)

MonadIO m => MonadIO (MaybeT m)

MonadIO m => MonadIO (IdentityT m)

MonadIO m => MonadIO (ContT r m)

MonadIO m => MonadIO (ReaderT r m)

MonadIO m => MonadIO (StateT s m)

MonadIO m => MonadIO (StateT s m)

MonadIO m => MonadIO (ExceptT e m)

(Error e, MonadIO m) => MonadIO (ErrorT e m)

(Monoid w, MonadIO m) => MonadIO (WriterT w m)

(Monoid w, MonadIO m) => MonadIO (WriterT w m)

MonadIO m => MonadIO (RouteT url m)

MonadIO (InitM g s m)

MonadIO m => MonadIO (WhebT g s m)

(Monoid w, MonadIO m) => MonadIO (RWST r w s m)

(Monoid w, MonadIO m) => MonadIO (RWST r w s m)

Types

module Web.Wheb.Types