effect 4.0.0-beta.103 → 4.0.0-beta.105

package/src/unstable/cluster/internal/resourceRef.ts

@@ -1,3 +1,4 @@
+import type * as Cause from "../../../Cause.ts"
 import * as Effect from "../../../Effect.ts"
 import * as Exit from "../../../Exit.ts"
 import * as Latch from "../../../Latch.ts"
@@ -7,7 +8,7 @@ import * as Scope from "../../../Scope.ts"
 import { internalInterruptors } from "./interruptors.ts"
 
 /** @internal */
-export type State<A> = {
+export type State<A, E> = {
   readonly _tag: "Closed"
 } | {
   readonly _tag: "Acquiring"
@@ -16,6 +17,10 @@ export type State<A> = {
   readonly _tag: "Acquired"
   readonly scope: Scope.Closeable
   readonly value: A
+} | {
+  readonly _tag: "Failed"
+  readonly scope: Scope.Closeable
+  readonly cause: Cause.Cause<E>
 }
 
 /** @internal */
@@ -24,7 +29,7 @@ export class ResourceRef<A, E = never> {
     parentScope: Scope.Scope,
     acquire: (scope: Scope.Scope) => Effect.Effect<A, E>
   ) {
-    const state = MutableRef.make<State<A>>({ _tag: "Closed" })
+    const state = MutableRef.make<State<A, E>>({ _tag: "Closed" })
 
     yield* Scope.addFinalizerExit(parentScope, (exit) => {
       const s = MutableRef.get(state)
@@ -44,10 +49,10 @@ export class ResourceRef<A, E = never> {
     return new ResourceRef(state, acquire)
   })
 
-  readonly state: MutableRef.MutableRef<State<A>>
+  readonly state: MutableRef.MutableRef<State<A, E>>
   readonly acquire: (scope: Scope.Scope) => Effect.Effect<A, E>
   constructor(
-    state: MutableRef.MutableRef<State<A>>,
+    state: MutableRef.MutableRef<State<A, E>>,
     acquire: (scope: Scope.Scope) => Effect.Effect<A, E>
   ) {
     this.state = state
@@ -84,15 +89,32 @@ export class ResourceRef<A, E = never> {
         MutableRef.set(this.state, { _tag: "Acquired", scope, value })
         return this.latch.open
       })
+    ).pipe(
+      Effect.onExit((exit) => {
+        if (Exit.isSuccess(exit)) {
+          return Effect.void
+        }
+        return Scope.close(scope, exit).pipe(
+          Effect.ensuring(Effect.sync(() => {
+            const state = this.state.current
+            if (state._tag === "Acquiring" && state.scope === scope) {
+              MutableRef.set(this.state, { _tag: "Failed", scope, cause: exit.cause })
+              this.latch.openUnsafe()
+            }
+          }))
+        )
+      })
     )
   }
 
-  await: Effect.Effect<A> = Effect.suspend(() => {
+  await: Effect.Effect<A, E> = Effect.suspend(() => {
     const s = this.state.current
     if (s._tag === "Closed") {
       return Effect.interrupt
     } else if (s._tag === "Acquired") {
       return Effect.succeed(s.value)
+    } else if (s._tag === "Failed") {
+      return Effect.failCause(s.cause)
     }
     return Effect.flatMap(this.latch.await, () => this.await)
   })

package/src/unstable/devtools/DevToolsClient.ts

@@ -184,7 +184,8 @@ const makeTracerEffect = Effect.gen(function*() {
   return Tracer.make({
     span(options) {
       const span = currentTracer.span(options)
-      client.sendUnsafe(span)
+      // the span is mutated in place, so send a snapshot of its current state
+      client.sendUnsafe({ ...span })
       const oldEvent = span.event
       span.event = function(this: Tracer.Span, name, startTime, attributes) {
         client.sendUnsafe({
@@ -201,7 +202,7 @@ const makeTracerEffect = Effect.gen(function*() {
       const oldEnd = span.end
       span.end = function(this: Tracer.Span, endTime, exit) {
         oldEnd.call(this, endTime, exit)
-        client.sendUnsafe(span)
+        client.sendUnsafe({ ...span })
       }
 
       return span

package/src/unstable/encoding/Ini.ts

@@ -0,0 +1,174 @@
+/**
+ * Parses INI configuration files.
+ *
+ * This module contains the decoding surface used by Effect's CLI without
+ * pulling in the complete `ini` package.
+ *
+ * @since 4.0.0
+ */
+
+/*
+ * The parser is adapted from `ini` 7.0.0.
+ *
+ * Copyright (c) Isaac Z. Schlueter and Contributors
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+const hasOwn = Object.prototype.hasOwnProperty
+
+const splitSections = (value: string): Array<string> => {
+  const sections: Array<string> = []
+  let start = 0
+  let index = 0
+  while ((index = value.indexOf(".", index)) !== -1) {
+    if (index === 0 || value[index - 1] !== "\\") {
+      sections.push(value.slice(start, index))
+      start = index + 1
+    }
+    index++
+  }
+  sections.push(value.slice(start))
+  return sections
+}
+
+const isQuoted = (value: string): boolean =>
+  value.length >= 2 &&
+  ((value.startsWith("\"") && value.endsWith("\"")) ||
+    (value.startsWith("'") && value.endsWith("'")))
+
+const unquote = (input: string | undefined): string => {
+  let value = (input ?? "").trim()
+  if (isQuoted(value)) {
+    if (value[0] === "'") {
+      value = value.slice(1, -1)
+    }
+    try {
+      return JSON.parse(value)
+    } catch {
+      return value
+    }
+  }
+
+  let escaped = false
+  let output = ""
+  for (const character of value) {
+    if (escaped) {
+      output += character === ";" || character === "#" || character === "\\"
+        ? character
+        : `\\${character}`
+      escaped = false
+    } else if (character === ";" || character === "#") {
+      break
+    } else if (character === "\\") {
+      escaped = true
+    } else {
+      output += character
+    }
+  }
+  return output.trim()
+}
+
+/**
+ * Parses an INI document into a null-prototype record.
+ *
+ * Section names separated by dots become nested records, repeated keys ending
+ * in `[]` become arrays, and the scalar values `true`, `false`, and `null` are
+ * decoded. Other scalar values remain strings.
+ *
+ * @category decoding
+ * @since 4.0.0
+ */
+export const parse = (input: string): Record<string, unknown> => {
+  const output: Record<string, any> = Object.create(null)
+  let current = output
+  const sectionPattern = /^\[([^\]]*)\]\s*$/
+  const propertyPattern = /^([^=]+)(=(.*))?$/
+
+  for (const line of input.split(/[\r\n]+/g)) {
+    if (line.length === 0 || /^\s*(?:[;#]|$)/.test(line)) {
+      continue
+    }
+
+    const sectionMatch = sectionPattern.exec(line)
+    if (sectionMatch !== null) {
+      const section = unquote(sectionMatch[1])
+      if (section === "__proto__") {
+        current = Object.create(null)
+      } else {
+        current = output[section] ??= Object.create(null)
+      }
+      continue
+    }
+
+    const propertyMatch = propertyPattern.exec(line)
+    if (propertyMatch === null) {
+      continue
+    }
+
+    const rawKey = unquote(propertyMatch[1])
+    const array = rawKey.length > 2 && rawKey.endsWith("[]")
+    const key = array ? rawKey.slice(0, -2) : rawKey
+    if (key === "__proto__") {
+      continue
+    }
+
+    const rawValue = propertyMatch[2] === undefined ? true : unquote(propertyMatch[3])
+    const value = rawValue === "true" || rawValue === "false" || rawValue === "null"
+      ? JSON.parse(rawValue)
+      : rawValue
+
+    if (array) {
+      if (!hasOwn.call(current, key)) {
+        current[key] = []
+      } else if (!Array.isArray(current[key])) {
+        current[key] = [current[key]]
+      }
+    }
+    if (Array.isArray(current[key])) {
+      current[key].push(value)
+    } else {
+      current[key] = value
+    }
+  }
+
+  const remove: Array<string> = []
+  for (const section of Object.keys(output)) {
+    if (typeof output[section] !== "object" || output[section] === null || Array.isArray(output[section])) {
+      continue
+    }
+
+    const parts = splitSections(section)
+    const last = parts.pop()!
+    const key = last.replace(/\\\./g, ".")
+    current = output
+    for (const part of parts) {
+      if (part === "__proto__") {
+        continue
+      }
+      if (!hasOwn.call(current, part) || typeof current[part] !== "object" || current[part] === null) {
+        current[part] = Object.create(null)
+      }
+      current = current[part]
+    }
+    if (current === output && key === last) {
+      continue
+    }
+    current[key] = output[section]
+    remove.push(section)
+  }
+  for (const section of remove) {
+    delete output[section]
+  }
+  return output
+}

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
     })
   )
 
@@ -368,25 +387,29 @@ export const transformation: SchemaTransformation.Transformation<
   unknown,
   Uint8Array<ArrayBuffer>
 > = SchemaTransformation.transformOrFail({
-  decode(e, _options) {
+  decode(e, options) {
     try {
       return Effect.succeed(Msgpackr.decode(e))
     } catch {
       return Effect.fail(
-        new SchemaIssue.InvalidValue({
-          message: "Expected valid MessagePack bytes"
-        })
+        new SchemaIssue.InvalidValue(
+          { expected: "valid MessagePack bytes" },
+          e,
+          options
+        )
       )
     }
   },
-  encode(t, _options) {
+  encode(t, options) {
     try {
       return Effect.succeed(Msgpackr.encode(t) as Uint8Array<ArrayBuffer>)
     } catch {
       return Effect.fail(
-        new SchemaIssue.InvalidValue({
-          message: "Expected a MessagePack-serializable value"
-        })
+        new SchemaIssue.InvalidValue(
+          { expected: "a MessagePack-serializable value" },
+          t,
+          options
+        )
       )
     }
   }

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": {