effect-start 0.10.0 → 0.11.0

package/src/Route.ts

@@ -2,9 +2,7 @@ import * as HttpMethod from "@effect/platform/HttpMethod"
 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 * as Function from "effect/Function"
 import * as Pipeable from "effect/Pipeable"
 import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
@@ -71,6 +69,7 @@ export type RouteMethod =
   | "*"
   | HttpMethod.HttpMethod
 
+// TODO: This should be a RouterPattern and moved to its file?
 export type RoutePattern = `/${string}`
 
 /**
@@ -185,7 +184,7 @@ type RouteBuilder = {
   get: typeof get
   put: typeof put
   patch: typeof patch
-  del: typeof del
+  delete: typeof _delete
   options: typeof options
   head: typeof head
 
@@ -285,20 +284,26 @@ export function matches(
 }
 
 export const post = makeMethodModifier("POST")
-
 export const get = makeMethodModifier("GET")
 export const put = makeMethodModifier("PUT")
 export const patch = makeMethodModifier("PATCH")
-export const del = makeMethodModifier("DELETE")
 export const options = makeMethodModifier("OPTIONS")
 export const head = makeMethodModifier("HEAD")
+const _delete = makeMethodModifier("DELETE")
+export {
+  _delete as delete,
+}
 
 export const text = makeMediaFunction<"GET", "text/plain", string>(
   "GET",
   "text/plain",
 )
 
-export const html = makeMediaFunction<"GET", "text/html", string | JsxObject>(
+export const html = makeMediaFunction<
+  "GET",
+  "text/html",
+  string | GenericJsxObject
+>(
   "GET",
   "text/html",
 )
@@ -525,7 +530,7 @@ const SetProto = {
   get,
   put,
   patch,
-  del,
+  delete: _delete,
   options,
   head,
 
@@ -611,21 +616,21 @@ export type DecodeRouteSchemas<Schemas extends RouteSchemas> =
 
 /**
  * Context passed to route handler functions.
+ *
+ * @template {Input} Decoded schema values (pathParams, urlParams, etc.)
+ * @template {Next}  Return type of next() based on media type
  */
 export type RouteContext<
   Input extends RouteContextDecoded = {},
