effect 4.0.0-beta.94 → 4.0.0-beta.98

package/src/unstable/httpapi/HttpApiClient.ts

@@ -15,6 +15,7 @@ import * as Cause from "../../Cause.ts"
 import type * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import { identity } from "../../Function.ts"
+import * as internalRecord from "../../internal/record.ts"
 import * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
@@ -37,6 +38,7 @@ import * as HttpApiEndpoint from "./HttpApiEndpoint.ts"
 import type * as HttpApiGroup from "./HttpApiGroup.ts"
 import type * as HttpApiMiddleware from "./HttpApiMiddleware.ts"
 import * as HttpApiSchema from "./HttpApiSchema.ts"
+import * as MediaType from "./internal/mediaType.ts"
 
 /**
  * The type-safe client shape generated from HTTP API groups, with non-top-level
@@ -45,18 +47,15 @@ import * as HttpApiSchema from "./HttpApiSchema.ts"
  * @category models
  * @since 4.0.0
  */
-export type Client<Groups extends HttpApiGroup.Any, E = never, R = never> = Simplify<
+export type Client<Groups extends HttpApiGroup.Constraint, E = never, R = never> = Simplify<
   & {
-    readonly [Group in Extract<Groups, { readonly topLevel: false }> as HttpApiGroup.Name<Group>]: Client.Group<
+    readonly [Group in Extract<Groups, { readonly topLevel: false }> as HttpApiGroup.Identifier<Group>]: Client.Group<
       Group,
-      Group["identifier"],
       E,
       R
     >
   }
-  & {
-    readonly [Method in Client.TopLevelMethods<Groups, E, R> as Method[0]]: Method[1]
-  }
+  & Client.TopLevelMethods<Groups, E, R>
 >
 
 /**
@@ -66,7 +65,7 @@ export type Client<Groups extends HttpApiGroup.Any, E = never, R = never> = Simp
  * @category models
  * @since 4.0.0
  */
-export type ForApi<Api extends HttpApi.Any, E = never, R = never> = Api extends
+export type ForApi<Api extends HttpApi.Constraint, E = never, R = never> = Api extends
   HttpApi.HttpApi<infer _Id, infer Groups> ? Client<Groups, E, R> :
   never
 
