Web.Hyperbole.Effect

Documentation

newtype Host

Constructors

Host

Fields

• text :: ByteString

Instances

Show Host

Defined in Web.Hyperbole.Effect

Methods

showsPrec :: Int -> Host -> ShowS

show :: Host -> String

showList :: [Host] -> ShowS

data Request

Constructors

Request

Fields

• host :: Host
• path :: [Segment]
• query :: Query
• body :: ByteString
• method :: Method
• cookies :: [(ByteString, ByteString)]

Instances

Show Request

Defined in Web.Hyperbole.Effect

Methods

showsPrec :: Int -> Request -> ShowS

show :: Request -> String

showList :: [Request] -> ShowS

data Response

Valid responses for a Hyperbole effect. Use notFound, etc instead. Reminds you to use load in your Page

myPage :: (Hyperbole :> es) => Page es Response
myPage = do
  -- compiler error: () does not equal Response
  pure ()

Constructors

Response (View () ())

NotFound

Redirect Url

Err ResponseError

Empty

data ResponseError

Constructors

ErrParse Text

ErrParam Text

ErrOther Text

ErrNotHandled (Event Text Text)

ErrAuth

Instances

Show ResponseError

Defined in Web.Hyperbole.Effect

Methods

showsPrec :: Int -> ResponseError -> ShowS

show :: ResponseError -> String

showList :: [ResponseError] -> ShowS

newtype Page es a

Hyperbole applications are divided into Pages. Each Page must load the whole page , and handle each type of HyperView

myPage :: (Hyperbole :> es) => Page es Response
myPage = do
  handle messages
  load pageView

pageView = do
  el_ "My Page"
  hyper (Message 1) $ messageView "Starting Message"

Constructors

Page (Eff es a)

Instances

Applicative (Page es)

Defined in Web.Hyperbole.Effect

Methods

pure :: a -> Page es a

(<*>) :: Page es (a -> b) -> Page es a -> Page es b

liftA2 :: (a -> b -> c) -> Page es a -> Page es b -> Page es c

(*>) :: Page es a -> Page es b -> Page es b

(<*) :: Page es a -> Page es b -> Page es a

Functor (Page es)

Defined in Web.Hyperbole.Effect

Methods

fmap :: (a -> b) -> Page es a -> Page es b

(<$) :: a -> Page es b -> Page es a

Monad (Page es)

Defined in Web.Hyperbole.Effect

Methods

(>>=) :: Page es a -> (a -> Page es b) -> Page es b

(>>) :: Page es a -> Page es b -> Page es b

return :: a -> Page es a

data Event id act

An action, with its corresponding id

Constructors

Event

Fields

• viewId :: id
• action :: act

Instances

(Show act, Show id) => Show (Event id act)

Defined in Web.Hyperbole.Effect

Methods

showsPrec :: Int -> Event id act -> ShowS

show :: Event id act -> String

showList :: [Event id act] -> ShowS

data Server :: Effect where

Low level effect mapping request/response to either HTTP or WebSockets

Constructors

LoadRequest :: Server m Request

SendResponse :: Session -> Response -> Server m ()

Instances

type DispatchOf Server

Defined in Web.Hyperbole.Effect

type DispatchOf Server = 'Dynamic

data Hyperbole :: Effect where

In any load or handle, you can use this Effect to get extra request information or control the response manually.

For most Pages, you won't need to use this effect directly. Use custom Routes for request info, and return Views to respond

Constructors

GetRequest :: Hyperbole m Request

RespondEarly :: Response -> Hyperbole m a

SetSession :: ToHttpApiData a => Text -> a -> Hyperbole m ()

DelSession :: Text -> Hyperbole m ()

GetSession :: FromHttpApiData a => Text -> Hyperbole m (Maybe a)

Instances

type DispatchOf Hyperbole

Defined in Web.Hyperbole.Effect

type DispatchOf Hyperbole = 'Dynamic

data HyperState

Constructors

HyperState

Fields

• request :: Request
• session :: Session