-> = {
-  request: HttpServerRequest.HttpServerRequest
-  get url(): URL
-  slots: Record<string, string>
-  next: () => Effect.Effect<any, any, any>
-} & Input
-
-/**
- * Extracts fields from a Schema.Struct or returns never if not a struct.
- */
-type ExtractStructFields<S> = S extends Schema.Struct<infer Fields> ? Fields
-  : never
+  Next = unknown,
+> =
+  & {
+    request: HttpServerRequest.HttpServerRequest
+    get url(): URL
+    slots: Record<string, string>
+    next: <E = unknown, R = unknown>() => Effect.Effect<Next, E, R>
+  }
+  & Input
 
 /**
  * Merges two RouteSchemas types.
@@ -789,6 +794,31 @@ function makeSet<
   ) as RouteSet<M, Schemas>
 }
 
+type HandlerInput<A, E, R> =
+  | A
+  | Effect.Effect<A, E, R>
+  | ((context: RouteContext) =>
+    | Effect.Effect<A, E, R>
+    | Generator<YieldWrap<Effect.Effect<A, E, R>>, A, never>)
+
+function normalizeHandler<A, E, R>(
+  handler: HandlerInput<A, E, R>,
+): RouteHandler<A, E, R> {
+  if (typeof handler === "function") {
+    return (context): Effect.Effect<A, E, R> => {
+      const result = (handler as Function)(context)
+      if (Effect.isEffect(result)) {
+        return result as Effect.Effect<A, E, R>
+      }
+      return Effect.gen(() => result) as Effect.Effect<A, E, R>
+    }
+  }
+  if (Effect.isEffect(handler)) {
+    return () => handler
+  }
+  return () => Effect.succeed(handler as A)
+}
+
 /**
  * Factory function that creates Route for a specific method & media.
  * Accepts Effect, function that returns Effect, and effectful generator.
@@ -809,13 +839,17 @@ function makeMediaFunction<
   >(
     this: S,
     handler: S extends RouteSet<infer _Routes, infer Schemas> ?
+        | A
         | Effect.Effect<A, E, R>
-        | ((context: RouteContext<DecodeRouteSchemas<Schemas>>) =>
+        | ((
+          context: RouteContext<DecodeRouteSchemas<Schemas>, ExpectedValue>,
+        ) =>
           | Effect.Effect<A, E, R>
           | Generator<YieldWrap<Effect.Effect<A, E, R>>, A, never>)
       :
+        | A
         | Effect.Effect<A, E, R>
-        | ((context: RouteContext<{}>) =>
+        | ((context: RouteContext<{}, ExpectedValue>) =>
           | Effect.Effect<A, E, R>
           | Generator<YieldWrap<Effect.Effect<A, E, R>>, A, never>),
   ): S extends RouteSet<infer Routes, infer Schemas> ? RouteSet<[
@@ -836,23 +870,6 @@ function makeMediaFunction<
       >,
     ], RouteSchemas.Empty>
   {
-    const normalizedHandler: RouteHandler<A, E, R> =
-      typeof handler === "function"
-        ? (context: RouteContext): Effect.Effect<A, E, R> => {
-          const result = handler(context)
-          if (Effect.isEffect(result)) {
-            return result
-          }
-          return Effect.gen(() =>
-            result as Generator<
-              YieldWrap<Effect.Effect<A, E, R>>,
-              A,
-              never
-            >
-          ) as Effect.Effect<A, E, R>
-        }
-        : () => handler
-
     const baseRoutes = isRouteSet(this)
       ? this.set
       : [] as const
@@ -866,7 +883,7 @@ function makeMediaFunction<
         make({
           method,
           media,
-          handler: normalizedHandler,
+          handler: normalizeHandler(handler),
           schemas: baseSchema,
         }),
       ] as ReadonlyArray<Route.Default>,
@@ -952,12 +969,12 @@ function makeMethodModifier<
   }
 }
 
-export type JsxObject = {
+export type GenericJsxObject = {
   type: any
   props: any
 }
 
-export function isJsxObject(value: unknown): value is JsxObject {
+export function isGenericJsxObject(value: unknown): value is GenericJsxObject {
   return typeof value === "object"
     && value !== null
     && "type" in value
@@ -1021,14 +1038,7 @@ export function layer(
   const layerRoutes: Route.Default[] = []
 
   for (const routeSet of routeSets) {
-    for (const route of routeSet.set) {
-      layerRoutes.push(make({
-        method: route.method,
-        media: route.media,
-        handler: route.handler,
-        schemas: {},
-      }))
-    }
+    layerRoutes.push(...routeSet.set)
   }
 
   const middlewareFunctions = routeMiddleware.map((spec) => spec.middleware)

package/src/RouteRender.ts

@@ -14,12 +14,17 @@ export function render<E, R>(
   return Effect.gen(function*() {
     const raw = yield* route.handler(context)
 
+    // Allow handlers to return HttpServerResponse directly (e.g. BunRoute proxy)
+    if (HttpServerResponse.isServerResponse(raw)) {
+      return raw
+    }
+
     switch (route.media) {
       case "text/plain":
         return HttpServerResponse.text(raw as string)
 
       case "text/html":
-        if (Route.isJsxObject(raw)) {
+        if (Route.isGenericJsxObject(raw)) {
           return HttpServerResponse.html(HyperHtml.renderToString(raw))
         }
         return HttpServerResponse.html(raw as string)
@@ -29,9 +34,6 @@ export function render<E, R>(
 
       case "*":
       default:
-        if (HttpServerResponse.isServerResponse(raw)) {
-          return raw
-        }
         return HttpServerResponse.text(String(raw))
     }
   })

package/src/Router.test.ts

@@ -0,0 +1,416 @@
+import * as t from "bun:test"
+import * as Effect from "effect/Effect"
+import * as Route from "./Route.ts"
+import * as Router from "./Router.ts"
+
+t.describe("Router", () => {
+  t.describe("mount", () => {
+    t.test("creates router with single route", () => {
+      const router = Router.mount("/hello", Route.text("Hello World"))
+
+      t.expect(router.entries).toHaveLength(1)
+      t.expect(router.entries[0].path).toBe("/hello")
+      t.expect(router.entries[0].route.set).toHaveLength(1)
+    })
+
+    t.test("chains multiple routes", () => {
+      const router = Router
+        .mount("/hello", Route.text("Hello"))
+        .mount("/world", Route.text("World"))
+
+      t.expect(router.entries).toHaveLength(2)
+      t.expect(router.entries[0].path).toBe("/hello")
+      t.expect(router.entries[1].path).toBe("/world")
+    })
+
+    t.test("merges routes at same path", () => {
+      const router = Router
+        .mount("/api", Route.get(Route.json({ method: "get" })))
+        .mount("/api", Route.post(Route.json({ method: "post" })))
+
+      t.expect(router.entries).toHaveLength(1)
+      t.expect(router.entries[0].path).toBe("/api")
+    })
+  })
+
+  t.describe("mounts", () => {
+    t.test("exposes mounted routes as Record", () => {
+      const router = Router
+        .mount("/hello", Route.text("Hello"))
+        .mount("/world", Route.text("World"))
+
+      t.expect(router.mounts["/hello"]).toBeDefined()
+      t.expect(router.mounts["/world"]).toBeDefined()
+      t.expect(router.mounts["/hello"].set).toHaveLength(1)
+    })
+
+    t.test("mounts contain routes with layers applied", async () => {
+      const layer = Route.layer(
+        Route.html(function*(c) {
+          const inner = yield* c.next()
+          return `<wrap>${inner}</wrap>`
+        }),
+      )
+
+      const router = Router
+        .use(layer)
+        .mount("/page", Route.html(Effect.succeed("content")))
+
+      const mountedRoute = router.mounts["/page"]
+      t.expect(mountedRoute).toBeDefined()
+      t.expect(mountedRoute.set).toHaveLength(1)
+
+      const route = mountedRoute.set[0]
+      const mockContext: Route.RouteContext = {
+        request: {} as any,
+        url: new URL("http://localhost/page"),
+        slots: {},
+        next: () => Effect.void,
+      }
+
+      const result = await Effect.runPromise(
+        route.handler(mockContext) as Effect.Effect<unknown>,
+      )
+
+      t.expect(result).toBe("<wrap>content</wrap>")
+    })
+  })
+
+  t.describe("use", () => {
+    t.test("adds global layer", () => {
+      const layer = Route.layer(
+        Route.html(function*(c) {
+          const inner = yield* c.next()
+          return `<html><body>${inner}</body></html>`
+        }),
+      )
+
+      const router = Router.use(layer)
+
+      t.expect(router.globalLayers).toHaveLength(1)
+      t.expect(router.entries).toHaveLength(0)
+    })
+
+    t.test("applies layer to subsequently mounted routes", () => {
+      const layer = Route.layer(
+        Route.html(function*(c) {
+          const inner = yield* c.next()
+          return `<html><body>${inner}</body></html>`
+        }),
+      )
+
+      const router = Router
+        .use(layer)
+        .mount("/", Route.text("Hello world!"))
+
+      t.expect(router.globalLayers).toHaveLength(1)
+      t.expect(router.entries).toHaveLength(1)
+      t.expect(router.entries[0].layers).toHaveLength(1)
+    })
+
+    t.test("layer only applies to routes mounted after use()", async () => {
+      const layer = Route.layer(
+        Route.html(function*(c) {
+          const inner = yield* c.next()
+          return `<wrap>${inner}</wrap>`
+        }),
+      )
+
+      const router = Router
+        .mount("/before", Route.html(Effect.succeed("before-content")))
+        .use(layer)
+        .mount("/after", Route.html(Effect.succeed("after-content")))
+
+      const mockContext = (path: string): Route.RouteContext => ({
+        request: {} as any,
+        url: new URL(`http://localhost${path}`),
+        slots: {},
+        next: () => Effect.void,
+      })
+
+      const beforeRoute = router.mounts["/before"].set[0]
+      const afterRoute = router.mounts["/after"].set[0]
+
+      const beforeResult = await Effect.runPromise(
+        beforeRoute.handler(mockContext("/before")) as Effect.Effect<unknown>,
+      )
+      const afterResult = await Effect.runPromise(
+        afterRoute.handler(mockContext("/after")) as Effect.Effect<unknown>,
+      )
+
+      t.expect(beforeResult).toBe("before-content")
+      t.expect(afterResult).toBe("<wrap>after-content</wrap>")
+    })
+  })
+
+  t.describe("layer application - runtime behavior", () => {
+    t.test("layer handler wraps route handler", async () => {
+      const layer = Route.layer(
+        Route.html(function*(c) {
+          const inner = yield* c.next()
+          return `<wrap>${inner}</wrap>`
+        }),
+      )
+
+      const router = Router
+        .use(layer)
+        .mount("/page", Route.html(Effect.succeed("content")))
+
+      const mountedRoute = router.mounts["/page"]
+      const route = mountedRoute.set[0]
+
+      const mockContext: Route.RouteContext = {
+        request: {} as any,
+        url: new URL("http://localhost/page"),
+        slots: {},
+        next: () => Effect.succeed("unused"),
+      }
+
+      const result = await Effect.runPromise(
+        route.handler(mockContext) as Effect.Effect<unknown>,
+      )
+
+      t.expect(result).toBe("<wrap>content</wrap>")
+    })
+
+    t.test("multiple layers are applied in order", async () => {
+      const outerLayer = Route.layer(
+        Route.html(function*(c) {
+          const inner = yield* c.next()
+          return `<outer>${inner}</outer>`
+        }),
+      )
+
+      const innerLayer = Route.layer(
+        Route.html(function*(c) {
+          const inner = yield* c.next()
+          return `<inner>${inner}</inner>`
+        }),
+      )
+
+      const router = Router
+        .use(outerLayer)
+        .use(innerLayer)
+        .mount("/page", Route.html(Effect.succeed("content")))
+
+      const mountedRoute = router.mounts["/page"]
+      const route = mountedRoute.set[0]
+
+      const mockContext: Route.RouteContext = {
+        request: {} as any,
+        url: new URL("http://localhost/page"),
+        slots: {},
+        next: () => Effect.succeed("unused"),
+      }
+
+      const result = await Effect.runPromise(
+        route.handler(mockContext) as Effect.Effect<unknown>,
+      )
+
+      t.expect(result).toBe("<outer><inner>content</inner></outer>")
+    })
+
+    t.test("layer only applies to matching media type", async () => {
+      const htmlLayer = Route.layer(
+        Route.html(function*(c) {
+          const inner = yield* c.next()
+          return `<wrap>${inner}</wrap>`
+        }),
+      )
+
+      const router = Router
+        .use(htmlLayer)
+        .mount("/api", Route.json({ data: "value" }))
+
+      const mountedRoute = router.mounts["/api"]
+      const route = mountedRoute.set[0]
+
+      const mockContext: Route.RouteContext = {
+        request: {} as any,
+        url: new URL("http://localhost/api"),
+        slots: {},
+        next: () => Effect.succeed("unused"),
+      }
+
+      const result = await Effect.runPromise(
+        route.handler(mockContext) as Effect.Effect<unknown>,
+      )
+
+      t.expect(result).toEqual({ data: "value" })
+    })
+
+    t.test("route without layer is not wrapped", async () => {
+      const router = Router.mount("/hello", Route.text("Hello"))
+
+      const mountedRoute = router.mounts["/hello"]
+      const route = mountedRoute.set[0]
+
+      const mockContext: Route.RouteContext = {
+        request: {} as any,
+        url: new URL("http://localhost/hello"),
+        slots: {},
+        next: () => Effect.succeed("unused"),
+      }
+
+      const result = await Effect.runPromise(
+        route.handler(mockContext) as Effect.Effect<unknown>,
+      )
+
+      t.expect(result).toBe("Hello")
+    })
+  })
+
+  t.describe("type inference", () => {
+    t.test("infers never for routes without requirements", () => {
+      const router = Router.mount("/hello", Route.text("Hello"))
+
+      type RouterError = Router.RouterBuilder.Error<typeof router>
+      type RouterContext = Router.RouterBuilder.Context<typeof router>
+
+      const _checkError: RouterError = undefined as never
+      const _checkContext: RouterContext = undefined as never
+
+      t.expect(true).toBe(true)
+    })
+
+    t.test("infers error type from route handler", () => {
+      class MyError {
+        readonly _tag = "MyError"
+      }
+
+      const router = Router.mount(
+        "/fail",
+        Route.text(Effect.fail(new MyError())),
+      )
+
+      type RouterError = Router.RouterBuilder.Error<typeof router>
+
+      const _checkError: MyError extends RouterError ? true : false = true
+
+      t.expect(true).toBe(true)
+    })
+
+    t.test("infers context type from route handler", () => {
+      class MyService extends Effect.Tag("MyService")<
+        MyService,
+        { getValue(): string }
+      >() {}
+
+      const router = Router.mount(
+        "/service",
+        Route.text(
+          Effect.gen(function*() {
+            const svc = yield* MyService
+            return svc.getValue()
+          }),
+        ),
+      )
+
+      type RouterContext = Router.RouterBuilder.Context<typeof router>
+
+      const _checkContext: MyService extends RouterContext ? true : false = true
+
+      t.expect(true).toBe(true)
+    })
+
+    t.test("unions error types from multiple routes", () => {
+      class ErrorA {
+        readonly _tag = "ErrorA"
+      }
+      class ErrorB {
+        readonly _tag = "ErrorB"
+      }
+
+      const router = Router
+        .mount("/a", Route.text(Effect.fail(new ErrorA())))
+        .mount("/b", Route.text(Effect.fail(new ErrorB())))
+
+      type RouterError = Router.RouterBuilder.Error<typeof router>
+
+      const _checkA: ErrorA extends RouterError ? true : false = true
+      const _checkB: ErrorB extends RouterError ? true : false = true
+
+      t.expect(true).toBe(true)
+    })
+
+    t.test("unions context types from multiple routes", () => {
+      class ServiceA extends Effect.Tag("ServiceA")<
+        ServiceA,
+        { getA(): string }
+      >() {}
+      class ServiceB extends Effect.Tag("ServiceB")<
+        ServiceB,
+        { getB(): string }
+      >() {}
+
+      const router = Router
+        .mount(
+          "/a",
+          Route.text(
+            Effect.gen(function*() {
+              const svc = yield* ServiceA
+              return svc.getA()
+            }),
+          ),
+        )
+        .mount(
+          "/b",
+          Route.text(
+            Effect.gen(function*() {
+              const svc = yield* ServiceB
+              return svc.getB()
+            }),
+          ),
+        )
+
+      type RouterContext = Router.RouterBuilder.Context<typeof router>
+
+      const _checkA: ServiceA extends RouterContext ? true : false = true
+      const _checkB: ServiceB extends RouterContext ? true : false = true
+
+      t.expect(true).toBe(true)
+    })
+  })
+
+  t.describe("fromManifest", () => {
+    t.test("loads routes from manifest", async () => {
+      const manifest: Router.RouterManifest = {
+        routes: [
+          {
+            path: "/test",
+            load: () => Promise.resolve({ default: Route.text("Test") }),
+          },
+        ],
+      }
+
+      const router = await Effect.runPromise(Router.fromManifest(manifest))
+
+      t.expect(router.entries).toHaveLength(1)
+      t.expect(router.entries[0].path).toBe("/test")
+    })
+
+    t.test("loads layers from manifest", async () => {
+      const layer = Route.layer(
+        Route.html(function*(c) {
+          const inner = yield* c.next()
+          return `<wrap>${inner}</wrap>`
+        }),
+      )
+
+      const manifest: Router.RouterManifest = {
+        routes: [
+          {
+            path: "/test",
+            load: () => Promise.resolve({ default: Route.text("Test") }),
+            layers: [() => Promise.resolve({ default: layer })],
+          },
+        ],
+      }
+
+      const router = await Effect.runPromise(Router.fromManifest(manifest))
+
+      t.expect(router.entries).toHaveLength(1)
+      t.expect(router.entries[0].layers).toHaveLength(1)
+    })
+  })
+})