@effect/platform 0.69.26 → 0.69.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/platform",
-  "version": "0.69.26",
+  "version": "0.69.28",
   "description": "Unified interfaces for common platform-specific services",
   "license": "MIT",
   "repository": {
@@ -14,7 +14,7 @@
     "multipasta": "^0.2.5"
   },
   "peerDependencies": {
-    "effect": "^3.10.17"
+    "effect": "^3.10.19"
   },
   "publishConfig": {
     "provenance": true

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"
@@ -88,7 +89,7 @@ export const serve = <R = never>(
   httpApp.pipe(
     Effect.map((app) => HttpServer.serve(app as any, middleware!)),
     Layer.unwrapEffect,
-    Layer.provide(Router.Live)
+    Layer.provide([Router.Live, Middleware.layer])
   )
 
 /**
@@ -100,23 +101,24 @@ export const serve = <R = never>(
 export const httpApp: Effect.Effect<
   HttpApp.Default<never, HttpRouter.HttpRouter.DefaultServices>,
   never,
-  Router | HttpApi.Api
+  Router | HttpApi.Api | Middleware
 > = Effect.gen(function*() {
   const { api, context } = yield* HttpApi.Api
   const middleware = makeMiddlewareMap(api.middlewares, context)
   const router = applyMiddleware(middleware, yield* Router.router)
-  const apiMiddleware = yield* Effect.serviceOption(Middleware)
+  const apiMiddlewareService = yield* Middleware
+  const apiMiddleware = yield* apiMiddlewareService.retrieve
   const errorSchema = makeErrorSchema(api as any)
   const encodeError = Schema.encodeUnknown(errorSchema)
   return router.pipe(
-    apiMiddleware._tag === "Some" ? apiMiddleware.value : identity,
-    Effect.catchAll((error) =>
-      Effect.matchEffect(Effect.provide(encodeError(error), context), {
-        onFailure: () => Effect.die(error),
+    apiMiddleware,
+    Effect.catchAllCause((cause) =>
+      Effect.matchEffect(Effect.provide(encodeError(Cause.squash(cause)), context), {
+        onFailure: () => Effect.failCause(cause),
         onSuccess: Effect.succeed
       })
     )
-  )
+  ) as any
 })
 
 /**
@@ -125,6 +127,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"
  *
@@ -140,6 +143,7 @@ export const httpApp: Effect.Effect<
  *     HttpServer.layerContext
  *   )
  * )
+ * ```
  */
 export const toWebHandler = <LA, LE>(
   layer: Layer.Layer<LA | HttpApi.Api | HttpRouter.HttpRouter.DefaultServices, LE>,
@@ -157,7 +161,7 @@ export const toWebHandler = <LA, LE>(
   readonly dispose: () => Promise<void>
 } => {
   const runtime = ManagedRuntime.make(
-    Layer.merge(layer, Router.Live),
+    Layer.mergeAll(layer, Router.Live, Middleware.layer),
     options?.memoMap
   )
   let handlerCached: ((request: Request) => Promise<Response>) | undefined
@@ -505,8 +509,7 @@ 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,
@@ -515,7 +518,7 @@ const requestPayload = (
   | Scope
 > =>
   HttpMethod.hasBody(request.method)
-    ? isMultipart
+    ? request.headers["content-type"].includes("multipart/form-data")
       ? Effect.orDie(request.multipart)
       : Effect.orDie(request.json)
     : Effect.succeed(urlParams)
@@ -551,10 +554,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)
@@ -576,7 +575,7 @@ const handlerToRoute = (
         }
         if (decodePayload._tag === "Some") {
           request.payload = yield* Effect.flatMap(
-            requestPayload(httpRequest, urlParams, isMultipart),
+            requestPayload(httpRequest, urlParams),
             decodePayload.value
           )
         }
@@ -745,8 +744,26 @@ const toResponseError = toResponseSchema(HttpApiSchema.getStatusErrorAST)
  */
 export class Middleware extends Context.Tag("@effect/platform/HttpApiBuilder/Middleware")<
   Middleware,
-  HttpMiddleware.HttpMiddleware
->() {}
+  {
+    readonly add: (middleware: HttpMiddleware.HttpMiddleware) => Effect.Effect<void>
+    readonly retrieve: Effect.Effect<HttpMiddleware.HttpMiddleware>
+  }
+>() {
+  /**
+   * @since 1.0.0
+   */
+  static readonly layer = Layer.sync(Middleware, () => {
+    let middleware: HttpMiddleware.HttpMiddleware = identity
+    return Middleware.of({
+      add: (f) =>
+        Effect.sync(() => {
+          const prev = middleware
+          middleware = (app) => f(prev(app))
+        }),
+      retrieve: Effect.sync(() => middleware)
+    })
+  })
+}
 
 /**
  * @since 1.0.0
@@ -756,26 +773,24 @@ export type MiddlewareFn<Error, R = HttpRouter.HttpRouter.Provided> = (
   httpApp: HttpApp.Default
 ) => HttpApp.Default<Error, R>
 
-const middlewareAdd = (middleware: HttpMiddleware.HttpMiddleware): Effect.Effect<HttpMiddleware.HttpMiddleware> =>
-  Effect.map(
-    Effect.context<never>(),
-    (context) => {
-      const current = Context.getOption(context, Middleware)
-      const withContext: HttpMiddleware.HttpMiddleware = (httpApp) =>
-        Effect.mapInputContext(middleware(httpApp), (input) => Context.merge(context, input))
-      return current._tag === "None" ? withContext : (httpApp) => withContext(current.value(httpApp))
-    }
-  )
+const middlewareAdd = (
+  middleware: HttpMiddleware.HttpMiddleware
+): Effect.Effect<void, never, Middleware> =>
+  Effect.gen(function*() {
+    const context = yield* Effect.context<never>()
+    const service = yield* Middleware
+    yield* service.add((httpApp) =>
+      Effect.mapInputContext(middleware(httpApp), (input) => Context.merge(context, input))
+    )
+  })
 
 const middlewareAddNoContext = (
   middleware: HttpMiddleware.HttpMiddleware
-): Effect.Effect<HttpMiddleware.HttpMiddleware> =>
-  Effect.map(
-    Effect.serviceOption(Middleware),
-    (current): HttpMiddleware.HttpMiddleware => {
-      return current._tag === "None" ? middleware : (httpApp) => middleware(current.value(httpApp))
-    }
-  )
+): Effect.Effect<void, never, Middleware> =>
+  Effect.gen(function*() {
+    const service = yield* Middleware
+    yield* service.add(middleware)
+  })
 
 /**
  * Create an `HttpApi` level middleware `Layer`.
@@ -852,9 +867,9 @@ export const middleware: {
   const withContext = apiFirst ? args[2]?.withContext === true : (args as any)[1]?.withContext === true
   const add = withContext ? middlewareAdd : middlewareAddNoContext
   const middleware = apiFirst ? args[1] : args[0]
-  return Effect.isEffect(middleware)
-    ? Layer.effect(Middleware, Effect.flatMap(middleware as any, add))
-    : Layer.effect(Middleware, add(middleware as any))
+  return (Effect.isEffect(middleware)
+    ? Layer.effectDiscard(Effect.flatMap(middleware as any, add))
+    : Layer.effectDiscard(add(middleware as any))).pipe(Layer.provide(Middleware.layer))
 }
 
 /**
@@ -937,7 +952,9 @@ export const middlewareScoped: {
   const withContext = apiFirst ? args[2]?.withContext === true : (args as any)[1]?.withContext === true
   const add = withContext ? middlewareAdd : middlewareAddNoContext
   const middleware = apiFirst ? args[1] : args[0]
-  return Layer.scoped(Middleware, Effect.flatMap(middleware as any, add))
+  return Layer.scopedDiscard(Effect.flatMap(middleware as any, add)).pipe(
+    Layer.provide(Middleware.layer)
+  )
 }
 
 /**

package/src/HttpApiClient.ts

@@ -160,12 +160,7 @@ 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 encodeHeaders = endpoint.headersSchema.pipe(
@@ -185,7 +180,7 @@ 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.payload instanceof FormData) {
               httpRequest = HttpClientRequest.bodyFormData(httpRequest, request.payload)
             } else if (encodePayload._tag === "Some") {
               const payload = yield* encodePayload.value(request.payload)

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

@@ -269,14 +269,30 @@ export const fromApi = <A extends HttpApi.HttpApi.Any>(self: A): OpenAPISpec =>
       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
+          const content: Mutable<OpenApiSpecContent> = {}
+          const members = schema.ast._tag === "Union" ? schema.ast.types : [schema.ast]
+          const jsonTypes: Array<AST.AST> = []
+          const multipartTypes: Array<AST.AST> = []
+
+          for (const member of members) {
+            if (HttpApiSchema.getMultipart(member)) {
+              multipartTypes.push(member)
+            } else {
+              jsonTypes.push(member)
+            }
+          }
+
+          if (jsonTypes.length > 0) {
+            content["application/json"] = {
+              schema: makeJsonSchemaOrRef(Schema.make(AST.Union.make(jsonTypes)))
+            }
+          }
+          if (multipartTypes.length > 0) {
+            content["multipart/form-data"] = {
+              schema: makeJsonSchemaOrRef(Schema.make(AST.Union.make(multipartTypes)))
+            }
           }
+          op.requestBody = { content, required: true }
         })
       )
       for (const [status, ast] of successes) {

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/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>(