effect-start 0.11.1 → 0.13.0

package/src/TestLogger.test.ts

@@ -0,0 +1,38 @@
+import * as t 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"
+
+t.it("TestLogger captures log messages", () =>
+  Effect
+    .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)
+
+      t.expect(messages).toHaveLength(3)
+      t.expect(messages[0]).toContain("[Error]")
+      t.expect(messages[0]).toContain("This is an error")
+      t.expect(messages[1]).toContain("[Warning]")
+      t.expect(messages[1]).toContain("This is a warning")
+      t.expect(messages[2]).toContain("[Info]")
+      t.expect(messages[2]).toContain("This is info")
+    })
+    .pipe(Effect.provide(TestLogger.layer()), Effect.runPromise))
+
+t.it("TestLogger starts with empty messages", () =>
+  Effect
+    .gen(function*() {
+      const logger = yield* TestLogger.TestLogger
+      const messages = yield* Ref.get(logger.messages)
+
+      t.expect(messages).toHaveLength(0)
+    })
+    .pipe(Effect.provide(TestLogger.layer()), Effect.runPromise))

package/src/TestLogger.ts

@@ -0,0 +1,56 @@
+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 Ref from "effect/Ref"
+
+export type TestLoggerContext = {
+  messages: Ref.Ref<Array<string>>
+}
+
+export class TestLogger extends Context.Tag("effect-start/TestLogger")<
+  TestLogger,
+  TestLoggerContext
+>() {}
+
+export function layer(): Layer.Layer<TestLogger> {
+  return Layer.effect(
+    TestLogger,
+    Effect.gen(function*() {
+      const messages = yield* Ref.make<Array<string>>([])
+
+      const customLogger = Logger.make(({ message, logLevel }) => {
+        Effect.runSync(
+          Ref.update(
+            messages,
+            (msgs) => [...msgs, `[${logLevel._tag}] ${String(message)}`],
+          ),
+        )
+      })
+
+      yield* FiberRef.update(
+        FiberRef.currentLoggers,
+        (loggers) =>
+          HashSet.add(
+            HashSet.remove(loggers, Logger.defaultLogger),
+            customLogger,
+          ),
+      )
+
+      return {
+        messages,
+      }
+    }),
+  )
+}
+
+export const messages: Effect.Effect<
+  Array<string>,
+  never,
+  TestLogger
+> = Effect.gen(function*() {
+  const logger = yield* TestLogger
+  return yield* Ref.get(logger.messages)
+})

package/src/bun/BunHttpServer.ts

@@ -13,8 +13,8 @@ import * as FiberSet from "effect/FiberSet"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import type * as Scope from "effect/Scope"
+import * as FileRouter from "../FileRouter.ts"
 import * as Random from "../Random.ts"
