@effect/platform 0.68.6 → 0.69.1

package/dist/esm/HttpApiBuilder.js

@@ -1,9 +1,6 @@
 /**
  * @since 1.0.0
  */
-import * as AST from "@effect/schema/AST";
-import * as ParseResult from "@effect/schema/ParseResult";
-import * as Schema from "@effect/schema/Schema";
 import * as Chunk from "effect/Chunk";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
@@ -11,14 +8,19 @@ import * as Encoding from "effect/Encoding";
 import * as FiberRef from "effect/FiberRef";
 import { identity } from "effect/Function";
 import { globalValue } from "effect/GlobalValue";
+import * as HashMap from "effect/HashMap";
+import * as HashSet from "effect/HashSet";
 import * as Layer from "effect/Layer";
+import * as ManagedRuntime from "effect/ManagedRuntime";
 import * as Option from "effect/Option";
+import * as ParseResult from "effect/ParseResult";
 import { pipeArguments } from "effect/Pipeable";
 import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
 import { unify } from "effect/Unify";
 import * as HttpApi from "./HttpApi.js";
-import * as HttpApiEndpoint from "./HttpApiEndpoint.js";
 import { HttpApiDecodeError } from "./HttpApiError.js";
+import * as HttpApiMiddleware from "./HttpApiMiddleware.js";
 import * as HttpApiSchema from "./HttpApiSchema.js";
 import * as HttpApp from "./HttpApp.js";
 import * as HttpMethod from "./HttpMethod.js";
@@ -35,6 +37,16 @@ import * as OpenApi from "./OpenApi.js";
  * @category router
  */
 export class Router extends /*#__PURE__*/HttpRouter.Tag("@effect/platform/HttpApiBuilder/Router")() {}
