effect 4.0.3 → 4.0.5

package/src/http/internal/decompression.ts

@@ -0,0 +1,226 @@
+import * as ByteSize from "../../ByteSize.ts"
+import * as Effect from "../../Effect.ts"
+import * as Inspectable from "../../Inspectable.ts"
+import type * as Option from "../../Option.ts"
+import type { ReadonlyRecord } from "../../Record.ts"
+import type * as Schema from "../../Schema.ts"
+import type * as Socket from "../../socket/Socket.ts"
+import * as Stream from "../../Stream.ts"
+import * as Headers from "../Headers.ts"
+import * as HttpIncomingMessage from "../HttpIncomingMessage.ts"
+import type { HttpMethod } from "../HttpMethod.ts"
+import { HttpServerError, RequestParseError } from "../HttpServerError.ts"
+import * as HttpServerRequest from "../HttpServerRequest.ts"
+import * as Multipart from "../Multipart.ts"
+import * as UrlParams from "../UrlParams.ts"
+
+/**
+ * @internal
+ */
+export type Coding = "gzip" | "deflate"
+
+const defaultMaxDecompressedSize = ByteSize.mebibytes(10)
+
+/**
+ * Parses a `Content-Encoding` header into the codings to undo, in the order
+ * they were applied. `identity` members are dropped. Returns `undefined` if
+ * any member is unsupported.
+ *
+ * @internal
+ */
+export const parseContentEncoding = (header: string): ReadonlyArray<Coding> | undefined => {
+  const codings: Array<Coding> = []
+  for (const member of header.split(",")) {
+    const coding = member.trim().toLowerCase()
+    if (coding === "" || coding === "identity") continue
+    if (coding !== "gzip" && coding !== "deflate") return undefined
+    codings.push(coding)
+  }
+  return codings
+}
+
+/**
+ * Wraps a request so that its body accessors yield the decompressed body.
+ * Decompression happens lazily, when a body accessor is read.
+ *
+ * @internal
+ */
+export class DecompressedRequest extends Inspectable.Class implements HttpServerRequest.HttpServerRequest {
+  readonly [HttpServerRequest.TypeId]: typeof HttpServerRequest.TypeId
+  readonly [HttpIncomingMessage.TypeId]: typeof HttpIncomingMessage.TypeId
+  readonly inner: HttpServerRequest.HttpServerRequest
+  readonly codings: ReadonlyArray<Coding>
+  readonly maxDecompressedSize: ByteSize.ByteSize | undefined
+  readonly headers: Headers.Headers
+
+  constructor(
+    inner: HttpServerRequest.HttpServerRequest,
+    codings: ReadonlyArray<Coding>,
+    maxDecompressedSize: ByteSize.ByteSize | undefined
+  ) {
+    super()
+    this[HttpServerRequest.TypeId] = HttpServerRequest.TypeId
+    this[HttpIncomingMessage.TypeId] = HttpIncomingMessage.TypeId
+    this.inner = inner
+    this.codings = codings
+    this.maxDecompressedSize = maxDecompressedSize
+    this.headers = Headers.removeMany(inner.headers, ["content-encoding", "content-length"])
+  }
+
+  toJSON(): unknown {
+    return HttpIncomingMessage.inspect(this, {
+      _id: "HttpServerRequest",
+      method: this.method,
+      url: this.originalUrl
+    })
+  }
+
+  modify(
+    options: {
+      readonly url?: string
+      readonly headers?: Headers.Headers
+      readonly remoteAddress?: Option.Option<string>
+    }
+  ): HttpServerRequest.HttpServerRequest {
+    return new DecompressedRequest(this.inner.modify(options), this.codings, this.maxDecompressedSize)
+  }
+
+  get source(): object {
+    return this.inner.source
+  }
+
+  get url(): string {
+    return this.inner.url
+  }
+
+  get originalUrl(): string {
+    return this.inner.originalUrl
+  }
+
+  get method(): HttpMethod {
+    return this.inner.method
+  }
+
+  get cookies(): ReadonlyRecord<string, string> {
+    return this.inner.cookies
+  }
+
+  get remoteAddress(): Option.Option<string> {
+    return this.inner.remoteAddress
+  }
+
+  get upgrade(): Effect.Effect<Socket.Socket, HttpServerError> {
+    return this.inner.upgrade
+  }
+
+  // Platform accessors such as `NodeHttpServerRequest.toServerResponse` read
+  // the response handle from the request.
+  get response(): unknown {
+    return (this.inner as any).response
+  }
+
+  get stream(): Stream.Stream<Uint8Array, HttpServerError> {
+    return Stream.unwrap(Effect.withFiber((fiber) => {
+      const limit = this.maxDecompressedSize ?? fiber.getRef(HttpIncomingMessage.MaxBodySize) ??
+        defaultMaxDecompressedSize
+      return Effect.succeed(Stream.fromReadableStream({
+        evaluate: () => {
+          let body = Stream.toReadableStreamWith(this.inner.stream, fiber.context)
+          for (let i = this.codings.length - 1; i >= 0; i--) {
+            body = body.pipeThrough(
+              new DecompressionStream(this.codings[i]) as unknown as ReadableWritablePair<Uint8Array, Uint8Array>
+            )
+          }
+          let size = 0
+          return body.pipeThrough(
+            new TransformStream<Uint8Array, Uint8Array>({
+              transform: (chunk, controller) => {
+                size += chunk.byteLength
+                if (size > limit) {
+                  controller.error(
+                    this.parseError(undefined, `Decompressed request body exceeds ${limit} bytes`, "BodyTooLarge")
+                  )
+                } else {
+                  controller.enqueue(chunk)
+                }
+              }
+            })
+          )
+        },
+        onError: (cause) => cause instanceof HttpServerError ? cause : this.parseError(cause)
+      }))
+    }))
+  }
+
+  private bytesEffect: Effect.Effect<Uint8Array, HttpServerError> | undefined
+  private get bytes(): Effect.Effect<Uint8Array, HttpServerError> {
+    return this.bytesEffect ??= Effect.runSync(Effect.cached(Stream.mkUint8Array(this.stream)))
+  }
+
+  get text(): Effect.Effect<string, HttpServerError> {
+    return Effect.map(this.bytes, (bytes) => textDecoder.decode(bytes))
+  }
+
+  get json(): Effect.Effect<Schema.Json, HttpServerError> {
+    return Effect.flatMap(this.text, (text) =>
+      Effect.try({
+        try: () => text === "" ? null : JSON.parse(text) as Schema.Json,
+        catch: (cause) => this.parseError(cause)
+      }))
+  }
+
+  get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, HttpServerError> {
+    return Effect.flatMap(this.text, (text) =>
+      Effect.try({
+        try: () => UrlParams.fromInput(new URLSearchParams(text)),
+        catch: (cause) => this.parseError(cause)
+      }))
+  }
+
+  get arrayBuffer(): Effect.Effect<ArrayBuffer, HttpServerError> {
+    return Effect.map(
+      this.bytes,
+      (bytes) => bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer
+    )
+  }
+
+  get multipartStream(): Stream.Stream<Multipart.Part, Multipart.MultipartError> {
+    return Stream.pipeThroughChannel(
+      Stream.mapError(
+        this.stream,
+        (cause) => Multipart.MultipartError.fromReason(multipartReasons.get(cause) ?? "InternalError", cause)
+      ),
+      Multipart.makeChannel(this.headers)
+    )
+  }
+
+  private multipartEffect: HttpServerRequest.HttpServerRequest["multipart"] | undefined
+  get multipart(): HttpServerRequest.HttpServerRequest["multipart"] {
+    return this.multipartEffect ??= Effect.runSync(Effect.cached(Multipart.toPersisted(this.multipartStream)))
+  }
+
+  private parseError(
+    cause: unknown,
+    description?: string,
+    multipartReason: MultipartReason = "Parse"
+  ): HttpServerError {
+    const error = new HttpServerError({
+      reason: new RequestParseError({
+        request: this,
+        ...(description === undefined ? undefined : { description }),
+        ...(cause === undefined ? undefined : { cause })
+      })
+    })
+    multipartReasons.set(error, multipartReason)
+    return error
+  }
+}
+
+const textDecoder = new TextDecoder()
+
+type MultipartReason = "Parse" | "BodyTooLarge"
+
+// Failures caused by the client's data, keyed to the multipart reason they map
+// to. Transport errors from the inner request are absent and map to
+// `InternalError`.
+const multipartReasons = new WeakMap<HttpServerError, MultipartReason>()

