effect-start 0.15.0 → 0.16.0

package/src/bun/BunRoute.ts

@@ -1,11 +1,9 @@
-// @ts-nocheck
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
 import type * as Bun from "bun"
 import * as Array from "effect/Array"
+import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
-import * as Predicate from "effect/Predicate"
+import * as Entity from "../Entity.ts"
 import * as Hyper from "../hyper/Hyper.ts"
 import * as HyperHtml from "../hyper/HyperHtml.ts"
 import * as Random from "../Random.ts"
@@ -13,108 +11,159 @@ import * as Route from "../Route.ts"
 import * as RouterPattern from "../RouterPattern.ts"
 import * as BunHttpServer from "./BunHttpServer.ts"
 
-const BunHandlerTypeId: unique symbol = Symbol.for("effect-start/BunHandler")
-
 const INTERNAL_FETCH_HEADER = "x-effect-start-internal-fetch"
 
-export type BunHandler =
-  & Route.RouteHandler<string, Router.RouterError, BunHttpServer.BunHttpServer>
-  & {
-    [BunHandlerTypeId]: typeof BunHandlerTypeId
-    internalPathPrefix: string
-    load: () => Promise<Bun.HTMLBundle>
-  }
+export class BunRouteError extends Data.TaggedError("BunRouteError")<{
+  reason: "ProxyError" | "UnsupportedPattern"
+  pattern: string
+  message: string
+}> {}
 
