effect-start 0.25.0 → 0.26.0

package/dist/RouteHttp.js

@@ -1,367 +0,0 @@
-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 Runtime from "effect/Runtime"
-import * as Stream from "effect/Stream"
-import * as ContentNegotiation from "./ContentNegotiation.js"
-import * as Entity from "./Entity.js"
-import * as Route from "./Route.js"
-import * as RouteHttpTracer from "./RouteHttpTracer.js"
-import * as RouteTree from "./RouteTree.js"
-import * as StreamExtra from "./StreamExtra.js"
-
-// Used to match Accept headers against available route formats.
-// text/* matches any text type (text/plain, text/event-stream, text/markdown, etc.)
-const formatToMediaType = /** @type {const} */ {
-  text: "text/*",
-  html: "text/html",
-  json: "application/json",
-  bytes: "application/octet-stream",
-}
-
-// Used after content negotiation to determine which format was selected.
-const mediaTypeToFormat = /** @type {const} */ {
-  "text/*": "text",
-  "text/html": "html",
-  "application/json": "json",
-  "application/octet-stream": "bytes",
-}
-
-/**
- * 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 isClientAbort = (cause) =>
-  Cause.isInterruptedOnly(cause) &&
-  HashSet.some(Cause.interruptors(cause), (id) => id === clientAbortFiberId)
-
-const getStatusFromCause = (cause) => {
-  const failure = Cause.failureOption(cause)
-
-  if (failure._tag === "Some") {
-    const error = failure.value
-    if (error._tag === "ParseError" || error._tag === "RequestBodyError") {
-      return 400
-    }
-  }
-
-  return 500
-}
-
-const respondError = (options) =>
-  new Response(JSON.stringify(options, null, 2), {
-    status: options.status,
-    headers: { "content-type": "application/json" },
-  })
-
-function streamResponse(
-  stream,
-  headers,
-  status,
-  runtime,
-) {
-  const encoder = new TextEncoder()
-  const byteStream = (stream).pipe(
-    Stream.map(
-      (chunk) =>
-        typeof chunk === "string" ? encoder.encode(chunk) : (chunk),
-    ),
-    Stream.catchAll((error) =>
-      Stream.fail(error instanceof Error ? error : new Error(String(error))),
-    ),
-  )
-  return new Response(Stream.toReadableStreamRuntime(byteStream, runtime), {
-    status,
-    headers: headers,
-  })
-}
-
-function toResponse(
-  entity,
-  format,
-  runtime,
-) {
-  const contentType = Entity.type(entity)
-  const status = entity.status ?? 200
-  const headers = { ...entity.headers, "content-type": contentType }
-
-  if (StreamExtra.isStream(entity.body)) {
-    return Effect.succeed(streamResponse(entity.body, headers, status, runtime))
-  }
-
-  if (format === "json") {
-    return Effect.map(
-      entity.json,
-      (data) => new Response(JSON.stringify(data), { status, headers }),
-    )
-  }
-
-  if (format === "text" || format === "html") {
-    return Effect.map(
-      entity.text,
-      (text) => new Response(text, { status, headers }),
-    )
-  }
-
-  if (format === "bytes") {
-    return Effect.map(
-      entity.bytes,
-      (bytes) => new Response(bytes, { status, headers }),
-    )
-  }
-
-  return Effect.succeed(streamResponse(entity.stream, headers, status, runtime))
-}
-
-function determineSelectedFormat(
-  accept,
-  routes,
-) {
-  const formats = routes
-    .filter((r) => Route.descriptor(r).method !== "*")
-    .map((r) => Route.descriptor(r).format)
-    .filter((f) => Boolean(f) && f !== "*")
-
-  const uniqueFormats = [...new Set(formats)]
-  const mediaTypes = uniqueFormats.map((f) => formatToMediaType[f]).filter(Boolean)
-
-  if (mediaTypes.length === 0) {
-    return undefined
-  }
-
-  if (!accept) {
-    return uniqueFormats[0]
-  }
-
-  const negotiated = ContentNegotiation.media(accept, mediaTypes)
-  if (negotiated.length > 0) {
-    return mediaTypeToFormat[negotiated[0]]
-  }
-
-  return undefined
-}
-
-export const toWebHandlerRuntime = (runtime) => {
-  const runFork = Runtime.runFork(runtime)
-
-  return (routes) => {
-    const grouped = Object.groupBy(
-      routes,
-      (route) => Route.descriptor(route).method?.toUpperCase() ?? "*",
-    )
-    const wildcards = grouped["*"] ?? []
-    const methodGroups = {
-      GET: undefined,
-      POST: undefined,
-      PUT: undefined,
-      PATCH: undefined,
-      DELETE: undefined,
-      HEAD: undefined,
-      OPTIONS: undefined,
-    }
-
-    for (const method in grouped) {
-      if (method !== "*") {
-        methodGroups[method] = grouped[method]
-      }
-    }
-
-    return (request) => {
-      const method = request.method.toUpperCase()
-      const accept = request.headers.get("accept")
-      const methodRoutes = methodGroups[method] ?? []
-
-      if (methodRoutes.length === 0 && wildcards.length === 0) {
-        return Promise.resolve(respondError({ status: 405, message: "method not allowed" }))
-      }
-
-      const allRoutes = [...wildcards, ...methodRoutes]
-      const selectedFormat = determineSelectedFormat(accept, allRoutes)
-
-      const specificFormats = new Set()
-      let hasWildcardFormatRoutes = false
-      for (const r of allRoutes) {
-        const format = Route.descriptor(r).format
-        if (format === "*") hasWildcardFormatRoutes = true
-        else if (format) specificFormats.add(format)
-      }
-      const hasSpecificFormatRoutes = specificFormats.size > 0
-      const varyAccept = specificFormats.size > 1
-
-      if (selectedFormat === undefined && hasSpecificFormatRoutes && !hasWildcardFormatRoutes) {
-        return Promise.resolve(respondError({ status: 406, message: "not acceptable" }))
-      }
-
-      const createChain = (initialContext) => {
-        let index = 0
-        let currentContext = initialContext
-        let routePathSet = false
-
-        const runNext = (passedContext) => {
-          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
-
-          if (format && format !== "*" && format !== selectedFormat) {
-            return runNext()
-          }
-
-          currentContext = { ...currentContext, ...descriptor }
-
-          const nextArg = (ctx) => 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 = Effect.withFiberRuntime((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 respondError({ status: 406, message: "not acceptable" })
-          }
-
-          const response = yield* toResponse(entity, selectedFormat, runtime)
-          if (varyAccept) {
-            response.headers.set("vary", "Accept")
-          }
-          return response
-        })
-
-        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 new Promise((resolve) => {
-        const fiber = runFork(
-          effect.pipe(
-            Effect.scoped,
-            Effect.catchAllCause((cause) =>
-              Effect.gen(function* () {
-                yield* Effect.logError(cause)
-                const status = getStatusFromCause(cause)
-                const message = Cause.pretty(cause, { renderErrorCause: true })
-                return respondError({ status, message })
-              }),
-            ),
-          ),
-        )
-
-        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(respondError({ status: 499, message: "client closed request" }))
-          } else {
-            const status = getStatusFromCause(exit.cause)
-            const message = Cause.pretty(exit.cause, { renderErrorCause: true })
-            resolve(respondError({ status, message }))
-          }
-        })
-      })
-    }
-  }
-}
-
-export const toWebHandler =
-  toWebHandlerRuntime(Runtime.defaultRuntime)
-
-export function* walkHandles(
-  tree,
-  runtime = Runtime.defaultRuntime,
-) {
-  const pathGroups = new Map()
-
-  for (const route of RouteTree.walk(tree)) {
-    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, toHandler(routes)]
-  }
-}

package/dist/RouteHttpTracer.js

@@ -1,90 +0,0 @@
-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 * as Tracer from "effect/Tracer"
-
-export const currentTracerDisabledWhen = GlobalValue.globalValue(
-  Symbol.for("effect-start/RouteHttp/tracerDisabledWhen"),
-  () => FiberRef.unsafeMake(() => false),
-)
-
-export const withTracerDisabledWhen = (
-  effect,
-  predicate,
-) => Effect.locally(effect, currentTracerDisabledWhen, predicate)
-
-export const currentSpanNameGenerator = GlobalValue.globalValue(
-  Symbol.for("effect-start/RouteHttp/spanNameGenerator"),
-  () =>
-    FiberRef.unsafeMake((request) => `http.server ${request.method}`),
-)
-
-export const withSpanNameGenerator = (
-  effect,
-  f,
-) => Effect.locally(effect, currentSpanNameGenerator, f)
-
-const w3cTraceparent = (headers) => {
-  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) => {
-  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) => {
-  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) => {
-  let span = w3cTraceparent(headers)
-  if (span._tag === "Some") return span
-
-  span = b3Single(headers)
-  if (span._tag === "Some") return span
-
-  return xb3(headers)
-}

package/dist/RouteMount.js

@@ -1,86 +0,0 @@
-import * as Function from "effect/Function"
-import * as Route from "./Route.js"
-
-const RouteSetTypeId = Symbol.for("effect-start/RouteSet")
-
-// oxlint-disable-next-line import/first, typescript/consistent-type-imports -- typeof import() is not an import statement
-
-export const use = makeMethodDescriber("*")
-export const get = makeMethodDescriber("GET")
-export const post = makeMethodDescriber("POST")
-export const put = makeMethodDescriber("PUT")
-export const del = makeMethodDescriber("DELETE")
-export const patch = makeMethodDescriber("PATCH")
-export const head = makeMethodDescriber("HEAD")
-export const options = makeMethodDescriber("OPTIONS")
-
-export const add = function (
-  path,
-  routes,
-) {
-  const baseItems = Route.isRouteSet(this) ? Route.items(this) : (/** @type {const} */ [])
-
-  const routeSet = typeof routes === "function" ? routes(make([])) : routes
-  const routeItems = Route.items(routeSet)
-  const newItems = routeItems.map((item) => {
-    const itemDescriptor = Route.descriptor(item)
-    const concatenatedPath =
-      typeof itemDescriptor?.path === "string" ? path + itemDescriptor.path : path
-    const newDescriptor = { ...itemDescriptor, path: concatenatedPath }
-    return Route.isRoute(item)
-      ? Route.make(item.handler, newDescriptor)
-      : Route.set(Route.items(item), newDescriptor)
-  })
-
-  return make([...baseItems, ...newItems])
-}
-
-const Proto = Object.assign(Object.create(null), {
-  [RouteSetTypeId]: RouteSetTypeId,
-  *[Symbol.iterator]() {
-    yield* Route.items(this)
-  },
-  use,
-  get,
-  post,
-  put,
-  del,
-  patch,
-  head,
-  options,
-  add,
-})
-
-function make(items) {
-  return Object.assign(Object.create(Proto), {
-    [Route.RouteItems]: items,
-    [Route.RouteDescriptor]: {},
-  })
-}
-
-function makeMethodDescriber(method) {
-  function describeMethod(
-    ...fs
-  ) {
-    const baseItems = Route.isRouteSet(this) ? Route.items(this) : (/** @type {const} */ [])
-
-    const methodSet = Route.set([], { method })
-    const f = Function.flow(...(fs))
-    const result = f(methodSet)
-    const resultItems = Route.items(result)
-
-    // Items are already flat (only Routes), just merge method into each descriptor
-    const flattenedItems = resultItems.map((item) => {
-      const itemDescriptor = Route.descriptor(item)
-      const newDescriptor = { method, ...itemDescriptor }
-      return Route.make(
-        (item).handler,
-        newDescriptor,
-      )
-    })
-
-    return make([...baseItems, ...flattenedItems])
-  }
-  return describeMethod
-}
-