Flesh out more of the headers API

Author: JordanMartinez

src/Node/Http2/Headers.js

@@ -0,0 +1,8 @@
+import { sensitiveHeaders } from "node:http2";
+
+export const mkHeadersImpl = (insensitive, sensitive, sensitiveKeys) => 
+  ({
+    ...insensitive,
+    ...sensitive,
+    [sensitiveHeaders]: sensitiveKeys,
+  });

src/Node/Http2/Headers.purs

@@ -0,0 +1,74 @@
+module Node.Http2.Headers where
+
+import Prelude
+
+import Data.FoldableWithIndex (foldlWithIndex)
+import Data.Function.Uncurried (Fn3, runFn3)
+import Data.Maybe (Maybe)
+import Foreign.Object (Object)
+import Foreign.Object as Object
+import Node.Http2.Types (Headers)
+import Prim.Row as Row
+import Unsafe.Coerce (unsafeCoerce)
+
+-- | Makes an `Headers` value where all headers are insensitive.
+mkHeadersI :: forall insensitive. { | insensitive } -> Headers
+mkHeadersI = unsafeCoerce
+
+-- | Makes an `Headers` value containing both insensitive headers (first argument)
+-- | and sensitive headers (second argument).
+-- | ```
+-- | mkHeaders { ":method": "GET" } { "sensitive-header": "secret" }
+-- | ```
+-- |
+-- | Note: the `Union` and `Nub` constraints simply prove that labels in one record
+-- | do not appear in the other one.
+mkHeaders
+  :: forall insensitive sensitive all
+   . Row.Union insensitive sensitive all
+  => Row.Nub all all
+  => { | insensitive }
+  -> { | sensitive }
+  -> Headers
+mkHeaders insensitive sensitive =
+  runFn3 mkHeadersImpl insensitive sensitive (Object.keys $ unsafeCoerce sensitive)
+
+foreign import mkHeadersImpl :: forall insensitive sensitive. Fn3 { | insensitive } { | sensitive } (Array String) (Headers)
+
+-- | Note: this is unsafe because 
+-- | - a server response's ":status" pseudo header's value will have type `Int`, not `String`
+-- | - a server response's "set-cookie" header's value will have type `Array String`, not `String`
+-- | 
+-- | See https://nodejs.org/dist/latest-v18.x/docs/api/http2.html#headers-object
+unsafeToObject :: Headers -> Object String
+unsafeToObject = unsafeCoerce
+
+status :: Headers -> Maybe Int
+status = unsafeCoerce <<< lookup ":status"
+
+method :: Headers -> Maybe String
+method = lookup ":method"
+
+scheme :: Headers -> Maybe String
+scheme = lookup ":scheme"
+
+authority :: Headers -> Maybe String
+authority = lookup ":authority"
+
+path :: Headers -> Maybe String
+path = lookup ":path"
+
+lookup :: String -> Headers -> Maybe String
+lookup key headers = Object.lookup key $ unsafeCoerce headers
+
+printHeaders :: Headers -> String
+printHeaders = printHeaders' "; "
+
+printHeaders' :: String -> Headers -> String
+printHeaders' sep r = _.val $ foldlWithIndex printKeyValue { init: true, val: "" } $ (unsafeCoerce r :: Object String)
+  where
+  printKeyValue k acc v = do
+    let kv = k <> "=" <> v
+    { init: false
+    , val: if acc.init then kv else acc.val <> sep <> kv
+    }

src/Node/Http2/SensitiveHeaders.js

@@ -72,7 +72,7 @@ sessionHandle = EventHandle "session" mkEffectFn1
 sessionErrorHandle :: EventHandle2 Http2SecureServer Error (Http2Session Server)
 sessionErrorHandle = EventHandle "sessionError" \cb -> mkEffectFn2 \a b -> cb a b
 
-streamHandle :: EventHandle4 Http2SecureServer (Http2Stream Server) Headers BitwiseFlag (Array String)
+streamHandle :: EventHandle4 Http2SecureServer (Http2Stream Server) (Headers) BitwiseFlag (Array String)
 streamHandle = EventHandle "stream" \cb -> mkEffectFn4 \a b c d -> cb a b c d
 
 timeoutHandle :: EventHandle0 TlsServer

src/Node/Http2/SensitiveHeaders.purs

@@ -63,8 +63,8 @@ import Node.Buffer.Immutable (ImmutableBuffer)
 import Node.EventEmitter (EventEmitter, EventHandle(..))
 import Node.EventEmitter.UtilTypes (EventHandle0, EventHandle1, EventHandle2, EventHandle3, EventHandle4)
 import Node.Http2.ErrorCode (ErrorCode)
-import Node.Http2.FrameType (FrameType)
 import Node.Http2.Flags (BitwiseFlag)
+import Node.Http2.FrameType (FrameType)
 import Node.Http2.Types (Headers, Http2Session, Http2Stream, Settings, StreamId)
 import Node.Net.Types (Socket, TCP)
 import Node.TLS.Types (Client, Server)

src/Node/Http2/Server.purs

@@ -52,7 +52,12 @@ type Settings =
 -- | `Http2SecureServer` extends `TLS.Server`, `Net.Server` and `EventEmitter`
 foreign import data Http2SecureServer :: Type
 
+-- | Type is provided below, but the corresponding bindings for the Compatibility API
+-- | is not provided.
 foreign import data Http2ServerRequest :: Type
+
+-- | Type is provided below, but the corresponding bindings for the Compatibility API
+-- | is not provided.
 foreign import data Http2ServerResponse :: Type
 
 -- | `allowHTTP1` <boolean> Incoming client connections that do not support HTTP/2 will be downgraded to HTTP/1.x when set to true. See the 'unknownProtocol' event. See ALPN negotiation. Default: false.

src/Node/Http2/Session.purs

@@ -3,19 +3,18 @@ module Test.Main where
 import Prelude
 
 import Data.Array as Array
-import Data.FoldableWithIndex (forWithIndex_)
 import Effect (Effect)
 import Effect.Class.Console (log)
 import Effect.Exception as Exception
 import Effect.Ref as Ref
-import Foreign.Object (Object)
 import Node.Buffer as Buffer
 import Node.Buffer.Immutable (ImmutableBuffer)
 import Node.Encoding (Encoding(..))
 import Node.EventEmitter (on)
 import Node.FS.Sync as FS
 import Node.Http2.Client as Client
 import Node.Http2.ErrorCode as ErrorCode
+import Node.Http2.Headers (printHeaders')
 import Node.Http2.Server as Server
 import Node.Http2.Session as Session
 import Node.Http2.Stream (toDuplex)
@@ -59,8 +58,7 @@ main = do
   on Server.streamHandle server.http2 \stream headers flags rawHeaders -> do
     streamId <- H2Stream.id stream
     log $ "server - onStream for id: " <> show streamId
-    forWithIndex_ (unsafeCoerce headers :: Object String) \k v ->
-      log $ k <> ": " <> v
+    log $ printHeaders' "\n" headers
     log $ "server - onStream - Flags: " <> show flags
     log $ "server - onStream - Raw Headers: " <> show rawHeaders
     let duplex = H2Stream.toDuplex stream
@@ -102,8 +100,7 @@ main = do
     Stream.end duplex
     on H2Stream.responseHandle stream \headers flags -> do
       log "client - onResponse"
-      forWithIndex_ (unsafeCoerce headers :: Object String) \k v ->
-        log $ k <> ": " <> v
+      log $ printHeaders' "\n" headers
       log $ "Flags: " <> show flags
       chunksRef <- Ref.new []
       on Stream.dataHandle duplex \buf ->