effect 4.0.3 → 4.0.4

package/src/cluster/Sharding.ts

@@ -692,6 +692,12 @@ const make = Effect.gen(function*() {
   const storageReadLatch = yield* Latch.make(true)
   const openStorageReadLatch = constant(Effect.asVoid(storageReadLatch.open))
 
+  type PendingNotification = {
+    resume: (_: Effect.Effect<void, EntityNotAssignedToRunner>) => void
+    readonly message: Message.IncomingRequest<any>
+  }
+  const pendingNotifications = new Map<Snowflake.Snowflake, PendingNotification>()
+
   const storageReadLock = Semaphore.makeUnsafe(1)
   const withStorageReadLock = storageReadLock.withPermits(1)
 
@@ -725,7 +731,7 @@ const make = Effect.gen(function*() {
   if (storageEnabled && initialRunnerAddress) {
     const selfAddress = initialRunnerAddress
 
-    yield* Effect.gen(function*() {
+    const storageReadLoop = Effect.gen(function*() {
       yield* Effect.logDebug("Starting")
       yield* Effect.addFinalizer(() => Effect.logDebug("Shutting down"))
 
@@ -982,8 +988,7 @@ const make = Effect.gen(function*() {
         module: "effect/cluster/Sharding",
         fiber: "Storage read loop",
         runner: selfAddress
-      }),
-      Effect.forkIn(shardingScope)
+      })
     )
 
     // open the storage latch every poll interval
@@ -1110,6 +1115,9 @@ const make = Effect.gen(function*() {
         ),
       Effect.forkIn(shardingScope)
     )
+
+    // fork after the state the loop reads has been initialized
+    yield* Effect.forkIn(storageReadLoop, shardingScope)
   }
 
   // --- Sending messages ---
@@ -1150,11 +1158,6 @@ const make = Effect.gen(function*() {
     return isRequest ? Effect.andThen(awaitShardLock(address.shardId), send) : send
   }
 
-  type PendingNotification = {
-    resume: (_: Effect.Effect<void, EntityNotAssignedToRunner>) => void
-    readonly message: Message.IncomingRequest<any>
-  }
-  const pendingNotifications = new Map<Snowflake.Snowflake, PendingNotification>()
   const notifyLocal = <M extends Message.Outgoing<any> | Message.Incoming<any>>(
     message: M,
     discard: boolean,
@@ -1172,7 +1175,7 @@ const make = Effect.gen(function*() {
       const state = entityManagers.get(address.entityType)
       if (!state) {
         return Effect.flatMap(waitForEntityManager(address.entityType), loop)
-      } else if (state.status === "closed" || !isEntityOnLocalShards(address)) {
+      } else if (state.status === "closed") {
         return Effect.fail(new EntityNotAssignedToRunner({ address }))
       }
 

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`.