https://github.com/athanclark/wai-transformers

Simple parameterization of Wai's Application type
https://github.com/athanclark/wai-transformers

haskell wai wai-transformers

Last synced: about 2 months ago
JSON representation

Simple parameterization of Wai's Application type

• Host: GitHub
• URL: https://github.com/athanclark/wai-transformers
• Owner: athanclark
• License: bsd-3-clause
• Created: 2015-09-22T02:53:01.000Z (over 9 years ago)
• Default Branch: master
• Last Pushed: 2018-03-22T14:11:09.000Z (almost 7 years ago)
• Last Synced: 2024-04-26T01:02:14.761Z (10 months ago)
• Topics: haskell, wai, wai-transformers
• Language: Haskell
• Size: 15.6 KB
• Stars: 2
• Watchers: 3
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
wai-transformers

================

Simple parameterization of Wai's `Application` and `Middleware` types.

## Overview

Wai's `Application` type is defined as follows:

```haskell

type Application = Request -> (Response -> IO ResponseReceived) -> IO ResponseReceived

```

This is great for the server - we can just `flip ($)` the middlewares together to get

an effectful server. However, what if we want to encode useful information in our

middleware chain / end-point application? Something like a `ReaderT Env` environment,

where useful data like a universal salt, current hostname, or global mutable references can

be referenced later if it were wedged-in.

The design looks like this:

```haskell

type ApplicationT m = Request -> (Response -> IO ResponseReceived) -> m ResponseReceived

```

Now we can encode MTL-style contexts with applications we write

```haskell

type MiddlewareT m = ApplicationT m -> ApplicationT m

data AuthConfig = AuthConfig

  { authFunction :: Request -> Either AuthException (Response -> Response)

  }

simpleAuth :: ( MonadReader AuthConfig m

              , MonadError AuthException m

              ) => MiddlewareT m

simpleAuth app req resp = do

  auth <- authFunction <$> ask

  case auth req of

    Left e = throwError e

    Right f = app req (resp . f)

simpleAuth' :: Middleware

simpleAuth' app req resp =

  eReceived <- runExceptT $ runReaderT (simpleAuth app req resp) myAuthConfig

  case eReceived of

    Left e = resp $ respondLBS "Unauthorized!"

    Right r = return r

```