+/**
+ * Create a top-level `HttpApi` layer.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export const api = api => Layer.effect(HttpApi.Api, Effect.map(Effect.context(), context => ({
+  api: api,
+  context
+})));
 /**
  * Build an `HttpApp` from an `HttpApi` instance, and serve it using an
  * `HttpServer`.
@@ -45,7 +57,7 @@ export class Router extends /*#__PURE__*/HttpRouter.Tag("@effect/platform/HttpAp
  * @since 1.0.0
  * @category constructors
  */
-export const serve = middleware => httpApp.pipe(Effect.map(HttpServer.serve(middleware)), Layer.unwrapEffect, Layer.provide(Router.Live));
+export const serve = middleware => httpApp.pipe(Effect.map(app => HttpServer.serve(app, middleware)), Layer.unwrapEffect, Layer.provide(Router.Live));
 /**
  * Construct an `HttpApp` from an `HttpApi` instance.
  *
@@ -53,12 +65,16 @@ export const serve = middleware => httpApp.pipe(Effect.map(HttpServer.serve(midd
  * @category constructors
  */
 export const httpApp = /*#__PURE__*/Effect.gen(function* () {
-  const api = yield* HttpApi.HttpApi;
-  const router = yield* Router.router;
+  const {
+    api,
+    context
+  } = yield* HttpApi.Api;
+  const middleware = makeMiddlewareMap(api.middlewares, context);
+  const router = applyMiddleware(middleware, yield* Router.router);
   const apiMiddleware = yield* Effect.serviceOption(Middleware);
   const errorSchema = makeErrorSchema(api);
   const encodeError = Schema.encodeUnknown(errorSchema);
-  return router.pipe(apiMiddleware._tag === "Some" ? apiMiddleware.value : identity, Effect.catchAll(error => Effect.matchEffect(encodeError(error), {
+  return router.pipe(apiMiddleware._tag === "Some" ? apiMiddleware.value : identity, Effect.catchAll(error => Effect.matchEffect(Effect.provide(encodeError(error), context), {
     onFailure: () => Effect.die(error),
     onSuccess: Effect.succeed
   })));
@@ -69,45 +85,42 @@ export const httpApp = /*#__PURE__*/Effect.gen(function* () {
  * @since 1.0.0
  * @category constructors
  * @example
- * import { HttpApi } from "@effect/platform"
- * import { Etag, HttpApiBuilder, HttpMiddleware, HttpPlatform } from "@effect/platform"
- * import { NodeContext } from "@effect/platform-node"
- * import { Layer, ManagedRuntime } from "effect"
+ * import { HttpApi, HttpApiBuilder, HttpServer } from "@effect/platform"
+ * import { Layer } from "effect"
+ *
+ * class MyApi extends HttpApi.empty {}
  *
- * const ApiLive = HttpApiBuilder.api(HttpApi.empty)
+ * const MyApiLive = HttpApiBuilder.api(MyApi)
  *
- * const runtime = ManagedRuntime.make(
+ * const { dispose, handler } = HttpApiBuilder.toWebHandler(
  *   Layer.mergeAll(
- *     ApiLive,
- *     HttpApiBuilder.Router.Live,
- *     HttpPlatform.layer,
- *     Etag.layerWeak
- *   ).pipe(
- *     Layer.provideMerge(NodeContext.layer)
+ *     MyApiLive,
+ *     // you could also use NodeHttpServer.layerContext, depending on your
+ *     // server's platform
+ *     HttpServer.layerContext
  *   )
  * )
- *
- * const handler = HttpApiBuilder.toWebHandler(runtime, HttpMiddleware.logger)
  */
-export const toWebHandler = (runtime, middleware) => {
+export const toWebHandler = (layer, options) => {
+  const runtime = ManagedRuntime.make(Layer.merge(layer, Router.Live), options?.memoMap);
+  let handlerCached;
   const handlerPromise = httpApp.pipe(Effect.bindTo("httpApp"), Effect.bind("runtime", () => runtime.runtimeEffect), Effect.map(({
     httpApp,
     runtime
-  }) => HttpApp.toWebHandlerRuntime(runtime)(middleware ? middleware(httpApp) : httpApp)), runtime.runPromise);
-  return request => handlerPromise.then(handler => handler(request));
+  }) => HttpApp.toWebHandlerRuntime(runtime)(options?.middleware ? options.middleware(httpApp) : httpApp)), Effect.tap(handler => {
+    handlerCached = handler;
+  }), runtime.runPromise);
+  function handler(request) {
+    if (handlerCached !== undefined) {
+      return handlerCached(request);
+    }
+    return handlerPromise.then(handler => handler(request));
+  }
+  return {
+    handler,
+    dispose: runtime.dispose
+  };
 };
-/**
- * Build a root level `Layer` from an `HttpApi` instance.
- *
- * The `Layer` will provide the `HttpApi` service, and will require the
- * implementation for all the `HttpApiGroup`'s contained in the `HttpApi`.
- *
- * The resulting `Layer` can be provided to the `HttpApiBuilder.serve` layer.
- *
- * @since 1.0.0
- * @category constructors
- */
-export const api = self => Layer.succeed(HttpApi.HttpApi, self);
 /**
  * @since 1.0.0
  * @category handlers
@@ -119,6 +132,28 @@ const HandlersProto = {
   },
   pipe() {
     return pipeArguments(this, arguments);
+  },
+  handle(name, handler) {
+    const endpoint = HashMap.unsafeGet(this.group.endpoints, name);
+    return makeHandlers({
+      group: this.group,
+      handlers: Chunk.append(this.handlers, {
+        endpoint,
+        handler,
+        withFullResponse: false
+      })
+    });
+  },
+  handleRaw(name, handler) {
+    const endpoint = HashMap.unsafeGet(this.group.endpoints, name);
+    return makeHandlers({
+      group: this.group,
+      handlers: Chunk.append(this.handlers, {
+        endpoint,
+        handler,
+        withFullResponse: true
+      })
+    });
   }
 };
 const makeHandlers = options => {
@@ -128,81 +163,186 @@ const makeHandlers = options => {
   return self;
 };
 /**
- * Create a `Layer` that will implement all the endpoints in an `HttpApiGroup`.
+ * Create a `Layer` that will implement all the endpoints in an `HttpApi`.
  *
  * An unimplemented `Handlers` instance is passed to the `build` function, which
  * you can use to add handlers to the group.
  *
- * You can implement endpoints using the `HttpApiBuilder.handle` api.
+ * You can implement endpoints using the `handlers.handle` api.
  *
  * @since 1.0.0
  * @category handlers
  */
 export const group = (api, groupName, build) => Router.use(router => Effect.gen(function* () {
   const context = yield* Effect.context();
-  const group = Chunk.findFirst(api.groups, group => group.identifier === groupName);
-  if (group._tag === "None") {
-    throw new Error(`Group "${groupName}" not found in API`);
-  }
+  const group = HashMap.unsafeGet(api.groups, groupName);
   const result = build(makeHandlers({
-    group: group.value,
+    group,
     handlers: Chunk.empty()
   }));
   const handlers = Effect.isEffect(result) ? yield* result : result;
+  const groupMiddleware = makeMiddlewareMap(group.middlewares, context);
   const routes = [];
   for (const item of handlers.handlers) {
-    if (item._tag === "Middleware") {
-      for (const route of routes) {
-        ;
-        route.handler = item.middleware(route.handler);
+    const middleware = makeMiddlewareMap(item.endpoint.middlewares, context, groupMiddleware);
+    routes.push(handlerToRoute(item.endpoint, middleware, function (request) {
+      return Effect.mapInputContext(item.handler(request), input => Context.merge(context, input));
+    }, item.withFullResponse));
+  }
+  yield* router.concat(HttpRouter.fromIterable(routes));
+}));
+// internal
+const requestPayload = (request, urlParams, isMultipart) => HttpMethod.hasBody(request.method) ? isMultipart ? Effect.orDie(request.multipart) : Effect.orDie(request.json) : Effect.succeed(urlParams);
+const makeMiddlewareMap = (middleware, context, initial) => {
+  const map = new Map(initial);
+  HashSet.forEach(middleware, tag => {
+    map.set(tag.key, {
+      tag,
+      effect: Context.unsafeGet(context, tag)
+    });
+  });
+  return map;
+};
+const handlerToRoute = (endpoint_, middleware, handler, isFullResponse) => {
+  const endpoint = endpoint_;
+  const decodePath = Option.map(endpoint.pathSchema, Schema.decodeUnknown);
+  const isMultipart = endpoint.payloadSchema.pipe(Option.map(schema => HttpApiSchema.getMultipart(schema.ast)), Option.getOrElse(() => false));
+  const decodePayload = Option.map(endpoint.payloadSchema, Schema.decodeUnknown);
+  const decodeHeaders = Option.map(endpoint.headersSchema, Schema.decodeUnknown);
+  const decodeUrlParams = Option.map(endpoint.urlParamsSchema, Schema.decodeUnknown);
+  const encodeSuccess = Schema.encode(makeSuccessSchema(endpoint.successSchema));
+  return HttpRouter.makeRoute(endpoint.method, endpoint.path, applyMiddleware(middleware, Effect.withFiberRuntime(fiber => {
+    const context = fiber.getFiberRef(FiberRef.currentContext);
+    const request = Context.unsafeGet(context, HttpServerRequest.HttpServerRequest);
+    const routeContext = Context.unsafeGet(context, HttpRouter.RouteContext);
+    const urlParams = Context.unsafeGet(context, HttpServerRequest.ParsedSearchParams);
+    return (decodePath._tag === "Some" ? decodePath.value(routeContext.params) : Effect.succeed(routeContext.params)).pipe(Effect.bindTo("pathParams"), decodePayload._tag === "Some" ? Effect.bind("payload", _ => Effect.flatMap(requestPayload(request, urlParams, isMultipart), decodePayload.value)) : identity, decodeHeaders._tag === "Some" ? Effect.bind("headers", _ => decodeHeaders.value(request.headers)) : identity, decodeUrlParams._tag === "Some" ? Effect.bind("urlParams", _ => decodeUrlParams.value(urlParams)) : identity, Effect.flatMap(input => {
+      const request = {
+        path: input.pathParams
+      };
+      if ("payload" in input) {
+        request.payload = input.payload;
+      }
+      if ("headers" in input) {
+        request.headers = input.headers;
+      }
+      if ("urlParams" in input) {
+        request.urlParams = input.urlParams;
       }
+      return handler(request);
+    }), isFullResponse ? identity : Effect.flatMap(encodeSuccess), Effect.catchIf(ParseResult.isParseError, HttpApiDecodeError.refailParseError));
+  })));
+};
+const applyMiddleware = (middleware, handler) => {
+  for (const entry of middleware.values()) {
+    const effect = HttpApiMiddleware.SecurityTypeId in entry.tag ? makeSecurityMiddleware(entry) : entry.effect;
+    if (entry.tag.optional) {
+      const previous = handler;
+      handler = Effect.matchEffect(effect, {
+        onFailure: () => previous,
+        onSuccess: entry.tag.provides !== undefined ? value => Effect.provideService(previous, entry.tag.provides, value) : _ => previous
+      });
     } else {
-      routes.push(handlerToRoute(item.endpoint, function (request) {
-        return Effect.mapInputContext(item.handler(request), input => Context.merge(context, input));
-      }, item.withFullResponse));
+      handler = entry.tag.provides !== undefined ? Effect.provideServiceEffect(handler, entry.tag.provides, effect) : Effect.zipRight(effect, handler);
     }
   }
-  yield* router.concat(HttpRouter.fromIterable(routes));
-}));
-/**
- * Add the implementation for an `HttpApiEndpoint` to a `Handlers` group.
- *
- * @since 1.0.0
- * @category handlers
- */
-export const handle = (name, handler, options) => self => {
-  const o = Chunk.findFirst(self.group.endpoints, endpoint => endpoint.name === name);
-  if (o._tag === "None") {
-    throw new Error(`Endpoint "${name}" not found in group "${self.group.identifier}"`);
+  return handler;
+};
+const securityMiddlewareCache = /*#__PURE__*/globalValue("securityMiddlewareCache", () => new WeakMap());
+const makeSecurityMiddleware = entry => {
+  if (securityMiddlewareCache.has(entry.tag)) {
+    return securityMiddlewareCache.get(entry.tag);
+  }
+  let effect;
+  for (const [key, security] of Object.entries(entry.tag.security)) {
+    const decode = securityDecode(security);
+    const handler = entry.effect[key];
+    const middleware = Effect.flatMap(decode, handler);
+    effect = effect === undefined ? middleware : Effect.catchAll(effect, () => middleware);
   }
-  const endpoint = o.value;
-  return makeHandlers({
-    group: self.group,
-    handlers: Chunk.append(self.handlers, {
-      _tag: "Handler",
-      endpoint,
-      handler,
-      withFullResponse: options?.withFullResponse === true
-    })
+  if (effect === undefined) {
+    effect = Effect.void;
+  }
+  securityMiddlewareCache.set(entry.tag, effect);
+  return effect;
+};
+const responseSchema = /*#__PURE__*/Schema.declare(HttpServerResponse.isServerResponse);
+const makeSuccessSchema = schema => {
+  const schemas = new Set();
+  HttpApiSchema.deunionize(schemas, schema);
+  return Schema.Union(...Array.from(schemas, toResponseSuccess));
+};
+const makeErrorSchema = api => {
+  const schemas = new Set();
+  HttpApiSchema.deunionize(schemas, api.errorSchema);
+  HashMap.forEach(api.groups, group => {
+    HashMap.forEach(group.endpoints, endpoint => {
+      HttpApiSchema.deunionize(schemas, endpoint.errorSchema);
+    });
+    HttpApiSchema.deunionize(schemas, group.errorSchema);
   });
+  return Schema.Union(...Array.from(schemas, toResponseError));
 };
-/**
- * Add `HttpMiddleware` to a `Handlers` group.
- *
- * Any errors are required to have a corresponding schema in the API.
- * You can add middleware errors to an `HttpApiGroup` using the `HttpApiGroup.addError`
- * api.
- *
- * @since 1.0.0
- * @category middleware
- */
-export const middleware = middleware => self => makeHandlers({
-  ...self,
-  handlers: Chunk.append(self.handlers, {
-    _tag: "Middleware",
-    middleware
-  })
-});
+const decodeForbidden = (_, __, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, _, "Encode only schema"));
+const toResponseSchema = getStatus => {
+  const cache = new WeakMap();
+  const schemaToResponse = (data, _, ast) => {
+    const isEmpty = HttpApiSchema.isVoid(ast.to);
+    const status = getStatus(ast.to);
+    if (isEmpty) {
+      return HttpServerResponse.empty({
+        status
+      });
+    }
+    const encoding = HttpApiSchema.getEncoding(ast.to);
+    switch (encoding.kind) {
+      case "Json":
+        {
+          return Effect.mapError(HttpServerResponse.json(data, {
+            status,
+            contentType: encoding.contentType
+          }), error => new ParseResult.Type(ast, error, "Could not encode to JSON"));
+        }
+      case "Text":
+        {
+          return ParseResult.succeed(HttpServerResponse.text(data, {
+            status,
+            contentType: encoding.contentType
+          }));
+        }
+      case "Uint8Array":
+        {
+          return ParseResult.succeed(HttpServerResponse.uint8Array(data, {
+            status,
+            contentType: encoding.contentType
+          }));
+        }
+      case "UrlParams":
+        {
+          return ParseResult.succeed(HttpServerResponse.urlParams(data, {
+            status,
+            contentType: encoding.contentType
+          }));
+        }
+    }
+  };
+  return schema => {
+    if (cache.has(schema.ast)) {
+      return cache.get(schema.ast);
+    }
+    const transform = Schema.transformOrFail(responseSchema, schema, {
+      decode: decodeForbidden,
+      encode: schemaToResponse
+    });
+    cache.set(transform.ast, transform);
+    return transform;
+  };
+};
+const toResponseSuccess = /*#__PURE__*/toResponseSchema(HttpApiSchema.getStatusSuccessAST);
+const toResponseError = /*#__PURE__*/toResponseSchema(HttpApiSchema.getStatusErrorAST);
+// ----------------------------------------------------------------------------
+// Global middleware
+// ----------------------------------------------------------------------------
 /**
  * @since 1.0.0
  * @category middleware
@@ -222,7 +362,7 @@ const middlewareAddNoContext = middleware => Effect.map(Effect.serviceOption(Mid
  * @since 1.0.0
  * @category middleware
  */
-export const middlewareLayer = (...args) => {
+export const middleware = (...args) => {
   const apiFirst = HttpApi.isHttpApi(args[0]);
   const withContext = apiFirst ? args[2]?.withContext === true : args[1]?.withContext === true;
   const add = withContext ? middlewareAdd : middlewareAddNoContext;
@@ -236,7 +376,7 @@ export const middlewareLayer = (...args) => {
  * @since 1.0.0
  * @category middleware
  */
-export const middlewareLayerScoped = (...args) => {
+export const middlewareScoped = (...args) => {
   const apiFirst = HttpApi.isHttpApi(args[0]);
   const withContext = apiFirst ? args[2]?.withContext === true : args[1]?.withContext === true;
   const add = withContext ? middlewareAdd : middlewareAddNoContext;
@@ -249,7 +389,7 @@ export const middlewareLayerScoped = (...args) => {
  * @since 1.0.0
  * @category middleware
  */
-export const middlewareCors = options => middlewareLayer(HttpMiddleware.cors(options));
+export const middlewareCors = options => middleware(HttpMiddleware.cors(options));
 /**
  * A middleware that adds an openapi.json endpoint to the API.
  *
@@ -257,7 +397,9 @@ export const middlewareCors = options => middlewareLayer(HttpMiddleware.cors(opt
  * @category middleware
  */
 export const middlewareOpenApi = options => Router.use(router => Effect.gen(function* () {
-  const api = yield* HttpApi.HttpApi;
+  const {
+    api
+  } = yield* HttpApi.Api;
   const spec = OpenApi.fromApi(api);
   const response = yield* HttpServerResponse.json(spec).pipe(Effect.orDie);
   yield* router.get(options?.path ?? "/openapi.json", Effect.succeed(response));
@@ -265,7 +407,7 @@ export const middlewareOpenApi = options => Router.use(router => Effect.gen(func
 const bearerLen = `Bearer `.length;
 /**
  * @since 1.0.0
- * @category middleware
+ * @category security
  */
 export const securityDecode = self => {
   switch (self._tag) {
@@ -312,9 +454,9 @@ export const securityDecode = self => {
  * You can use this api before returning a response from an endpoint handler.
  *
  * ```ts
- * ApiBuilder.handle(
+ * handlers.handle(
  *   "authenticate",
- *   (_) => ApiBuilder.securitySetCookie(security, "secret123")
+ *   (_) => HttpApiBuilder.securitySetCookie(security, "secret123")
  * )
  * ```
  *
@@ -329,152 +471,4 @@ export const securitySetCookie = (self, value, options) => {
     ...options
   })));
 };
-/**
- * Make a middleware from an `HttpApiSecurity` instance, that can be used when
- * constructing a `Handlers` group.
- *
- * @since 1.0.0
- * @category middleware
- * @example
- * import { HttpApiBuilder, HttpApiSecurity } from "@effect/platform"
- * import { Schema } from "@effect/schema"
- * import { Context, Effect, Redacted } from "effect"
- *
- * class User extends Schema.Class<User>("User")({
- *   id: Schema.Number
- * }) {}
- *
- * class CurrentUser extends Context.Tag("CurrentUser")<CurrentUser, User>() {}
- *
- * class Accounts extends Context.Tag("Accounts")<Accounts, {
- *   readonly findUserByAccessToken: (accessToken: string) => Effect.Effect<User>
- * }>() {}
- *
- * const securityMiddleware = Effect.gen(function*() {
- *   const accounts = yield* Accounts
- *   return HttpApiBuilder.middlewareSecurity(
- *     HttpApiSecurity.bearer,
- *     CurrentUser,
- *     (token) => accounts.findUserByAccessToken(Redacted.value(token))
- *   )
- * })
- */
-export const middlewareSecurity = (self, tag, f) => middleware(Effect.provideServiceEffect(tag, Effect.flatMap(securityDecode(self), f)));
-/**
- * Make a middleware from an `HttpApiSecurity` instance, that can be used when
- * constructing a `Handlers` group.
- *
- * This version does not supply any context to the handlers.
- *
- * @since 1.0.0
- * @category middleware
- */
-export const middlewareSecurityVoid = (self, f) => middleware(httpApp => securityDecode(self).pipe(Effect.flatMap(f), Effect.zipRight(httpApp)));
-// internal
-const requestPayload = (request, urlParams, isMultipart) => HttpMethod.hasBody(request.method) ? isMultipart ? Effect.orDie(request.multipart) : Effect.orDie(request.json) : Effect.succeed(urlParams);
-const handlerToRoute = (endpoint, handler, isFullResponse) => {
-  const decodePath = Option.map(endpoint.pathSchema, Schema.decodeUnknown);
-  const isMultipart = endpoint.payloadSchema.pipe(Option.map(schema => HttpApiSchema.getMultipart(schema.ast)), Option.getOrElse(() => false));
-  const decodePayload = Option.map(endpoint.payloadSchema, Schema.decodeUnknown);
-  const decodeHeaders = Option.map(endpoint.headersSchema, Schema.decodeUnknown);
-  const encoding = HttpApiSchema.getEncoding(endpoint.successSchema.ast);
-  const successStatus = HttpApiSchema.getStatusSuccess(endpoint.successSchema);
-  const encodeSuccess = Option.map(HttpApiEndpoint.schemaSuccess(endpoint), schema => {
-    const encode = Schema.encodeUnknown(schema);
-    switch (encoding.kind) {
-      case "Json":
-        {
-          return body => Effect.orDie(Effect.flatMap(encode(body), json => HttpServerResponse.json(json, {
-            status: successStatus,
-            contentType: encoding.contentType
-          })));
-        }
-      case "Text":
-        {
-          return body => Effect.map(Effect.orDie(encode(body)), text => HttpServerResponse.text(text, {
-            status: successStatus,
-            contentType: encoding.contentType
-          }));
-        }
-      case "Uint8Array":
-        {
-          return body => Effect.map(Effect.orDie(encode(body)), data => HttpServerResponse.uint8Array(data, {
-            status: successStatus,
-            contentType: encoding.contentType
-          }));
-        }
-      case "UrlParams":
-        {
-          return body => Effect.map(Effect.orDie(encode(body)), params => HttpServerResponse.urlParams(params, {
-            status: successStatus,
-            contentType: encoding.contentType
-          }));
-        }
-    }
-  });
-  return HttpRouter.makeRoute(endpoint.method, endpoint.path, Effect.withFiberRuntime(fiber => {
-    const context = fiber.getFiberRef(FiberRef.currentContext);
-    const request = Context.unsafeGet(context, HttpServerRequest.HttpServerRequest);
-    const routeContext = Context.unsafeGet(context, HttpRouter.RouteContext);
-    const urlParams = Context.unsafeGet(context, HttpServerRequest.ParsedSearchParams);
-    return (decodePath._tag === "Some" ? Effect.catchAll(decodePath.value(routeContext.params), HttpApiDecodeError.refailParseError) : Effect.succeed(routeContext.params)).pipe(Effect.bindTo("pathParams"), decodePayload._tag === "Some" ? Effect.bind("payload", _ => requestPayload(request, urlParams, isMultipart).pipe(Effect.orDie, Effect.flatMap(raw => Effect.catchAll(decodePayload.value(raw), HttpApiDecodeError.refailParseError)))) : identity, decodeHeaders._tag === "Some" ? Effect.bind("headers", _ => Effect.orDie(decodeHeaders.value(request.headers))) : identity, Effect.flatMap(input => {
-      const request = {
-        path: input.pathParams
-      };
-      if ("payload" in input) {
-        request.payload = input.payload;
-      }
-      if ("headers" in input) {
-        request.headers = input.headers;
-      }
-      return handler(request);
-    }), isFullResponse ? identity : encodeSuccess._tag === "Some" ? Effect.flatMap(encodeSuccess.value) : Effect.as(HttpServerResponse.empty({
-      status: successStatus
-    })));
-  }));
-};
-const astCache = /*#__PURE__*/globalValue("@effect/platform/HttpApiBuilder/astCache", () => new WeakMap());
-const makeErrorSchema = api => {
-  const schemas = new Set();
-  function processSchema(schema) {
-    if (astCache.has(schema.ast)) {
-      schemas.add(astCache.get(schema.ast));
-      return;
-    }
-    const ast = schema.ast;
-    if (ast._tag === "Union") {
-      for (const astType of ast.types) {
-        const errorSchema = Schema.make(astType).annotations({
-          ...ast.annotations,
-          ...astType.annotations
-        });
-        astCache.set(astType, errorSchema);
-        schemas.add(errorSchema);
-      }
-    } else {
-      astCache.set(ast, schema);
-      schemas.add(schema);
-    }
-  }
-  processSchema(api.errorSchema);
-  for (const group of api.groups) {
-    for (const endpoint of group.endpoints) {
-      processSchema(endpoint.errorSchema);
-    }
-    processSchema(group.errorSchema);
-  }
-  return Schema.Union(...[...schemas].map(schema => {
-    const status = HttpApiSchema.getStatusError(schema);
-    const encoded = AST.encodedAST(schema.ast);
-    const isEmpty = encoded._tag === "VoidKeyword";
-    return Schema.transformOrFail(Schema.Any, schema, {
-      decode: (_, __, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, _, "Encode only schema")),
-      encode: (error, _, ast) => isEmpty ? HttpServerResponse.empty({
-        status
-      }) : HttpServerResponse.json(error, {
-        status
-      }).pipe(Effect.mapError(error => new ParseResult.Type(ast, error, "Could not encode to JSON")))
-    });
-  }));
-};
 //# sourceMappingURL=HttpApiBuilder.js.map