effect-start 0.9.0

package/src/Router.ts

@@ -0,0 +1,80 @@
+import * as HttpApp from "@effect/platform/HttpApp"
+import * as HttpRouter from "@effect/platform/HttpRouter"
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as Function from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as FileHttpRouter from "./FileHttpRouter.ts"
+import * as FileRouter from "./FileRouter.ts"
+import * as Route from "./Route"
+
+export const ServerMethods = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD",
+] as const
+
+export type ServerMethod = (typeof ServerMethods)[number]
+
+export type ServerModule = {
+  default: Route.Route | Route.RouteSet.Default
+}
+
+export type ServerRoute = {
+  path: `/${string}`
+  segments: readonly FileRouter.Segment[]
+  load: () => Promise<ServerModule>
+}
+
+export type RouteManifest = {
+  modules: readonly FileRouter.RouteModule[]
+}
+
+export type RouterContext =
+  & RouteManifest
+  & {
+    httpRouter: HttpRouter.HttpRouter
+  }
+
+export class Router extends Context.Tag("effect-start/Router")<
+  Router,
+  RouterContext
+>() {}
+
+export function layer(
+  manifest: RouteManifest,
+): Layer.Layer<Router, never, never> {
+  return Layer.effect(
+    Router,
+    Effect.gen(function*() {
+      const serverRoutes = manifest.modules.map((mod) => ({
+        path: mod.path,
+        load: mod.load,
+      }))
+      const httpRouter = yield* FileHttpRouter.make(serverRoutes)
+      return {
+        ...manifest,
+        httpRouter,
+      }
+    }),
+  )
+}
+
+export function layerPromise(
+  load: () => Promise<RouteManifest>,
+): Layer.Layer<Router, never, never> {
+  return Layer.unwrapEffect(
+    Effect.gen(function*() {
+      const importedModule = yield* Function.pipe(
+        Effect.promise(() => load()),
+        Effect.orDie,
+      )
+
+      return layer(importedModule)
+    }),
+  )
+}

package/src/SseHttpResponse.ts

@@ -0,0 +1,55 @@
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
+import * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
+import * as Function from "effect/Function"
+import * as Schedule from "effect/Schedule"
+import * as Stream from "effect/Stream"
+import * as StreamExtra from "./StreamExtra.ts"
+
+const DefaultHeartbeatInterval = Duration.seconds(5)
+
+export const make = <T = any>(stream: Stream.Stream<T, any>, options?: {
+  heartbeatInterval?: Duration.DurationInput
+}) =>
+  Effect.gen(function*() {
+    const heartbeat = Stream.repeat(
+      Stream.succeed(null),
+      Schedule.spaced(options?.heartbeatInterval ?? DefaultHeartbeatInterval),
+    )
+
+    const encoder = new TextEncoder()
+
+    const events = Function.pipe(
+      Stream.merge(
+        heartbeat.pipe(
+          Stream.map(() => ":\n\n"),
+        ),
+        stream.pipe(
+          Stream.map(event => `data: ${JSON.stringify(event)}\n\n`),
+        ),
+      ),
+      // without Stream.tap, only two events are sent
+      // Effect.fork(Stream.runDrain) doesn't seem to work.
+      // Asked for help here: [2025-04-09]
+      // https://discord.com/channels/795981131316985866/1359523331400929341
+      Stream.tap(v => Effect.gen(function*() {})),
+      Stream.map(str => encoder.encode(str)),
+    )
+
+    const toStream = StreamExtra.toReadableStreamRuntimePatched(
+      yield* Effect.runtime(),
+    )
+
+    // see toStream to understand why we're not using
+    // HttpServerResponse.stream here.
+    return HttpServerResponse.raw(
+      toStream(events),
+      {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+        },
+      },
+    )
+  })

package/src/Start.ts

