Added some test, maybe all effect types should be changed to Aff..

Author: Woody88

package-lock.json

@@ -0,0 +1,29 @@
+{
+  "name": "purescript-sse-stream",
+  "version": "1.0.0",
+  "description": "Stream for writing Server-Sent Events",
+  "main": "index.js",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/purescript-node-contrib/purescript-sse-stream.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/purescript-node-contrib/purescript-sse-stream/issues"
+  },
+  "homepage": "https://github.com/purescript-node-contrib/purescript-sse-stream#readme",
+  "dependencies": {
+    "ssestream": "^1.1.0"
+  },
+  "devDependencies": {
+    "stream-buffers": "^3.0.2"
+  }
+}

package.json

@@ -2,14 +2,15 @@
 Welcome to a Spago project!
 You can edit this file as you like.
 -}
-{ name = "my-project"
+{ name = "sse-stream"
 , dependencies =
   [ "console"
   , "effect"
   , "http-types"
   , "node-http"
   , "node-streams"
   , "psci-support"
+  , "spec"
   ]
 , packages = ./packages.dhall
 , sources = [ "src/**/*.purs", "test/**/*.purs" ]

spago.dhall

@@ -1,12 +1,16 @@
 "use strict";
-const SseStream = require('ssestream')
+const SseStream = require('ssestream').default
 
-exports.createSseStream = req => () => { new SseStream(req) }
+exports.createSseStream = req => () => { return new SseStream(req) }
+
+exports.createSseStream_ = () => { return new SseStream() }
 
 exports.pipe = sse => stream => () => { sse.pipe(stream) }
 
 exports._write = sse => message => () => { sse.write(message) }
-
+// exports._writeMessage = sse => message => cb => () => { sse.write(message,) }
 exports._writeHead = sse => statusCode => headers => () => { 
   sse.writeHead(statusCode, headers) 
-}
+}
+
+exports.end = sse => () => { sse.end() }

src/SSE.js

@@ -1,5 +1,7 @@
 module SSE 
   ( createSseStream
+  , createSseStream_
+  , end
   , pipe 
   , write
   , writeHead
@@ -22,18 +24,20 @@ writeHead sse {code, message} hdrs = _writeHead sse code headers
   where 
     headers = Object.fromFoldable hdrs 
 
-write :: SseStream -> ServerEvent -> Effect Unit 
-write sse (Comment comment) =  _write sse { comment }
-write sse (RetryEvent retry) =  _write sse { retry }
+write :: SseStream -> ServerEvent -> Effect Boolean 
+write sse (Comment comment) =  _write sse { comment } 
+write sse (RetryEvent retry) =  _write sse { retry } 
 write sse (ServerEvent {data: d, event: e, id: i}) = case d,e,i of  
-  _data,Nothing,Nothing    -> _write sse { data: _data }
-  _data,Just event,Just id -> _write sse { data: _data, event, id }
-  _data,Just event,Nothing -> _write sse { data: _data, event }
+  _data,Nothing,Nothing    -> _write sse { data: _data } 
+  _data,Just event,Just id -> _write sse { data: _data, event, id } 
+  _data,Just event,Nothing -> _write sse { data: _data, event } 
   _data,Nothing,Just id    -> _write sse { data: _data, id }
 
 -- TO CONSIDER: since the SseStream object extends Transform class 
 -- and Transform is simply a duplex, should we return a Duplex type instead?
 foreign import createSseStream :: HTTP.Request -> Effect SseStream
+foreign import createSseStream_ :: Effect SseStream
 foreign import pipe :: forall r. SseStream -> Writable r -> Effect (Writable r)
-foreign import _write :: forall message. SseStream -> { | message } -> Effect Unit  
-foreign import _writeHead :: SseStream -> Int -> Object String -> Effect Unit
+foreign import _write :: forall message. SseStream -> { | message } -> Effect Boolean  
+foreign import _writeHead :: SseStream -> Int -> Object String -> Effect Unit
+foreign import end :: SseStream -> Effect Unit 

src/SSE.purs

@@ -0,0 +1,10 @@
+"use strict";
+
+exports.writableStreamBuffer = () => {
+  var W = require('stream-buffers').WritableStreamBuffer
+  return new W
+}
+
+exports.contentStr = w => () => {
+  return w.getContentsAsString('utf8')
+}

test/Main.js

@@ -2,10 +2,53 @@ module Test.Main where
 
 import Prelude
 
+import Control.Plus (empty)
+import Data.Either (Either(..))
 import Effect (Effect)
-import Effect.Class.Console (log)
+import Effect.Aff (launchAff_, makeAff, nonCanceler)
+import Effect.Class (liftEffect)
+import Node.Stream (Writable)
+import Node.Stream as Stream
+import SSE as SSE
+import SSE.Types (ServerEvent(..))
+import Test.Spec (describe, it)
+import Test.Spec.Assertions (shouldEqual)
+import Test.Spec.Reporter.Console (consoleReporter)
+import Test.Spec.Runner (runSpec)
+
+foreign import writableStreamBuffer :: Effect (Writable ())
+
+foreign import contentStr :: Writable () -> Effect String 
 
 main :: Effect Unit
-main = do
-  log "🍝"
-  log "You should add some tests."
+main = launchAff_ $ runSpec [consoleReporter] do
+  describe "SseStream" do
+      it "writes multiple multiline messages" do
+        let msg1 = ServerEvent { data: "hello\nworld", id: empty, event: empty }
+            msg2 = ServerEvent { data: "こんにちは\n世界", id: empty, event: empty }
+
+        sse  <- liftEffect $ SSE.createSseStream_
+        sink <- liftEffect $ writableStreamBuffer
+
+        _ <- liftEffect $ SSE.pipe sse sink 
+
+        _ <- liftEffect $ SSE.write sse msg1 
+        _ <- liftEffect $ SSE.write sse msg2 
+        _ <- liftEffect $ SSE.end sse 
+
+        result  <- makeAff \done -> do 
+              Stream.onFinish sink do
+                content <- contentStr sink
+                done $ Right content
+              pure nonCanceler
+
+        let expected = """:ok
+
+data: hello
+data: world
+
+data: こんにちは
+data: 世界
+
+"""
+        result `shouldEqual` expected