effect-start 0.27.0 → 0.29.0

package/src/RouteHttp.ts

@@ -7,15 +7,15 @@ import * as Option from "effect/Option"
 import type * 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 ContentNegotiation from "./_ContentNegotiation.ts"
 import * as Entity from "./Entity.ts"
-import type * as Http from "./Http.ts"
+import type * as Http from "./_Http.ts"
 import * as Route from "./Route.ts"
 import type * as RouteBody from "./RouteBody.ts"
 import * as RouteHttpTracer from "./RouteHttpTracer.ts"
 import type * as RouteMount from "./RouteMount.ts"
 import * as RouteTree from "./RouteTree.ts"
-import * as StreamExtra from "./StreamExtra.ts"
+import * as StreamExtra from "./_StreamExtra.ts"
 
 type UnboundedRouteWithMethod = Route.Route.With<{
   method: RouteMount.RouteMount.Method
@@ -63,10 +63,13 @@ const getStatusFromCause = (cause: Cause.Cause<unknown>): number => {
   return 500
 }
 
-const respondError = (options: { status: number; message: string }): Response =>
+const respondError = (
+  options: { status: number; message: string },
+  headers?: Record<string, string>,
+): Response =>
   new Response(JSON.stringify(options, null, 2), {
     status: options.status,
-    headers: { "content-type": "application/json" },
+    headers: { "content-type": "application/json", ...headers },
   })
 
 function streamResponse(
@@ -188,140 +191,158 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
       }
     }
 
-    return (request) => {
-      const method = request.method.toUpperCase()
-      const accept = request.headers.get("accept")
-      const methodRoutes = methodGroups[method] ?? []
+    const allowedMethods = Object.keys(methodGroups)
+      .filter((m) => methodGroups[m] !== undefined && methodGroups[m]!.length > 0)
+      .join(", ")
+
+    return (request) =>
+      new Promise((resolve) => {
+        const method = request.method.toUpperCase()
+        const accept = request.headers.get("accept")
+        const methodRoutes = methodGroups[method] ?? []
+
+        if (method === "OPTIONS" && methodRoutes.length === 0 && wildcards.length === 0) {
+          return resolve(
+            new Response(null, {
+              status: 204,
+              headers: { allow: allowedMethods },
+            }),
+          )
+        }
 
-      if (methodRoutes.length === 0 && wildcards.length === 0) {
-        return Promise.resolve(respondError({ status: 405, message: "method not allowed" }))
-      }
+        if (methodRoutes.length === 0 && wildcards.length === 0) {
+          return resolve(
+            respondError({ status: 405, message: "method not allowed" }, { allow: allowedMethods }),
+          )
+        }
 
-      const allRoutes = [...wildcards, ...methodRoutes]
-      const selectedFormat = determineSelectedFormat(accept, allRoutes)
+        const allRoutes = [...wildcards, ...methodRoutes]
+        const selectedFormat = determineSelectedFormat(accept, allRoutes)
 
-      const specificFormats = new Set<string>()
-      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
+        const specificFormats = new Set<string>()
+        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" }))
-      }
+        if (selectedFormat === undefined && hasSpecificFormatRoutes && !hasWildcardFormatRoutes) {
+          return resolve(respondError({ status: 406, message: "not acceptable" }))
+        }
 
-      const createChain = (initialContext: any): Effect.Effect<Entity.Entity<any>, any, any> => {
-        let index = 0
-        let currentContext = initialContext
-        let routePathSet = false
+        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
-          }
+          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 }),
-            )
-          }
+            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
+            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()
-          }
+            if (format && format !== "*" && format !== selectedFormat) {
+              return runNext()
+            }
 
-          currentContext = { ...currentContext, ...descriptor }
+            currentContext = { ...currentContext, ...descriptor }
 
-          const nextArg = (ctx?: any) => Entity.effect(Effect.suspend(() => runNext(ctx)))
+            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)
-            })
+            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 handler(currentContext, nextArg)
+          return runNext()
         }
 
-        return runNext()
-      }
+        const effect = Effect.withFiberRuntime<Response, unknown, R>((fiber) => {
+          const tracerDisabled =
+            !fiber.getFiberRef(FiberRef.currentTracerEnabled) ||
+            fiber.getFiberRef(RouteHttpTracer.currentTracerDisabledWhen)(request)
 
-      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 url = new URL(request.url)
+          const innerEffect = Effect.gen(function* () {
+            const result = yield* createChain({ request, selectedFormat })
 
-        const innerEffect = Effect.gen(function* () {
-          const result = yield* createChain({ request, selectedFormat })
+            const entity = Entity.isEntity(result) ? result : Entity.make(result, { status: 200 })
 
-          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" })
+            }
 
-          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
+          })
 
-          const response = yield* toResponse(entity, selectedFormat, runtime)
-          if (varyAccept) {
-            response.headers.set("vary", "Accept")
+          if (tracerDisabled) {
+            return innerEffect
           }
-          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)
-            }
+          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))
 
