effect 4.0.0-beta.6 → 4.0.0-beta.62

package/src/unstable/httpapi/HttpApiError.ts

@@ -1,27 +1,27 @@
 /**
  * @since 4.0.0
  */
+import * as Data from "../../Data.ts"
+import * as Effect from "../../Effect.ts"
+import * as ErrorReporter from "../../ErrorReporter.ts"
+import { hasProperty } from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
+import * as HttpServerRespondable from "../http/HttpServerRespondable.ts"
+import * as HttpServerResponse from "../http/HttpServerResponse.ts"
 import * as HttpApiSchema from "./HttpApiSchema.ts"
 
-/**
- * @category errors
- * @since 4.0.0
- */
-export class HttpApiSchemaError extends Schema.ErrorClass<HttpApiSchemaError>("effect/HttpApiSchemaError")({
-  _tag: Schema.tag("HttpApiSchemaError"),
-  message: Schema.String
-}, {
-  httpApiStatus: 400,
-  description: "The request or response did not match the expected schema"
-}) {
-  /**
-   * @since 4.0.0
-   */
-  static fromSchemaError(error: Schema.SchemaError): HttpApiSchemaError {
-    return new HttpApiSchemaError({ message: error.message })
-  }
-}
+const badRequestResponse = HttpServerResponse.empty({ status: 400 })
+const unauthorizedResponse = HttpServerResponse.empty({ status: 401 })
+const forbiddenResponse = HttpServerResponse.empty({ status: 403 })
+const notFoundResponse = HttpServerResponse.empty({ status: 404 })
+const methodNotAllowedResponse = HttpServerResponse.empty({ status: 405 })
+const notAcceptableResponse = HttpServerResponse.empty({ status: 406 })
+const requestTimeoutResponse = HttpServerResponse.empty({ status: 408 })
+const conflictResponse = HttpServerResponse.empty({ status: 409 })
+const goneResponse = HttpServerResponse.empty({ status: 410 })
+const internalServerErrorResponse = HttpServerResponse.empty({ status: 500 })
+const notImplementedResponse = HttpServerResponse.empty({ status: 501 })
+const serviceUnavailableResponse = HttpServerResponse.empty({ status: 503 })
 
 /**
  * @category Built-in errors
@@ -32,7 +32,13 @@ export class BadRequest extends Schema.ErrorClass<BadRequest>("effect/HttpApiErr
 }, {
   description: "BadRequest",
   httpApiStatus: 400
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(badRequestResponse)
+  }
+  static readonly singleton = new BadRequest()
+}
 
 /**
  * @category NoContent errors
@@ -51,7 +57,12 @@ export class Unauthorized extends Schema.ErrorClass<Unauthorized>("effect/HttpAp
 }, {
   description: "Unauthorized",
   httpApiStatus: 401
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(unauthorizedResponse)
+  }
+}
 
 /**
  * @category NoContent errors
@@ -70,7 +81,12 @@ export class Forbidden extends Schema.ErrorClass<Forbidden>("effect/HttpApiError
 }, {
   description: "Forbidden",
   httpApiStatus: 403
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(forbiddenResponse)
+  }
+}
 
 /**
  * @category NoContent errors
@@ -89,7 +105,12 @@ export class NotFound extends Schema.ErrorClass<NotFound>("effect/HttpApiError/N
 }, {
   description: "NotFound",
   httpApiStatus: 404
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(notFoundResponse)
+  }
+}
 
 /**
  * @category NoContent errors
@@ -108,7 +129,12 @@ export class MethodNotAllowed extends Schema.ErrorClass<MethodNotAllowed>("effec
 }, {
   description: "MethodNotAllowed",
   httpApiStatus: 405
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(methodNotAllowedResponse)
+  }
+}
 
 /**
  * @category NoContent errors
@@ -127,7 +153,12 @@ export class NotAcceptable extends Schema.ErrorClass<NotAcceptable>("effect/Http
 }, {
   description: "NotAcceptable",
   httpApiStatus: 406
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(notAcceptableResponse)
+  }
+}
 
 /**
  * @category NoContent errors
@@ -146,7 +177,12 @@ export class RequestTimeout extends Schema.ErrorClass<RequestTimeout>("effect/Ht
 }, {
   description: "RequestTimeout",
   httpApiStatus: 408
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(requestTimeoutResponse)
+  }
+}
 
 /**
  * @category NoContent errors
@@ -165,7 +201,12 @@ export class Conflict extends Schema.ErrorClass<Conflict>("effect/HttpApiError/C
 }, {
   description: "Conflict",
   httpApiStatus: 409
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(conflictResponse)
+  }
+}
 
 /**
  * @since 4.0.0
@@ -184,7 +225,12 @@ export class Gone extends Schema.ErrorClass<Gone>("effect/HttpApiError/Gone")({
 }, {
   description: "Gone",
   httpApiStatus: 410
-}) {}
+}) {
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(goneResponse)
+  }
+}
 
 /**
  * @category NoContent errors
@@ -205,7 +251,11 @@ export class InternalServerError
     description: "InternalServerError",
     httpApiStatus: 500
   })
-{}
+{
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(internalServerErrorResponse)
+  }
+}
 
 /**
  * @category NoContent errors
@@ -224,7 +274,11 @@ export class NotImplemented extends Schema.ErrorClass<NotImplemented>("effect/Ht
 }, {
   description: "NotImplemented",
   httpApiStatus: 501
-}) {}
+}) {
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(notImplementedResponse)
+  }
+}
 
 /**
  * @category NoContent errors
@@ -245,7 +299,11 @@ export class ServiceUnavailable
     description: "ServiceUnavailable",
     httpApiStatus: 503
   })
-{}
+{
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(serviceUnavailableResponse)
+  }
+}
 
 /**
  * @category NoContent errors
@@ -254,3 +312,44 @@ export class ServiceUnavailable
 export const ServiceUnavailableNoContent = ServiceUnavailable.pipe(HttpApiSchema.asNoContent({
   decode: () => new ServiceUnavailable({})
 }))
+
+/**
+ * @category Parsing errors
+ * @since 4.0.0
+ */
+export type HttpApiSchemaErrorTypeId = "~effect/httpapi/HttpApiError/HttpApiSchemaError"
+
+/**
+ * @category Parsing errors
+ * @since 4.0.0
+ */
+export const HttpApiSchemaErrorTypeId: HttpApiSchemaErrorTypeId = "~effect/httpapi/HttpApiError/HttpApiSchemaError"
+
+/**
+ * @category Parsing errors
+ * @since 4.0.0
+ */
+export class HttpApiSchemaError extends Data.TaggedClass("HttpApiSchemaError")<{
+  readonly kind: "Params" | "Headers" | "Query" | "Body" | "Payload"
+  readonly cause: Schema.SchemaError
+}> {
+  readonly [HttpApiSchemaErrorTypeId]: HttpApiSchemaErrorTypeId = HttpApiSchemaErrorTypeId
+
+  static is(u: unknown): u is HttpApiSchemaError {
+    return hasProperty(u, HttpApiSchemaErrorTypeId)
+  }
+
+  static wrap<A, R>(
+    kind: HttpApiSchemaError["kind"],
+    effect: Effect.Effect<A, Schema.SchemaError, R>
+  ): Effect.Effect<A, HttpApiSchemaError, R> {
+    return Effect.mapError(effect, (error) => new HttpApiSchemaError({ kind, cause: error }))
+  }
+
+  readonly name = "HttpApiSchemaError"
+  readonly message = this.kind;
+
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(badRequestResponse)
+  }
+}