-import * as Router from "../Router.ts"
 import EmptyHTML from "./_empty.html"
 import {
   makeResponse,
@@ -42,7 +42,7 @@ interface ServeOptions {
   readonly development?: boolean
 }
 
-export type BunServer = {
+export type BunHttpServer = {
   readonly server: Bun.Server<WebSocketContext>
   readonly addRoutes: (routes: BunRoute.BunRoutes) => void
   // TODO: we probably don't want to expose these methods publicly
@@ -50,14 +50,14 @@ export type BunServer = {
   readonly popHandler: () => void
 }
 
-export const BunServer = Context.GenericTag<BunServer>(
+export const BunHttpServer = Context.GenericTag<BunHttpServer>(
   "effect-start/BunServer",
 )
 
 export const make = (
   options: ServeOptions,
 ): Effect.Effect<
-  BunServer,
+  BunHttpServer,
   never,
   Scope.Scope
 > =>
@@ -138,7 +138,7 @@ export const make = (
       })
     }
 
-    return BunServer.of({
+    return BunHttpServer.of({
       server,
       pushHandler(fetch) {
         handlerStack.push(fetch)
@@ -160,14 +160,15 @@ export const make = (
 
 export const layer = (
   options?: ServeOptions,
-): Layer.Layer<BunServer> => Layer.scoped(BunServer, make(options ?? {}))
+): Layer.Layer<BunHttpServer> =>
+  Layer.scoped(BunHttpServer, make(options ?? {}))
 
 export const makeHttpServer: Effect.Effect<
   HttpServer.HttpServer,
   never,
-  Scope.Scope | BunServer
+  Scope.Scope | BunHttpServer
 > = Effect.gen(function*() {
-  const bunServer = yield* BunServer
+  const bunServer = yield* BunHttpServer
 
   return HttpServer.make({
     address: {
@@ -229,20 +230,26 @@ export const makeHttpServer: Effect.Effect<
 
 export const layerServer = (
   options?: ServeOptions,
-): Layer.Layer<HttpServer.HttpServer | BunServer> =>
+): Layer.Layer<HttpServer.HttpServer | BunHttpServer> =>
   Layer.provideMerge(
     Layer.scoped(HttpServer.HttpServer, makeHttpServer),
     layer(options ?? {}),
   )
 
-export function layerRoutes() {
+/**
+ * Adds routes from {@like FileRouter.FileRouter} to Bun Server.
+ *
+ * It ain't clean but it works until we figure out interfaces
+ * for other servers.
+ */
+export function layerFileRouter() {
   return Layer.effectDiscard(
     Effect.gen(function*() {
-      const bunServer = yield* BunServer
-      const routerContext = yield* Effect.serviceOption(Router.Router)
+      const bunServer = yield* BunHttpServer
+      const manifest = yield* Effect.serviceOption(FileRouter.FileRouter)
 
-      if (Option.isSome(routerContext)) {
-        const router = yield* Router.fromManifest(routerContext.value)
+      if (Option.isSome(manifest)) {
+        const router = yield* FileRouter.fromManifest(manifest.value)
         const bunRoutes = yield* BunRoute.routesFromRouter(router)
         bunServer.addRoutes(bunRoutes)
       }

package/src/bun/BunRoute.test.ts

@@ -4,12 +4,12 @@ import type { HTMLBundle } from "bun"
 import * as t from "bun:test"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
+import * as assert from "node:assert"
 import * as Route from "../Route.ts"
 import * as Router from "../Router.ts"
 import * as BunHttpServer from "./BunHttpServer.ts"
 import * as BunRoute from "./BunRoute.ts"
 
-
 t.describe(`${BunRoute.validateBunPattern.name}`, () => {
   t.test("allows exact paths", () => {
     const result = BunRoute.validateBunPattern("/users")
@@ -28,35 +28,27 @@ t.describe(`${BunRoute.validateBunPattern.name}`, () => {
 
   t.test("rejects prefixed params", () => {
     const result = BunRoute.validateBunPattern("/users/pk_[id]")
-    t.expect(result._tag).toBe("Some")
-    if (result._tag === "Some") {
-      t.expect(result.value.reason).toBe("UnsupportedPattern")
-      t.expect(result.value.pattern).toBe("/users/pk_[id]")
-    }
+    assert.strictEqual(result._tag, "Some")
+    t.expect(result.value.reason).toBe("UnsupportedPattern")
+    t.expect(result.value.pattern).toBe("/users/pk_[id]")
   })
 
   t.test("rejects suffixed params", () => {
     const result = BunRoute.validateBunPattern("/users/[id]_details")
-    t.expect(result._tag).toBe("Some")
-    if (result._tag === "Some") {
-      t.expect(result.value.reason).toBe("UnsupportedPattern")
-    }
+    assert.strictEqual(result._tag, "Some")
+    t.expect(result.value.reason).toBe("UnsupportedPattern")
   })
 
   t.test("rejects dot suffix on params", () => {
     const result = BunRoute.validateBunPattern("/api/[id].json")
-    t.expect(result._tag).toBe("Some")
-    if (result._tag === "Some") {
-      t.expect(result.value.reason).toBe("UnsupportedPattern")
-    }
+    assert.strictEqual(result._tag, "Some")
+    t.expect(result.value.reason).toBe("UnsupportedPattern")
   })
 
   t.test("rejects tilde suffix on params", () => {
     const result = BunRoute.validateBunPattern("/api/[id]~test")
-    t.expect(result._tag).toBe("Some")
-    if (result._tag === "Some") {
-      t.expect(result.value.reason).toBe("UnsupportedPattern")
-    }
+    assert.strictEqual(result._tag, "Some")
+    t.expect(result.value.reason).toBe("UnsupportedPattern")
   })
 
   t.test("allows optional params (implemented via two patterns)", () => {
@@ -83,34 +75,11 @@ t.describe(`${BunRoute.routesFromRouter.name}`, () => {
         ),
     )
 
-    t.expect(result._tag).toBe("Left")
-    if (result._tag === "Left") {
-      t.expect(result.left._tag).toBe("RouterError")
-      t.expect(result.left.reason).toBe("UnsupportedPattern")
-    }
+    assert.strictEqual(result._tag, "Left")
+    t.expect(result.left._tag).toBe("RouterError")
+    t.expect(result.left.reason).toBe("UnsupportedPattern")
   })
 
-  t.it(
-    "converts text route to fetch handler",
-    () =>
-      Effect.runPromise(
-        Effect
-          .gen(function*() {
-            const bunServer = yield* BunHttpServer.BunServer
-            return 23
-          })
-          .pipe(
-            Effect.provide(
-              Layer.mergeAll(
-                BunHttpServer.layer({
-                  port: 0,
-                }),
-              ),
-            ),
-          ),
-      ),
-  )
-
   t.test("converts text route to fetch handler", async () => {
     const fetch = await makeFetch(
       Router.mount("/hello", Route.text("Hello World")),
@@ -408,7 +377,7 @@ t.describe("BunRoute placeholder replacement", () => {
     await Effect.runPromise(
       Effect
         .gen(function*() {
-          const bunServer = yield* BunHttpServer.BunServer
+          const bunServer = yield* BunHttpServer.BunHttpServer
           const routes = yield* BunRoute.routesFromRouter(router)
           bunServer.addRoutes(routes)
 
@@ -440,7 +409,7 @@ t.describe("BunRoute placeholder replacement", () => {
     await Effect.runPromise(
       Effect
         .gen(function*() {
-          const bunServer = yield* BunHttpServer.BunServer
+          const bunServer = yield* BunHttpServer.BunHttpServer
           const routes = yield* BunRoute.routesFromRouter(router)
           bunServer.addRoutes(routes)
 
@@ -465,8 +434,6 @@ t.describe("BunRoute placeholder replacement", () => {
   })
 })
 
-
-
 type FetchFn = (path: string, init?: { method?: string }) => Promise<Response>
 
 type HandlerFn = (
@@ -474,9 +441,8 @@ type HandlerFn = (
   server: unknown,
 ) => Response | Promise<Response>
 
-
 async function makeBunRoutes(
-  router: Router.RouterBuilder.Any,
+  router: Router.Router.Any,
 ): Promise<BunRoute.BunRoutes> {
   return Effect.runPromise(
     BunRoute.routesFromRouter(router).pipe(
@@ -485,7 +451,7 @@ async function makeBunRoutes(
   )
 }
 
-async function makeFetch(router: Router.RouterBuilder.Any): Promise<FetchFn> {
+async function makeFetch(router: Router.Router.Any): Promise<FetchFn> {
   const routes = await makeBunRoutes(router)
   const mockServer = {} as import("bun").Server<unknown>
 

package/src/bun/BunRoute.ts

@@ -40,7 +40,7 @@ export function html(
   const handler: Route.RouteHandler<
     HttpServerResponse.HttpServerResponse,
     Router.RouterError,
-    BunHttpServer.BunServer
+    BunHttpServer.BunHttpServer
   > = (context) =>
     Effect.gen(function*() {
       const originalRequest = context.request.source as Request
@@ -58,7 +58,8 @@ export function html(
         )
       }
 
-      const bunServer = yield* BunHttpServer.BunServer
+      const bunServer = yield* BunHttpServer.BunHttpServer
+
       const internalPath = `${internalPathPrefix}${context.url.pathname}`
       const internalUrl = new URL(internalPath, bunServer.server.url)
 
@@ -181,61 +182,6 @@ function makeHandler(routes: Route.Route.Default[]) {
   })
 }
 
-/**
- * Finds BunRoutes in the Router and returns
- * a mapping of paths to their bundles that can be passed
- * to Bun's `serve` function.
- */
-export function bundlesFromRouter(
-  router: Router.RouterContext,
-): Effect.Effect<Record<string, Bun.HTMLBundle>> {
-  return Function.pipe(
-    Effect.forEach(
-      router.routes,
-      (mod) =>
-        Effect.promise(() =>
-          mod.load().then((m) => ({ path: mod.path, exported: m.default }))
-        ),
-    ),
-    Effect.map((modules) =>
-      modules.flatMap(({ path, exported }) => {
-        if (Route.isRouteSet(exported)) {
-          return [...exported.set]
-            .filter(isBunRoute)
-            .map((route) =>
-              [
-                path,
-                route,
-              ] as const
-            )
-        }
-
-        return []
-      })
-    ),
-    Effect.flatMap((bunRoutes) =>
-      Effect.forEach(
-        bunRoutes,
-        ([path, route]) =>
-          Effect.promise(() =>
-            route.load().then((bundle) => {
-              const httpPath = RouterPattern.toBun(path)
-
-              return [
-                httpPath,
-                bundle,
-              ] as const
-            })
-          ),
-        { concurrency: "unbounded" },
-      )
-    ),
-    Effect.map((entries) =>
-      Object.fromEntries(entries) as Record<string, Bun.HTMLBundle>
-    ),
-  )
-}
-
 type BunServerFetchHandler = (
   request: Request,
   server: Bun.Server<unknown>,
@@ -314,11 +260,11 @@ export function validateBunPattern(
  * the HtmlBundle natively on the internal route.
  */
 export function routesFromRouter(
-  router: Router.RouterBuilder.Any,
-  runtime?: Runtime.Runtime<BunHttpServer.BunServer>,
-): Effect.Effect<BunRoutes, Router.RouterError, BunHttpServer.BunServer> {
+  router: Router.Router.Any,
+  runtime?: Runtime.Runtime<BunHttpServer.BunHttpServer>,
+): Effect.Effect<BunRoutes, Router.RouterError, BunHttpServer.BunHttpServer> {
   return Effect.gen(function*() {
-    const rt = runtime ?? (yield* Effect.runtime<BunHttpServer.BunServer>())
+    const rt = runtime ?? (yield* Effect.runtime<BunHttpServer.BunHttpServer>())
     const result: BunRoutes = {}
 
     for (const entry of router.entries) {

package/src/bun/BunRoute_bundles.test.ts

@@ -15,13 +15,13 @@ t.describe("BunRoute proxy with Bun.serve", () => {
     await Effect.runPromise(
       Effect
         .gen(function*() {
-          const bunServer = yield* BunHttpServer.BunServer
+          const bunServer = yield* BunHttpServer.BunHttpServer
+
           const routes = yield* BunRoute.routesFromRouter(router)
           bunServer.addRoutes(routes)
 
           const internalPath = Object.keys(routes).find((k) =>
             k.includes(".BunRoute-")
-
           )
           t.expect(internalPath).toBeDefined()
 
@@ -71,7 +71,7 @@ t.describe("BunRoute proxy with Bun.serve", () => {
     await Effect.runPromise(
       Effect
         .gen(function*() {
-          const bunServer = yield* BunHttpServer.BunServer
+          const bunServer = yield* BunHttpServer.BunHttpServer
           const routes = yield* BunRoute.routesFromRouter(router)
           bunServer.addRoutes(routes)
 
@@ -119,7 +119,8 @@ t.describe("BunRoute proxy with Bun.serve", () => {
     await Effect.runPromise(
       Effect
         .gen(function*() {
-          const bunServer = yield* BunHttpServer.BunServer
+          const bunServer = yield* BunHttpServer.BunHttpServer
+
           const routes = yield* BunRoute.routesFromRouter(router)
           bunServer.addRoutes(routes)
 
@@ -160,7 +161,7 @@ t.describe("BunRoute proxy with Bun.serve", () => {
     await Effect.runPromise(
       Effect
         .gen(function*() {
-          const bunServer = yield* BunHttpServer.BunServer
+          const bunServer = yield* BunHttpServer.BunHttpServer
           const routes = yield* BunRoute.routesFromRouter(router)
           bunServer.addRoutes(routes)