effect 4.0.0-beta.103 → 4.0.0-beta.104

package/src/unstable/encoding/Msgpack.ts

@@ -12,12 +12,13 @@
 import { Packr, Unpackr } from "msgpackr"
 import * as Msgpackr from "msgpackr"
 import * as Arr from "../../Array.ts"
+import * as Cause from "../../Cause.ts"
 import * as Channel from "../../Channel.ts"
 import * as ChannelSchema from "../../ChannelSchema.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import { dual } from "../../Function.ts"
-import type * as Pull from "../../Pull.ts"
+import * as Pull from "../../Pull.ts"
 import * as Schema from "../../Schema.ts"
 import * as SchemaIssue from "../../SchemaIssue.ts"
 import * as SchemaTransformation from "../../SchemaTransformation.ts"
@@ -134,37 +135,55 @@ export const decode = <IE = never, Done = unknown>(): Channel.Channel<
   Channel.fromTransform((upstream, _scope) =>
     Effect.sync(() => {
       const unpackr = new Unpackr()
-      let incomplete: Uint8Array<ArrayBuffer> | undefined = undefined
-      return Effect.flatMap(
-        upstream,
-        function loop(chunk): Pull.Pull<Arr.NonEmptyReadonlyArray<unknown>, IE | MsgPackError, Done> {
-          const out = Arr.empty<unknown>()
-          for (let i = 0; i < chunk.length; i++) {
-            let buf = chunk[i]
-            if (incomplete !== undefined) {
-              const prev = buf
-              buf = new Uint8Array(incomplete.length + buf.length)
-              buf.set(incomplete)
-              buf.set(prev, incomplete.length)
-              incomplete = undefined
-            }
-            try {
-              out.push(...unpackr.unpackMultiple(buf))
-            } catch (cause) {
-              const error: any = cause
-              if (error.incomplete) {
-                incomplete = buf.subarray(error.lastPosition)
-                if (error.values) {
-                  out.push(...error.values)
-                }
-              } else {
-                return Effect.fail(new MsgPackError({ kind: "Unpack", cause }))
+      let incomplete: {
+        readonly bytes: Uint8Array<ArrayBuffer>
+        readonly cause: unknown
+      } | undefined = undefined
+
+      const pull = Effect.suspend((): Pull.Pull<Arr.NonEmptyReadonlyArray<unknown>, IE | MsgPackError, Done> =>
+        Pull.matchEffect(upstream, {
+          onSuccess: loop,
+          onFailure: Effect.failCause,
+          onDone: (done): Pull.Pull<never, MsgPackError, Done> =>
+            incomplete === undefined
+              ? Cause.done(done)
+              : Effect.fail(new MsgPackError({ kind: "Unpack", cause: incomplete.cause }))
+        })
+      )
+
+      function loop(chunk: Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>): Pull.Pull<
+        Arr.NonEmptyReadonlyArray<unknown>,
+        IE | MsgPackError,
+        Done
+      > {
+        const out = Arr.empty<unknown>()
+        for (let i = 0; i < chunk.length; i++) {
+          let buf = chunk[i]
+          if (incomplete !== undefined) {
+            const prev = buf
+            buf = new Uint8Array(incomplete.bytes.length + buf.length)
+            buf.set(incomplete.bytes)
+            buf.set(prev, incomplete.bytes.length)
+            incomplete = undefined
+          }
+          try {
+            out.push(...unpackr.unpackMultiple(buf))
+          } catch (cause) {
+            const error: any = cause
+            if (error.incomplete) {
+              incomplete = { bytes: buf.subarray(error.lastPosition), cause }
+              if (error.values) {
+                out.push(...error.values)
               }
+            } else {
+              return Effect.fail(new MsgPackError({ kind: "Unpack", cause }))
             }
           }
-          return Arr.isReadonlyArrayNonEmpty(out) ? Effect.succeed(out) : Effect.flatMap(upstream, loop)
         }
-      )
+        return Arr.isReadonlyArrayNonEmpty(out) ? Effect.succeed(out) : pull
+      }
+
+      return pull
     })
   )
 

package/src/unstable/encoding/Ndjson.ts

@@ -73,7 +73,15 @@ export const encodeString = <IE = never, Done = unknown>(): Channel.Channel<
   Channel.fromTransform((upstream, _scope) =>
     Effect.succeed(Effect.flatMap(upstream, (input) => {
       try {
-        return Effect.succeed(Arr.of(input.map((item) => JSON.stringify(item)).join("\n") + "\n"))
+        return Effect.succeed(Arr.of(
+          input.map((item) => {
+            const output = JSON.stringify(item)
+            if (output === undefined) {
+              throw new TypeError("Value cannot be represented as JSON")
+            }
+            return output
+          }).join("\n") + "\n"
+        ))
       } catch (cause) {
         return Effect.fail(new NdjsonError({ kind: "Pack", cause }))
       }

package/src/unstable/encoding/Sse.ts

@@ -255,9 +255,9 @@ export function makeParser(onParse: (event: AnyEvent) => void, options?: DecodeO
   let buffer: string
   let startingPosition: number
   let startingFieldLength: number
+  let discardTrailingNewline: boolean
 
   // Event state
-  let eventId: string | undefined
   let lastEventId: string | undefined
   let eventName: string | undefined
   let data: string
@@ -270,8 +270,9 @@ export function makeParser(onParse: (event: AnyEvent) => void, options?: DecodeO
     buffer = ""
     startingPosition = 0
     startingFieldLength = -1
+    discardTrailingNewline = false
 
-    eventId = undefined
+    lastEventId = undefined
     eventName = undefined
     data = ""
   }
@@ -279,10 +280,10 @@ export function makeParser(onParse: (event: AnyEvent) => void, options?: DecodeO
   function feed(chunk: string): SseError | undefined {
     buffer = buffer ? buffer + chunk : chunk
 
-    // Strip any UTF8 byte order mark (BOM) at the start of the stream.
+    // 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 && hasBom(buffer)) {
+    if (isFirstChunk && buffer.startsWith(BOM)) {
       buffer = buffer.slice(BOM.length)
     }
 
@@ -291,7 +292,6 @@ export function makeParser(onParse: (event: AnyEvent) => void, options?: DecodeO
     // Set up chunk-specific processing state
     const length = buffer.length
     let position = 0
-    let discardTrailingNewline = false
 
     // Read the current buffer byte by byte
     while (position < length) {
@@ -364,12 +364,11 @@ export function makeParser(onParse: (event: AnyEvent) => void, options?: DecodeO
       if (data.length > 0) {
         onParse({
           _tag: "Event",
-          id: eventId,
-          event: eventName ?? "message",
+          id: lastEventId,
+          event: eventName || "message",
           data: data.slice(0, -1) // remove trailing newline
         })
         data = ""
-        eventId = undefined
       }
       eventName = undefined
       return
@@ -396,22 +395,15 @@ export function makeParser(onParse: (event: AnyEvent) => void, options?: DecodeO
     } else if (field === "event") {
       eventName = value
     } else if (field === "id" && !value.includes("\u0000")) {
-      eventId = value
       lastEventId = value
-    } else if (field === "retry") {
+    } else if (field === "retry" && /^\d+$/.test(value)) {
       const retry = parseInt(value, 10)
-      if (!Number.isNaN(retry)) {
-        onParse(new Retry({ duration: Duration.millis(retry), lastEventId }))
-      }
+      onParse(new Retry({ duration: Duration.millis(retry), lastEventId }))
     }
   }
 }
 
-const BOM = [239, 187, 191]
-
-function hasBom(buffer: string) {
-  return BOM.every((charCode: number, index: number) => buffer.charCodeAt(index) === charCode)
-}
+const BOM = "\uFEFF"
 
 /**
  * Stateful Server-Sent Events parser returned by `makeParser`.
@@ -662,9 +654,7 @@ export const encoder: Encoder = {
         if (event.event !== "message") {
           data += `event: ${event.event}\n`
         }
-        if (event.data !== "") {
-          data += `data: ${event.data.replace(/\n/g, "\ndata: ")}\n`
-        }
+        data += `data: ${event.data.replace(/\n/g, "\ndata: ")}\n`
         return data + "\n"
       }
       case "Retry": {