package/src/unstable/httpapi/HttpApiGroup.ts

@@ -2,10 +2,10 @@
  * @since 4.0.0
  */
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
+import * as Context from "../../Context.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Record from "../../Record.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type { PathInput } from "../http/HttpRouter.ts"
 import type * as HttpApiEndpoint from "./HttpApiEndpoint.ts"
 import type * as HttpApiMiddleware from "./HttpApiMiddleware.ts"
@@ -38,7 +38,7 @@ export interface HttpApiGroup<
   readonly key: string
   readonly topLevel: TopLevel
   readonly endpoints: Record.ReadonlyRecord<string, Endpoints>
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
 
   /**
    * Add an `HttpApiEndpoint` to an `HttpApiGroup`.
@@ -61,7 +61,7 @@ export interface HttpApiGroup<
    * Endpoints added after this api is called **will not** have the middleware
    * applied.
    */
-  middleware<I extends HttpApiMiddleware.AnyId, S>(middleware: ServiceMap.Service<I, S>): HttpApiGroup<
+  middleware<I extends HttpApiMiddleware.AnyId, S>(middleware: Context.Key<I, S>): HttpApiGroup<
     Id,
     HttpApiEndpoint.AddMiddleware<Endpoints, I>,
     TopLevel
@@ -70,20 +70,20 @@ export interface HttpApiGroup<
   /**
    * Merge the annotations of an `HttpApiGroup` with the provided annotations.
    */