@@ -0,0 +1,133 @@
+import * as BunContext from "@effect/platform-bun/BunContext"
+import * as BunHttpServer from "@effect/platform-bun/BunHttpServer"
+import * as BunRuntime from "@effect/platform-bun/BunRuntime"
+import * as FetchHttpClient from "@effect/platform/FetchHttpClient"
+import * as HttpClient from "@effect/platform/HttpClient"
+import * as HttpRouter from "@effect/platform/HttpRouter"
+import * as HttpServer from "@effect/platform/HttpServer"
+import * as Effect from "effect/Effect"
+import * as Function from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as BunBundle from "./bun/BunBundle.ts"
+import * as Bundle from "./Bundle.ts"
+import * as BundleHttp from "./BundleHttp.ts"
+import * as FileRouter from "./FileRouter.ts"
+import * as HttpAppExtra from "./HttpAppExtra.ts"
+import * as Router from "./Router.ts"
+import * as StartApp from "./StartApp.ts"
+
+// TODO: we probably want to remove this API to avoid
+// multiple entrypoints for routers and bundles.
+// We could handle endpoints routing in {@link layer}
+// or {@link serve}.
+// Serve probably makes more sense because it's an entrypoint
+// for serving an HTTP server
+export function router(options: {
+  load: () => Promise<Router.RouteManifest>
+  path: string
+}) {
+  return Layer.provideMerge(
+    // add it to BundleHttp
+    Layer.effectDiscard(
+      Effect.gen(function*() {
+        const httpRouter = yield* HttpRouter.Default
+        const startRouter = yield* Router.Router
+
+        yield* httpRouter.concat(startRouter.httpRouter)
+      }),
+    ),
+    Layer.merge(
+      Router.layerPromise(options.load),
+      FileRouter.layer(options),
+    ),
+  )
+}
+
+export function bundleClient(config: BunBundle.BuildOptions | string) {
+  const clientLayer = Layer.effect(
+    Bundle.ClientBundle,
+    Function.pipe(
+      BunBundle.buildClient(config),
+      Bundle.handleBundleErrorSilently,
+    ),
+  )
+  const assetsLayer = Layer.effectDiscard(Effect.gen(function*() {
+    const router = yield* HttpRouter.Default
+    const app = BundleHttp.toHttpApp(Bundle.ClientBundle)
+
+    yield* router.mountApp(
+      "/_bundle",
+      // we need to use as any here because HttpRouter.Default
+      // only accepts default services.
+      app as any,
+    )
+  }))
+
+  return Layer.mergeAll(
+    clientLayer,
+    assetsLayer,
+  )
+}
+
+export function layer<
+  Layers extends [
+    Layer.Layer<never, any, any>,
+    ...Array<Layer.Layer<never, any, any>>,
+  ],
+>(...layers: Layers): Layer.Layer<
+  { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number],
+  { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
+  { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
+> {
+  return Layer.mergeAll(...layers)
+}
+
+export function serve<ROut, E>(
+  load: () => Promise<{
+    default: Layer.Layer<
+      ROut,
+      E,
+      | HttpServer.HttpServer
+      | HttpRouter.Default
+      | HttpClient.HttpClient
+      | BunContext.BunContext
+    >
+  }>,
+) {
+  const appLayer = Function.pipe(
+    Effect.tryPromise(load),
+    Effect.map(v => v.default),
+    Effect.orDie,
+    Layer.unwrapEffect,
+  )
+
+  return Function.pipe(
+    Layer.unwrapEffect(Effect.gen(function*() {
+      const middlewareService = yield* StartApp.StartApp
+      const middleware = yield* middlewareService.middleware
+
+      const finalMiddleware = Function.flow(
+        HttpAppExtra.handleErrors,
+        middleware,
+      )
+
+      return Function.pipe(
+        HttpRouter
+          .Default
+          .serve(finalMiddleware),
+        HttpServer.withLogAddress,
+      )
+    })),
+    Layer.provide(appLayer),
+    Layer.provide([
+      FetchHttpClient.layer,
+      HttpRouter.Default.Live,
+      BunHttpServer.layer({
+        port: 3000,
+      }),
+      StartApp.layer(),
+    ]),
+    Layer.launch,
+    BunRuntime.runMain,
+  )
+}

package/src/StartApp.ts

@@ -0,0 +1,43 @@
+import * as HttpApp from "@effect/platform/HttpApp"
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as Function from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Ref from "effect/Ref"
+
+type NewType = HttpApp.Default<never, never>
+
+type StartMiddleware = <E, R>(
+  self: HttpApp.Default<E, R>,
+) => NewType
+
+export class StartApp extends Context.Tag("effect-start/StartApp")<
+  StartApp,
+  {
+    readonly env: "development" | "production" | string
+    readonly relativeUrlRoot?: string
+    readonly addMiddleware: (
+      middleware: StartMiddleware,
+    ) => Effect.Effect<void>
+    readonly middleware: Ref.Ref<StartMiddleware>
+  }
+>() {
+}
+
+export function layer(options?: {
+  env?: string
+}) {
+  return Layer.sync(StartApp, () => {
+    const env = options?.env ?? process.env.NODE_ENV ?? "development"
+    const middleware = Ref.unsafeMake(
+      Function.identity as StartMiddleware,
+    )
+
+    return StartApp.of({
+      env,
+      middleware,
+      addMiddleware: (f) =>
+        Ref.update(middleware, (prev) => (app) => f(prev(app))),
+    })
+  })
+}

package/src/StartHttp.ts

@@ -0,0 +1,42 @@
+import * as HttpApp from "@effect/platform/HttpApp"
+import * as HttpMiddleware from "@effect/platform/HttpMiddleware"
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
+import * as Effect from "effect/Effect"
+import {
+  Bundle,
+  BundleHttp,
+} from "."
+
+type SsrRenderer = (req: Request) => PromiseLike<Response>
+
+/**
+ * Attempts to render SSR page. If the renderer returns 404,
+ * we fall back to app.
+ */
+export function ssr(renderer: SsrRenderer) {
+  return Effect.gen(function*() {
+    const request = yield* HttpServerRequest.HttpServerRequest
+    const webRequest = request.source as Request
+    const ssrRes = yield* Effect.tryPromise(() => renderer(webRequest))
+
+    return HttpServerResponse.raw(ssrRes.body, {
+      status: ssrRes.status,
+      headers: ssrRes.headers,
+    })
+  })
+}
+
+export function withBundleAssets(opts?: {
+  path?: string
+}) {
+  return HttpMiddleware.make(app =>
+    Effect.gen(function*() {
+      const request = yield* HttpServerRequest.HttpServerRequest
+      const bundleResponse = yield* BundleHttp.httpApp()
+
+      // Fallback to original app
+      return yield* app
+    })
+  )
+}

package/src/StreamExtra.ts

@@ -0,0 +1,146 @@
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as Fiber from "effect/Fiber"
+import { dual } from "effect/Function"
+import * as Predicate from "effect/Predicate"
+import * as Runtime from "effect/Runtime"
+import * as Stream from "effect/Stream"
+import {
+  runForEachChunk,
+  StreamTypeId,
+} from "effect/Stream"
+
+/**
+ * Patched version of original Stream.toReadableStreamRuntime (v3.14.4) to
+ * fix an issue in Bun when native stream controller stops working when request
+ * is terminated by the client:
+ *
+ *  TypeError: Value of "this" must be of type ReadableStreamDefaultController
+ *
+ * See related issues:
+ * https://github.com/Effect-TS/effect/issues/4538
+ * https://github.com/oven-sh/bun/issues/17837
+ */
+export const toReadableStreamRuntimePatched = dual<
+  <A, XR>(
+    runtime: Runtime.Runtime<XR>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined },
+  ) => <E, R extends XR>(self: Stream.Stream<A, E, R>) => ReadableStream<A>,
+  <A, E, XR, R extends XR>(
+    self: Stream.Stream<A, E, R>,
+    runtime: Runtime.Runtime<XR>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined },
+  ) => ReadableStream<A>
+>(
+  (args) =>
+    Predicate.hasProperty(args[0], StreamTypeId) || Effect.isEffect(args[0]),
+  <A, E, XR, R extends XR>(
+    self: Stream.Stream<A, E, R>,
+    runtime: Runtime.Runtime<XR>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined },
+  ): ReadableStream<A> => {
+    const runFork = Runtime.runFork(runtime)
+    let currentResolve: (() => void) | undefined = undefined
+    let fiber: Fiber.RuntimeFiber<void, E> | undefined = undefined
+    const latch = Effect.unsafeMakeLatch(false)
+
+    return new ReadableStream<A>({
+      start(controller) {
+        fiber = runFork(
+          runForEachChunk(self, (chunk) =>
+            latch.whenOpen(Effect.sync(() => {
+              latch.unsafeClose()
+              try {
+                for (const item of chunk) {
+                  controller.enqueue(item)
+                }
+              } catch (e) {
+                if (
+                  (e as Error).message
+                    === `Value of "this" must be of type ReadableStreamDefaultController`
+                ) {
+                  // Do nothing when this happens in Bun.
+                } else {
+                  throw e
+                }
+              }
+              currentResolve!()
+              currentResolve = undefined
+            }))),
+        )
+        // --- CHANGES HERE ---
+        // In original code, we had fiber.addObserver here that called
+        // error() or close() on controller. This patched version removes it.
+      },
+      pull() {
+        return new Promise<void>((resolve) => {
+          currentResolve = resolve
+          Effect.runSync(latch.open)
+        })
+      },
+      cancel() {
+        if (!fiber) return
+        return Effect.runPromise(Effect.asVoid(Fiber.interrupt(fiber)))
+      },
+    }, options?.strategy)
+  },
+)
+
+export const toReadableStreamRuntimePatched2 = dual<
+  <A, XR>(
+    runtime: Runtime.Runtime<XR>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined },
+  ) => <E, R extends XR>(self: Stream.Stream<A, E, R>) => ReadableStream<A>,
+  <A, E, XR, R extends XR>(
+    self: Stream.Stream<A, E, R>,
+    runtime: Runtime.Runtime<XR>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined },
+  ) => ReadableStream<A>
+>(
+  (args) =>
+    Predicate.hasProperty(args[0], StreamTypeId) || Effect.isEffect(args[0]),
+  <A, E, XR, R extends XR>(
+    self: Stream.Stream<A, E, R>,
+    runtime: Runtime.Runtime<XR>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined },
+  ): ReadableStream<A> => {
+    const runSync = Runtime.runSync(runtime)
+    const runFork = Runtime.runFork(runtime)
+    let currentResolve: (() => void) | undefined = undefined
+    let fiber: Fiber.RuntimeFiber<void, E> | undefined = undefined
+    const latch = Effect.unsafeMakeLatch(false)
+
+    return new ReadableStream<A>({
+      start(controller) {
+        fiber = runFork(
+          runForEachChunk(self, (chunk) =>
+            latch.whenOpen(Effect.sync(() => {
+              latch.unsafeClose()
+              for (const item of chunk) {
+                controller.enqueue(item)
+              }
+              currentResolve!()
+              currentResolve = undefined
+            }))),
+        )
+        fiber.addObserver((exit) => {
+          if (exit._tag === "Failure") {
+            controller.error(Cause.squash(exit.cause))
+          } else {
+            controller.close()
+          }
+        })
+      },
+      pull() {
+        return new Promise<void>((resolve) => {
+          currentResolve = resolve
+          Effect.runSync(latch.open)
+        })
+      },
+      cancel() {
+        if (!fiber) return
+        return Effect.runPromise(Effect.asVoid(Fiber.interrupt(fiber)))
+      },
+    }, options?.strategy)
+  },
+)

