@effect/platform 0.69.27 → 0.69.29

package/src/HttpApiBuilder.ts

@@ -1,6 +1,7 @@
 /**
  * @since 1.0.0
  */
+import * as Cause from "effect/Cause"
 import * as Chunk from "effect/Chunk"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
@@ -38,6 +39,7 @@ import * as HttpServerRequest from "./HttpServerRequest.js"
 import * as HttpServerResponse from "./HttpServerResponse.js"
 import * as OpenApi from "./OpenApi.js"
 import type { Path } from "./Path.js"
+import * as UrlParams from "./UrlParams.js"
 
 /**
  * The router that the API endpoints are attached to.
@@ -111,13 +113,13 @@ export const httpApp: Effect.Effect<
   const encodeError = Schema.encodeUnknown(errorSchema)
   return router.pipe(
     apiMiddleware,
-    Effect.catchAll((error) =>
-      Effect.matchEffect(Effect.provide(encodeError(error), context), {
-        onFailure: () => Effect.die(error),
+    Effect.catchAllCause((cause) =>
+      Effect.matchEffect(Effect.provide(encodeError(Cause.squash(cause)), context), {
+        onFailure: () => Effect.failCause(cause),
         onSuccess: Effect.succeed
       })
     )
-  )
+  ) as any
 })
 
 /**
@@ -126,6 +128,7 @@ export const httpApp: Effect.Effect<
  * @since 1.0.0
  * @category constructors
  * @example
+ * ```ts
  * import { HttpApi, HttpApiBuilder, HttpServer } from "@effect/platform"
  * import { Layer } from "effect"
  *
@@ -141,6 +144,7 @@ export const httpApp: Effect.Effect<
  *     HttpServer.layerContext
  *   )
  * )
+ * ```
  */
 export const toWebHandler = <LA, LE>(
   layer: Layer.Layer<LA | HttpApi.Api | HttpRouter.HttpRouter.DefaultServices, LE>,
@@ -506,20 +510,31 @@ export const handler = <
 
 const requestPayload = (
   request: HttpServerRequest.HttpServerRequest,
-  urlParams: ReadonlyRecord<string, string | Array<string>>,
-  isMultipart: boolean
+  urlParams: ReadonlyRecord<string, string | Array<string>>
 ): Effect.Effect<
   unknown,
   never,
   | FileSystem
   | Path
   | Scope
-> =>
-  HttpMethod.hasBody(request.method)
-    ? isMultipart
-      ? Effect.orDie(request.multipart)
-      : Effect.orDie(request.json)
-    : Effect.succeed(urlParams)
+> => {
+  if (!HttpMethod.hasBody(request.method)) {
+    return Effect.succeed(urlParams)
+  }
+  const contentType = request.headers["content-type"]
+    ? request.headers["content-type"].toLowerCase().trim()
+    : "application/json"
+  if (contentType.includes("application/json")) {
+    return Effect.orDie(request.json)
+  } else if (contentType.includes("multipart/form-data")) {
+    return Effect.orDie(request.multipart)
+  } else if (contentType.includes("x-www-form-urlencoded")) {
+    return Effect.map(Effect.orDie(request.urlParamsBody), UrlParams.toRecord)
+  } else if (contentType.startsWith("text/")) {
+    return Effect.orDie(request.text)
+  }
+  return Effect.map(Effect.orDie(request.arrayBuffer), (buffer) => new Uint8Array(buffer))
+}
 
 type MiddlewareMap = Map<string, {
   readonly tag: HttpApiMiddleware.TagClassAny
@@ -552,10 +567,6 @@ const handlerToRoute = (
 ): HttpRouter.Route<any, any> => {
   const endpoint = endpoint_ as HttpApiEndpoint.HttpApiEndpoint.AnyWithProps
   const decodePath = Option.map(endpoint.pathSchema, Schema.decodeUnknown)
-  const isMultipart = endpoint.payloadSchema.pipe(
-    Option.map((schema) => HttpApiSchema.getMultipart(schema.ast)),
-    Option.getOrElse(() => false)
-  )
   const decodePayload = Option.map(endpoint.payloadSchema, Schema.decodeUnknown)
   const decodeHeaders = Option.map(endpoint.headersSchema, Schema.decodeUnknown)
   const decodeUrlParams = Option.map(endpoint.urlParamsSchema, Schema.decodeUnknown)
@@ -577,7 +588,7 @@ const handlerToRoute = (
         }
         if (decodePayload._tag === "Some") {
           request.payload = yield* Effect.flatMap(
-            requestPayload(httpRequest, urlParams, isMultipart),
+            requestPayload(httpRequest, urlParams),
             decodePayload.value
           )
         }

package/src/HttpApiClient.ts

@@ -4,6 +4,7 @@
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import { identity } from "effect/Function"
+import { globalValue } from "effect/GlobalValue"
 import * as Option from "effect/Option"
 import * as ParseResult from "effect/ParseResult"
 import type * as Predicate from "effect/Predicate"
@@ -15,12 +16,14 @@ import * as HttpApi from "./HttpApi.js"
 import type { HttpApiEndpoint } from "./HttpApiEndpoint.js"
 import type { HttpApiGroup } from "./HttpApiGroup.js"
 import * as HttpApiSchema from "./HttpApiSchema.js"
+import * as HttpBody from "./HttpBody.js"
 import * as HttpClient from "./HttpClient.js"
 import * as HttpClientError from "./HttpClientError.js"
 import * as HttpClientRequest from "./HttpClientRequest.js"
 import * as HttpClientResponse from "./HttpClientResponse.js"
 import * as HttpMethod from "./HttpMethod.js"
 import type { HttpApiMiddleware } from "./index.js"
+import * as UrlParams from "./UrlParams.js"
 
 /**
  * @since 1.0.0
@@ -160,13 +163,13 @@ const makeClient = <Groups extends HttpApiGroup.Any, ApiError, ApiR>(
         successes.forEach((ast, status) => {
           decodeMap[status] = ast._tag === "None" ? responseAsVoid : schemaToResponse(ast.value)
         })
-        const isMultipart = endpoint.payloadSchema.pipe(
-          Option.map((schema) => HttpApiSchema.getMultipart(schema.ast)),
-          Option.getOrElse(() => false)
-        )
-        const encodePayload = endpoint.payloadSchema.pipe(
-          Option.filter(() => !isMultipart),
-          Option.map(Schema.encodeUnknown)
+        const encodePayloadBody = endpoint.payloadSchema.pipe(
+          Option.map((schema) => {
+            if (HttpMethod.hasBody(endpoint.method)) {
+              return Schema.encodeUnknown(payloadSchemaBody(schema as any))
+            }
+            return Schema.encodeUnknown(schema)
+          })
         )
         const encodeHeaders = endpoint.headersSchema.pipe(
           Option.map(Schema.encodeUnknown)
@@ -185,13 +188,16 @@ const makeClient = <Groups extends HttpApiGroup.Any, ApiError, ApiR>(
             let httpRequest = HttpClientRequest.make(endpoint.method)(
               request && request.path ? makeUrl(request.path) : endpoint.path
             )
-            if (isMultipart) {
+            if (request && request.payload instanceof FormData) {
               httpRequest = HttpClientRequest.bodyFormData(httpRequest, request.payload)
-            } else if (encodePayload._tag === "Some") {
-              const payload = yield* encodePayload.value(request.payload)
-              httpRequest = HttpMethod.hasBody(endpoint.method)
-                ? yield* Effect.orDie(HttpClientRequest.bodyJson(httpRequest, payload))
-                : HttpClientRequest.setUrlParams(httpRequest, payload as any)
+            } else if (encodePayloadBody._tag === "Some") {
+              if (HttpMethod.hasBody(endpoint.method)) {
+                const body = (yield* encodePayloadBody.value(request.payload)) as HttpBody.HttpBody
+                httpRequest = HttpClientRequest.setBody(httpRequest, body)
+              } else {
+                const urlParams = (yield* encodePayloadBody.value(request.payload)) as Record<string, string>
+                httpRequest = HttpClientRequest.setUrlParams(httpRequest, urlParams)
+              }
             }
             if (encodeHeaders._tag === "Some") {
               httpRequest = HttpClientRequest.setHeaders(
@@ -421,3 +427,58 @@ const statusCodeError = (response: HttpClientResponse.HttpClientResponse) =>
   )
 
 const responseAsVoid = (_response: HttpClientResponse.HttpClientResponse) => Effect.void
+
+const HttpBodyFromSelf = Schema.declare(HttpBody.isHttpBody)
+
+const payloadSchemaBody = (schema: Schema.Schema.All): Schema.Schema<any, HttpBody.HttpBody> => {
+  const members = schema.ast._tag === "Union" ? schema.ast.types : [schema.ast]
+  return Schema.Union(...members.map(bodyFromPayload)) as any
+}
+
+const bodyFromPayloadCache = globalValue(
+  "@effect/platform/HttpApiClient/bodyFromPayloadCache",
+  () => new WeakMap<AST.AST, Schema.Schema.Any>()
+)
+
+const bodyFromPayload = (ast: AST.AST) => {
+  if (bodyFromPayloadCache.has(ast)) {
+    return bodyFromPayloadCache.get(ast)!
+  }
+  const schema = Schema.make(ast)
+  const encoding = HttpApiSchema.getEncoding(ast)
+  const transform = Schema.transformOrFail(
+    HttpBodyFromSelf,
+    schema,
+    {
+      decode(fromA, _, ast) {
+        return ParseResult.fail(new ParseResult.Forbidden(ast, fromA, "encode only schema"))
+      },
+      encode(toI, _, ast) {
+        switch (encoding.kind) {
+          case "Json": {
+            return HttpBody.json(toI).pipe(
+              ParseResult.mapError((error) => new ParseResult.Type(ast, toI, `Could not encode as JSON: ${error}`))
+            )
+          }
+          case "Text": {
+            if (typeof toI !== "string") {
+              return ParseResult.fail(new ParseResult.Type(ast, toI, "Expected a string"))
+            }
+            return ParseResult.succeed(HttpBody.text(toI))
+          }
+          case "UrlParams": {
+            return ParseResult.succeed(HttpBody.urlParams(UrlParams.fromInput(toI as any)))
+          }
+          case "Uint8Array": {
+            if (!(toI instanceof Uint8Array)) {
+              return ParseResult.fail(new ParseResult.Type(ast, toI, "Expected a Uint8Array"))
+            }
+            return ParseResult.succeed(HttpBody.uint8Array(toI))
+          }
+        }
+      }
+    }
+  )
+  bodyFromPayloadCache.set(ast, transform)
+  return transform
+}

package/src/HttpApiEndpoint.ts

@@ -406,7 +406,8 @@ export declare namespace HttpApiEndpoint {
     & ([UrlParams] extends [never] ? {} : { readonly urlParams: UrlParams })
     & ([Headers] extends [never] ? {} : { readonly headers: Headers })
     & ([Payload] extends [never] ? {}
-      : [Payload] extends [Brand<HttpApiSchema.MultipartTypeId>] ? { readonly payload: FormData }
+      : Payload extends infer P ?
+        P extends Brand<HttpApiSchema.MultipartTypeId> ? { readonly payload: FormData } : { readonly payload: P }
       : { readonly payload: Payload })
   ) extends infer Req ? keyof Req extends never ? (void | { readonly withResponse?: WithResponse }) :
     Req & { readonly withResponse?: WithResponse } :

package/src/HttpClient.ts

@@ -12,6 +12,7 @@ import type * as Predicate from "effect/Predicate"
 import type { Ref } from "effect/Ref"
 import type * as Schedule from "effect/Schedule"
 import type * as Scope from "effect/Scope"
+import type { NoInfer } from "effect/Types"
 import type { Cookies } from "./Cookies.js"
 import type * as Error from "./HttpClientError.js"
 import type * as ClientRequest from "./HttpClientRequest.js"
@@ -636,34 +637,47 @@ export const retry: {
 } = internal.retry
 
 /**
- * Retries common transient errors, such as rate limiting or network issues.
+ * Retries common transient errors, such as rate limiting, timeouts or network issues.
+ *
+ * Specifying a `while` predicate allows you to consider other errors as
+ * transient.
  *
  * @since 1.0.0
  * @category error handling
  */
 export const retryTransient: {
   /**
-   * Retries common transient errors, such as rate limiting or network issues.
+   * Retries common transient errors, such as rate limiting, timeouts or network issues.
+   *
+   * Specifying a `while` predicate allows you to consider other errors as
+   * transient.
    *
    * @since 1.0.0
    * @category error handling
    */
   <B, E, R1 = never>(
-    options:
-      | { readonly schedule?: Schedule.Schedule<B, NoInfer<E>, R1>; readonly times?: number }
-      | Schedule.Schedule<B, NoInfer<E>, R1>
+    options: {
+      readonly while?: Predicate.Predicate<NoInfer<E>>
+      readonly schedule?: Schedule.Schedule<B, NoInfer<E>, R1>
+      readonly times?: number
+    } | Schedule.Schedule<B, NoInfer<E>, R1>
   ): <R>(self: HttpClient<E, R>) => HttpClient<E, R1 | R>
   /**
-   * Retries common transient errors, such as rate limiting or network issues.
+   * Retries common transient errors, such as rate limiting, timeouts or network issues.
+   *
+   * Specifying a `while` predicate allows you to consider other errors as
+   * transient.
    *
    * @since 1.0.0
    * @category error handling
    */
   <E, R, B, R1 = never>(
     self: HttpClient<E, R>,
-    options:
-      | { readonly schedule?: Schedule.Schedule<B, NoInfer<E>, R1>; readonly times?: number }
-      | Schedule.Schedule<B, NoInfer<E>, R1>
+    options: {
+      readonly while?: Predicate.Predicate<NoInfer<E>>
+      readonly schedule?: Schedule.Schedule<B, NoInfer<E>, R1>
+      readonly times?: number
+    } | Schedule.Schedule<B, NoInfer<E>, R1>
   ): HttpClient<E, R1 | R>
 } = internal.retryTransient
 

package/src/OpenApi.ts

@@ -231,7 +231,7 @@ export const fromApi = <A extends HttpApi.HttpApi.Any>(self: A): OpenAPISpec =>
       })
       spec.tags!.push(tag)
     },
