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 :: MinOpts)

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

getReqState :: 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 generated from Default

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

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

modifyReqState' :: 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.

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

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 (Maybe 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 :: Default s => WhebOptions g s IO -> IO ()

Convenience wrapper for runWhebServerT function in IO

runWhebServerT :: Default s => (m EResponse -> IO EResponse) -> WhebOptions g s m -> IO ()

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

debugHandler :: Default s => WhebOptions g s IO -> WhebT g s IO a -> IO (Either WhebError a)

Convenience wrapper for debugHandlerT function in IO

debugHandlerT :: Default s => 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 ()

Add raw routes

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

addRoutes :: [Route 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 ()

Running

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

Generate WhebOptions from InitM in IO

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

Types

module Web.Wheb.Types

class Default a where

A class for types with a default value.

Methods

def :: a

The default value for this type.

Instances

Default Double

Default Float

Default Int

Default Int8

Default Int16

Default Int32

Default Int64

Default Integer

Default Ordering

Default Word

Default Word8

Default Word16

Default Word32

Default Word64

Default ()

Default All

Default Any

Default IntSet

Default SetCookie

Default TimeLocale

Default [a]

Integral a => Default (Ratio a)

Default a => Default (IO a)

Default (Maybe a)

(Default a, RealFloat a) => Default (Complex a)

Default a => Default (Dual a)

Default (Endo a)

Num a => Default (Sum a)

Num a => Default (Product a)

Default (First a)

Default (Last a)

Default a => Default (Tree a)

Default (Seq a)

Default (IntMap v)

Default (Set v)

Default (DList a)

Default s => Default (InternalState s)

Default r => Default (e -> r)

(Default a, Default b) => Default (a, b)

Default (Map k v)

(Default a, Default b, Default c) => Default (a, b, c)

(Default a, Default b, Default c, Default d) => Default (a, b, c, d)

(Default a, Default b, Default c, Default d, Default e) => Default (a, b, c, d, e)

(Default a, Default b, Default c, Default d, Default e, Default f) => Default (a, b, c, d, e, f)

(Default a, Default b, Default c, Default d, Default e, Default f, Default g) => Default (a, b, c, d, e, f, g)