effect-start 0.15.0 → 0.17.0

package/src/RouteHttp.ts

@@ -1,108 +1,173 @@
-import * as Array from "effect/Array"
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
+import * as FiberId from "effect/FiberId"
+import * as FiberRef from "effect/FiberRef"
+import * as HashSet from "effect/HashSet"
+import * as Option from "effect/Option"
+import * as ParseResult from "effect/ParseResult"
 import * as Runtime from "effect/Runtime"
+import * as Stream from "effect/Stream"
 import * as ContentNegotiation from "./ContentNegotiation.ts"
+import * as Entity from "./Entity.ts"
 import * as Http from "./Http.ts"
 import * as Route from "./Route.ts"
 import * as RouteBody from "./RouteBody.ts"
+import * as RouteHttpTracer from "./RouteHttpTracer.ts"
 import * as RouteMount from "./RouteMount.ts"
 import * as RouteTree from "./RouteTree.ts"
+import * as StreamExtra from "./StreamExtra.ts"
+
+export {
+  currentSpanNameGenerator,
+  currentTracerDisabledWhen,
+  parentSpanFromHeaders,
+  withSpanNameGenerator,
+  withTracerDisabledWhen,
+} from "./RouteHttpTracer.ts"
 
 type UnboundedRouteWithMethod = Route.Route.With<{
   method: RouteMount.RouteMount.Method
   format?: RouteBody.Format
 }>
 
+// Used to match Accept headers against available route formats.
+// text/* matches any text type (text/plain, text/event-stream, text/markdown, etc.)
 const formatToMediaType = {
-  text: "text/plain",
+  text: "text/*",
   html: "text/html",
   json: "application/json",
   bytes: "application/octet-stream",
 } as const
 