package/src/TestHttpClient.test.ts

@@ -0,0 +1,54 @@
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
+import * as t from "bun:test"
+import * as Effect from "effect/Effect"
+import * as TestHttpClient from "./TestHttpClient.ts"
+import { effectFn } from "./testing.ts"
+
+const App = Effect.gen(function*() {
+  const req = yield* HttpServerRequest.HttpServerRequest
+
+  if (req.url == "/") {
+    return HttpServerResponse.text("Hello, World!")
+  }
+
+  return HttpServerResponse.text("Not Found", {
+    status: 404,
+  })
+})
+
+const AppClient = TestHttpClient.make(App)
+
+const effect = effectFn()
+
+t.it("ok", () =>
+  effect(function*() {
+    const res = yield* AppClient.get("/")
+
+    t
+      .expect(
+        res.status,
+      )
+      .toEqual(200)
+    t
+      .expect(
+        yield* res.text,
+      )
+      .toEqual("Hello, World!")
+  }))
+
+t.it("not found", () =>
+  effect(function*() {
+    const res = yield* AppClient.get("/nope")
+
+    t
+      .expect(
+        res.status,
+      )
+      .toEqual(404)
+    t
+      .expect(
+        yield* res.text,
+      )
+      .toEqual("Not Found")
+  }))

