Related to #8.

I think that these libs can be seen as really valuable source of types and solutions - especially @julienchan lib:

https://github.com/julienchan/purescript-node-wai

https://github.com/matthieubulte/purescript-wai

If you consider moving this lib to the purescript-node-contrib and we want to establish some sort of a standard here then probably we should consider merging some parts from there and also push into tighter collaboration as we are still a really tiny community and there is no space for such a separation I think ;-)
What do you think?

I wanted to try using this in a side project, but I'm not sure how to compile it because http-types isn't in the package set and your spago.dhall is referencing a local project on your computer.

So....

Given that Request includes a backend-specific request object, it might be better to redefine that type via row polymorphism:

newtype Request otherRows
    = Request { method          :: H.Method 
              , rawPathInfo     :: String
              , httpVersion     :: H.HttpVersion
              , rawQueryString  :: String
              , requestHeaders  :: H.RequestHeaders
              , isSecure        :: Boolean
              , remoteHost      :: String 
              , pathInfo        :: Array String 
              , queryString     :: Object String 
              , body            :: Aff (Maybe Buffer)
              , bodyLength      :: RequestBodyLength
              , headerHost      :: String 
              , headerRange     :: Maybe String 
              , headerReferer   :: Maybe String 
              , headerUserAgent :: Maybe String
              , rawHeader       :: Maybe Buffer
              | otherRows
              }

newtype RequestNodeJs =
  RequestNodeJs (Request (nodeRequest :: Maybe HTTP.Request))

defaultRequest would need to be changed. There's two ways:

• change it to a RecordBuilder API, so that one can build it
• specify a backend-specific one for each

When I look at the Haskell version of wai, they use IO as their monad. The corresponding monad in PureScript is not Effect but Aff because the former doesn't allow one to do asynchronous things.

Shouldn't Application be redefined to use Aff rather then Effect?

Hi @Woody88 !

I'm building backends that utilize AWS api gateway and Lambda. Basically that simply involves creating the ff:

newtype ApiGwHandler
  = ApiGwHandler (EffectFn2 ApiGwReq LambdaContext (Promise ApiGwResp))

Note that ApiGwReq, LambdaContext and ApiGwResp are all just records broadly described here:

https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html

I'd love to be be able to use purescript WAI to get a bit more generalization. Current problem is WAI.HttpRequest is defined to newtype node's http request.

If it were a regular record, it would be simple for me to write a simple ApiGwReq -> WAI.HttpRequest and make this usable on AWS lambda.

On the Response side, it's going to be a bit of a shame since from what I can tell, on AWS API GW/Lambda, I need to output a fixed string (possibly base 64 encoded) for the body. So I'll simply evaluate all the Response type to that.

As an aside, we've been deploying on AWS lambda/api gateway while developing locally by simply having an express server execute the EffectFn2 mentioned above. I'd love to replace the latter with purescript-warp. And once I have a wai binding for AWS lambda then we'll transition our backend to that as well. :)

Since Haskell is lazy by default, they can have a lot of fields in their Record type for Request. If we port their model 1-to-1, will there be performance issues for doing that?