-const formatToContentType = {
-  text: "text/plain; charset=utf-8",
-  html: "text/html; charset=utf-8",
-  json: "application/json",
-  bytes: "application/octet-stream",
+// Used after content negotiation to determine which format was selected.
+const mediaTypeToFormat = {
+  "text/*": "text",
+  "text/html": "html",
+  "application/json": "json",
+  "application/octet-stream": "bytes",
 } as const
 
-function toResponse(result: unknown, format?: string): Response {
-  if (result instanceof Response) {
-    return result
-  }
+/**
+ * A synthetic fiber used to tag interruptions caused by client disconnects.
+ * Number stands for HTTP status 499 "Client Closed Request".
+ * This is what @effect/platform does to signal request cancelation.
+ */
+export const clientAbortFiberId = FiberId.runtime(-499, 0)
 
-  const contentType = format && format in formatToContentType
-    ? formatToContentType[format]
-    : typeof result === "string"
-    ? "text/html; charset=utf-8"
-    : "application/json"
+const isClientAbort = (cause: Cause.Cause<unknown>): boolean =>
+  Cause.isInterruptedOnly(cause)
+  && HashSet.some(
+    Cause.interruptors(cause),
+    (id) => id === clientAbortFiberId,
+  )
 
-  const body = contentType === "application/json"
-    ? JSON.stringify(result)
-    : result
+const getStatusFromCause = (cause: Cause.Cause<unknown>): number => {
+  const failure = Cause.failureOption(cause)
 
-  return new Response(body as BodyInit, {
-    headers: { "Content-Type": contentType },
-  })
+  if (failure._tag === "Some") {
+    const error = failure.value as { _tag?: string }
+    if (error._tag === "ParseError" || error._tag === "RequestBodyError") {
+      return 400
+    }
+  }
+
+  return 500
 }
 
-function getMediaType(format: string | undefined): string | undefined {
-  return format && format in formatToMediaType
-    ? formatToMediaType[format]
-    : undefined
+function streamResponse(
+  stream: Stream.Stream<unknown, unknown, unknown>,
+  headers: Record<string, string | null | undefined>,
+  status: number,
+  runtime: Runtime.Runtime<any>,
+): Response {
+  const encoder = new TextEncoder()
+  const byteStream = (stream as Stream.Stream<unknown, unknown, never>).pipe(
+    Stream.map((chunk): Uint8Array =>
+      typeof chunk === "string"
+        ? encoder.encode(chunk)
+        : chunk as Uint8Array
+    ),
+    Stream.catchAll((error) =>
+      Stream.fail(
+        error instanceof Error ? error : new Error(String(error)),
+      )
+    ),
+  )
+  return new Response(
+    Stream.toReadableStreamRuntime(byteStream, runtime),
+    { status, headers: headers as Record<string, string> },
+  )
 }
 
-const defaultFormatPriority = ["json", "text", "html", "bytes"] as const
+function toResponse(
+  entity: Entity.Entity<any>,
+  format: string | undefined,
+  runtime: Runtime.Runtime<any>,
+): Effect.Effect<Response, ParseResult.ParseError> {
+  const contentType = Entity.type(entity)
+  const status = entity.status ?? 200
+  const headers = { ...entity.headers, "content-type": contentType }
 
-function negotiateRoute(
-  routes: UnboundedRouteWithMethod[],
-  accept: string | null,
-): UnboundedRouteWithMethod | undefined {
-  if (routes.length === 1) {
-    if (!accept) return routes[0]
-    const format = Route.descriptor(routes[0]).format
-    const mediaType = getMediaType(format)
-    if (!mediaType) return routes[0]
-    const matched = ContentNegotiation.media(accept, [mediaType])
-    return matched.length > 0 ? routes[0] : undefined
+  if (StreamExtra.isStream(entity.body)) {
+    return Effect.succeed(streamResponse(entity.body, headers, status, runtime))
   }
 
-  const formatMap = new Map<string, UnboundedRouteWithMethod>()
-  const available: string[] = []
-  const mediaTypeMap = new Map<string, UnboundedRouteWithMethod>()
+  if (format === "json") {
+    return Effect.map(
+      entity.json as Effect.Effect<object, ParseResult.ParseError>,
+      (data) => new Response(JSON.stringify(data), { status, headers }),
+    )
+  }
 
-  for (const route of routes) {
-    const format = Route.descriptor(route).format
-    if (format && !formatMap.has(format)) {
-      formatMap.set(format, route)
-    }
-    const mediaType = getMediaType(format)
-    if (format && mediaType && !mediaTypeMap.has(mediaType)) {
-      available.push(mediaType)
-      mediaTypeMap.set(mediaType, route)
-    }
+  if (format === "text" || format === "html") {
+    return Effect.map(
+      entity.text as Effect.Effect<string, ParseResult.ParseError>,
+      (text) => new Response(text, { status, headers }),
+    )
   }
 
-  if (!accept) {
-    for (const format of defaultFormatPriority) {
-      const route = formatMap.get(format)
-      if (route) return route
-    }
-    return routes[0]
+  if (format === "bytes") {
+    return Effect.map(
+      entity.bytes as Effect.Effect<Uint8Array, ParseResult.ParseError>,
+      (bytes) => new Response(bytes as BodyInit, { status, headers }),
+    )
+  }
+
+  return Effect.succeed(
+    streamResponse(entity.stream, headers, status, runtime),
+  )
+}
+
+type Handler = (
+  context: any,
+  next: (context?: Record<string, unknown>) => Entity.Entity<any, any>,
+) => Effect.Effect<Entity.Entity<any>, any, any>
+
+function determineSelectedFormat(
+  accept: string | null,
+  routes: UnboundedRouteWithMethod[],
+): RouteBody.Format | undefined {
+  const formats = routes
+    .filter((r) => Route.descriptor(r).method !== "*")
+    .map((r) => Route.descriptor(r).format)
+    .filter((f): f is Exclude<RouteBody.Format, "*"> => Boolean(f) && f !== "*")
+
+  const uniqueFormats = [...new Set(formats)]
+  const mediaTypes = uniqueFormats
+    .map((f) => formatToMediaType[f])
+    .filter(Boolean)
+
+  if (mediaTypes.length === 0) {
+    return undefined
   }
 
-  if (available.length === 0) {
-    return routes[0]
+  if (!accept) {
+    return uniqueFormats[0]
   }
 
-  const preferred = ContentNegotiation.media(accept, available)
-  if (preferred.length > 0) {
-    const best = mediaTypeMap.get(preferred[0])
-    if (best) {
-      return best
-    }
+  const negotiated = ContentNegotiation.media(accept, mediaTypes)
+  if (negotiated.length > 0) {
+    return mediaTypeToFormat[negotiated[0]]
   }
 
   return undefined
@@ -111,15 +176,13 @@ function negotiateRoute(
 export const toWebHandlerRuntime = <R>(
   runtime: Runtime.Runtime<R>,
 ) => {
-  const run = Runtime.runPromise(runtime)
+  const runFork = Runtime.runFork(runtime)
 
   return (
-    routes: Iterable<
-      UnboundedRouteWithMethod
-    >,
+    routes: Iterable<UnboundedRouteWithMethod>,
   ): Http.WebHandler => {
-    const grouped = Array.groupBy(
-      Array.fromIterable(routes),
+    const grouped = Object.groupBy(
+      routes,
       (route) => Route.descriptor(route).method?.toUpperCase() ?? "*",
     )
     const wildcards = grouped["*"] ?? []
@@ -137,49 +200,221 @@ export const toWebHandlerRuntime = <R>(
 
     for (const method in grouped) {
       if (method !== "*") {
-        methodGroups[method] = [...wildcards, ...grouped[method]]
+        methodGroups[method] = grouped[method]
       }
     }
 
     return (request) => {
       const method = request.method.toUpperCase()
       const accept = request.headers.get("accept")
-      const group = methodGroups[method]
+      const methodRoutes = methodGroups[method] ?? []
 
-      if (!group || group.length === 0) {
+      if (methodRoutes.length === 0 && wildcards.length === 0) {
         return Promise.resolve(
-          new Response("Method Not Allowed", { status: 405 }),
+          Response.json({ status: 405, message: "method not allowed" }, {
+            status: 405,
+          }),
         )
       }
 
-      const route = negotiateRoute(group, accept)
-      if (!route) {
+      const allRoutes = [...wildcards, ...methodRoutes]
+      const selectedFormat = determineSelectedFormat(accept, allRoutes)
+
+      const hasSpecificFormatRoutes = allRoutes.some((r) => {
+        const format = Route.descriptor(r).format
+        return format && format !== "*"
+      })
+      const hasWildcardFormatRoutes = allRoutes.some((r) =>
+        Route.descriptor(r).format === "*"
+      )
+
+      if (
+        selectedFormat === undefined
+        && hasSpecificFormatRoutes
+        && !hasWildcardFormatRoutes
+      ) {
         return Promise.resolve(
-          new Response("Not Acceptable", { status: 406 }),
+          Response.json({ status: 406, message: "not acceptable" }, {
+            status: 406,
+          }),
         )
       }
-      const descriptor = Route.descriptor(route)
 
-      const context = {
-        ...descriptor,
-        request,
+      const createChain = (
+        initialContext: any,
+      ): Effect.Effect<Entity.Entity<any>, any, any> => {
+        let index = 0
+        let currentContext = initialContext
+        let routePathSet = false
+
+        const runNext = (
+          passedContext?: any,
+        ): Effect.Effect<Entity.Entity<any>, any, any> => {
+          if (passedContext !== undefined) {
+            currentContext = passedContext
+          }
+
+          if (index >= allRoutes.length) {
+            return Effect.succeed(
+              Entity.make(
+                { status: 404, message: "route not found" },
+                { status: 404 },
+              ),
+            )
+          }
+
+          const route = allRoutes[index++]
+          const descriptor = Route.descriptor(route)
+          const format = descriptor.format
+          const handler = route.handler as unknown as Handler
+
+          if (format && format !== "*" && format !== selectedFormat) {
+            return runNext()
+          }
+
+          currentContext = { ...currentContext, ...descriptor }
+
+          const nextArg = (ctx?: any) =>
+            Entity.effect(Effect.suspend(() => runNext(ctx)))
+
+          const routePath = descriptor["path"]
+          if (!routePathSet && routePath !== undefined) {
+            routePathSet = true
+            return Effect.flatMap(
+              Effect.currentSpan.pipe(Effect.option),
+              (spanOption) => {
+                if (Option.isSome(spanOption)) {
+                  spanOption.value.attribute("http.route", routePath)
+                }
+                return handler(currentContext, nextArg)
+              },
+            )
+          }
+
+          return handler(currentContext, nextArg)
+        }
+
+        return runNext()
       }
 
-      const effect = route.handler(
-        context as any,
-        () => Effect.succeed(undefined),
+      const effect = Effect.withFiberRuntime<Response, unknown, R>(
+        (fiber) => {
+          const tracerDisabled =
+            !fiber.getFiberRef(FiberRef.currentTracerEnabled)
+            || fiber.getFiberRef(RouteHttpTracer.currentTracerDisabledWhen)(
+              request,
+            )
+
+          const url = new URL(request.url)
+
+          const innerEffect = Effect.gen(function*() {
+            const result = yield* createChain({ request, selectedFormat })
+
+            const entity = Entity.isEntity(result)
+              ? result
+              : Entity.make(result, { status: 200 })
+
+            if (entity.status === 404 && entity.body === undefined) {
+              return Response.json({ status: 406, message: "not acceptable" }, {
+                status: 406,
+              })
+            }
+
+            return yield* toResponse(entity, selectedFormat, runtime)
+          })
+
+          if (tracerDisabled) {
+            return innerEffect
+          }
+
+          const spanNameGenerator = fiber.getFiberRef(
+            RouteHttpTracer.currentSpanNameGenerator,
+          )
+
+          return Effect.useSpan(
+            spanNameGenerator(request),
+            {
+              parent: Option.getOrUndefined(
+                RouteHttpTracer.parentSpanFromHeaders(request.headers),
+              ),
+              kind: "server",
+              captureStackTrace: false,
+            },
+            (span) => {
+              span.attribute("http.request.method", request.method)
+              span.attribute("url.full", url.toString())
+              span.attribute("url.path", url.pathname)
+              const query = url.search.slice(1)
+              if (query !== "") {
+                span.attribute("url.query", query)
+              }
+              span.attribute("url.scheme", url.protocol.slice(0, -1))
+
+              const userAgent = request.headers.get("user-agent")
+              if (userAgent !== null) {
+                span.attribute("user_agent.original", userAgent)
+              }
+
+              return Effect.flatMap(
+                Effect.exit(Effect.withParentSpan(innerEffect, span)),
+                (exit) => {
+                  if (exit._tag === "Success") {
+                    span.attribute(
+                      "http.response.status_code",
+                      exit.value.status,
+                    )
+                  }
+                  return exit
+                },
+              )
+            },
+          )
+        },
       )
 
-      return run(
-        effect.pipe(
-          Effect.map((result) => toResponse(result, descriptor.format)),
-          Effect.catchAllCause((cause) =>
-            Effect.succeed(
-              new Response(Cause.pretty(cause), { status: 500 }),
-            )
+      return new Promise((resolve) => {
+        const fiber = runFork(
+          effect.pipe(
+            Effect.scoped,
+            Effect.catchAllCause((cause) =>
+              Effect.gen(function*() {
+                yield* Effect.logError(cause)
+                const status = getStatusFromCause(cause)
+                return Response.json({ status, message: Cause.pretty(cause) }, {
+                  status,
+                })
+              })
+            ),
           ),
-        ),
-      )
+        )
+
+        request.signal?.addEventListener(
+          "abort",
+          () => {
+            fiber.unsafeInterruptAsFork(clientAbortFiberId)
+          },
+          { once: true },
+        )
+
+        fiber.addObserver((exit) => {
+          if (exit._tag === "Success") {
+            resolve(exit.value)
+          } else if (isClientAbort(exit.cause)) {
+            resolve(
+              Response.json({ status: 499, message: "client closed request" }, {
+                status: 499,
+              }),
+            )
+          } else {
+            const status = getStatusFromCause(exit.cause)
+            resolve(
+              Response.json({ status, message: Cause.pretty(exit.cause) }, {
+                status,
+              }),
+            )
+          }
+        })
+      })
     }
   }
 }
@@ -190,30 +425,19 @@ export const toWebHandler: (
 
 export function* walkHandles(
   tree: RouteTree.RouteTree,
+  runtime: Runtime.Runtime<never> = Runtime.defaultRuntime,
 ): Generator<[path: string, handler: Http.WebHandler]> {
-  const pathGroups = new Map<
-    string,
-    Array<Route.Route.With<{ path: string; method: string }>>
-  >()
+  const pathGroups = new Map<string, RouteMount.MountedRoute[]>()
 
   for (const route of RouteTree.walk(tree)) {
-    const descriptor = Route.descriptor(route)
-    const path = descriptor.path
-    const routes = pathGroups.get(path) ?? []
-    routes.push(route)
-    pathGroups.set(path, routes)
+    const path = Route.descriptor(route).path
+    const group = pathGroups.get(path) ?? []
+    group.push(route)
+    pathGroups.set(path, group)
   }
 
+  const toHandler = toWebHandlerRuntime(runtime)
   for (const [path, routes] of pathGroups) {
-    yield [path, toWebHandler(routes)]
+    yield [path, toHandler(routes as Iterable<UnboundedRouteWithMethod>)]
   }
 }
-
-export function fetch(
-  handle: Http.WebHandler,
-  init: RequestInit & ({ url: string } | { path: string }),
-): Promise<Response> {
-  const url = "path" in init ? `http://localhost${init.path}` : init.url
-  const request = new Request(url, init)
-  return Promise.resolve(handle(request))
-}

package/src/RouteHttpTracer.ts

@@ -0,0 +1,92 @@
+import * as Effect from "effect/Effect"
+import * as FiberRef from "effect/FiberRef"
+import * as GlobalValue from "effect/GlobalValue"
+import * as Option from "effect/Option"
+import type * as Predicate from "effect/Predicate"
+import * as Tracer from "effect/Tracer"
+
+export const currentTracerDisabledWhen = GlobalValue.globalValue(
+  Symbol.for("effect-start/RouteHttp/tracerDisabledWhen"),
+  () => FiberRef.unsafeMake<Predicate.Predicate<Request>>(() => false),
+)
+
+export const withTracerDisabledWhen = <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+  predicate: Predicate.Predicate<Request>,
+): Effect.Effect<A, E, R> =>
+  Effect.locally(effect, currentTracerDisabledWhen, predicate)
+
+export const currentSpanNameGenerator = GlobalValue.globalValue(
+  Symbol.for("effect-start/RouteHttp/spanNameGenerator"),
+  () =>
+    FiberRef.unsafeMake<(request: Request) => string>(
+      (request) => `http.server ${request.method}`,
+    ),
+)
+
+export const withSpanNameGenerator = <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+  f: (request: Request) => string,
+): Effect.Effect<A, E, R> => Effect.locally(effect, currentSpanNameGenerator, f)
+
+const w3cTraceparent = (
+  headers: Headers,
+): Option.Option<Tracer.ExternalSpan> => {
+  const header = headers.get("traceparent")
+  if (header === null) return Option.none()
+
+  const parts = header.split("-")
+  if (parts.length < 4) return Option.none()
+
+  const [_version, traceId, spanId, flags] = parts
+  if (!traceId || !spanId) return Option.none()
+
+  return Option.some(Tracer.externalSpan({
+    spanId,
+    traceId,
+    sampled: flags === "01",
+  }))
+}
+
+const b3Single = (headers: Headers): Option.Option<Tracer.ExternalSpan> => {
+  const header = headers.get("b3")
+  if (header === null) return Option.none()
+
+  const parts = header.split("-")
+  if (parts.length < 2) return Option.none()
+
+  const [traceId, spanId, sampledStr] = parts
+  if (!traceId || !spanId) return Option.none()
+
+  return Option.some(Tracer.externalSpan({
+    spanId,
+    traceId,
+    sampled: sampledStr === "1",
+  }))
+}
+
+const xb3 = (headers: Headers): Option.Option<Tracer.ExternalSpan> => {
+  const traceId = headers.get("x-b3-traceid")
+  const spanId = headers.get("x-b3-spanid")
+  if (traceId === null || spanId === null) return Option.none()
+
+  const sampled = headers.get("x-b3-sampled")
+
+  return Option.some(Tracer.externalSpan({
+    spanId,
+    traceId,
+    sampled: sampled === "1",
+  }))
+}
+
+export const parentSpanFromHeaders = (
+  headers: Headers,
+): Option.Option<Tracer.ExternalSpan> => {
+  let span = w3cTraceparent(headers)
+  if (span._tag === "Some") return span
+
+  span = b3Single(headers)
+  if (span._tag === "Some") return span
+
+  return xb3(headers)
+}