@@ -122,19 +121,43 @@ export declare namespace Client {
     : [Mode] extends ["response-only"] ? HttpClientResponse.HttpClientResponse
     : Success
 
+  type GroupByEndpoint<Group extends HttpApiGroup.Constraint, E, R> = Group["endpoints"] extends
+    infer Endpoints extends Readonly<Record<string, HttpApiEndpoint.ConstraintRequest>> ? {
+      readonly [Identifier in keyof Endpoints]: Method<Endpoints[Identifier], E, R>
+    }
+    : {}
+
   /**
-   * The client object for one API group, mapping each endpoint name in that group to
-   * its typed client method.
+   * The client object for one API group, mapping each endpoint identifier in that
+   * group to its typed client method.
    *
    * @category models
    * @since 4.0.0
    */
-  export type Group<Groups extends HttpApiGroup.Any, GroupName extends Groups["identifier"], E, R> =
-    [HttpApiGroup.WithName<Groups, GroupName>] extends [HttpApiGroup.HttpApiGroup<infer _GroupName, infer _Endpoints>] ?
-      {
-        readonly [Endpoint in _Endpoints as HttpApiEndpoint.Name<Endpoint>]: Method<Endpoint, E, R>
-      } :
-      never
+  export type Group<Group extends HttpApiGroup.Constraint, E, R> = GroupByEndpoint<Group, E, R>
+
+  type MethodReturn<
+    Endpoint extends HttpApiEndpoint.ConstraintRequest,
+    E,
+    R,
+    Mode extends ResponseMode
+  > = Effect.Effect<
+    Response<SuccessType<Endpoint["~Success"]>, Mode>,
+    | HttpApiMiddleware.Error<Endpoint["~Middleware"]>
+    | HttpApiMiddleware.ClientError<Endpoint["~Middleware"]>
+    | E
+    | HttpClientError.HttpClientError
+    | ([Mode] extends ["response-only"] ? never : Endpoint["~Error"]["Type"] | Schema.SchemaError),
+    | R
+    | Endpoint["~Params"]["EncodingServices"]
+    | Endpoint["~Query"]["EncodingServices"]
+    | Endpoint["~Payload"]["EncodingServices"]
+    | Endpoint["~Headers"]["EncodingServices"]
+    | ([Mode] extends ["response-only"] ? never
+      :
+        | SuccessDecodingServices<Endpoint["~Success"]>
+        | Endpoint["~Error"]["DecodingServices"])
+  >
 
   /**
    * The typed function generated for an endpoint, accepting the endpoint request
@@ -144,40 +167,21 @@ export declare namespace Client {
    * @category models
    * @since 4.0.0
    */
-  export type Method<Endpoint, E, R> = [Endpoint] extends [
-    HttpApiEndpoint.HttpApiEndpoint<
-      infer _Name,
-      infer _Method,
-      infer _Path,
-      infer _Params,
-      infer _Query,
-      infer _Payload,
-      infer _Headers,
-      infer _Success,
-      infer _Error,
-      infer _Middleware,
-      infer _MR
+  export type Method<
+    Endpoint extends HttpApiEndpoint.ConstraintRequest,
+    E,
+    R
+  > = <Mode extends ResponseMode = ResponseMode>(
+    request: Simplify<
+      HttpApiEndpoint.ClientRequest<
+        Endpoint["~Params"],
+        Endpoint["~Query"],
+        Endpoint["~Payload"],
+        Endpoint["~Headers"],
+        Mode
+      >
     >
-  ] ? <Mode extends ResponseMode = ResponseMode>(
-      request: Simplify<HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, Mode>>
-    ) => Effect.Effect<
-      Response<SuccessType<_Success>, Mode>,
-      | HttpApiMiddleware.Error<_Middleware>
-      | HttpApiMiddleware.ClientError<_Middleware>
-      | E
-      | HttpClientError.HttpClientError
-      | ([Mode] extends ["response-only"] ? never : _Error["Type"] | Schema.SchemaError),
-      | R
-      | _Params["EncodingServices"]
-      | _Query["EncodingServices"]
-      | _Payload["EncodingServices"]
-      | _Headers["EncodingServices"]
-      | ([Mode] extends ["response-only"] ? never
-        :
-          | SuccessDecodingServices<_Success>
-          | _Error["DecodingServices"])
-    > :
-    never
+  ) => MethodReturn<Endpoint, E, R, Mode>
 
   /**
    * Extracts client methods for endpoints in top-level groups so they can be exposed
@@ -186,25 +190,31 @@ export declare namespace Client {
    * @category models
    * @since 4.0.0
    */
-  export type TopLevelMethods<Groups extends HttpApiGroup.Any, E, R> =
-    Extract<Groups, { readonly topLevel: true }> extends
-      HttpApiGroup.HttpApiGroup<infer _Id, infer _Endpoints, infer _TopLevel> ?
-      _Endpoints extends infer Endpoint ? [HttpApiEndpoint.Name<Endpoint>, Method<Endpoint, E, R>]
-      : never :
-      never
+  export type TopLevelMethods<Groups extends HttpApiGroup.Constraint, E, R> = {
+    readonly [
+      Endpoint in Extract<
+        HttpApiGroup.Endpoints<Extract<Groups, { readonly topLevel: true }>>,
+        HttpApiEndpoint.ConstraintRequest
+      > as Endpoint["identifier"]
+    ]: Method<Endpoint, E, R>
+  }
 }
 