package/src/http/internal/tracing.ts

@@ -1,5 +1,6 @@
 import type * as Tracer from "../../Tracer.ts"
 import * as Headers from "../Headers.ts"
+import * as UrlParams from "../UrlParams.ts"
 
 const defaultPorts: Record<string, number> = {
   "http:": 80,
@@ -9,16 +10,17 @@ const defaultPorts: Record<string, number> = {
 }
 
 /**
- * Records the `url.*` and `server.*` attributes for a request URL.
+ * Records `url.*` and `server.*` attributes with URL redaction.
  *
  * @internal
  */
 export const addUrlAttributes = (
   span: Tracer.Span,
-  url: URL
+  url: URL,
+  redactedNames: ReadonlyArray<string | RegExp>
 ): void => {
-  const query = url.search.slice(1)
-  span.attribute("url.full", url.toString())
+  const query = UrlParams.redactUrl(url.search, redactedNames).slice(1)
+  span.attribute("url.full", UrlParams.redactUrl(url.href, redactedNames))
   span.attribute("url.path", url.pathname)
   if (query !== "") {
     span.attribute("url.query", query)
@@ -34,6 +36,21 @@ export const addUrlAttributes = (
   }
 }
 
+/**
+ * Adds the names of `Redacted` parameters to the redacted names.
+ *
+ * @internal
+ */
+export const redactedNames = (
+  urlParams: UrlParams.UrlParams,
+  redactedNames: ReadonlyArray<string | RegExp>
+): ReadonlyArray<string | RegExp> => {
+  const keys = urlParams.params.filter(([, value]) => typeof value !== "string").map(([key]) => key)
+  return keys.length === 0
+    ? redactedNames
+    : [...redactedNames, ...new URLSearchParams(keys.map((key) => [key, ""])).keys()]
+}
+
 /** @internal */
 export const addHeaderAttributes = (
   span: Tracer.Span,

package/src/http/internal/urlParams.ts

@@ -0,0 +1,5 @@
+import * as Redacted from "../../Redacted.ts"
+
+/** @internal */
+export const unwrap = (value: string | Redacted.Redacted): string =>
+  typeof value === "string" ? value : Redacted.value(value)

package/src/http-api/HttpApiClient.ts

@@ -23,6 +23,7 @@ import * as HttpClientError from "../http/HttpClientError.ts"
 import * as HttpClientRequest from "../http/HttpClientRequest.ts"
 import type * as HttpClientResponse from "../http/HttpClientResponse.ts"
 import * as HttpMethod from "../http/HttpMethod.ts"
+import * as internalUrlParams from "../http/internal/urlParams.ts"
 import * as UrlParams from "../http/UrlParams.ts"
 import * as InternalRecord from "../internal/record.ts"
 import * as Predicate from "../Predicate.ts"
@@ -746,7 +747,7 @@ export const urlBuilder = <Api extends HttpApi.Constraint>(api: Api, options?: {
         )
         for (const [key, value] of urlParams.params) {
           if (value !== undefined) {
-            url.searchParams.append(key, value)
+            url.searchParams.append(key, internalUrlParams.unwrap(value))
           }
         }
         return url.toString()

package/src/http-api/HttpApiScalar.ts

@@ -60,6 +60,11 @@ export type ScalarConfig = {
   layout?: "modern" | "classic"
   /** URL to a request proxy for the API client */
   proxyUrl?: string
+  /** Authentication preferences for the API client */
+  authentication?: {
+    /** OpenAPI security scheme names to select by default */
+    preferredSecurityScheme?: string | Array<string | Array<string>> | null
+  }
   /** Browser JavaScript function expression used by Scalar for documents and test requests */
   customFetch?: string
   /** Whether to show the sidebar */

package/src/internal/core.ts

@@ -321,6 +321,26 @@ export const causeCombine: {
   }
 )
 
+/**
+ * Appends the interrupts from `interrupts` that `self` does not contain yet.
+ * Unlike `causeCombine`, it never calls hash or equality methods, which can be
+ * user-defined, random, or throwing.
+ *
+ * @internal
+ */
+export const causeAddInterrupts = <E>(self: Cause.Cause<E>, interrupts: Cause.Cause<never>): Cause.Cause<E> => {
+  const reasons: Array<Cause.Reason<E>> = self.reasons.slice()
+  for (const reason of interrupts.reasons) {
+    if (
+      isInterruptReason(reason) &&
+      !reasons.some((r) => isInterruptReason(r) && r.fiberId === reason.fiberId && r.annotations === reason.annotations)
+    ) {
+      reasons.push(reason)
+    }
+  }
+  return reasons.length === self.reasons.length ? self : new CauseImpl(reasons)
+}
+
 /** @internal */
 export const causeEmpty: Cause.Cause<never> = new CauseImpl([])
 
@@ -600,7 +620,7 @@ export const exitFailCause: <E>(cause: Cause.Cause<E>) => Exit.Exit<never, E> =
       if (skippedHandler) {
         cause = causeFromReasons(cause.reasons.filter((reason) => reason._tag !== "Fail"))
       }
-      cause = causeCombine(cause, interruptedCause)
+      cause = causeAddInterrupts(cause, interruptedCause)
       annotated = true
     }
     return cont

package/src/internal/dateTime.ts

@@ -934,10 +934,6 @@ export const subtractDuration: {
     mapEpochMillis(self, (millis) => millis - Duration.toMillis(Duration.fromInputUnsafe(duration)))
 )
 
-const addMillis = (date: Date, amount: number): void => {
-  date.setTime(date.getTime() + amount)
-}
-
 /** @internal */
 export const add: {
   (
@@ -949,20 +945,26 @@ export const add: {
   ): A
 } = dual(
   2,
-  (self: DateTime.DateTime, parts: Partial<DateTime.DateTime.PartsForMath>): DateTime.DateTime =>
-    mutate(self, (date) => {
+  (self: DateTime.DateTime, parts: Partial<DateTime.DateTime.PartsForMath>): DateTime.DateTime => {
+    // time units move the instant, calendar units move the wall clock
+    const shifted = mutateUtc(self, (date) => {
       if (parts.milliseconds) {
-        addMillis(date, parts.milliseconds)
+        date.setTime(date.getTime() + parts.milliseconds)
       }
       if (parts.seconds) {
-        addMillis(date, parts.seconds * 1000)
+        date.setTime(date.getTime() + parts.seconds * 1000)
       }
       if (parts.minutes) {
-        addMillis(date, parts.minutes * 60 * 1000)
+        date.setTime(date.getTime() + parts.minutes * 60 * 1000)
       }
       if (parts.hours) {
-        addMillis(date, parts.hours * 60 * 60 * 1000)
+        date.setTime(date.getTime() + parts.hours * 60 * 60 * 1000)
       }
+    })
+    if (!parts.days && !parts.weeks && !parts.months && !parts.years) {
+      return shifted
+    }
+    return mutate(shifted, (date) => {
       if (parts.days) {
         date.setUTCDate(date.getUTCDate() + parts.days)
       }
@@ -989,6 +991,7 @@ export const add: {
         }
       }
     })
+  }
 )
 
 /** @internal */

package/src/internal/effect.ts

@@ -49,6 +49,7 @@ import { internalCall } from "../Utils.ts"
 import type { Primitive } from "./core.ts"
 import {
   args,
+  causeAddInterrupts,
   causeAnnotate,
   causeCombine,
   causeEmpty,
@@ -130,9 +131,9 @@ export class Interrupt extends ReasonBase<"Interrupt"> implements Cause.Interrup
     )
   }
   [Hash.symbol](): number {
-    return Hash.combine(Hash.string(`${this._tag}:${this.fiberId}`))(
-      Hash.random(this.annotations)
-    )
+    // Equality compares annotations by reference, so leave them out instead of
+    // hashing them randomly.
+    return Hash.string(`${this._tag}:${this.fiberId}`)
   }
 }
 
@@ -566,7 +567,7 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
       cause = causeAnnotate(cause, annotations)
     }
     this._interruptedCause = this._interruptedCause
-      ? causeCombine(this._interruptedCause, cause)
+      ? causeAddInterrupts(this._interruptedCause, cause)
       : cause
     if (this.interruptible) {
       if (this._running) {
@@ -1507,14 +1508,19 @@ const succeedPayload = function(this: { readonly payload: any }, _value: unknown
 // V8 includes the property name of a stored continuation in its stack trace.
 // Other engines need an explicit frame for the stack cleaner to cut at.
 const continuationMarksStack = (() => {
-  if (getStackTraceLimit() === 0) return false
+  const limit = getStackTraceLimit()
+  if (limit === 0) return false
   const marker = "~effect/Effect/stackProbe"
   const probe = {
     [marker]: function stackProbe() {
-      return new Error().stack
+      return new Error()
     }
   }
-  return probe[marker]()?.includes("[as " + marker + "]") === true
+  // Only the probe frame is needed to detect the continuation property name.
+  setStackTraceLimit(1)
+  const error = probe[marker]()
+  setStackTraceLimit(limit)
+  return error.stack?.includes("[as " + marker + "]") === true
 })()
 const mapCont = function(this: { readonly payload: any }, value: any, fiber: FiberImpl) {
   const f = this.payload