-  annotateMerge<I>(annotations: ServiceMap.ServiceMap<I>): HttpApiGroup<Id, Endpoints, TopLevel>
+  annotateMerge<I>(annotations: Context.Context<I>): HttpApiGroup<Id, Endpoints, TopLevel>
 
   /**
    * Add an annotation to an `HttpApiGroup`.
    */
-  annotate<I, S>(key: ServiceMap.Service<I, S>, value: S): HttpApiGroup<Id, Endpoints, TopLevel>
+  annotate<I, S>(key: Context.Key<I, S>, value: S): HttpApiGroup<Id, Endpoints, TopLevel>
 
   /**
    * For each endpoint in an `HttpApiGroup`, update the annotations with a new
-   * ServiceMap.
+   * Context.
    *
    * Note that this will only update the annotations before this api is called.
    */
-  annotateEndpointsMerge<I>(annotations: ServiceMap.ServiceMap<I>): HttpApiGroup<Id, Endpoints, TopLevel>
+  annotateEndpointsMerge<I>(annotations: Context.Context<I>): HttpApiGroup<Id, Endpoints, TopLevel>
 
   /**
    * For each endpoint in an `HttpApiGroup`, add an annotation.
@@ -91,7 +91,7 @@ export interface HttpApiGroup<
    * Note that this will only add the annotation to the endpoints before this api
    * is called.
    */
-  annotateEndpoints<I, S>(key: ServiceMap.Service<I, S>, value: S): HttpApiGroup<Id, Endpoints, TopLevel>
+  annotateEndpoints<I, S>(key: Context.Key<I, S>, value: S): HttpApiGroup<Id, Endpoints, TopLevel>
 }
 
 /**
@@ -112,6 +112,7 @@ export interface Any {
   readonly [TypeId]: typeof TypeId
   readonly identifier: string
   readonly key: string
+  readonly endpoints: Record.ReadonlyRecord<string, HttpApiEndpoint.Any>
 }
 
 /**
@@ -238,7 +239,7 @@ const Proto = {
       annotations: this.annotations
     })
   },
-  middleware(this: AnyWithProps, middleware: HttpApiMiddleware.AnyKey) {
+  middleware(this: AnyWithProps, middleware: HttpApiMiddleware.AnyService) {
     return makeProto({
       identifier: this.identifier,
       topLevel: this.topLevel,
@@ -246,23 +247,23 @@ const Proto = {
       annotations: this.annotations
     })
   },
-  annotateMerge<I>(this: AnyWithProps, annotations: ServiceMap.ServiceMap<I>) {
+  annotateMerge<I>(this: AnyWithProps, annotations: Context.Context<I>) {
     return makeProto({
       identifier: this.identifier,
       topLevel: this.topLevel,
       endpoints: this.endpoints,
-      annotations: ServiceMap.merge(this.annotations, annotations)
+      annotations: Context.merge(this.annotations, annotations)
     })
   },
-  annotate<I, S>(this: AnyWithProps, annotation: ServiceMap.Service<I, S>, value: S) {
+  annotate<I, S>(this: AnyWithProps, annotation: Context.Key<I, S>, value: S) {
     return makeProto({
       identifier: this.identifier,
       topLevel: this.topLevel,
       endpoints: this.endpoints,
-      annotations: ServiceMap.add(this.annotations, annotation, value)
+      annotations: Context.add(this.annotations, annotation, value)
     })
   },
-  annotateEndpointsMerge<I>(this: AnyWithProps, annotations: ServiceMap.ServiceMap<I>) {
+  annotateEndpointsMerge<I>(this: AnyWithProps, annotations: Context.Context<I>) {
     return makeProto({
       identifier: this.identifier,
       topLevel: this.topLevel,
@@ -270,7 +271,7 @@ const Proto = {
       annotations: this.annotations
     })
   },
-  annotateEndpoints<I, S>(this: AnyWithProps, annotation: ServiceMap.Service<I, S>, value: S) {
+  annotateEndpoints<I, S>(this: AnyWithProps, annotation: Context.Key<I, S>, value: S) {
     return makeProto({
       identifier: this.identifier,
       topLevel: this.topLevel,
@@ -291,7 +292,7 @@ const makeProto = <
   readonly identifier: Id
   readonly topLevel: TopLevel
   readonly endpoints: Record.ReadonlyRecord<string, Endpoints>
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
 }): HttpApiGroup<Id, Endpoints, TopLevel> => {
   function HttpApiGroup() {}
   Object.setPrototypeOf(HttpApiGroup, Proto)
@@ -315,5 +316,5 @@ export const make = <const Id extends string, const TopLevel extends boolean = f
     identifier,
     topLevel: options?.topLevel ?? false as any,
     endpoints: Record.empty(),
-    annotations: ServiceMap.empty()
+    annotations: Context.empty()
   }) as any

package/src/unstable/httpapi/HttpApiMiddleware.ts

@@ -1,12 +1,12 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
 import { hasProperty } from "../../Predicate.ts"
 import type * as Schema from "../../Schema.ts"
 import { Scope } from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type { unhandled } from "../../Types.ts"
 import type * as HttpClientError from "../http/HttpClientError.ts"
 import type * as HttpClientRequest from "../http/HttpClientRequest.ts"
@@ -14,6 +14,7 @@ import type * as HttpClientResponse from "../http/HttpClientResponse.ts"
 import type * as HttpRouter from "../http/HttpRouter.ts"
 import type { HttpServerResponse } from "../http/HttpServerResponse.ts"
 import type * as HttpApiEndpoint from "./HttpApiEndpoint.ts"
+import { HttpApiSchemaError } from "./HttpApiError.ts"
 import type * as HttpApiGroup from "./HttpApiGroup.ts"
 import type * as HttpApiSecurity from "./HttpApiSecurity.ts"
 
@@ -25,19 +26,25 @@ const SecurityTypeId = "~effect/httpapi/HttpApiMiddleware/Security"
  * @since 4.0.0
  * @category guards
  */