-type UrlBuilderRequest<Endpoint extends HttpApiEndpoint.Any> = (
-  & ([HttpApiEndpoint.Params<Endpoint>["Type"]] extends [never] ? {}
-    : { readonly params: HttpApiEndpoint.Params<Endpoint>["Type"] })
-  & ([HttpApiEndpoint.Query<Endpoint>["Type"]] extends [never] ? {}
-    : { readonly query: HttpApiEndpoint.Query<Endpoint>["Type"] })
+type UrlBuilderRequestPart<Key extends string, Value> = [Value] extends [never] ? {}
+  : { readonly [K in Key]: Value }
+
+type UrlBuilderRequest<
+  Endpoint extends HttpApiEndpoint.Constraint,
+  Params = HttpApiEndpoint.Params<Endpoint>["Type"],
+  Query = HttpApiEndpoint.Query<Endpoint>["Type"]
+> = (
+  & UrlBuilderRequestPart<"params", Params>
+  & UrlBuilderRequestPart<"query", Query>
 ) extends infer Request ? keyof Request extends never ? void | undefined : Request
   : never
 
-type UrlBuilderArgs<Endpoint extends HttpApiEndpoint.Any> = [UrlBuilderRequest<Endpoint>] extends [void | undefined] ?
-  [request?: UrlBuilderRequest<Endpoint>]
-  : [request: UrlBuilderRequest<Endpoint>]
+type UrlBuilderArgs<Request> = [Request] extends [void | undefined] ? [request?: Request]
+  : [request: Request]
 
 /**
  * The type-safe URL builder shape for an HTTP API, mirroring the generated client
@@ -213,49 +223,50 @@ type UrlBuilderArgs<Endpoint extends HttpApiEndpoint.Any> = [UrlBuilderRequest<E
  * @category models
  * @since 4.0.0
  */
-export type UrlBuilder<Api extends HttpApi.Any> = Api extends HttpApi.HttpApi<infer _ApiId, infer Groups> ? Simplify<
-    & {
-      readonly [Group in Extract<Groups, { readonly topLevel: false }> as HttpApiGroup.Name<Group>]: UrlBuilderGroup<
-        HttpApiGroup.Endpoints<Group>
-      >
-    }
-    & {
-      readonly [Method in UrlBuilderTopLevelMethods<Groups> as Method[0]]: Method[1]
-    }
-  >
+export type UrlBuilder<Api extends HttpApi.Constraint> = Api extends HttpApi.HttpApi<infer _ApiId, infer Groups> ?
+  [Extract<Groups, { readonly topLevel: true }>] extends [never] ? UrlBuilderGroups<Groups>
+  : [Extract<Groups, { readonly topLevel: false }>] extends [never] ? UrlBuilderTopLevelMethods<Groups>
+  : Simplify<UrlBuilderGroups<Groups> & UrlBuilderTopLevelMethods<Groups>>
   : never
 
-type UrlBuilderGroup<Endpoints extends HttpApiEndpoint.Any> = {
-  readonly [Endpoint in Endpoints as HttpApiEndpoint.Name<Endpoint>]: UrlBuilderMethod<Endpoint>
+type UrlBuilderGroups<Groups extends HttpApiGroup.Constraint> = {
+  readonly [Group in Extract<Groups, { readonly topLevel: false }> as HttpApiGroup.Identifier<Group>]: UrlBuilderGroup<
+    HttpApiGroup.Endpoints<Group>
+  >
 }
 
-type UrlBuilderMethod<Endpoint extends HttpApiEndpoint.Any> = (
-  ...args: UrlBuilderArgs<Endpoint>
+type UrlBuilderGroup<Endpoints extends HttpApiEndpoint.Constraint> = {
+  readonly [Endpoint in Endpoints as HttpApiEndpoint.Identifier<Endpoint>]: UrlBuilderMethod<Endpoint>
+}
+
+type UrlBuilderMethod<Endpoint extends HttpApiEndpoint.Constraint> = (
+  ...args: UrlBuilderArgs<UrlBuilderRequest<Endpoint>>
 ) => string
 
-type UrlBuilderTopLevelMethods<Groups extends HttpApiGroup.Any> = Extract<Groups, { readonly topLevel: true }> extends
-  HttpApiGroup.HttpApiGroup<infer _Id, infer _Endpoints, infer _TopLevel> ?
-  _Endpoints extends infer Endpoint extends HttpApiEndpoint.Any ?
-    [HttpApiEndpoint.Name<Endpoint>, UrlBuilderMethod<Endpoint>]
-  : never :
-  never
+type UrlBuilderTopLevelMethods<Groups extends HttpApiGroup.Constraint> = {
+  readonly [
+    Endpoint in HttpApiGroup.Endpoints<Extract<Groups, { readonly topLevel: true }>> as HttpApiEndpoint.Identifier<
+      Endpoint
+    >
+  ]: UrlBuilderMethod<Endpoint>
+}
 
 /** @internal */
-export const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>(
+export const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Constraint, E, R>(
   api: HttpApi.HttpApi<ApiId, Groups>,
   options: {
     readonly httpClient: HttpClient.HttpClient.With<E, R>
     readonly predicate?: Predicate.Predicate<{
-      readonly endpoint: HttpApiEndpoint.AnyWithProps
-      readonly group: HttpApiGroup.AnyWithProps
+      readonly endpoint: HttpApiEndpoint.Top
+      readonly group: HttpApiGroup.Top
     }>
     readonly onGroup?: (options: {
-      readonly group: HttpApiGroup.AnyWithProps
+      readonly group: HttpApiGroup.Top
       readonly mergedAnnotations: Context.Context<never>
     }) => void
     readonly onEndpoint: (options: {
-      readonly group: HttpApiGroup.AnyWithProps
-      readonly endpoint: HttpApiEndpoint.AnyWithProps
+      readonly group: HttpApiGroup.Top
+      readonly endpoint: HttpApiEndpoint.Top
       readonly mergedAnnotations: Context.Context<never>
       readonly middleware: ReadonlySet<HttpApiMiddleware.AnyService>
       readonly successes: ReadonlyMap<number, readonly [Schema.Top, ...Array<Schema.Top>]>
@@ -280,8 +291,8 @@ export const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any
     )
 
     function executeMiddleware(
-      group: HttpApiGroup.AnyWithProps,
-      endpoint: HttpApiEndpoint.AnyWithProps,
+      group: HttpApiGroup.Top,
+      endpoint: HttpApiEndpoint.Top,
       request: HttpClientRequest.HttpClientRequest,
       middlewareKeys: ReadonlyArray<string>,
       index: number
@@ -321,9 +332,15 @@ export const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any
           (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<unknown, unknown, unknown>
         > = { orElse: statusOrElse }
         const decodeResponse = HttpClientResponse.matchStatus(decodeMap)
-        errors.forEach((schemas, status) => {
-          // decoders
-          const decode = schemasToResponse(schemas)
+        const errorAlternatives = new Map<number, Array<ResponseAlternative>>()
+        for (const [status, schemas] of errors.entries()) {
+          const grouped = groupSchemasByContentType(schemas)
+          for (const [contentType, schemas] of grouped.entries()) {
+            addResponseAlternative(errorAlternatives, status, contentType, schemasToResponse(schemas))
+          }
+        }
+        for (const [status, alternatives] of errorAlternatives.entries()) {
+          const decode = makeResponseDecoder(alternatives)
           decodeMap[status] = (response) =>
             Effect.flatMap(
               Effect.catchCause(decode(response), (cause) =>
@@ -340,7 +357,7 @@ export const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any
                 ))),
               Effect.fail
             )
-        })
+        }
 
         const successAlternatives = new Map<number, Array<ResponseAlternative>>()
         for (const [status, schemas] of successes.entries()) {
@@ -456,7 +473,7 @@ export const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any
  * @category constructors
  * @since 4.0.0
  */
-export const make = <ApiId extends string, Groups extends HttpApiGroup.Any>(
+export const make = <ApiId extends string, Groups extends HttpApiGroup.Constraint>(
   api: HttpApi.HttpApi<ApiId, Groups>,
   options?: {
     readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined
@@ -484,7 +501,7 @@ export const make = <ApiId extends string, Groups extends HttpApiGroup.Any>(
  * @category constructors
  * @since 4.0.0
  */
-export const makeWith = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>(
+export const makeWith = <ApiId extends string, Groups extends HttpApiGroup.Constraint, E, R>(
   api: HttpApi.HttpApi<ApiId, Groups>,
   options: {
     readonly httpClient: HttpClient.HttpClient.With<E, R>
@@ -493,16 +510,24 @@ export const makeWith = <ApiId extends string, Groups extends HttpApiGroup.Any,
       | undefined
     readonly baseUrl?: URL | string | undefined
   }
-): Effect.Effect<Client<Groups, E, R>, never, HttpApiGroup.MiddlewareClient<Groups>> => {
+): Effect.Effect<
+  Client<Groups, Exclude<E, HttpClientError.HttpClientError>, R>,
+  never,
+  HttpApiGroup.MiddlewareClient<Groups>
+> => {
   const client: Record<string, Record<string, any>> = {}
   return makeClient(api, {
     ...options,
     onGroup({ group }) {
       if (group.topLevel) return
-      client[group.identifier] = {}
+      internalRecord.set(client, group.identifier, {})
     },
     onEndpoint({ endpoint, endpointFn, group }) {
-      ;(group.topLevel ? client : client[group.identifier])[endpoint.name] = endpointFn
+      internalRecord.set(
+        group.topLevel ? client : client[group.identifier],
+        endpoint.identifier,
+        endpointFn
+      )
     }
   }).pipe(Effect.as(client)) as any
 }
@@ -516,14 +541,14 @@ export const makeWith = <ApiId extends string, Groups extends HttpApiGroup.Any,
  */
 export const group = <
   ApiId extends string,
-  Groups extends HttpApiGroup.Any,
-  const GroupName extends HttpApiGroup.Name<Groups>,
+  Groups extends HttpApiGroup.Constraint,
+  const GroupIdentifier extends HttpApiGroup.Identifier<Groups>,
   E,
   R
 >(
   api: HttpApi.HttpApi<ApiId, Groups>,
   options: {
-    readonly group: GroupName
+    readonly group: GroupIdentifier
     readonly httpClient: HttpClient.HttpClient.With<E, R>
     readonly transformResponse?:
       | ((effect: Effect.Effect<unknown, unknown, unknown>) => Effect.Effect<unknown, unknown, unknown>)
@@ -531,20 +556,32 @@ export const group = <
     readonly baseUrl?: URL | string | undefined
   }
 ): Effect.Effect<
-  Client.Group<Groups, GroupName, E, R>,
+  Client.Group<HttpApiGroup.WithIdentifier<Groups, GroupIdentifier>, E, R>,
   never,
-  HttpApiGroup.MiddlewareClient<HttpApiGroup.WithName<Groups, GroupName>>
+  HttpApiGroup.MiddlewareClient<HttpApiGroup.WithIdentifier<Groups, GroupIdentifier>>
 > => {
   const client: Record<string, any> = {}
   return makeClient(api, {
     ...options,
     predicate: ({ group }) => group.identifier === options.group,
     onEndpoint({ endpoint, endpointFn }) {
-      client[endpoint.name] = endpointFn
+      internalRecord.set(client, endpoint.identifier, endpointFn)
     }
   }).pipe(Effect.map(() => client)) as any
 }
 
+type EndpointReturn<
+  Groups extends HttpApiGroup.Constraint,
+  GroupIdentifier extends HttpApiGroup.Identifier<Groups>,
+  EndpointIdentifier extends HttpApiGroup.EndpointsWithIdentifier<Groups, GroupIdentifier>["identifier"],
+  E,
+  R,
+  Endpoint extends HttpApiEndpoint.ConstraintRequest = Extract<
+    HttpApiEndpoint.WithIdentifier<HttpApiGroup.EndpointsWithIdentifier<Groups, GroupIdentifier>, EndpointIdentifier>,
+    HttpApiEndpoint.ConstraintRequest
+  >
+> = Effect.Effect<Client.Method<Endpoint, E, R>, never, HttpApiEndpoint.MiddlewareClient<Endpoint>>
+
 /**
  * Builds the typed client method for one endpoint in one API group, using the
  * supplied `HttpClient` and endpoint metadata.
@@ -554,38 +591,33 @@ export const group = <
  */
 export const endpoint = <
   ApiId extends string,
-  Groups extends HttpApiGroup.Any,
-  const GroupName extends HttpApiGroup.Name<Groups>,
-  const EndpointName extends HttpApiEndpoint.Name<HttpApiGroup.EndpointsWithName<Groups, GroupName>>,
+  Groups extends HttpApiGroup.Constraint,
+  const GroupIdentifier extends HttpApiGroup.Identifier<Groups>,
+  const EndpointIdentifier extends HttpApiGroup.EndpointsWithIdentifier<Groups, GroupIdentifier>["identifier"],
   E,
   R
 >(
   api: HttpApi.HttpApi<ApiId, Groups>,
   options: {
-    readonly group: GroupName
-    readonly endpoint: EndpointName
+    readonly group: GroupIdentifier
+    readonly endpoint: EndpointIdentifier
     readonly httpClient: HttpClient.HttpClient.With<E, R>
-    readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined
+    readonly transformClient?:
+      | ((client: HttpClient.HttpClient.With<E, R>) => HttpClient.HttpClient.With<E, R>)
+      | undefined
     readonly transformResponse?:
       | ((effect: Effect.Effect<unknown, unknown, unknown>) => Effect.Effect<unknown, unknown, unknown>)
       | undefined
     readonly baseUrl?: URL | string | undefined
   }
-): Effect.Effect<
-  Client.Method<
-    HttpApiEndpoint.WithName<HttpApiGroup.Endpoints<HttpApiGroup.WithName<Groups, GroupName>>, EndpointName>,
-    E,
-    R
-  >,
-  never,
-  HttpApiEndpoint.MiddlewareClient<
-    HttpApiEndpoint.WithName<HttpApiGroup.Endpoints<HttpApiGroup.WithName<Groups, GroupName>>, EndpointName>
-  >
-> => {
+): EndpointReturn<Groups, GroupIdentifier, EndpointIdentifier, E, R> => {
   let client: any = undefined
   return makeClient(api, {
     ...options,
-    predicate: ({ endpoint, group }) => group.identifier === options.group && endpoint.name === options.endpoint,
+    httpClient: options.transformClient
+      ? options.transformClient(options.httpClient)
+      : options.httpClient,
+    predicate: ({ endpoint, group }) => group.identifier === options.group && endpoint.identifier === options.endpoint,
     onEndpoint({ endpointFn }) {
       client = endpointFn
     }
@@ -622,15 +654,15 @@ export const endpoint = <
  * @category constructors
  * @since 4.0.0
  */
-export const urlBuilder = <Api extends HttpApi.Any>(api: Api, options?: {
+export const urlBuilder = <Api extends HttpApi.Constraint>(api: Api, options?: {
   readonly baseUrl?: URL | string | undefined
 }): UrlBuilder<Api> => {
   const builder: Record<string, any> = {}
 
-  HttpApi.reflect(api as unknown as HttpApi.AnyWithProps, {
+  HttpApi.reflect(api as unknown as HttpApi.Top, {
     onGroup({ group }) {
       if (group.topLevel) return
-      builder[group.identifier] = {}
+      internalRecord.set(builder, group.identifier, {})
     },
     onEndpoint({ group, endpoint }) {
       const makeUrl = compilePath(endpoint.path)
@@ -656,7 +688,11 @@ export const urlBuilder = <Api extends HttpApi.Any>(api: Api, options?: {
         const url = query === "" ? path : `${path}?${query}`
         return options?.baseUrl === undefined ? url : new URL(url, options.baseUrl.toString()).toString()
       }
-      ;(group.topLevel ? builder : builder[group.identifier])[endpoint.name] = endpointBuilder
+      internalRecord.set(
+        group.topLevel ? builder : builder[group.identifier],
+        endpoint.identifier,
+        endpointBuilder
+      )
     }
   })
 
@@ -706,7 +742,7 @@ function addResponseAlternative(
   contentType: string,
   decode: ResponseDecoder
 ) {
-  const normalizedContentType = normalizeContentType(contentType)
+  const normalizedContentType = MediaType.normalize(contentType)
   const alternatives = map.get(status)
   if (alternatives === undefined) {
     map.set(status, [{ contentType: normalizedContentType, decode }])
@@ -721,7 +757,7 @@ function makeResponseDecoder(alternatives: ReadonlyArray<ResponseAlternative>):
     return first.decode
   }
   return (response) => {
-    const contentType = normalizeContentType(response.headers["content-type"] ?? "")
+    const contentType = MediaType.normalize(response.headers["content-type"] ?? "")
     const alternative = alternatives.find((alternative) => alternative.contentType === contentType)
     return alternative === undefined
       ? failUnsupportedContentType(response, contentType, alternatives)
@@ -734,7 +770,9 @@ function groupSchemasByContentType(
 ): Map<string, Arr.NonEmptyReadonlyArray<Schema.Top>> {
   const grouped = new Map<string, [Schema.Top, ...Array<Schema.Top>]>()
   for (const schema of schemas) {
-    const contentType = HttpApiSchema.getResponseEncoding(schema.ast).contentType
+    const contentType = HttpApiSchema.isNoContent(schema.ast)
+      ? ""
+      : MediaType.normalize(HttpApiSchema.getResponseEncoding(schema.ast).contentType)
     const existing = grouped.get(contentType)
     if (existing === undefined) {
       grouped.set(contentType, [schema])
@@ -745,12 +783,6 @@ function groupSchemasByContentType(
   return grouped
 }
 
-function normalizeContentType(contentType: string): string {
-  const normalized = contentType.toLowerCase().trim()
-  const index = normalized.indexOf(";")
-  return index === -1 ? normalized : normalized.slice(0, index).trim()
-}
-
 function failUnsupportedContentType(
   response: HttpClientResponse.HttpClientResponse,
   contentType: string,
@@ -772,7 +804,7 @@ function failUnsupportedContentType(
 
 const reservedStreamFailureEvent = "effect/httpapi/stream/failure"
 
-function getStreamSuccessSchemas(endpoint: HttpApiEndpoint.AnyWithProps): Array<HttpApiSchema.StreamSchema> {
+function getStreamSuccessSchemas(endpoint: HttpApiEndpoint.Top): Array<HttpApiSchema.StreamSchema> {
   const schemas: Array<HttpApiSchema.StreamSchema> = []
   for (const schema of endpoint.success) {
     if (HttpApiSchema.isStreamSchema(schema)) {
@@ -783,47 +815,60 @@ function getStreamSuccessSchemas(endpoint: HttpApiEndpoint.AnyWithProps): Array<
 }
 
 function streamToResponse(streamSchema: HttpApiSchema.StreamSchema) {
+  const sse = HttpApiSchema.isStreamUint8Array(streamSchema)
+    ? undefined
+    : {
+      declaration: streamSchema,
+      decoder: makeSseDecoder(streamSchema)
+    }
   return (response: HttpClientResponse.HttpClientResponse) =>
     Effect.map(Effect.context<never>(), (context) =>
       Stream.provideContext(
-        HttpApiSchema.isStreamUint8Array(streamSchema) ?
+        sse === undefined ?
           response.stream :
-          decodeSseStream(response.stream, streamSchema),
+          decodeSseStream(response.stream, sse.declaration, sse.decoder),
         context as Context.Context<unknown>
       ))
 }
 
-function decodeSseStream(
-  stream: Stream.Stream<Uint8Array, HttpClientError.HttpClientError>,
+function makeSseDecoder(
   declaration: HttpApiSchema.StreamSse<Sse.EventCodec, Schema.Constraint, unknown>
-): Stream.Stream<unknown, unknown, unknown> {
+) {
   const Event = Schema.Union([
-    declaration.events,
     Schema.Struct({
       event: Schema.Literal(reservedStreamFailureEvent),
       data: Schema.fromJsonString(Schema.toCodecJson(Schema.Cause(declaration.error, Schema.Defect())))
-    })
+    }),
+    declaration.events
   ])
+  return Sse.decodeSchema(Event)
+}
+
+function decodeSseStream(
+  stream: Stream.Stream<Uint8Array, HttpClientError.HttpClientError>,
+  declaration: HttpApiSchema.StreamSse<Sse.EventCodec, Schema.Constraint, unknown>,
+  decoder: ReturnType<typeof makeSseDecoder>
+): Stream.Stream<unknown, unknown, unknown> {
   const events = Stream.transformPull(
     stream.pipe(
       Stream.decodeText,
-      Stream.pipeThroughChannel(Sse.decodeSchema(Event))
+      Stream.pipeThroughChannel(decoder)
     ),
     (pull) =>
       Effect.sync(() => {
-        let failureCause: Cause.Cause<unknown> | undefined = undefined
+        let pendingFailureCause: Cause.Cause<unknown> | undefined = undefined
         return Effect.suspend(() => {
-          if (failureCause) {
-            return Effect.failCause(failureCause)
+          if (pendingFailureCause !== undefined) {
+            return Effect.failCause(pendingFailureCause)
           }
           return Effect.flatMap(pull, (events) => {
             for (let i = 0; i < events.length; i++) {
               const event = events[i]
-              if (event.event === reservedStreamFailureEvent) {
+              if (event.event === reservedStreamFailureEvent && Cause.isCause(event.data)) {
                 if (i === 0) {
                   return Effect.failCause(event.data)
                 }
-                failureCause = event.data
+                pendingFailureCause = event.data
                 events = events.slice(0, i) as any
                 break
               }
@@ -986,7 +1031,7 @@ function getEncodePayloadSchemaFromBody(
             if (!Predicate.isObject(t)) {
               return Effect.fail(new SchemaIssue.InvalidValue(Option.some(t), { message: "Expected a record" }))
             }
-            return Effect.succeed(HttpBody.urlParams(UrlParams.fromInput(t as any)))
+            return Effect.succeed(HttpBody.urlParams(UrlParams.fromInput(t as any), encoding.contentType))
           }
           case "Uint8Array": {
             if (!(t instanceof Uint8Array)) {