-export function isBunHandler(input: unknown): input is BunHandler {
-  return typeof input === "function"
-    && Predicate.hasProperty(input, BunHandlerTypeId)
+export type BunDescriptors = {
+  bunPrefix: string
+  bunLoad: () => Promise<Bun.HTMLBundle>
+}
+
+export function descriptors(
+  route: Route.Route.Route,
+): BunDescriptors | undefined {
+  const descriptor = Route.descriptor(route) as Partial<BunDescriptors>
+  if (
+    typeof descriptor.bunPrefix === "string"
+    && typeof descriptor.bunLoad === "function"
+  ) {
+    return descriptor as BunDescriptors
+  }
+  return undefined
 }
 
-export function bundle(
+export function htmlBundle(
   load: () => Promise<Bun.HTMLBundle | { default: Bun.HTMLBundle }>,
-): BunHandler {
-  const internalPathPrefix = `/.BunRoute-${Random.token(6)}`
-
-  const handler = (context: Route.RouteContext, next: Route.RouteNext) =>
-    Effect.gen(function*() {
-      const request = yield* HttpServerRequest.HttpServerRequest
-      const originalRequest = request.source as Request
-
-      if (
-        originalRequest.headers.get(INTERNAL_FETCH_HEADER) === "true"
-      ) {
-        return yield* Effect.fail(
-          new Router.RouterError({
-            reason: "ProxyError",
-            pattern: context.url.pathname,
-            message:
-              "Request to internal Bun server was caught by BunRoute handler. This should not happen. Please report a bug.",
-          }),
-        )
-      }
-
-      const bunServer = yield* BunHttpServer.BunHttpServer
-
-      const internalPath = `${internalPathPrefix}${context.url.pathname}`
-      const internalUrl = new URL(internalPath, bunServer.server.url)
-
-      const headers = new Headers(originalRequest.headers)
-      headers.set(INTERNAL_FETCH_HEADER, "true")
-
-      const proxyRequest = new Request(internalUrl, {
-        method: originalRequest.method,
-        headers,
-      })
+) {
+  const bunPrefix = `/.BunRoute-${Random.token(6)}`
+  const bunLoad = () => load().then(mod => "default" in mod ? mod.default : mod)
+  const descriptors = { bunPrefix, bunLoad, format: "html" as const }
+
+  return function<
+    D extends Route.RouteDescriptor.Any,
+    B extends {},
+    I extends Route.Route.Tuple,
+  >(
+    self: Route.RouteSet.RouteSet<D, B, I>,
+  ): Route.RouteSet.RouteSet<
+    D,
+    B,
+    [
+      ...I,
+      Route.Route.Route<
+        BunDescriptors & { format: "html" },
+        { request: Request },
+        string,
+        BunRouteError,
+        BunHttpServer.BunHttpServer
+      >,
+    ]
+  > {
+    const handler: Route.Route.Handler<
+      BunDescriptors & { format: "html" } & { request: Request },
+      string,
+      BunRouteError,
+      BunHttpServer.BunHttpServer
+    > = (context, next) =>
+      Effect.gen(function*() {
+        const originalRequest = context.request
+
+        if (
+          originalRequest.headers.get(INTERNAL_FETCH_HEADER) === "true"
+        ) {
+          const url = new URL(originalRequest.url)
+          return yield* Effect.fail(
+            new BunRouteError({
+              reason: "ProxyError",
+              pattern: url.pathname,
+              message:
+                "Request to internal Bun server was caught by BunRoute handler. This should not happen. Please report a bug.",
+            }),
+          )
+        }
 
-      const response = yield* Effect.tryPromise({
-        try: () => fetch(proxyRequest),
-        catch: (error) =>
-          new Router.RouterError({
-            reason: "ProxyError",
-            pattern: internalPath,
-            message: `Failed to fetch internal HTML bundle: ${String(error)}`,
-          }),
-      })
+        const bunServer = yield* BunHttpServer.BunHttpServer
+        const url = new URL(originalRequest.url)
+
+        const internalPath = `${bunPrefix}${url.pathname}`
+        const internalUrl = new URL(internalPath, bunServer.server.url)
+
+        const headers = new Headers(originalRequest.headers)
+        headers.set(INTERNAL_FETCH_HEADER, "true")
+
+        const proxyRequest = new Request(internalUrl, {
+          method: originalRequest.method,
+          headers,
+        })
+
+        const response = yield* Effect.tryPromise({
+          try: () => fetch(proxyRequest),
+          catch: (error) =>
+            new BunRouteError({
+              reason: "ProxyError",
+              pattern: internalPath,
+              message: `Failed to fetch internal HTML bundle: ${String(error)}`,
+            }),
+        })
+
+        let html = yield* Effect.tryPromise({
+          try: () => response.text(),
+          catch: (error) =>
+            new BunRouteError({
+              reason: "ProxyError",
+              pattern: internalPath,
+              message: String(error),
+            }),
+        })
+
+        const childEntity = yield* Entity.resolve(next(context))
+        const children = childEntity?.body ?? childEntity
+
+        let childrenHtml = ""
+        if (children != null) {
+          if ((children as unknown) instanceof Response) {
+            childrenHtml = yield* Effect.promise(() =>
+              (children as unknown as Response).text()
+            )
+          } else if (Hyper.isGenericJsxObject(children)) {
+            childrenHtml = HyperHtml.renderToString(children)
+          } else {
+            childrenHtml = String(children)
+          }
+        }
 
-      let html = yield* Effect.tryPromise({
-        try: () => response.text(),
-        catch: (error) =>
-          new Router.RouterError({
-            reason: "ProxyError",
-            pattern: internalPath,
-            message: String(error),
-          }),
+        html = html.replace(/%children%/g, childrenHtml)
+
+        return Entity.make(html, {
+          status: response.status,
+          headers: {
+            "content-type": response.headers.get("content-type"),
+          },
+        })
       })
 
-      const children = yield* next()
-      let childrenHtml = ""
-      if (children != null) {
-        if (HttpServerResponse.isServerResponse(children)) {
-          const webResponse = HttpServerResponse.toWeb(children)
-          childrenHtml = yield* Effect.promise(() => webResponse.text())
-        } else if (Hyper.isGenericJsxObject(children)) {
-          childrenHtml = HyperHtml.renderToString(children)
-        } else {
-          childrenHtml = String(children)
-        }
-      }
-
-      html = html.replace(/%yield%/g, childrenHtml)
-      html = html.replace(
-        /%slots\.(\w+)%/g,
-        (_, name) => context.slots[name] ?? "",
-      )
-
-      return html
-    })
-
-  return Object.assign(handler, {
-    [BunHandlerTypeId]: BunHandlerTypeId,
-    internalPathPrefix,
-    load: () => load().then(mod => "default" in mod ? mod.default : mod),
-  }) as BunHandler
+    const route = Route.make<
+      BunDescriptors & { format: "html" },
+      { request: Request },
+      string,
+      BunRouteError,
+      BunHttpServer.BunHttpServer
+    >(handler, descriptors)
+
+    return Route.set(
+      [...Route.items(self), route] as any,
+      Route.descriptor(self),
+    )
+  }
 }
 
+
+
 type BunServerFetchHandler = (
   request: Request,
   server: Bun.Server<unknown>,
@@ -127,14 +176,6 @@ type BunServerRouteHandler =
 
 export type BunRoutes = Record<string, BunServerRouteHandler>
 
-type MethodHandlers = Partial<
-  Record<Bun.Serve.HTTPMethod, BunServerFetchHandler>
->
-
-function isMethodHandlers(value: unknown): value is MethodHandlers {
-  return typeof value === "object" && value !== null && !("index" in value)
-}
-
 /**
  * Validates that a route pattern can be implemented with Bun.serve routes.
  *
@@ -156,7 +197,7 @@ function isMethodHandlers(value: unknown): value is MethodHandlers {
 
 export function validateBunPattern(
   pattern: string,
-): Option.Option<Router.RouterError> {
+): Option.Option<BunRouteError> {
   const segments = RouterPattern.parse(pattern)
 
   const unsupported = Array.findFirst(segments, (seg) => {
@@ -169,7 +210,7 @@ export function validateBunPattern(
 
   if (Option.isSome(unsupported)) {
     return Option.some(
-      new Router.RouterError({
+      new BunRouteError({
         reason: "UnsupportedPattern",
         pattern,
         message:
@@ -182,7 +223,7 @@ export function validateBunPattern(
   return Option.none()
 }
 
-export const isHTMLBundle = (handle: any) => {
+export const isHtmlBundle = (handle: any) => {
   return (
     typeof handle === "object"
     && handle !== null

package/src/index.ts

@@ -1,4 +1,5 @@
 export * as Bundle from "./bundler/Bundle.ts"
+export * as Entity from "./Entity.ts"
 export * as FileRouter from "./FileRouter.ts"
 export * as Route from "./Route.ts"
 export * as Start from "./Start.ts"

package/src/testing/TestLogger.test.ts

@@ -1,6 +1,5 @@
 import * as test from "bun:test"
 import * as Effect from "effect/Effect"
-import * as Logger from "effect/Logger"
 import * as Ref from "effect/Ref"
 import * as TestLogger from "./TestLogger.ts"
 
@@ -9,12 +8,10 @@ test.it("TestLogger captures log messages", () =>
     .gen(function*() {
       const logger = yield* TestLogger.TestLogger
 
-      // Log some messages
       yield* Effect.logError("This is an error")
       yield* Effect.logWarning("This is a warning")
       yield* Effect.logInfo("This is info")
 
-      // Read captured messages
       const messages = yield* Ref.get(logger.messages)
 
       test

package/src/testing/TestLogger.ts

@@ -1,9 +1,11 @@
+import * as Cause from "effect/Cause"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as FiberRef from "effect/FiberRef"
 import * as HashSet from "effect/HashSet"
 import * as Layer from "effect/Layer"
 import * as Logger from "effect/Logger"
+import * as MutableRef from "effect/MutableRef"
 import * as Ref from "effect/Ref"
 
 export type TestLoggerContext = {
@@ -20,13 +22,19 @@ export function layer(): Layer.Layer<TestLogger> {
     TestLogger,
     Effect.gen(function*() {
       const messages = yield* Ref.make<Array<string>>([])
+      const mutableRef = (messages as any).ref as MutableRef.MutableRef<
+        Array<string>
+      >
 
-      const customLogger = Logger.make(({ message, logLevel }) => {
-        Effect.runSync(
-          Ref.update(
-            messages,
-            (msgs) => [...msgs, `[${logLevel._tag}] ${String(message)}`],
-          ),
+      const customLogger = Logger.make(({ message, logLevel, cause }) => {
+        const causeStr = !Cause.isEmpty(cause)
+          ? ` ${Cause.pretty(cause)}`
+          : ""
+        MutableRef.update(
+          mutableRef,
+          (
+            msgs,
+          ) => [...msgs, `[${logLevel._tag}] ${String(message)}${causeStr}`],
         )
       })
 
@@ -39,9 +47,7 @@ export function layer(): Layer.Layer<TestLogger> {
           ),
       )
 
-      return {
-        messages,
-      }
+      return { messages }
     }),
   )
 }