Safe Haskell	None
Language	GHC2021

Web.Hyperbole.Application

Synopsis

waiApp :: (ByteString -> ByteString) -> Eff '[Hyperbole, Server, Concurrent, IOE] Response -> Application
websocketsOr :: ConnectionOptions -> ServerApp -> Application -> Application
defaultConnectionOptions :: ConnectionOptions
liveApp :: (ByteString -> ByteString) -> Eff '[Hyperbole, Server, Concurrent, IOE] Response -> Application
socketApp :: forall (es :: [Effect]). (IOE :> es, Concurrent :> es) => Eff (Hyperbole ': (Server ': es)) Response -> PendingConnection -> Eff es ()
basicDocument :: Text -> ByteString -> ByteString
routeRequest :: forall (es :: [Effect]) route. (Hyperbole :> es, Route route) => (route -> Eff es Response) -> Eff es Response

Documentation

waiApp :: (ByteString -> ByteString) -> Eff '[Hyperbole, Server, Concurrent, IOE] Response -> Application Source #

websocketsOr :: ConnectionOptions -> ServerApp -> Application -> Application #

Upgrade a websockets ServerApp to a wai Application. Uses the given backup Application to handle Requests that are not WebSocket requests.

websocketsOr opts ws_app backup_app = \req respond ->
    case websocketsApp opts ws_app req of
        Nothing  -> backup_app req send_response
        Just res -> respond res

For example, below is an Application that sends "Hello, client!" to each connected client.

app :: Application
app = websocketsOr defaultConnectionOptions wsApp backupApp
  where
    wsApp :: ServerApp
    wsApp pending_conn = do
        conn <- acceptRequest pending_conn
        sendTextData conn ("Hello, client!" :: Text)

    backupApp :: Application
    backupApp _ respond = respond $ responseLBS status400 [] "Not a WebSocket request"

defaultConnectionOptions :: ConnectionOptions #

The default connection options:

Nothing happens when a pong is received.
Compression is disabled.
Lenient unicode decoding.
30 second timeout for connection establishment.

liveApp :: (ByteString -> ByteString) -> Eff '[Hyperbole, Server, Concurrent, IOE] Response -> Application Source #

Turn one or more Pages into a Wai Application. Respond using both HTTP and WebSockets

main :: IO ()
main = do
  run 3000 $ do
    liveApp (basicDocument "Example") (runPage page)

socketApp :: forall (es :: [Effect]). (IOE :> es, Concurrent :> es) => Eff (Hyperbole ': (Server ': es)) Response -> PendingConnection -> Eff es () Source #

basicDocument :: Text -> ByteString -> ByteString Source #

wrap HTML fragments in a simple document with a custom title and include required embeds

liveApp (basicDocument "App Title") (routeRequest router)

You may want to specify a custom document function to import custom javascript, css, or add other information to the <head>

import Data.String.Interpolate (i)
import Web.Hyperbole (scriptEmbed, cssResetEmbed)

customDocument :: ByteString -> ByteString
customDocument content =
  [i|<html>
    <head>
      <title>My Website</title>
      <script type="text/javascript">#{scriptEmbed}</script>
      <style type="text/css">#{cssResetEmbed}</style>
      <script type="text/javascript" src="custom.js"></script>
    </head>
    <body>#{content}</body>
  </html>|]

routeRequest :: forall (es :: [Effect]) route. (Hyperbole :> es, Route route) => (route -> Eff es Response) -> Eff es Response Source #

Route URL patterns to different pages

import Example.Docs.Page.Messages qualified as Messages
import Example.Docs.Page.Users qualified as Users

type UserId = Int

data AppRoute
  = Main
  | Messages
  | User UserId
  deriving (Eq, Generic)

instance Route AppRoute where
  baseRoute = Just Main

router :: (Hyperbole :> es) => AppRoute -> Eff es Response
router Messages = runPage Messages.page
router (User cid) = runPage $ Users.page cid
router Main = do
  view $ do
    el_ "click a link below to visit a page"
    route Messages id "Messages"
    route (User 1) id "User 1"
    route (User 2) id "User 2"