-            return Effect.flatMap(Effect.exit(Effect.withParentSpan(innerEffect, span)), (exit) => {
-              if (exit._tag === "Success") {
-                span.attribute("http.response.status_code", exit.value.status)
+              const userAgent = request.headers.get("user-agent")
+              if (userAgent !== null) {
+                span.attribute("user_agent.original", userAgent)
               }
-              return exit
-            })
-          },
-        )
-      })
 
-      return new Promise((resolve) => {
+              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
+                },
+              )
+            },
+          )
+        })
+
         const fiber = runFork(
           effect.pipe(
             Effect.scoped,
@@ -356,7 +377,6 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
           }
         })
       })
-    }
   }
 }
 

package/src/RouteMount.ts

@@ -1,11 +1,11 @@
 import * as Function from "effect/Function"
 import type * as Types from "effect/Types"
-import type * as Http from "./Http.ts"
-import type * as PathPattern from "./PathPattern.ts"
+import type * as Http from "./_Http.ts"
+import type * as PathPattern from "./_PathPattern.ts"
 import * as Route from "./Route.ts"
 import type * as RouteBody from "./RouteBody.ts"
 
-const RouteSetTypeId: unique symbol = Symbol.for("effect-start/RouteSet")
+const RouteSetTypeId = "~effect-start/RouteSet" as const
 
 // oxlint-disable-next-line import/first, typescript/consistent-type-imports -- typeof import() is not an import statement
 type Module = typeof import("./RouteMount.ts")

package/src/RouteSchema.ts

@@ -3,8 +3,8 @@ import type * as ParseResult from "effect/ParseResult"
 import * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
 import * as Entity from "./Entity.ts"
-import * as Http from "./Http.ts"
-import * as PathPattern from "./PathPattern.ts"
+import * as Http from "./_Http.ts"
+import * as PathPattern from "./_PathPattern.ts"
 import * as Route from "./Route.ts"
 import * as RouteHook from "./RouteHook.ts"
 

package/src/RouteSse.ts

@@ -5,46 +5,37 @@ import * as Stream from "effect/Stream"
 import type * as Utils from "effect/Utils"
 import * as Entity from "./Entity.ts"
 import * as Route from "./Route.ts"
-import * as StreamExtra from "./StreamExtra.ts"
-import type * as Values from "./Values.ts"
+import * as StreamExtra from "./_StreamExtra.ts"
+import type * as Values from "./_Values.ts"
 
 const HEARTBEAT_INTERVAL = Duration.seconds(5)
 const HEARTBEAT = ": <3\n\n"
 
