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

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -30,7 +30,7 @@ import * as SchemaIssue from "../../SchemaIssue.ts"
 import * as SchemaTransformation from "../../SchemaTransformation.ts"
 import * as Scope from "../../Scope.ts"
 import * as Stream from "../../Stream.ts"
-import type { Covariant, NoInfer } from "../../Types.ts"
+import type { NoInfer } from "../../Types.ts"
 import * as UndefinedOr from "../../UndefinedOr.ts"
 import * as Sse from "../encoding/Sse.ts"
 import type { Cookie } from "../http/Cookies.ts"
@@ -52,6 +52,7 @@ import type * as HttpApiGroup from "./HttpApiGroup.ts"
 import * as HttpApiMiddleware from "./HttpApiMiddleware.ts"
 import * as HttpApiSchema from "./HttpApiSchema.ts"
 import type * as HttpApiSecurity from "./HttpApiSecurity.ts"
+import * as MediaType from "./internal/mediaType.ts"
 import * as OpenApi from "./OpenApi.ts"
 
 /**
@@ -60,7 +61,7 @@ import * as OpenApi from "./OpenApi.ts"
  * @category constructors
  * @since 4.0.0
  */
-export const layer = <Id extends string, Groups extends HttpApiGroup.Any>(
+export const layer = <Id extends string, Groups extends HttpApiGroup.Constraint>(
   api: HttpApi.HttpApi<Id, Groups>,
   options?: {
     readonly openapiPath?: `/${string}` | undefined
@@ -87,7 +88,8 @@ export const layer = <Id extends string, Groups extends HttpApiGroup.Any>(
     const availableGroups = Array.from(services.mapUnsafe.keys()).filter((key) =>
       key.startsWith("effect/httpapi/HttpApiGroup/")
     )
-    for (const group of Object.values(api.groups)) {
+    const groups = Object.values(api.groups) as ReadonlyArray<HttpApiGroup.Top>
+    for (const group of groups) {
       const groupRoutes = services.mapUnsafe.get(group.key)?.routes as Array<HttpRouter.Route<any, any>>
       if (groupRoutes === undefined) {
         const available = availableGroups.length === 0 ? "none" : availableGroups.join(", ")
@@ -118,17 +120,17 @@ export const layer = <Id extends string, Groups extends HttpApiGroup.Any>(
  */
 export const group = <
   ApiId extends string,
-  Groups extends HttpApiGroup.Any,
-  const Name extends HttpApiGroup.Name<Groups>,
+  Groups extends HttpApiGroup.Constraint,
+  const Identifier extends HttpApiGroup.Identifier<Groups>,
   Return
 >(
   api: HttpApi.HttpApi<ApiId, Groups>,
-  groupName: Name,
+  groupIdentifier: Identifier,
   build: (
-    handlers: Handlers.FromGroup<HttpApiGroup.WithName<Groups, Name>>
+    handlers: Handlers.FromGroup<HttpApiGroup.WithIdentifier<Groups, Identifier>>
   ) => Handlers.ValidateReturn<Return>
 ): Layer.Layer<
-  HttpApiGroup.ApiGroup<ApiId, Name>,
+  HttpApiGroup.Service<ApiId, Identifier>,
   Handlers.Error<Return>,
   Exclude<Handlers.Context<Return>, Scope.Scope>
 > =>
@@ -136,9 +138,9 @@ export const group = <
     const services = (yield* Effect.context<any>()).pipe(
       Context.omit(Scope.Scope)
     )
-    const group = api.groups[groupName]!
+    const group = api.groups[groupIdentifier] as HttpApiGroup.Constraint
     const result = build(makeHandlers(group))
-    const handlers: Handlers<any, any> = Effect.isEffect(result)
+    const handlers: Handlers<any, any, any> = Effect.isEffect(result)
       ? (yield* result as Effect.Effect<any, any, any>)
       : result
     const routes: Array<HttpRouter.Route<any, any>> = []
@@ -153,21 +155,96 @@ export const group = <
     )
   })) as any
 
-/**
- * Type identifier symbol used to brand `Handlers` values.
- *
- * @category type IDs
- * @since 4.0.0
- */
-export const HandlersTypeId: unique symbol = Symbol.for("@effect/platform/HttpApiBuilder/Handlers")
+const HandlersTypeId = "~effect/httpapi/HttpApiBuilder/Handlers"
 
-/**
- * Type of the `Handlers` type identifier symbol.
- *
- * @category type IDs
- * @since 4.0.0
- */
-export type HandlersTypeId = typeof HandlersTypeId
+type EndpointMap<Endpoints extends HttpApiEndpoint.Constraint> = {
+  readonly [Endpoint in Endpoints as HttpApiEndpoint.Identifier<Endpoint>]: Endpoint
+}
+
+type HandlerRequirements<
+  Endpoint extends HttpApiEndpoint.Constraint,
+  R1,
+  R = HttpApiEndpoint.ExcludeProvided<
+    Endpoint,
+    R1 | HttpApiEndpoint.ServerServices<Endpoint>
+  >
+> =
+  | HttpApiEndpoint.Middleware<Endpoint>
+  | HttpApiEndpoint.MiddlewareServices<Endpoint>
+  | ([R] extends [never] ? never : HttpRouter.Request<"Requires", R>)
+
+interface HandlerOptions {
+  readonly uninterruptible?: boolean | undefined
+}
+
+/** @internal */
+export interface HandlerRuntime {
+  readonly endpoint: HttpApiEndpoint.Top
+  readonly handler: HttpApiEndpoint.Handler<HttpApiEndpoint.Constraint, unknown, unknown>
+  readonly isRaw: boolean
+  readonly uninterruptible: boolean
+}
+
+type HandleAllEntry<Endpoint extends HttpApiEndpoint.Constraint> =
+  | HttpApiEndpoint.Handler<
+    Endpoint,
+    HttpApiEndpoint.MiddlewareError<Endpoint>,
+    unknown
+  >
+  | {
+    readonly handler: HttpApiEndpoint.Handler<
+      Endpoint,
+      HttpApiEndpoint.MiddlewareError<Endpoint>,
+      unknown
+    >
+    readonly options?: HandlerOptions | undefined
+  }
+
+type HandleAllHandlers<EndpointsByIdentifier extends Record<string, HttpApiEndpoint.Constraint>> = {
+  readonly [Identifier in keyof EndpointsByIdentifier]?: HandleAllEntry<EndpointsByIdentifier[Identifier]>
+}
+
+type HandleAllExtraKeys<
+  EndpointsByIdentifier extends Record<string, HttpApiEndpoint.Constraint>,
+  HandlersByIdentifier
+> = {
+  readonly [Identifier in Exclude<keyof HandlersByIdentifier, keyof EndpointsByIdentifier>]: never
+}
+
+type NotHandledIdentifier<Identifier extends PropertyKey, HandledIdentifiers extends PropertyKey> = Identifier extends
+  HandledIdentifiers ? never :
+  unknown
+
+type HandleAllEntryHandler<Entry> = Entry extends { readonly handler: infer Handler } ? Handler : Entry
+
+type HandleAllRequirements<
+  EndpointsByIdentifier extends Record<string, HttpApiEndpoint.Constraint>,
+  HandlersByIdentifier extends HandleAllHandlers<EndpointsByIdentifier>
+> = {
+  readonly [Identifier in keyof HandlersByIdentifier & keyof EndpointsByIdentifier]: HandleAllEntryHandler<
+    HandlersByIdentifier[Identifier]
+  > extends HttpApiEndpoint.Handler<
+    EndpointsByIdentifier[Identifier],
+    HttpApiEndpoint.MiddlewareError<EndpointsByIdentifier[Identifier]>,
+    infer R1
+  > ? HandlerRequirements<EndpointsByIdentifier[Identifier], R1> :
+    never
+}[keyof HandlersByIdentifier & keyof EndpointsByIdentifier]
+
+type HandlersResult<A> = A extends Effect.Effect<infer H, any, any> ? H : A
+
+type MissingHandlerNames<H extends Handlers<any, any, any>> = Exclude<
+  keyof H["~EndpointsByIdentifier"],
+  H["~HandledIdentifiers"]
+>
+
+type ValidateHandlersReturn<
+  A,
+  H = HandlersResult<A>,
+  Missing = H extends Handlers<any, any, any> ? MissingHandlerNames<H> : never
+> = H extends Handlers<any, any, any> ? [Missing] extends [never] ? A
+  : `Endpoint not handled: ${Missing & string}`
+  : `Must return the implemented handlers`
 
 /**
  * Mutable handler collection for one `HttpApi` group.
@@ -175,59 +252,77 @@ export type HandlersTypeId = typeof HandlersTypeId
  * **Details**
  *
  * Each call to `handle` or `handleRaw` registers an endpoint implementation and
- * removes that endpoint from the type-level set of endpoints still requiring
- * handlers.
+ * adds that endpoint identifier to the type-level set of implemented endpoints.
+ * Endpoint identifiers that were already handled are rejected at the type level.
  *
  * @category handlers
  * @since 4.0.0
  */
 export interface Handlers<
   R,
-  Endpoints extends HttpApiEndpoint.Any = never
+  EndpointsByIdentifier extends Record<string, HttpApiEndpoint.Constraint> = {},
+  HandledIdentifiers extends keyof EndpointsByIdentifier = never
 > extends Pipeable {
-  readonly [HandlersTypeId]: {
-    _Endpoints: Covariant<Endpoints>
-  }
-  readonly group: HttpApiGroup.AnyWithProps
-  readonly handlers: Map<string, Handlers.Item<R>>
+  readonly [HandlersTypeId]: typeof HandlersTypeId
+  readonly "~EndpointsByIdentifier": EndpointsByIdentifier
+  readonly "~HandledIdentifiers": HandledIdentifiers
+  /** @internal */
+  readonly group: HttpApiGroup.Top
+  /** @internal */
+  readonly handlers: Map<string, HandlerRuntime>
 
   /**
-   * Add the implementation for an `HttpApiEndpoint` to a `Handlers` group.
+   * Add the implementation for an unhandled `HttpApiEndpoint` to a `Handlers` group.
    */
-  handle<Name extends HttpApiEndpoint.Name<Endpoints>, R1>(
-    name: Name,
-    handler: HttpApiEndpoint.HandlerWithName<Endpoints, Name, HttpApiEndpoint.ErrorsWithName<Endpoints, Name>, R1>,
+  handle<
+    Identifier extends keyof EndpointsByIdentifier,
+    R1
+  >(
+    identifier: Identifier & NotHandledIdentifier<Identifier, HandledIdentifiers>,
+    handler: HttpApiEndpoint.Handler<
+      EndpointsByIdentifier[Identifier],
+      HttpApiEndpoint.MiddlewareError<EndpointsByIdentifier[Identifier]>,
+      R1
+    >,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): Handlers<
-    | R
-    | HttpApiEndpoint.MiddlewareWithName<Endpoints, Name>
-    | HttpApiEndpoint.MiddlewareServicesWithName<Endpoints, Name>
-    | (HttpApiEndpoint.ExcludeProvidedWithName<
-      Endpoints,
-      Name,
-      R1 | HttpApiEndpoint.ServerServicesWithName<Endpoints, Name>
-    > extends infer _R ? _R extends never ? never : HttpRouter.Request<"Requires", _R> : never),
-    HttpApiEndpoint.ExcludeName<Endpoints, Name>
+    R | HandlerRequirements<EndpointsByIdentifier[Identifier], R1>,
+    EndpointsByIdentifier,
+    HandledIdentifiers | Identifier
   >
 
   /**
-   * Add the implementation for an `HttpApiEndpoint` to a `Handlers` group.
+   * Add implementations for unhandled `HttpApiEndpoint`s in a `Handlers` group.
+   */
+  handleAll<const HandlersByIdentifier extends HandleAllHandlers<Omit<EndpointsByIdentifier, HandledIdentifiers>>>(
+    handlers:
+      & HandlersByIdentifier
+      & HandleAllExtraKeys<Omit<EndpointsByIdentifier, HandledIdentifiers>, HandlersByIdentifier>
+  ): Handlers<
+    R | HandleAllRequirements<EndpointsByIdentifier, HandlersByIdentifier>,
+    EndpointsByIdentifier,
+    HandledIdentifiers | keyof HandlersByIdentifier & keyof EndpointsByIdentifier
+  >
+
+  /**
+   * Add the implementation for an unhandled `HttpApiEndpoint` to a `Handlers` group.
    * This version opts out of automatic payload decoding and provides the raw request.
    */
-  handleRaw<Name extends HttpApiEndpoint.Name<Endpoints>, R1>(
-    name: Name,
-    handler: HttpApiEndpoint.HandlerRawWithName<Endpoints, Name, HttpApiEndpoint.ErrorsWithName<Endpoints, Name>, R1>,
+  handleRaw<
+    Identifier extends keyof EndpointsByIdentifier,
+    R1
+  >(
+    identifier: Identifier & NotHandledIdentifier<Identifier, HandledIdentifiers>,
+    handler: HttpApiEndpoint.HandlerRaw<
+      EndpointsByIdentifier[Identifier],
+      HttpApiEndpoint.MiddlewareError<EndpointsByIdentifier[Identifier]>,
+      R1
+    >,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): Handlers<
-    | R
-    | HttpApiEndpoint.MiddlewareWithName<Endpoints, Name>
-    | HttpApiEndpoint.MiddlewareServicesWithName<Endpoints, Name>
-    | (HttpApiEndpoint.ExcludeProvidedWithName<
-      Endpoints,
-      Name,
-      R1 | HttpApiEndpoint.ServerServicesWithName<Endpoints, Name>
-    > extends infer _R ? _R extends never ? never : HttpRouter.Request<"Requires", _R> : never),
-    HttpApiEndpoint.ExcludeName<Endpoints, Name>
+    R | HandlerRequirements<EndpointsByIdentifier[Identifier], R1>,
+    EndpointsByIdentifier,
+    HandledIdentifiers | Identifier
   >
 }
 
@@ -237,34 +332,6 @@ export interface Handlers<
  * @since 4.0.0
  */
 export declare namespace Handlers {
-  /**
-   * A `Handlers` value with its context and endpoint types erased.
-   *
-   * @category handlers
-   * @since 4.0.0
-   */
-  export interface Any {
-    readonly [HandlersTypeId]: any
-  }
-
-  /**
-   * Record stored for a registered endpoint handler.
-   *
-   * **Details**
-   *
-   * It keeps the endpoint metadata, handler function, whether raw request handling
-   * is used, and whether the handler should run uninterruptibly.
-   *
-   * @category handlers
-   * @since 4.0.0
-   */
-  export type Item<R> = {
-    readonly endpoint: HttpApiEndpoint.AnyWithProps
-    readonly handler: HttpApiEndpoint.Handler<any, any, R>
-    readonly isRaw: boolean
-    readonly uninterruptible: boolean
-  }
-
   /**
    * Creates a handler collection for a group where every endpoint in the group is
    * still awaiting an implementation.
@@ -272,9 +339,9 @@ export declare namespace Handlers {
    * @category handlers
    * @since 4.0.0
    */
-  export type FromGroup<Group extends HttpApiGroup.Any> = Handlers<
+  export type FromGroup<Group extends HttpApiGroup.Constraint> = Handlers<
     never,
-    HttpApiGroup.Endpoints<Group>
+    Group["endpoints"]
   >
 
   /**
@@ -285,22 +352,7 @@ export declare namespace Handlers {
    * @category handlers
    * @since 4.0.0
    */
-  export type ValidateReturn<A> = A extends (
-    | Handlers<
-      infer _R,
-      infer _Endpoints
-    >
-    | Effect.Effect<
-      Handlers<
-        infer _R,
-        infer _Endpoints
-      >,
-      infer _EX,
-      infer _RX
-    >
-  ) ? [_Endpoints] extends [never] ? A
-    : `Endpoint not handled: ${HttpApiEndpoint.Name<_Endpoints>}` :
-    `Must return the implemented handlers`
+  export type ValidateReturn<A> = ValidateHandlersReturn<A>
 
   /**
    * Extracts the error channel from an effect that produces a `Handlers`
@@ -312,7 +364,8 @@ export declare namespace Handlers {
   export type Error<A> = A extends Effect.Effect<
     Handlers<
       infer _R,
-      infer _Endpoints
+      infer _EndpointsByIdentifier,
+      infer _HandledIdentifiers
     >,
     infer _EX,
     infer _RX
@@ -328,12 +381,14 @@ export declare namespace Handlers {
    */
   export type Context<A> = A extends Handlers<
     infer _R,
-    infer _Endpoints
+    infer _EndpointsByIdentifier,
+    infer _HandledIdentifiers
   > ? _R :
     A extends Effect.Effect<
       Handlers<
         infer _R,
-        infer _Endpoints
+        infer _EndpointsByIdentifier,
+        infer _HandledIdentifiers
       >,
       infer _EX,
       infer _RX
@@ -341,34 +396,18 @@ export declare namespace Handlers {
     never
 }
 
-/**
- * Builds the server-side HTTP effect for a single endpoint in an API group using
- * the endpoint metadata, middleware, codecs, and supplied handler.
- *
- * @category handlers
- * @since 4.0.0
- */
-export const endpoint = <
-  ApiId extends string,
-  Groups extends HttpApiGroup.Any,
-  const GroupName extends HttpApiGroup.Name<Groups>,
-  const EndpointName extends HttpApiEndpoint.Name<HttpApiGroup.Endpoints<HttpApiGroup.WithName<Groups, GroupName>>>,
+type EndpointReturn<
+  Groups extends HttpApiGroup.Constraint,
+  GroupIdentifier extends HttpApiGroup.Identifier<Groups>,
+  EndpointIdentifier extends HttpApiGroup.Endpoints<
+    HttpApiGroup.WithIdentifier<Groups, GroupIdentifier>
+  >["identifier"],
   R,
-  Group extends HttpApiGroup.Any = HttpApiGroup.WithName<Groups, GroupName>,
-  Endpoint extends HttpApiEndpoint.Any = HttpApiEndpoint.WithName<HttpApiGroup.Endpoints<Group>, EndpointName>
->(
-  api: HttpApi.HttpApi<ApiId, Groups>,
-  groupName: GroupName,
-  endpointName: EndpointName,
-  handler: NoInfer<
-    HttpApiEndpoint.HandlerWithName<
-      HttpApiGroup.Endpoints<HttpApiGroup.WithName<Groups, GroupName>>,
-      EndpointName,
-      never,
-      R
-    >
+  Endpoint extends HttpApiEndpoint.Constraint = HttpApiEndpoint.WithIdentifier<
+    HttpApiGroup.Endpoints<HttpApiGroup.WithIdentifier<Groups, GroupIdentifier>>,
+    EndpointIdentifier
   >
-): Effect.Effect<
+> = Effect.Effect<
   Effect.Effect<
     HttpServerResponse,
     never,
@@ -385,10 +424,39 @@ export const endpoint = <
   | FileSystem
   | HttpPlatform
   | Path
-> =>
+>
+
+/**
+ * Builds the server-side HTTP effect for a single endpoint in an API group using
+ * the endpoint metadata, middleware, codecs, and supplied handler.
+ *
+ * @category handlers
+ * @since 4.0.0
+ */
+export const endpoint = <
+  ApiId extends string,
+  Groups extends HttpApiGroup.Constraint,
+  const GroupIdentifier extends HttpApiGroup.Identifier<Groups>,
+  const EndpointIdentifier extends HttpApiGroup.Endpoints<
+    HttpApiGroup.WithIdentifier<Groups, GroupIdentifier>
+  >["identifier"],
+  R
+>(
+  api: HttpApi.HttpApi<ApiId, Groups>,
+  groupIdentifier: GroupIdentifier,
+  endpointIdentifier: EndpointIdentifier,
+  handler: NoInfer<
+    HttpApiEndpoint.HandlerWithIdentifier<
+      HttpApiGroup.Endpoints<HttpApiGroup.WithIdentifier<Groups, GroupIdentifier>>,
+      EndpointIdentifier,
+      never,
+      R
+    >
+  >
+): EndpointReturn<Groups, GroupIdentifier, EndpointIdentifier, R> =>
   Effect.contextWith((context: Context.Context<any>) => {
-    const group = api.groups[groupName] as unknown as HttpApiGroup.AnyWithProps
-    const endpoint = group.endpoints[endpointName] as unknown as HttpApiEndpoint.AnyWithProps
+    const group = api.groups[groupIdentifier] as unknown as HttpApiGroup.Top
+    const endpoint = group.endpoints[endpointIdentifier]
     return Effect.succeed(handlerToHttpEffect(
       group,
       endpoint,
@@ -416,8 +484,10 @@ export const securityDecode = <Security extends HttpApiSecurity.HttpApiSecurity>
     case "Http": {
       return Effect.map(
         HttpServerRequest,
-        // schemeLength + space
-        (request) => Redacted.make((request.headers.authorization ?? "").slice(self.schemeLength + 1)) as any
+        (request) =>
+          Redacted.make(
+            getAuthorizationCredential(request.headers.authorization, self.scheme) ?? ""
+          ) as any
       )
     }
     case "ApiKey": {
@@ -444,24 +514,20 @@ export const securityDecode = <Security extends HttpApiSecurity.HttpApiSecurity>
         username: "",
         password: Redacted.make("")
       } as any
-      return HttpServerRequest.pipe(
-        Effect.flatMap((request) =>
-          Effect.fromResult(Encoding.decodeBase64String((request.headers.authorization ?? "").slice(basicLen)))
-        ),
-        Effect.match({
-          onFailure: () => empty,
-          onSuccess: (header) => {
-            const parts = header.split(":")
-            if (parts.length !== 2) {
-              return empty
-            }
-            return {
-              username: parts[0],
-              password: Redacted.make(parts[1])
-            } as any
-          }
-        })
-      )
+      return Effect.map(HttpServerRequest, (request) => {
+        const encoded = getAuthorizationCredential(request.headers.authorization, basicScheme)
+        if (encoded === undefined) return empty
+        const decoded = Result.getOrUndefined(Encoding.decodeBase64String(encoded))
+        if (decoded === undefined) return empty
+        // RFC 7617, Section 2: only the first colon separates the user-id from the password.
+        // https://www.rfc-editor.org/rfc/rfc7617.html#section-2
+        const separator = decoded.indexOf(":")
+        if (separator === -1) return empty
+        return {
+          username: decoded.slice(0, separator),
+          password: Redacted.make(decoded.slice(separator + 1))
+        } as any
+      })
     }
   }
 }
@@ -492,53 +558,101 @@ export const securitySetCookie = (
 // Internal
 // -----------------------------------------------------------------------------
 
-const basicLen = `Basic `.length
+const basicScheme = "Basic"
+
+function getAuthorizationCredential(
+  authorization: string | undefined,
+  scheme: string
+): string | undefined {
+  const schemeLength = scheme.length
+  // RFC 9110, Section 11.1: schemes are case-insensitive and credentials follow 1*SP.
+  // https://www.rfc-editor.org/rfc/rfc9110.html#section-11.1
+  if (
+    authorization === undefined ||
+    authorization.length <= schemeLength ||
+    authorization.charCodeAt(schemeLength) !== 32 ||
+    authorization.slice(0, schemeLength).toLowerCase() !== scheme.toLowerCase()
+  ) {
+    return undefined
+  }
+  let credentialStart = schemeLength + 1
+  while (authorization.charCodeAt(credentialStart) === 32) {
+    credentialStart++
+  }
+  return credentialStart === authorization.length ? undefined : authorization.slice(credentialStart)
+}
+
+const registerHandler = (
+  self: Handlers<any, any, any>,
+  identifier: string,
+  handler: HttpApiEndpoint.Handler<HttpApiEndpoint.Constraint, any, any>,
+  isRaw: boolean,
+  options?: HandlerOptions | undefined
+) => {
+  if (!Object.hasOwn(self.group.endpoints, identifier)) {
+    throw new Error(`HttpApiEndpoint "${identifier}" not found in HttpApiGroup "${self.group.identifier}"`)
+  }
+  if (self.handlers.has(identifier)) {
+    throw new Error(
+      `Handler for HttpApiEndpoint "${identifier}" is already registered in HttpApiGroup "${self.group.identifier}"`
+    )
+  }
+  const endpoint = self.group.endpoints[identifier]
+  self.handlers.set(identifier, {
+    endpoint,
+    handler,
+    isRaw,
+    uninterruptible: options?.uninterruptible ?? false
+  })
+  return self
+}
 
 const HandlersProto = {
-  [HandlersTypeId]: {
-    _Endpoints: identity
-  },
+  [HandlersTypeId]: HandlersTypeId,
   pipe() {
     return pipeArguments(this, arguments)
   },
   handle(
-    this: Handlers<any, HttpApiEndpoint.Any>,
-    name: string,
-    handler: HttpApiEndpoint.Handler<any, any, any>,
+    this: Handlers<any, any, any>,
+    identifier: string,
+    handler: HttpApiEndpoint.Handler<HttpApiEndpoint.Constraint, any, any>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ) {
-    const endpoint = this.group.endpoints[name]
-    this.handlers.set(name, {
-      endpoint,
-      handler,
-      isRaw: false,
-      uninterruptible: options?.uninterruptible ?? false
-    })
+    return registerHandler(this, identifier, handler, false, options)
+  },
+  handleAll(
+    this: Handlers<any, any, any>,
+    handlers: Record<
+      string,
+      HttpApiEndpoint.Handler<HttpApiEndpoint.Constraint, any, any> | {
+        readonly handler: HttpApiEndpoint.Handler<HttpApiEndpoint.Constraint, any, any>
+        readonly options?: HandlerOptions | undefined
+      }
+    >
+  ) {
+    for (const [identifier, entry] of Object.entries(handlers)) {
+      const handler = typeof entry === "function" ? entry : entry.handler
+      const options = typeof entry === "function" ? undefined : entry.options
+      registerHandler(this, identifier, handler, false, options)
+    }
     return this
   },
   handleRaw(
-    this: Handlers<any, HttpApiEndpoint.Any>,
-    name: string,
-    handler: HttpApiEndpoint.Handler<any, any, any>,
+    this: Handlers<any, any, any>,
+    identifier: string,
+    handler: HttpApiEndpoint.Handler<HttpApiEndpoint.Constraint, any, any>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ) {
-    const endpoint = this.group.endpoints[name]
-    this.handlers.set(name, {
-      endpoint,
-      handler,
-      isRaw: true,
-      uninterruptible: options?.uninterruptible ?? false
-    })
-    return this
+    return registerHandler(this, identifier, handler, true, options)
   }
 }
 
-const makeHandlers = <R, Endpoints extends HttpApiEndpoint.Any>(
-  group: HttpApiGroup.Any
-): Handlers<R, Endpoints> => {
+const makeHandlers = <R, Group extends HttpApiGroup.Constraint>(
+  group: Group
+): Handlers<R, EndpointMap<HttpApiGroup.Endpoints<Group>>> => {
   const self = Object.create(HandlersProto)
   self.group = group
-  self.handlers = new Map<string, Handlers.Item<R>>()
+  self.handlers = new Map<string, HandlerRuntime>()
   return self
 }
 
@@ -581,7 +695,7 @@ function decodePayload(
 ): Effect.Effect<unknown, Schema.SchemaError, unknown> | HttpServerResponse | undefined {
   const hasBody = HttpMethod.hasBody(httpRequest.method)
   const contentType = hasBody
-    ? getRequestMediaType(httpRequest)
+    ? MediaType.normalize(httpRequest.headers["content-type"] ?? "application/json")
     : "application/x-www-form-urlencoded"
   const existing = payloadBy.get(contentType)
   if (!existing) {
@@ -635,10 +749,10 @@ function decodePayload(
 }
 
 function handlerToHttpEffect(
-  group: HttpApiGroup.AnyWithProps,
-  endpoint: HttpApiEndpoint.AnyWithProps,
+  group: HttpApiGroup.Top,
+  endpoint: HttpApiEndpoint.Top,
   context: Context.Context<any>,
-  handler: HttpApiEndpoint.Handler<any, any, any>,
+  handler: HttpApiEndpoint.Handler<HttpApiEndpoint.Constraint, any, any>,
   isRaw: boolean
 ) {
   const encodeSuccess = Schema.encodeUnknownEffect(makeSuccessSchema(endpoint))
@@ -706,8 +820,8 @@ function handlerToHttpEffect(
 
 /** @internal */
 export function handlerToRoute(
-  group: HttpApiGroup.AnyWithProps,
-  handler: Handlers.Item<any>,
+  group: HttpApiGroup.Top,
+  handler: HandlerRuntime,
   context: Context.Context<any>
 ): HttpRouter.Route<any, any> {
   const endpoint = handler.endpoint
@@ -719,31 +833,20 @@ export function handlerToRoute(
   )
 }
 
-const getRequestContentType = (request: HttpServerRequest): string =>
-  request.headers["content-type"]
-    ? request.headers["content-type"].toLowerCase().trim()
-    : "application/json"
-
-const getRequestMediaType = (request: HttpServerRequest): string => {
-  const contentType = getRequestContentType(request)
-  const index = contentType.indexOf(";")
-  return index === -1 ? contentType : contentType.slice(0, index).trim()
-}
-
-const applyMiddleware = <A extends Effect.Effect<any, any, any>>(
-  group: HttpApiGroup.AnyWithProps,
-  endpoint: HttpApiEndpoint.AnyWithProps,
+const applyMiddleware = <Group extends HttpApiGroup.Constraint, A extends Effect.Effect<any, any, any>>(
+  group: Group,
+  endpoint: HttpApiEndpoint.Top,
   context: Context.Context<any>,
   handler: A
 ) => {
   const options = { group, endpoint }
   for (const key_ of endpoint.middlewares) {
-    const key = key_ as any as HttpApiMiddleware.AnyService
-    const service = Context.getUnsafe(context, key as any) as HttpApiMiddleware.HttpApiMiddleware<any, any, any>
+    const key = key_ as HttpApiMiddleware.AnyService
+    const service = Context.getUnsafe(context, key)
     const apply = HttpApiMiddleware.isSecurity(key)
-      ? makeSecurityMiddleware(key, service as any)
+      ? makeSecurityMiddleware(key, service)
       : service
-    handler = apply(handler, options) as A
+    handler = apply(handler, options)
   }
   return handler
 }
@@ -771,8 +874,8 @@ const makeSecurityMiddleware = (
   }
 
   const middleware = Effect.fnUntraced(function*(handler: Effect.Effect<any, any, any>, options: {
-    readonly group: HttpApiGroup.AnyWithProps
-    readonly endpoint: HttpApiEndpoint.AnyWithProps
+    readonly group: HttpApiGroup.Top
+    readonly endpoint: HttpApiEndpoint.Top
   }) {
     handler = Effect.mapError(handler, (error) => new HandlerError(error))
     let lastResult: Result.Result<any, any> | undefined
@@ -816,7 +919,7 @@ type StreamEncoder = (response: unknown, context: Context.Context<never>) =>
   | Effect.Effect<HttpServerResponse, Schema.SchemaError, unknown>
   | undefined
 
-function makeStreamEncoder(endpoint: HttpApiEndpoint.AnyWithProps): StreamEncoder | undefined {
+function makeStreamEncoder(endpoint: HttpApiEndpoint.Top): StreamEncoder | undefined {
   const streamSchema = getStreamSuccessSchema(endpoint)
   if (streamSchema === undefined) {
     return undefined
@@ -863,7 +966,7 @@ function makeStreamEncoder(endpoint: HttpApiEndpoint.AnyWithProps): StreamEncode
   }
 }
 
-function getStreamSuccessSchema(endpoint: HttpApiEndpoint.AnyWithProps) {
+function getStreamSuccessSchema(endpoint: HttpApiEndpoint.Top) {
   for (const schema of endpoint.success) {
     if (HttpApiSchema.isStreamSchema(schema)) {
       return schema
@@ -871,7 +974,7 @@ function getStreamSuccessSchema(endpoint: HttpApiEndpoint.AnyWithProps) {
   }
 }
 
-function hasBufferedSuccess(endpoint: HttpApiEndpoint.AnyWithProps): boolean {
+function hasBufferedSuccess(endpoint: HttpApiEndpoint.Top): boolean {
   for (const schema of endpoint.success) {
     if (Schema.isSchema(schema) && !HttpApiSchema.isStreamSchema(schema)) return true
   }
@@ -942,14 +1045,14 @@ const toResponseSuccessSchema = toResponseSchema(HttpApiSchema.getStatusSuccess)
 const toResponseErrorSchema = toResponseSchema(HttpApiSchema.getStatusError)
 
 function makeSuccessSchema(
-  endpoint: HttpApiEndpoint.AnyWithProps
+  endpoint: HttpApiEndpoint.Top
 ): Schema.ConstraintEncoder<HttpServerResponse, unknown> {
   const schemas = HttpApiEndpoint.getSuccessSchemas(endpoint).map(toResponseSuccessSchema)
   return schemas.length === 1 ? schemas[0] : Schema.Union(schemas)
 }
 
 function makeErrorSchema(
-  endpoint: HttpApiEndpoint.AnyWithProps
+  endpoint: HttpApiEndpoint.Top
 ): Schema.ConstraintEncoder<HttpServerResponse, unknown> {
   const schemas = HttpApiEndpoint.getErrorSchemas(endpoint).map(toResponseErrorSchema)
   if (schemas.length === 0) return Schema.Never
@@ -967,7 +1070,7 @@ function toResponseSchema(getStatus: (ast: SchemaAST.AST) => number) {
     const responseSchema = $HttpServerResponse.pipe(
       Schema.decodeTo(schema, getResponseTransformation(getStatus, schema))
     )
-    cache.set(responseSchema.ast, responseSchema)
+    cache.set(schema.ast, responseSchema)
     return responseSchema
   }
 }