effect 4.0.0-beta.2 → 4.0.0-beta.21

package/src/unstable/http/HttpServerError.ts

@@ -4,8 +4,11 @@
 import * as Cause from "../../Cause.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
+import * as ErrorReporter from "../../ErrorReporter.ts"
 import type * as Exit from "../../Exit.ts"
+import { constUndefined } from "../../Function.ts"
 import { hasProperty } from "../../Predicate.ts"
+import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Request from "./HttpServerRequest.ts"
 import * as Respondable from "./HttpServerRespondable.ts"
 import * as Response from "./HttpServerResponse.ts"
@@ -32,35 +35,24 @@ export class HttpServerError extends Data.TaggedError("HttpServerError")<{
     }
   }
 
-  /**
-   * @since 4.0.0
-   */
   readonly [TypeId] = TypeId
 
-  /**
-   * @since 4.0.0
-   */
   override stack = `${this.name}: ${this.message}`
 
-  /**
-   * @since 4.0.0
-   */
   get request(): Request.HttpServerRequest {
     return this.reason.request
   }
 
-  /**
-   * @since 4.0.0
-   */
   get response(): Response.HttpServerResponse | undefined {
     return "response" in this.reason ? this.reason.response : undefined
   }
 
-  /**
-   * @since 4.0.0
-   */
-  [Respondable.TypeId]() {
-    return this.reason[Respondable.TypeId]()
+  [Respondable.symbol]() {
+    return this.reason[Respondable.symbol]()
+  }
+
+  override get [ErrorReporter.ignore](): boolean {
+    return this.reason[ErrorReporter.ignore] ?? false
   }
 
   override get message(): string {
@@ -80,7 +72,7 @@ export class RequestParseError extends Data.TaggedError("RequestParseError")<{
   /**
    * @since 4.0.0
    */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 400 }))
   }
 
@@ -102,13 +94,12 @@ export class RouteNotFound extends Data.TaggedError("RouteNotFound")<{
   readonly description?: string
   readonly cause?: unknown
 }> implements Respondable.Respondable {
-  /**
-   * @since 4.0.0
-   */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 404 }))
   }
 
+  override readonly [ErrorReporter.ignore] = true
+
   get methodAndUrl() {
     return `${this.request.method} ${this.request.url}`
   }
@@ -130,7 +121,7 @@ export class InternalError extends Data.TaggedError("InternalError")<{
   /**
    * @since 4.0.0
    */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 500 }))
   }
 
@@ -159,10 +150,7 @@ export class ResponseError extends Data.TaggedError("ResponseError")<{
   readonly description?: string
   readonly cause?: unknown
 }> implements Respondable.Respondable {
-  /**
-   * @since 4.0.0
-   */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 500 }))
   }
 
@@ -196,16 +184,25 @@ export class ServeError extends Data.TaggedError("ServeError")<{
   readonly cause: unknown
 }> {}
 
+/**
+ * @since 4.0.0
+ * @category Annotations
+ */
+export class ClientAbort extends ServiceMap.Service<ClientAbort, true>()("effect/http/HttpServerError/ClientAbort") {
+  static annotation = this.serviceMap(true).pipe(
+    ServiceMap.add(Cause.StackTrace, {
+      name: "ClientAbort",
+      stack: constUndefined,
+      parent: undefined
+    })
+  )
+}
+
 const formatRequestMessage = (reason: string, description: string | undefined, info: string) => {
   const prefix = `${reason} (${info})`
   return description ? `${prefix}: ${description}` : prefix
 }
 
-/**
- * @since 4.0.0
- */
-export const clientAbortFiberId = -499
-
 /**
  * @since 4.0.0
  */