runHyperbole :: Server :> es => Eff (Hyperbole : es) Response -> Eff es Response

Run the Hyperbole effect to Server

request :: Hyperbole :> es => Eff es Request

Return all information about the Request

reqPath :: Hyperbole :> es => Eff es [Segment]

Return the request path

>>> reqPath
["users", "100"]

formData :: Hyperbole :> es => Eff es Form

Return the request body as a Web.FormUrlEncoded.Form

Prefer using Type-Safe Forms when possible

getEvent :: (HyperView id, Hyperbole :> es) => Eff es (Maybe (Event id (Action id)))

parseEvent :: HyperView id => Query -> Maybe (Event id (Action id))

lookupEvent :: Query -> Maybe (Event Text Text)

session :: (Hyperbole :> es, FromHttpApiData a) => Text -> Eff es (Maybe a)

Lookup a session variable by keyword

load $ do
  tok <- session "token"
  ...

setSession :: (Hyperbole :> es, ToHttpApiData a) => Text -> a -> Eff es ()

Set a session variable by keyword

load $ do
  t <- reqParam "token"
  setSession "token" t
  ...

clearSession :: Hyperbole :> es => Text -> Eff es ()

Clear the user's session

reqParams :: Hyperbole :> es => Eff es Query

Return the entire Query

myPage :: Page es Response
myPage = do
  load $ do
    q <- reqParams
    case lookupParam "token" q of
      Nothing -> pure $ errorView "Missing Token in Query String"
      Just t -> do
        sideEffectUsingToken token
        pure myPageView

lookupParam :: ByteString -> Query -> Maybe Text

Lookup the query param in the Query

reqParam :: (Hyperbole :> es, FromHttpApiData a) => Text -> Eff es a

Require a given parameter from the Query arguments

myPage :: Page es Response
myPage = do
  load $ do
    token <- reqParam "token"
    sideEffectUsingToken token
    pure myPageView

notFound :: Hyperbole :> es => Eff es a

Respond immediately with 404 Not Found

userLoad :: (Hyperbole :> es, Users :> es) => UserId -> Eff es User
userLoad uid = do
  mu <- send (LoadUser uid)
  maybe notFound pure mu

myPage :: (Hyperbole :> es, Users :> es) => Eff es View
myPage = do
  load $ do
    u <- userLoad 100
    -- skipped if user = Nothing
    pure $ userView u

parseError :: Hyperbole :> es => Text -> Eff es a

Respond immediately with a parse error

redirect :: Hyperbole :> es => Url -> Eff es a

Redirect immediately to the Url

respondEarly :: (Hyperbole :> es, HyperView id) => id -> View id () -> Eff es ()

Respond with the given view, and stop execution

view :: Hyperbole :> es => View () () -> Eff es Response

Manually set the response to the given view. Normally you return a View from load or handle instead of using this

load :: Hyperbole :> es => Eff es (View () ()) -> Page es Response

The load handler is run when the page is first loaded. Run any side effects needed, then return a view of the full page

myPage :: (Hyperbole :> es) => UserId -> Page es Response
myPage userId = do
  load $ do
    user <- loadUserFromDatabase userId
    pure $ userPageView user

handle :: forall id es. (Hyperbole :> es, HyperView id) => (id -> Action id -> Eff es (View id ())) -> Page es ()

A handler is run when an action for that HyperView is triggered. Run any side effects needed, then return a view of the corresponding type

myPage :: (Hyperbole :> es) => Page es Response
myPage = do
  handle messages
  load pageView

messages :: (Hyperbole :> es, MessageDatabase) => Message -> MessageAction -> Eff es (View Message ())
messages (Message mid) ClearMessage = do
  deleteMessageSideEffect mid
  pure $ messageView ""

messages (Message mid) (Louder m) = do
  let new = m <> "!"
  saveMessageSideEffect mid new
  pure $ messageView new

page :: Hyperbole :> es => Page es Response -> Eff es Response

Run a Page in Hyperbole