package/src/TestHttpClient.ts

@@ -0,0 +1,100 @@
+// @ts-nocheck
+import * as HttpApp from "@effect/platform/HttpApp"
+import * as HttpClient from "@effect/platform/HttpClient"
+import * as HttpClientError from "@effect/platform/HttpClientError"
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest"
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse"
+import { RouteNotFound } from "@effect/platform/HttpServerError"
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
+import * as Effect from "effect/Effect"
+import * as Function from "effect/Function"
+import * as Scope from "effect/Scope"
+import * as Stream from "effect/Stream"
+
+const WebHeaders = globalThis.Headers
+
+export const make = <E = any, R = any>(
+  httpApp: HttpApp.Default<E, R>,
+  opts?: {
+    baseUrl?: string | null
+    handleRouteNotFound?: (
+      e: RouteNotFound,
+    ) => Effect.Effect<HttpClientResponse.HttpClientResponse> | null
+  },
+): HttpClient.HttpClient.With<
+  HttpClientError.HttpClientError | E,
+  Exclude<
+    Scope.Scope | R,
+    HttpServerRequest.HttpServerRequest
+  >
+> =>
+  HttpClient
+    .make(
+      (request, url, signal) => {
+        const send = (
+          body: BodyInit | undefined,
+        ) => {
+          const app = httpApp
+          const serverRequest = HttpServerRequest.fromWeb(
+            new Request(url.toString(), {
+              method: request.method,
+              headers: new WebHeaders(request.headers),
+              body,
+              duplex: request.body._tag === "Stream" ? "half" : undefined,
+              signal,
+            } as any),
+          )
+
+          return Function.pipe(
+            app,
+            Effect.provideService(
+              HttpServerRequest.HttpServerRequest,
+              serverRequest,
+            ),
+            Effect.andThen(HttpServerResponse.toWeb),
+            Effect.andThen(res => HttpClientResponse.fromWeb(request, res)),
+            opts?.handleRouteNotFound === null
+              ? Function.identity
+              : Effect.catchTag("RouteNotFound", e =>
+                Effect
+                  .succeed(HttpClientResponse.fromWeb(
+                    e.request,
+                    new Response("Failed with RouteNotFound", {
+                      status: 404,
+                    }),
+                  ))),
+          )
+        }
+
+        switch (
+          request
+            .body
+            ._tag
+        ) {
+          case "Raw":
+          case "Uint8Array":
+            return send(
+              request
+                .body
+                .body as any,
+            )
+          case "FormData":
+            return send(request.body.formData)
+          case "Stream":
+            return Effect.flatMap(
+              Stream.toReadableStreamEffect(request.body.stream),
+              send,
+            )
+        }
+
+        return send(undefined)
+      },
+    )
+    .pipe(
+      opts?.baseUrl === null
+        ? Function.identity
+        : HttpClient.mapRequest(
+          HttpClientRequest.prependUrl(opts?.baseUrl ?? "http://localhost"),
+        ),
+    )