-export const isSecurity = (u: AnyKey): u is AnyKeySecurity => hasProperty(u, SecurityTypeId)
+export const isSecurity = (u: AnyService): u is AnyServiceSecurity => hasProperty(u, SecurityTypeId)
+
+type ErrorConstraint = Schema.Top | ReadonlyArray<Schema.Top>
+
+type ErrorSchemaFromConstraint<E> = E extends ReadonlyArray<Schema.Top> ? E[number]
+  : E extends Schema.Top ? E
+  : never
 
 /**
  * @since 4.0.0
  * @category models
  */
-export type HttpApiMiddleware<Provides, E extends Schema.Top, Requires> = (
+export type HttpApiMiddleware<Provides, E extends ErrorConstraint, Requires> = (
   httpEffect: Effect.Effect<HttpServerResponse, unhandled, Provides>,
   options: {
     readonly endpoint: HttpApiEndpoint.AnyWithProps
     readonly group: HttpApiGroup.AnyWithProps
   }
-) => Effect.Effect<HttpServerResponse, unhandled | E["Type"], Requires | HttpRouter.Provided>
+) => Effect.Effect<HttpServerResponse, unhandled | ErrorSchemaFromConstraint<E>["Type"], Requires | HttpRouter.Provided>
 
 /**
  * @since 4.0.0
@@ -46,7 +53,7 @@ export type HttpApiMiddleware<Provides, E extends Schema.Top, Requires> = (
 export type HttpApiMiddlewareSecurity<
   Security extends Record<string, HttpApiSecurity.HttpApiSecurity>,
   Provides,
-  E extends Schema.Top,
+  E extends ErrorConstraint,
   Requires
 > = {
   readonly [K in keyof Security]: (
@@ -56,7 +63,11 @@ export type HttpApiMiddlewareSecurity<
       readonly endpoint: HttpApiEndpoint.AnyWithProps
       readonly group: HttpApiGroup.AnyWithProps
     }
-  ) => Effect.Effect<HttpServerResponse, unhandled | E["Type"], Requires | HttpRouter.Provided>
+  ) => Effect.Effect<
+    HttpServerResponse,
+    unhandled | ErrorSchemaFromConstraint<E>["Type"],
+    Requires | HttpRouter.Provided
+  >
 }
 
 /**
@@ -87,10 +98,10 @@ export interface ForClient<Id> {
  * @since 4.0.0
  * @category models
  */
