Function toHttpApp

packages/platform/src/internal/httpRouter.ts:210–298

(
  self: Router.HttpRouter<E, R>
)

/** @internal */
export const toHttpApp = <E, R>(
  self: Router.HttpRouter<E, R>
): Effect.Effect<App.Default<E | Error.RouteNotFound, R>> =>
  Effect.map(FiberRef.get(currentRouterConfig), (config) => {
    const router = FindMyWay.make<Router.Route<E, R>>(config)
    const mounts = Chunk.toReadonlyArray(self.mounts).map(([path, app, options]) =>
      [
        path,
        new RouteContextImpl(
          new RouteImpl(
            "*",
            options?.includePrefix ? `${path}/*` as Router.PathInput : "/*",
            app,
            options?.includePrefix ? Option.none() : Option.some(path),
            false
          ),
          {}
        ),
        options
      ] as const
    )
    const mountsLen = mounts.length
    Chunk.forEach(self.routes, (route) => {
      if (route.method === "*") {
        router.all(route.path, route)
      } else {
        router.on(route.method, route.path, route)
      }
    })
    return Effect.withFiberRuntime<
      ServerResponse.HttpServerResponse,
      E | Error.RouteNotFound,
      R | ServerRequest.HttpServerRequest
    >((fiber) => {
      const context = Context.unsafeMake(new Map(fiber.getFiberRef(FiberRef.currentContext).unsafeMap))
      const request = Context.unsafeGet(context, ServerRequest.HttpServerRequest)
      if (mountsLen > 0) {
        const searchIndex = request.url.indexOf("?")
        const pathname = searchIndex === -1 ? request.url : request.url.slice(0, searchIndex)

        for (let i = 0; i < mountsLen; i++) {
          const [path, routeContext, options] = mounts[i]
          if (pathname === path || pathname.startsWith(path + "/")) {
            context.unsafeMap.set(RouteContext.key, routeContext)
            if (options?.includePrefix !== true) {
              context.unsafeMap.set(ServerRequest.HttpServerRequest.key, sliceRequestUrl(request, path))
            }
            return Effect.locally(
              Effect.flatMap(routeContext.route.handler, Respondable.toResponse) as App.Default<E, R>,
              FiberRef.currentContext,
              context
            )
          }
        }
      }

      let result = router.find(request.method, request.url)
      if (result === undefined && request.method === "HEAD") {