@@ -215,37 +212,37 @@ export const causeResponse = <E>(
   let response: Response.HttpServerResponse | undefined
   let effect = succeedInternalServerError
   const failures: Array<Cause.Reason<E>> = []
-  let interrupt: Cause.Interrupt | undefined
+  let interrupts: Array<Cause.Interrupt> = []
   let isClientInterrupt = false
   for (let i = 0; i < cause.reasons.length; i++) {
-    const f = cause.reasons[i]
-    switch (f._tag) {
+    const reason = cause.reasons[i]
+    switch (reason._tag) {
       case "Fail": {
-        effect = Respondable.toResponseOrElse(f.error, internalServerError)
-        failures.push(f)
+        effect = Respondable.toResponseOrElse(reason.error, internalServerError)
+        failures.push(reason)
         break
       }
       case "Die": {
-        if (Response.isHttpServerResponse(f.defect)) {
-          response = f.defect
+        if (Response.isHttpServerResponse(reason.defect)) {
+          response = reason.defect
         } else {
-          effect = Respondable.toResponseOrElseDefect(f.defect, internalServerError)
-          failures.push(f)
+          effect = Respondable.toResponseOrElseDefect(reason.defect, internalServerError)
+          failures.push(reason)
         }
         break
       }
       case "Interrupt": {
-        isClientInterrupt = isClientInterrupt || f.fiberId === clientAbortFiberId
+        isClientInterrupt = reason.annotations.has(ClientAbort.key)
         if (failures.length > 0) break
-        interrupt = f
+        interrupts.push(reason)
         break
       }
     }
   }
   if (response) {
     return Effect.succeed([response, Cause.fromReasons(failures)] as const)
-  } else if (interrupt && failures.length === 0) {
-    failures.push(isClientInterrupt ? Cause.makeInterruptReason(clientAbortFiberId) : interrupt)
+  } else if (interrupts.length > 0 && failures.length === 0) {
+    failures.push(...interrupts)
     effect = isClientInterrupt ? clientAbortError : serverAbortError
   }
   return Effect.mapEager(effect, (response) => {

package/src/unstable/http/HttpServerRequest.ts

@@ -43,7 +43,7 @@ export const TypeId = "~effect/http/HttpServerRequest"
  */
 export interface HttpServerRequest extends HttpIncomingMessage.HttpIncomingMessage<HttpServerError> {
   readonly [TypeId]: typeof TypeId
-  readonly source: unknown
+  readonly source: object
   readonly url: string
   readonly originalUrl: string
   readonly method: HttpMethod

package/src/unstable/http/HttpServerRespondable.ts

@@ -12,21 +12,21 @@ import * as Response from "./HttpServerResponse.ts"
  * @since 4.0.0
  * @category Type IDs
  */
-export const TypeId = "~effect/http/HttpServerRespondable"
+export const symbol = "~effect/http/HttpServerRespondable"
 
 /**
  * @since 4.0.0
  * @category models
  */
 export interface Respondable {
-  readonly [TypeId]: () => Effect.Effect<HttpServerResponse, unknown>
+  [symbol](): Effect.Effect<HttpServerResponse, unknown>
 }
 
 /**
  * @since 4.0.0
  * @category guards
  */
-export const isRespondable = (u: unknown): u is Respondable => hasProperty(u, TypeId)
+export const isRespondable = (u: unknown): u is Respondable => hasProperty(u, symbol)
 
 const badRequest = Response.empty({ status: 400 })
 const notFound = Response.empty({ status: 404 })
@@ -39,7 +39,7 @@ export const toResponse = (self: Respondable): Effect.Effect<HttpServerResponse>
   if (Response.isHttpServerResponse(self)) {
     return Effect.succeed(self)
   }
-  return Effect.orDie(self[TypeId]())
+  return Effect.orDie(self[symbol]())
 }
 
 /**
@@ -50,7 +50,7 @@ export const toResponseOrElse = (u: unknown, orElse: HttpServerResponse): Effect
   if (Response.isHttpServerResponse(u)) {
     return Effect.succeed(u)
   } else if (isRespondable(u)) {
-    return Effect.catchCause(u[TypeId](), () => Effect.succeed(orElse))
+    return Effect.catchCause(u[symbol](), () => Effect.succeed(orElse))
     // add support for some commmon types
   } else if (Schema.isSchemaError(u)) {
     return Effect.succeed(badRequest)
@@ -68,7 +68,7 @@ export const toResponseOrElseDefect = (u: unknown, orElse: HttpServerResponse):
   if (Response.isHttpServerResponse(u)) {
     return Effect.succeed(u)
   } else if (isRespondable(u)) {
-    return Effect.catchCause(u[TypeId](), () => Effect.succeed(orElse))
+    return Effect.catchCause(u[symbol](), () => Effect.succeed(orElse))
   }
   return Effect.succeed(orElse)
 }

package/src/unstable/http/HttpServerResponse.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import * as Effect from "../../Effect.ts"
+import * as ErrorReporter from "../../ErrorReporter.ts"
 import type * as FileSystem from "../../FileSystem.ts"
 import { dual } from "../../Function.ts"
 import type * as Inspectable from "../../Inspectable.ts"
@@ -28,7 +29,7 @@ const TypeId = "~effect/http/HttpServerResponse"
  * @since 4.0.0
  * @category models
  */
-export interface HttpServerResponse extends Inspectable.Inspectable, Pipeable {
+export interface HttpServerResponse extends Inspectable.Inspectable, Pipeable, ErrorReporter.Reportable {
   readonly [TypeId]: typeof TypeId
   readonly status: number
   readonly statusText?: string | undefined
@@ -327,7 +328,7 @@ export const formData = (
     statusText: options?.statusText,
     headers: options?.headers && Headers.fromInput(options.headers),
     cookies: options?.cookies,
-    body: Body.makeFormData(body)
+    body: Body.formData(body)
   })
 
 /**
@@ -834,6 +835,7 @@ const Proto: Omit<
 > = {
   ...PipeInspectableProto,
   [TypeId]: TypeId,
+  [ErrorReporter.ignore]: true,
   toJSON(this: HttpServerResponse) {
     return {
       _id: "HttpServerResponse",

package/src/unstable/http/Multipart.ts

@@ -203,13 +203,13 @@ export const PersistedFileSchema: PersistedFileSchema = Schema.declare(
  * @since 4.0.0
  * @category Schemas
  */
-export const FilesSchema: Schema.Array$<PersistedFileSchema> = Schema.Array(PersistedFileSchema)
+export const FilesSchema: Schema.$Array<PersistedFileSchema> = Schema.Array(PersistedFileSchema)
 
 /**
  * @since 4.0.0
  * @category Schemas
  */
-export const SingleFileSchema: Schema.decodeTo<PersistedFileSchema, Schema.Array$<PersistedFileSchema>> = FilesSchema
+export const SingleFileSchema: Schema.decodeTo<PersistedFileSchema, Schema.$Array<PersistedFileSchema>> = FilesSchema
   .check(
     Schema.isLengthBetween(1, 1)
   ).pipe(

package/src/unstable/http/UrlParams.ts

@@ -43,10 +43,14 @@ export const isUrlParams = (u: unknown): u is UrlParams => hasProperty(u, TypeId
  * @category models
  */
 export type Input =
-  | CoercibleRecord
+  | CoercibleRecordInput
   | Iterable<readonly [string, Coercible]>
   | URLSearchParams
 
+type CoercibleRecordInput = CoercibleRecord & {
+  readonly [Symbol.iterator]?: never
+}
+
 /**
  * @since 4.0.0
  * @category models
@@ -57,8 +61,17 @@ export type Coercible = string | number | bigint | boolean | null | undefined
  * @since 4.0.0
  * @category models
  */
-export interface CoercibleRecord {
-  readonly [key: string]: Coercible | ReadonlyArray<Coercible> | CoercibleRecord
+type CoercibleRecordField<A> = A extends Coercible ? A
+  : A extends ReadonlyArray<infer Item> ? ReadonlyArray<Item extends Coercible ? Item : never>
+  : A extends object ? CoercibleRecord<A>
+  : never
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export type CoercibleRecord<A extends object = any> = {
+  readonly [K in keyof A]: CoercibleRecordField<A[K]>
 }
 
 const Proto = {
@@ -110,7 +123,9 @@ export const fromInput = (input: Input): UrlParams => {
 }
 
 const fromInputNested = (input: Input): Array<[string | Array<string>, any]> => {
-  const entries = Symbol.iterator in input ? Arr.fromIterable(input) : Object.entries(input)
+  const entries = typeof (input as any)[Symbol.iterator] === "function"
+    ? Arr.fromIterable(input as Iterable<readonly [string, Coercible]>)
+    : Object.entries(input)
   const out: Array<[string | Array<string>, string]> = []
   for (const [key, value] of entries) {
     if (Array.isArray(value)) {
@@ -539,7 +554,7 @@ export const schemaJsonField = (field: string): schemaJsonField =>
  */
 export interface schemaRecord extends
   Schema.decodeTo<
-    Schema.Record$<Schema.String, Schema.Union<readonly [Schema.String, Schema.NonEmptyArray<Schema.String>]>>,
+    Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.NonEmptyArray<Schema.String>]>>,
     UrlParamsSchema,
     never,
     never

package/src/unstable/http/internal/preResponseHandler.ts

@@ -0,0 +1,15 @@
+import * as Effect from "../../../Effect.ts"
+import type { PreResponseHandler } from "../HttpEffect.ts"
+import type { HttpServerRequest } from "../HttpServerRequest.ts"
+
+/** @internal */
+export const requestPreResponseHandlers = new WeakMap<object, PreResponseHandler>()
+
+/** @internal */
+export const appendPreResponseHandlerUnsafe = (request: HttpServerRequest, handler: PreResponseHandler): void => {
+  const prev = requestPreResponseHandlers.get(request.source)
+  const next: PreResponseHandler = prev ?
+    (request, response) => Effect.flatMap(prev(request, response), (response) => handler(request, response))
+    : handler
+  requestPreResponseHandlers.set(request.source, next)
+}

package/src/unstable/httpapi/HttpApi.ts

@@ -67,13 +67,13 @@ export interface HttpApi<
    * api is called.
    */
   middleware<I extends HttpApiMiddleware.AnyId, S>(
-    middleware: ServiceMap.Service<I, S>
+    middleware: ServiceMap.Key<I, S>
   ): HttpApi<Id, HttpApiGroup.AddMiddleware<Groups, I>>
 
   /**
    * Annotate the `HttpApi`.
    */
-  annotate<I, S>(tag: ServiceMap.Service<I, S>, value: S): HttpApi<Id, Groups>
+  annotate<I, S>(tag: ServiceMap.Key<I, S>, value: S): HttpApi<Id, Groups>
 
   /**
    * Annotate the `HttpApi` with a ServiceMap.
@@ -137,14 +137,14 @@ const Proto = {
       annotations: this.annotations
     })
   },
-  middleware(this: AnyWithProps, tag: HttpApiMiddleware.AnyKey) {
+  middleware(this: AnyWithProps, tag: HttpApiMiddleware.AnyService) {
     return makeProto({
       identifier: this.identifier,
       groups: Record.map(this.groups, (group) => group.middleware(tag as any)),
       annotations: this.annotations
     })
   },
-  annotate(this: AnyWithProps, key: ServiceMap.Service<any, any>, value: any) {
+  annotate(this: AnyWithProps, key: ServiceMap.Key<any, any>, value: any) {
     return makeProto({
       identifier: this.identifier,
       groups: this.groups,
@@ -212,7 +212,7 @@ export const reflect = <Id extends string, Groups extends HttpApiGroup.Any>(
       readonly group: HttpApiGroup.AnyWithProps
       readonly endpoint: HttpApiEndpoint.AnyWithProps
       readonly mergedAnnotations: ServiceMap.ServiceMap<never>
-      readonly middleware: ReadonlySet<HttpApiMiddleware.AnyKey>
+      readonly middleware: ReadonlySet<HttpApiMiddleware.AnyService>
       readonly successes: ReadonlyMap<number, readonly [Schema.Top, ...Array<Schema.Top>]>
       readonly errors: ReadonlyMap<number, readonly [Schema.Top, ...Array<Schema.Top>]>
     }) => void

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -2,7 +2,7 @@
  * @since 4.0.0
  */
 import * as Effect from "../../Effect.ts"
-import * as Base64 from "../../encoding/Base64.ts"
+import * as Encoding from "../../Encoding.ts"
 import * as Fiber from "../../Fiber.ts"
 import type { FileSystem } from "../../FileSystem.ts"
 import { identity } from "../../Function.ts"
@@ -20,7 +20,7 @@ import * as Transformation from "../../SchemaTransformation.ts"
 import type * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
-import type { Covariant } from "../../Types.ts"
+import type { Covariant, NoInfer } from "../../Types.ts"
 import * as UndefinedOr from "../../UndefinedOr.ts"
 import type { Cookie } from "../http/Cookies.ts"
 import type * as Etag from "../http/Etag.ts"
@@ -63,7 +63,6 @@ export const layer = <Id extends string, Groups extends HttpApiGroup.Any>(
   | HttpPlatform
   | Path
   | HttpApiGroup.ToService<Id, Groups>
-  | HttpApiGroup.ErrorServicesEncode<Groups>
 > =>
   HttpRouter.use(Effect.fnUntraced(function*(router) {
     const services = yield* Effect.services<
@@ -168,7 +167,7 @@ export interface Handlers<
     | R
     | HttpApiEndpoint.MiddlewareWithName<Endpoints, Name>
     | HttpApiEndpoint.MiddlewareServicesWithName<Endpoints, Name>
-    | HttpApiEndpoint.ExcludeProvided<
+    | HttpApiEndpoint.ExcludeProvidedWithName<
       Endpoints,
       Name,
       R1 | HttpApiEndpoint.ServerServicesWithName<Endpoints, Name>
@@ -188,7 +187,7 @@ export interface Handlers<
     | R
     | HttpApiEndpoint.MiddlewareWithName<Endpoints, Name>
     | HttpApiEndpoint.MiddlewareServicesWithName<Endpoints, Name>
-    | HttpApiEndpoint.ExcludeProvided<
+    | HttpApiEndpoint.ExcludeProvidedWithName<
       Endpoints,
       Name,
       R1 | HttpApiEndpoint.ServerServicesWithName<Endpoints, Name>
@@ -284,6 +283,54 @@ export declare namespace Handlers {
     never
 }
 
+/**
+ * @since 4.0.0
+ * @category handlers
+ */
+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>>>,
+  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
+    >
+  >
+): Effect.Effect<
+  Effect.Effect<
+    HttpServerResponse,
+    never,
+    | HttpServerRequest
+    | HttpRouter.RouteContext
+    | Request.ParsedSearchParams
+    | Exclude<R, HttpApiEndpoint.MiddlewareProvides<Endpoint>>
+  >,
+  never,
+  | HttpApiEndpoint.ServerServices<Endpoint>
+  | HttpApiEndpoint.Middleware<Endpoint>
+  | HttpApiEndpoint.MiddlewareServices<Endpoint>
+  | Etag.Generator
+  | FileSystem
+  | HttpPlatform
+  | Path
+> =>
+  Effect.servicesWith((services: ServiceMap.ServiceMap<any>) => {
+    const group = api.groups[groupName] as unknown as HttpApiGroup.AnyWithProps
+    const endpoint = group.endpoints[endpointName] as unknown as HttpApiEndpoint.AnyWithProps
+    return Effect.succeed(handlerToHttpEffect(group, endpoint, services, handler as any, false))
+  })
+
 /**
  * @since 4.0.0
  * @category security
@@ -328,7 +375,7 @@ export const securityDecode = <Security extends HttpApiSecurity.HttpApiSecurity>
       } as any
       return HttpServerRequest.asEffect().pipe(
         Effect.flatMap((request) =>
-          Base64.decodeString((request.headers.authorization ?? "").slice(basicLen)).asEffect()
+          Encoding.decodeBase64String((request.headers.authorization ?? "").slice(basicLen)).asEffect()
         ),
         Effect.match({
           onFailure: () => empty,
@@ -356,7 +403,7 @@ export const securitySetCookie = (
   self: HttpApiSecurity.ApiKey,
   value: string | Redacted.Redacted,
   options?: Cookie["options"]
-): Effect.Effect<void> =>
+): Effect.Effect<void, never, HttpServerRequest> =>
   HttpEffect.appendPreResponseHandler((_req, response) =>
     Effect.orDie(
       Response.setCookie(response, self.key, stringOrRedacted(value), {
@@ -497,22 +544,23 @@ function decodePayload(
   }
 }
 
-function handlerToRoute(
+function handlerToHttpEffect(
   group: HttpApiGroup.AnyWithProps,
-  handler: Handlers.Item<any>,
-  services: ServiceMap.ServiceMap<any>
-): HttpRouter.Route<any, any> {
-  const endpoint = handler.endpoint
+  endpoint: HttpApiEndpoint.AnyWithProps,
+  services: ServiceMap.ServiceMap<any>,
+  handler: HttpApiEndpoint.Handler<any, any, any>,
+  isRaw: boolean
+) {
   const encodeSuccess = Schema.encodeUnknownEffect(makeSuccessSchema(endpoint))
   const encodeError = Schema.encodeUnknownEffect(makeErrorSchema(endpoint))
-  const decodeParams = UndefinedOr.map(HttpApiEndpoint.getParamsSchema(endpoint), Schema.decodeUnknownEffect)
-  const decodeHeaders = UndefinedOr.map(HttpApiEndpoint.getHeadersSchema(endpoint), Schema.decodeUnknownEffect)
-  const decodeQuery = UndefinedOr.map(HttpApiEndpoint.getQuerySchema(endpoint), Schema.decodeUnknownEffect)
+  const decodeParams = UndefinedOr.map(endpoint.params, Schema.decodeUnknownEffect)
+  const decodeHeaders = UndefinedOr.map(endpoint.headers, Schema.decodeUnknownEffect)
+  const decodeQuery = UndefinedOr.map(endpoint.query, Schema.decodeUnknownEffect)
 
-  const shouldParsePayload = endpoint.payload.size > 0 && !handler.isRaw
+  const shouldParsePayload = endpoint.payload.size > 0 && !isRaw
   const payloadBy = shouldParsePayload ? buildPayloadDecoders(endpoint.payload) : undefined
 
-  const effect = applyMiddleware(
+  return applyMiddleware(
     group,
     endpoint,
     services,
@@ -545,10 +593,11 @@ function handlerToRoute(
           request.payload = yield* result
         }
       }
-      const response = yield* handler.handler(request)
+      const response = yield* handler(request)
       return Response.isHttpServerResponse(response) ? response : yield* encodeSuccess(response)
     })
   ).pipe(
+    Effect.withErrorReporting,
     Effect.catch((error) => {
       if (Schema.isSchemaError(error)) {
         error = HttpApiSchemaError.fromSchemaError(error)
@@ -557,11 +606,18 @@ function handlerToRoute(
     }),
     Effect.provideServices(services)
   )
+}
 
+function handlerToRoute(
+  group: HttpApiGroup.AnyWithProps,
+  handler: Handlers.Item<any>,
+  services: ServiceMap.ServiceMap<any>
+): HttpRouter.Route<any, any> {
+  const endpoint = handler.endpoint
   return HttpRouter.route(
     endpoint.method,
     endpoint.path as HttpRouter.PathInput,
-    effect,
+    handlerToHttpEffect(group, endpoint, services, handler.handler, handler.isRaw),
     { uninterruptible: handler.uninterruptible }
   )
 }
@@ -585,7 +641,7 @@ const applyMiddleware = <A extends Effect.Effect<any, any, any>>(
 ) => {
   const options = { group, endpoint }
   for (const key_ of endpoint.middlewares) {
-    const key = key_ as any as HttpApiMiddleware.AnyKey
+    const key = key_ as any as HttpApiMiddleware.AnyService
     const service = services.mapUnsafe.get(key_.key) as HttpApiMiddleware.HttpApiMiddleware<any, any, any>
     const apply = HttpApiMiddleware.isSecurity(key)
       ? makeSecurityMiddleware(key, service as any)
@@ -601,7 +657,7 @@ const securityMiddlewareCache = new WeakMap<
 >()
 
 const makeSecurityMiddleware = (
-  key: HttpApiMiddleware.AnyKeySecurity,
+  key: HttpApiMiddleware.AnyServiceSecurity,
   service: HttpApiMiddleware.HttpApiMiddlewareSecurity<any, any, any, any>
 ): (effect: Effect.Effect<any, any, any>, options: any) => Effect.Effect<any, any, any> => {
   if (securityMiddlewareCache.has(key)) {

package/src/unstable/httpapi/HttpApiClient.ts

@@ -32,7 +32,7 @@ import * as HttpApiSchema from "./HttpApiSchema.ts"
  * @since 4.0.0
  * @category models
  */
-export type Client<Groups extends HttpApiGroup.Any, E, R> = Simplify<
+export type Client<Groups extends HttpApiGroup.Any, E = HttpApiSchemaError, R = never> = Simplify<
   & {
     readonly [Group in Extract<Groups, { readonly topLevel: false }> as HttpApiGroup.Name<Group>]: Client.Group<
       Group,
@@ -46,6 +46,14 @@ export type Client<Groups extends HttpApiGroup.Any, E, R> = Simplify<
   }
 >
 
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export type ForApi<Api extends HttpApi.Any, E = HttpApiSchemaError, R = never> = Api extends
+  HttpApi.HttpApi<infer _Id, infer Groups> ? Client<Groups, E, R> :
+  never
+
 /**
  * @since 4.0.0
  * @category models
@@ -128,7 +136,7 @@ const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>
       readonly group: HttpApiGroup.AnyWithProps
       readonly endpoint: HttpApiEndpoint.AnyWithProps
       readonly mergedAnnotations: ServiceMap.ServiceMap<never>
-      readonly middleware: ReadonlySet<HttpApiMiddleware.AnyKey>
+      readonly middleware: ReadonlySet<HttpApiMiddleware.AnyService>
       readonly successes: ReadonlyMap<number, readonly [Schema.Top, ...Array<Schema.Top>]>
       readonly errors: ReadonlyMap<number, readonly [Schema.Top, ...Array<Schema.Top>]>
       readonly endpointFn: Function
@@ -217,7 +225,7 @@ const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>
         })
 
         // encoders
-        const encodeParams = UndefinedOr.map(HttpApiEndpoint.getParamsSchema(endpoint), Schema.encodeUnknownEffect)
+        const encodeParams = UndefinedOr.map(endpoint.params, Schema.encodeUnknownEffect)
 
         const payloadSchemas = HttpApiEndpoint.getPayloadSchemas(endpoint)
         const encodePayload = Arr.isArrayNonEmpty(payloadSchemas) ?
@@ -226,8 +234,8 @@ const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>
             : Schema.encodeUnknownEffect(Schema.Union(payloadSchemas)) :
           undefined
 
-        const encodeHeaders = UndefinedOr.map(HttpApiEndpoint.getHeadersSchema(endpoint), Schema.encodeUnknownEffect)
-        const encodeQuery = UndefinedOr.map(HttpApiEndpoint.getQuerySchema(endpoint), Schema.encodeUnknownEffect)
+        const encodeHeaders = UndefinedOr.map(endpoint.headers, Schema.encodeUnknownEffect)
+        const encodeQuery = UndefinedOr.map(endpoint.query, Schema.encodeUnknownEffect)
 
         const middlewareKeys = Array.from(onEndpointOptions.middleware, (tag) => `${tag.key}/Client`)
 
@@ -314,7 +322,7 @@ export const make = <ApiId extends string, Groups extends HttpApiGroup.Any>(
     readonly baseUrl?: URL | string | undefined
   }
 ): Effect.Effect<
-  Client<Groups, HttpApiSchemaError, never>,
+  Client<Groups>,
   never,
   HttpClient.HttpClient | HttpApiGroup.MiddlewareClient<Groups>
 > =>