-    onEndpoint({ endpoint, errors, group, middleware, successes }) {
+    onEndpoint({ endpoint, errors, group, middleware, payloads, successes }) {
       const path = endpoint.path.replace(/:(\w+)[^/]*/g, "{$1}")
       const method = endpoint.method.toLowerCase() as OpenAPISpecMethodName
       const op: DeepMutable<OpenAPISpecOperation> = {
@@ -266,19 +266,15 @@ export const fromApi = <A extends HttpApi.HttpApi.Any>(self: A): OpenAPISpec =>
           op.security!.push({ [name]: [] })
         }
       })
-      endpoint.payloadSchema.pipe(
-        Option.filter(() => HttpMethod.hasBody(endpoint.method)),
-        Option.map((schema) => {
-          op.requestBody = {
-            content: {
-              [HttpApiSchema.getMultipart(schema.ast) ? "multipart/form-data" : "application/json"]: {
-                schema: makeJsonSchemaOrRef(schema)
-              }
-            },
-            required: true
+      if (payloads.size > 0) {
+        const content: Mutable<OpenApiSpecContent> = {}
+        payloads.forEach(({ ast }, contentType) => {
+          content[contentType as OpenApiSpecContentType] = {
+            schema: makeJsonSchemaOrRef(Schema.make(ast))
           }
         })
-      )
+        op.requestBody = { content, required: true }
+      }
       for (const [status, ast] of successes) {
         if (op.responses![status]) continue
         op.responses![status] = {

package/src/PlatformLogger.ts

@@ -14,6 +14,7 @@ import * as internal from "./internal/platformLogger.js"
  *
  * @since 1.0.0
  * @example
+ * ```ts
  * import { PlatformLogger } from "@effect/platform"
  * import { NodeFileSystem, NodeRuntime } from "@effect/platform-node"
  * import { Effect, Layer, Logger } from "effect"
@@ -31,6 +32,7 @@ import * as internal from "./internal/platformLogger.js"
  *   Effect.provide(LoggerLive),
  *   NodeRuntime.runMain
  * )
+ * ```
  */
 export const toFile: {
   /**
@@ -38,6 +40,7 @@ export const toFile: {
    *
    * @since 1.0.0
    * @example
+   * ```ts
    * import { PlatformLogger } from "@effect/platform"
    * import { NodeFileSystem, NodeRuntime } from "@effect/platform-node"
    * import { Effect, Layer, Logger } from "effect"
@@ -55,6 +58,7 @@ export const toFile: {
    *   Effect.provide(LoggerLive),
    *   NodeRuntime.runMain
    * )
+   * ```
    */
   (
     path: string,
@@ -73,6 +77,7 @@ export const toFile: {
    *
    * @since 1.0.0
    * @example
+   * ```ts
    * import { PlatformLogger } from "@effect/platform"
    * import { NodeFileSystem, NodeRuntime } from "@effect/platform-node"
    * import { Effect, Layer, Logger } from "effect"
@@ -90,6 +95,7 @@ export const toFile: {
    *   Effect.provide(LoggerLive),
    *   NodeRuntime.runMain
    * )
+   * ```
    */
   <Message>(
     self: Logger.Logger<Message, string>,

package/src/UrlParams.ts

@@ -274,6 +274,40 @@ const baseUrl = (): string | undefined => {
   return undefined
 }
 
+/**
+ * Builds a `Record` containing all the key-value pairs in the given `UrlParams`
+ * as `string` (if only one value for a key) or a `NonEmptyArray<string>`
+ * (when more than one value for a key)
+ *
+ * @example
+ * import { UrlParams } from "@effect/platform"
+ *
+ * const urlParams = UrlParams.fromInput({ a: 1, b: true, c: "string", e: [1, 2, 3] })
+ * const result = UrlParams.toRecord(urlParams)
+ *
+ * assert.deepStrictEqual(
+ *   result,
+ *   { "a": "1", "b": "true", "c": "string", "e": ["1", "2", "3"] }
+ * )
+ *
+ * @since 1.0.0
+ * @category conversions
+ */
+export const toRecord = (self: UrlParams): Record<string, string | Arr.NonEmptyArray<string>> => {
+  const out: Record<string, string | Arr.NonEmptyArray<string>> = {}
+  for (const [k, value] of self) {
+    const curr = out[k]
+    if (curr === undefined) {
+      out[k] = value
+    } else if (typeof curr === "string") {
+      out[k] = [curr, value]
+    } else {
+      curr.push(value)
+    }
+  }
+  return out
+}
+
 /**
  * @since 1.0.0
  * @category schema

package/src/internal/httpClient.ts

@@ -1,3 +1,4 @@
+import * as Cause from "effect/Cause"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import type * as Fiber from "effect/Fiber"
@@ -11,6 +12,7 @@ import * as Predicate from "effect/Predicate"
 import * as Ref from "effect/Ref"
 import * as Schedule from "effect/Schedule"
 import * as Scope from "effect/Scope"
+import type { NoInfer } from "effect/Types"
 import * as Cookies from "../Cookies.js"
 import * as Headers from "../Headers.js"
 import type * as Client from "../HttpClient.js"
@@ -565,6 +567,7 @@ export const retry: {
 export const retryTransient: {
   <B, E, R1 = never>(
     options: {
+      readonly while?: Predicate.Predicate<NoInfer<E>>
       readonly schedule?: Schedule.Schedule<B, NoInfer<E>, R1>
       readonly times?: number
     } | Schedule.Schedule<B, NoInfer<E>, R1>
@@ -572,6 +575,7 @@ export const retryTransient: {
   <E, R, B, R1 = never>(
     self: Client.HttpClient<E, R>,
     options: {
+      readonly while?: Predicate.Predicate<NoInfer<E>>
       readonly schedule?: Schedule.Schedule<B, NoInfer<E>, R1>
       readonly times?: number
     } | Schedule.Schedule<B, NoInfer<E>, R1>
@@ -581,6 +585,7 @@ export const retryTransient: {
   <E extends E0, E0, R, B, R1 = never>(
     self: Client.HttpClient<E, R>,
     options: {
+      readonly while?: Predicate.Predicate<NoInfer<E>>
       readonly schedule?: Schedule.Schedule<B, NoInfer<E>, R1>
       readonly times?: number
     } | Schedule.Schedule<B, NoInfer<E>, R1>
@@ -588,16 +593,23 @@ export const retryTransient: {
     transformResponse(
       self,
       Effect.retry({
-        while: (error) =>
-          Error.isHttpClientError(error) &&
-          ((error._tag === "RequestError" && error.reason === "Transport") ||
-            (error._tag === "ResponseError" && error.response.status >= 429)),
+        while: Schedule.ScheduleTypeId in options || options.while === undefined
+          ? isTransientError
+          : Predicate.or(isTransientError, options.while),
         schedule: Schedule.ScheduleTypeId in options ? options : options.schedule,
         times: Schedule.ScheduleTypeId in options ? undefined : options.times
       })
     )
 )
 
+const isTransientError = (error: unknown) =>
+  Predicate.hasProperty(error, Cause.TimeoutExceptionTypeId) || isTransientHttpError(error)
+
+const isTransientHttpError = (error: unknown) =>
+  Error.isHttpClientError(error) &&
+  ((error._tag === "RequestError" && error.reason === "Transport") ||
+    (error._tag === "ResponseError" && error.response.status >= 429))
+
 /** @internal */
 export const tap = dual<
   <_, E2, R2>(