-export interface SseEvent {
-  data?: string | undefined
-  type?: string
-  retry?: number
+interface SseEvent {
+  readonly [key: string]: unknown
+  readonly _tag?: string
+  readonly data?: string | undefined
+  readonly type?: string
+  readonly retry?: number
 }
 
-export type SseTaggedEvent = {
-  readonly _tag: string
-}
-
-export type SseEventInput = SseEvent | SseTaggedEvent
-
-function isTaggedEvent(event: SseEventInput): event is SseTaggedEvent {
-  return Object.hasOwn(event, "_tag") && typeof event["_tag"] === "string"
-}
-
-function formatSseEvent(event: SseEventInput): string {
-  if (isTaggedEvent(event)) {
+function formatSseEvent(event: SseEvent): string {
+  if (event._tag) {
     const json = JSON.stringify(event)
     return `event: ${event._tag}\ndata: ${json}\n\n`
   }
 
-  const e = event as SseEvent
   let result = ""
-  if (e.type) {
-    result += `event: ${e.type}\n`
+  if (event.type) {
+    result += `event: ${event.type}\n`
   }
-  if (typeof e.data === "string") {
-    for (const line of e.data.split("\n")) {
+  if (typeof event.data === "string") {
+    for (const line of event.data.split("\n")) {
       result += `data: ${line}\n`
     }
   }
-  if (e.retry !== undefined) {
-    result += `retry: ${e.retry}\n`
+  if (event.retry !== undefined) {
+    result += `retry: ${event.retry}\n`
   }
   if (result === "") {
     return ""
@@ -52,18 +43,18 @@ function formatSseEvent(event: SseEventInput): string {
   return result + "\n"
 }
 
-export type SseHandlerInput<B, E, R> =
-  | Stream.Stream<SseEventInput, E, R>
-  | Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
+type SseHandlerInput<B, E, R> =
+  | Stream.Stream<SseEvent, E, R>
+  | Effect.Effect<Stream.Stream<SseEvent, E, R>, E, R>
   | ((
       context: Values.Simplify<B>,
       next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<string>,
     ) =>
-      | Stream.Stream<SseEventInput, E, R>
-      | Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
+      | Stream.Stream<SseEvent, E, R>
+      | Effect.Effect<Stream.Stream<SseEvent, E, R>, E, R>
       | Generator<
           Utils.YieldWrap<Effect.Effect<unknown, E, R>>,
-          Stream.Stream<SseEventInput, E, R>,
+          Stream.Stream<SseEvent, E, R>,
           unknown
         >)
 
@@ -81,24 +72,24 @@ export function sse<
       E,
       R
     > = (ctx, _next) => {
-      const getStream = (): Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R> => {
+      const getStream = (): Effect.Effect<Stream.Stream<SseEvent, E, R>, E, R> => {
         if (typeof handler === "function") {
           const result = (handler as Function)(ctx, _next)
           if (StreamExtra.isStream(result)) {
-            return Effect.succeed(result as Stream.Stream<SseEventInput, E, R>)
+            return Effect.succeed(result as Stream.Stream<SseEvent, E, R>)
           }
           if (Effect.isEffect(result)) {
-            return result as Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
+            return result as Effect.Effect<Stream.Stream<SseEvent, E, R>, E, R>
           }
           return Effect.gen(function* () {
             return yield* result
-          }) as Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
+          }) as Effect.Effect<Stream.Stream<SseEvent, E, R>, E, R>
         }
         if (StreamExtra.isStream(handler)) {
-          return Effect.succeed(handler as Stream.Stream<SseEventInput, E, R>)
+          return Effect.succeed(handler as Stream.Stream<SseEvent, E, R>)
         }
         if (Effect.isEffect(handler)) {
-          return handler as Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
+          return handler as Effect.Effect<Stream.Stream<SseEvent, E, R>, E, R>
         }
         return Effect.succeed(Stream.empty)
       }

package/src/RouteTree.ts

@@ -1,9 +1,9 @@
 import * as Predicate from "effect/Predicate"
-import * as PathPattern from "./PathPattern.ts"
+import * as PathPattern from "./_PathPattern.ts"
 import * as Route from "./Route.ts"
 import type * as RouteMount from "./RouteMount.ts"
 
-const TypeId: unique symbol = Symbol.for("effect-start/RouteTree")
+const TypeId = "~effect-start/RouteTree" as const
 const RouteTreeRoutes: unique symbol = Symbol()
 
 type MethodRoute = Route.Route.With<{ method: string }>

package/src/RouteTrie.ts

@@ -1,4 +1,4 @@
-import * as PathPattern from "./PathPattern.ts"
+import * as PathPattern from "./_PathPattern.ts"
 import * as Route from "./Route.ts"
 
 export interface Node {

package/src/Socket.ts

@@ -1,50 +1,40 @@
 /*
  * Adapted from @effect/platform
  */
+import * as Data from "effect/Data"
 import * as Predicate from "effect/Predicate"
-import * as PlatformError from "./PlatformError.ts"
 
-export const SocketErrorTypeId: unique symbol = Symbol.for("@effect/platform/Socket/SocketError")
-
-export type SocketErrorTypeId = typeof SocketErrorTypeId
+const SocketErrorTypeId: unique symbol = Symbol.for("@effect/platform/Socket/SocketError")
 
 export const isSocketError = (u: unknown): u is SocketError =>
   Predicate.hasProperty(u, SocketErrorTypeId)
 
-export type SocketError = SocketGenericError | SocketCloseError
-
-export class SocketGenericError extends PlatformError.TypeIdError(
-  SocketErrorTypeId,
-  "SocketError",
-)<{
-  readonly reason: "Write" | "Read" | "Open" | "OpenTimeout"
-  readonly cause: unknown
-}> {
-  get message() {
-    return `An error occurred during ${this.reason}`
-  }
-}
-
-export class SocketCloseError extends PlatformError.TypeIdError(SocketErrorTypeId, "SocketError")<{
-  readonly reason: "Close"
-  readonly code: number
+export class SocketError extends Data.TaggedError("SocketError")<{
+  readonly reason: "Write" | "Read" | "Open" | "OpenTimeout" | "Close"
+  readonly cause?: unknown
+  readonly code?: number | undefined
   readonly closeReason?: string | undefined
 }> {
-  static is(u: unknown): u is SocketCloseError {
+  readonly [SocketErrorTypeId]: typeof SocketErrorTypeId = SocketErrorTypeId
+
+  static isClose(u: unknown): u is SocketError & { reason: "Close" } {
     return isSocketError(u) && u.reason === "Close"
   }
 
   static isClean(isClean: (code: number) => boolean) {
-    return function (u: unknown): u is SocketCloseError {
-      return SocketCloseError.is(u) && isClean(u.code)
+    return function (u: unknown): u is SocketError & { reason: "Close" } {
+      return SocketError.isClose(u) && u.code !== undefined && isClean(u.code)
     }
   }
 
   get message() {
-    if (this.closeReason) {
-      return `${this.reason}: ${this.code}: ${this.closeReason}`
+    if (this.reason === "Close") {
+      if (this.closeReason) {
+        return `${this.reason}: ${this.code}: ${this.closeReason}`
+      }
+      return `${this.reason}: ${this.code}`
     }
-    return `${this.reason}: ${this.code}`
+    return `An error occurred during ${this.reason}`
   }
 }