effect 4.0.3 → 4.0.5

package/src/encoding/Sse.ts

@@ -92,6 +92,12 @@ export interface DecodeOptions {
    * Maximum number of string code units retained for a pending event. The default is 10 MiB.
    */
   readonly maxEventSize?: number | undefined
+  /**
+   * Also dispatch an event that sets an `event:` name but has no `data:`
+   * line, with empty `data`. The WHATWG algorithm drops such events, but some
+   * protocols use them, such as graphql-sse's `complete`. Defaults to `false`.
+   */
+  readonly dispatchEmptyNamedEvents?: boolean | undefined
 }
 
 const defaultMaxEventSize = 10 * 1024 * 1024
@@ -270,13 +276,16 @@ export const decodeDataSchema = <Type, DecodingServices, IE, Done>(
  */
 export function makeParser(onParse: (event: AnyEvent) => void, options?: DecodeOptions): Parser {
   const maxEventSize = options?.maxEventSize ?? defaultMaxEventSize
+  const dispatchEmptyNamedEvents = options?.dispatchEmptyNamedEvents === true
 
   // Processing state
   let isFirstChunk: boolean
-  let buffer: string
-  let startingPosition: number
-  let startingFieldLength: number
+  // Pieces of the unterminated line, joined once when the line ends
+  let pending: Array<string>
+  let pendingLength: number
   let discardTrailingNewline: boolean
+  // Incremented by `reset`, so `feed` can stop if `onParse` resets the parser
+  let generation = 0
 
   // Event state
   let lastEventId: string | undefined
@@ -287,10 +296,10 @@ export function makeParser(onParse: (event: AnyEvent) => void, options?: DecodeO
   return { feed, reset }
 
   function reset(): void {
+    generation++
     isFirstChunk = true
-    buffer = ""
-    startingPosition = 0
-    startingFieldLength = -1
+    pending = []
+    pendingLength = 0
     discardTrailingNewline = false
 
     lastEventId = undefined
@@ -299,120 +308,98 @@ export function makeParser(onParse: (event: AnyEvent) => void, options?: DecodeO
   }
 
   function feed(chunk: string): SseError | undefined {
-    buffer = buffer ? buffer + chunk : chunk
-
     // Strip any UTF-8 byte order mark (BOM) at the start of the stream.
     // Note that we do not strip any non - UTF8 BOM, as eventsource streams are
     // always decoded as UTF8 as per the specification.
-    if (isFirstChunk && buffer.startsWith(BOM)) {
-      buffer = buffer.slice(BOM.length)
+    if (isFirstChunk && chunk.startsWith(BOM)) {
+      chunk = chunk.slice(BOM.length)
     }
 
     isFirstChunk = false
 
-    // Set up chunk-specific processing state
-    const length = buffer.length
+    const length = chunk.length
+    const currentGeneration = generation
     let position = 0
 
-    // Read the current buffer byte by byte
     while (position < length) {
-      // EventSource allows for carriage return + line feed, which means we
-      // need to ignore a linefeed character if the previous character was a
-      // carriage return
-      // @todo refactor to reduce nesting, consider checking previous byte?
-      // @todo but consider multiple chunks etc
+      // Skip the LF of a CRLF, whose CR may have ended the previous chunk
       if (discardTrailingNewline) {
-        if (buffer[position] === "\n") {
+        discardTrailingNewline = false
+        if (chunk.charCodeAt(position) === LF) {
           ++position
+          continue
         }
-        discardTrailingNewline = false
       }
 
-      let lineLength = -1
-      let fieldLength = startingFieldLength
-      let character: string
-
-      for (let index = position + startingPosition; lineLength < 0 && index < length; ++index) {
-        character = buffer[index]
-        if (character === ":" && fieldLength < 0) {
-          fieldLength = index - position
-        } else if (character === "\r") {
-          discardTrailingNewline = true
-          lineLength = index - position
-        } else if (character === "\n") {
-          lineLength = index - position
-        }
+      let lineEnd = position
+      while (lineEnd < length) {
+        const code = chunk.charCodeAt(lineEnd)
+        if (code === CR || code === LF) break
+        ++lineEnd
       }
 
-      if (lineLength < 0) {
-        startingPosition = length - position
-        startingFieldLength = fieldLength
+      if (lineEnd === length) {
+        pending.push(chunk.slice(position))
+        pendingLength += length - position
         break
-      } else {
-        startingPosition = 0
-        startingFieldLength = -1
       }
 
-      parseEventStreamLine(buffer, position, fieldLength, lineLength)
+      discardTrailingNewline = chunk.charCodeAt(lineEnd) === CR
 
-      position += lineLength + 1
-    }
+      let line = chunk.slice(position, lineEnd)
+      if (pending.length > 0) {
+        pending.push(line)
+        line = pending.join("")
+        pending = []
+        pendingLength = 0
+      }
+      parseLine(line)
+
+      if (generation !== currentGeneration) {
+        // `onParse` reset the parser, so drop the rest of this chunk
+        return
+      }
 
-    if (position === length) {
-      // If we consumed the entire buffer to read the event, reset the buffer
-      buffer = ""
-    } else if (position > 0) {
-      // If there are bytes left to process, set the buffer to the unprocessed
-      // portion of the buffer only
-      buffer = buffer.slice(position)
+      position = lineEnd + 1
     }
 
-    if (buffer.length + data.length > maxEventSize) {
+    if (pendingLength + data.length > maxEventSize) {
       const error = new SseError({ reason: new EventTooLarge({ maxEventSize }) })
       reset()
       return error
     }
   }
 
-  function parseEventStreamLine(
-    lineBuffer: string,
-    index: number,
-    fieldLength: number,
-    lineLength: number
-  ) {
-    if (lineLength === 0) {
-      // We reached the last line of this event
-      if (data.length > 0) {
+  function parseLine(line: string) {
+    if (line.length === 0) {
+      // End of event. Clear the state first so a throwing `onParse` cannot
+      // leak it into the next event
+      const named = eventName !== undefined && eventName !== ""
+      const event = eventName || "message"
+      const eventData = data
+      eventName = undefined
+      data = ""
+      if (eventData.length > 0 || (dispatchEmptyNamedEvents && named)) {
         onParse({
           _tag: "Event",
           id: lastEventId,
-          event: eventName || "message",
-          data: data.slice(0, -1) // remove trailing newline
+          event,
+          data: eventData.slice(0, -1) // remove trailing newline
         })
-        data = ""
       }
-      eventName = undefined
       return
     }
 
-    const noValue = fieldLength < 0
-    const field = lineBuffer.slice(index, index + (noValue ? lineLength : fieldLength))
-    let step = 0
-
-    if (noValue) {
-      step = lineLength
-    } else if (lineBuffer[index + fieldLength + 1] === " ") {
-      step = fieldLength + 2
-    } else {
-      step = fieldLength + 1
+    const colon = line.indexOf(":")
+    let field = line
+    let value = ""
+    if (colon >= 0) {
+      field = line.slice(0, colon)
+      value = line.slice(line.charCodeAt(colon + 1) === SPACE ? colon + 2 : colon + 1)
     }
 
-    const position = index + step
-    const valueLength = lineLength - step
-    const value = lineBuffer.slice(position, position + valueLength).toString()
-
     if (field === "data") {
-      data += value ? `${value}\n` : "\n"
+      data += value + "\n"
     } else if (field === "event") {
       eventName = value
     } else if (field === "id" && !value.includes("\u0000")) {
@@ -425,6 +412,9 @@ export function makeParser(onParse: (event: AnyEvent) => void, options?: DecodeO
 }
 
 const BOM = "\uFEFF"
+const LF = 10
+const CR = 13
+const SPACE = 32
 
 /**
  * Stateful Server-Sent Events parser returned by `makeParser`.
@@ -693,7 +683,7 @@ export const encoder: Encoder = {
         if (event.event !== "message") {
           data += `event: ${event.event}\n`
         }
-        data += `data: ${event.data.replace(/\n/g, "\ndata: ")}\n`
+        data += `data: ${event.data.replace(/\r\n|\r|\n/g, "\ndata: ")}\n`
         return data + "\n"
       }
       case "Retry": {