-export interface AnyKey extends ServiceMap.Service<any, any> {
+export interface AnyService extends Context.Key<any, any> {
   readonly [TypeId]: typeof TypeId
   readonly provides: any
-  readonly error: Schema.Top
+  readonly error: ReadonlySet<Schema.Top>
   readonly requiredForClient: boolean
   readonly "~ClientError": any
 }
@@ -99,7 +110,7 @@ export interface AnyKey extends ServiceMap.Service<any, any> {
  * @since 4.0.0
  * @category models
  */
-export interface AnyKeySecurity extends AnyKey {
+export interface AnyServiceSecurity extends AnyService {
   readonly [SecurityTypeId]: typeof SecurityTypeId
   readonly security: Record<string, HttpApiSecurity.HttpApiSecurity>
 }
@@ -112,7 +123,7 @@ export interface AnyId {
   readonly [TypeId]: {
     readonly provides: any
     readonly requires: any
-    readonly error: Schema.Top
+    readonly error: ErrorConstraint
     readonly clientError: any
     readonly requiredForClient: boolean
   }
@@ -140,8 +151,7 @@ export type ApplyServices<A extends AnyId, R> = Exclude<R, Provides<A>> | Requir
  * @since 4.0.0
  * @category models
  */
-export type ErrorSchema<A> = A extends { readonly [TypeId]: { readonly error: infer E } }
-  ? E extends Schema.Top ? E : never
+export type ErrorSchema<A> = A extends { readonly [TypeId]: { readonly error: infer E } } ? ErrorSchemaFromConstraint<E>
   : never
 
 /**
@@ -195,7 +205,7 @@ export type ServiceClass<
   Config extends {
     requires: any
     provides: any
-    error: Schema.Top
+    error: ErrorConstraint
     clientError: any
     requiredForClient: boolean
     security: Record<string, HttpApiSecurity.HttpApiSecurity>
@@ -204,9 +214,9 @@ export type ServiceClass<
     ([Config["security"]] extends [never] ? HttpApiMiddleware<Config["provides"], Config["error"], Config["requires"]>
       : HttpApiMiddlewareSecurity<Config["security"], Config["provides"], Config["error"], Config["requires"]>)
 > =
-  & ServiceMap.Service<Self, Service>
+  & Context.Service<Self, Service>
   & {
-    new(_: never): ServiceMap.ServiceClass.Shape<Id, Service> & {
+    new(_: never): Context.ServiceClass.Shape<Id, Service> & {
       readonly [TypeId]: {
         readonly error: Config["error"]
         readonly requires: Config["requires"]
@@ -216,7 +226,7 @@ export type ServiceClass<
       }
     }
     readonly [TypeId]: typeof TypeId
-    readonly error: Config["error"]
+    readonly error: ReadonlySet<Schema.Top>
     readonly requiredForClient: Config["requiredForClient"]
     readonly "~ClientError": Config["clientError"]
   }
@@ -238,7 +248,7 @@ export const Service = <
   } = { requires: never; provides: never; clientError: never }
 >(): <
   const Id extends string,
-  Error extends Schema.Top = never,
+  const Error extends ErrorConstraint = never,
   const Security extends Record<string, HttpApiSecurity.HttpApiSecurity> = never,
   RequiredForClient extends boolean = false
 >(
@@ -260,7 +270,7 @@ export const Service = <
   id: string,
   options?: {
     readonly security?: Record<string, HttpApiSecurity.HttpApiSecurity> | undefined
-    readonly error?: Schema.Top | undefined
+    readonly error?: ErrorConstraint | undefined
     readonly requiredForClient?: boolean | undefined
   } | undefined
 ) => {
@@ -270,7 +280,8 @@ export const Service = <
   const creationError = new Err()
   Err.stackTraceLimit = limit
 
-  class Service extends ServiceMap.Service<Self, any>()(id) {}
+  /** @effect-diagnostics-next-line classSelfMismatch:off */
+  class Service extends Context.Service<Self, any>()(id) {}
   const self = Service as any
   Object.defineProperty(Service, "stack", {
     get() {
@@ -278,10 +289,8 @@ export const Service = <
     }
   })
   self[TypeId] = TypeId
+  self.error = getError(options?.error)
   self.requiredForClient = options?.requiredForClient ?? false
-  if (options?.error !== undefined) {
-    self.error = options.error
-  }
   if (options?.security !== undefined) {
     if (Object.keys(options.security).length === 0) {
       throw new Error("HttpApiMiddleware.Service: security object must not be empty")
@@ -292,32 +301,86 @@ export const Service = <
   return self
 }
 
+function getError(error: ErrorConstraint | undefined): ReadonlySet<Schema.Top> {
+  if (error === undefined) return new Set()
+  return new Set(Array.isArray(error) ? error : [error])
+}
+
+/**
+ * Implement a middleware Layer that transforms `SchemaError`'s.
+ *
+ * ```ts
+ * import { Effect, Schema } from "effect"
+ * import { HttpApiMiddleware } from "effect/unstable/httpapi"
+ *
+ * export class CustomError extends Schema.TaggedErrorClass<CustomError>()("CustomError", {}) {}
+ *
+ * export class ErrorHandler extends HttpApiMiddleware.Service<ErrorHandler>()("api/ErrorHandler", {
+ *   error: CustomError
+ * }) {}
+ *
+ * export const ErrorHandlerLayer = HttpApiMiddleware.layerSchemaErrorTransform(
+ *   ErrorHandler,
+ *   (schemaError) =>
+ *     Effect.log("Got SchemaError", schemaError).pipe(
+ *       Effect.andThen(Effect.fail(new CustomError()))
+ *     )
+ * )
+ * ```
+ *
+ * @since 4.0.0
+ * @category SchemaError transform
+ */
+export const layerSchemaErrorTransform = <Id, E extends ErrorConstraint, Requires>(
+  service: Context.Service<Id, HttpApiMiddleware<never, E, Requires>>,
+  transform: (
+    error: HttpApiSchemaError,
+    context: { readonly endpoint: HttpApiEndpoint.AnyWithProps; readonly group: HttpApiGroup.AnyWithProps }
+  ) => Effect.Effect<
+    HttpServerResponse,
+    ErrorSchemaFromConstraint<E>["Type"] | HttpApiSchemaError,
+    Requires | HttpRouter.Provided
+  >
+): Layer.Layer<Id> =>
+  Layer.succeed(
+    service,
+    (httpEffect, options) =>
+      Effect.catch(
+        httpEffect,
+        (e): Effect.Effect<
+          HttpServerResponse,
+          unhandled | HttpApiSchemaError | ErrorSchemaFromConstraint<E>["Type"],
+          Requires | HttpRouter.Provided
+        > => HttpApiSchemaError.is(e) ? transform(e, options) : Effect.fail(e)
+      )
+  )
+
 /**
  * @since 4.0.0
  * @category client
  */
 export const layerClient = <Id extends AnyId, S, R, EX = never, RX = never>(
-  tag: ServiceMap.Service<Id, S>,
+  tag: Context.Key<Id, S>,
   service:
-    | HttpApiMiddlewareClient<Id[typeof TypeId]["error"]["Type"], Id[typeof TypeId]["clientError"], R>
+    | HttpApiMiddlewareClient<Error<Id>, Id[typeof TypeId]["clientError"], R>
     | Effect.Effect<
-      HttpApiMiddlewareClient<Id[typeof TypeId]["error"]["Type"], Id[typeof TypeId]["clientError"], R>,
+      HttpApiMiddlewareClient<Error<Id>, Id[typeof TypeId]["clientError"], R>,
       EX,
       RX
     >
 ): Layer.Layer<ForClient<Id>, EX, R | Exclude<RX, Scope>> =>
-  Layer.effectServices(Effect.gen(function*() {
-    const services = (yield* Effect.services<R | Scope>()).pipe(
-      ServiceMap.omit(Scope)
-    ) as ServiceMap.ServiceMap<R>
+  Layer.effectContext(Effect.gen(function*() {
+    const services = (yield* Effect.context<R | Scope>()).pipe(
+      Context.omit(Scope)
+    ) as Context.Context<R>
     const middleware = Effect.isEffect(service) ? yield* service : service
-    return ServiceMap.makeUnsafe(
+    return Context.makeUnsafe(
       new Map([[
         `${tag.key}/Client`,
         (options: any) =>
-          Effect.updateServices(
+          Effect.updateContext(
             middleware(options),
-            (requestContext) => ServiceMap.merge(services, requestContext)
+            (requestContext) => Context.merge(services, requestContext)
           )
       ]])
     )