effect-start 0.14.0 → 0.16.0

package/src/RouteRender.ts

@@ -1,40 +0,0 @@
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
-import * as Effect from "effect/Effect"
-import * as HyperHtml from "./HyperHtml.ts"
-import * as Route from "./Route.ts"
-
-/**
- * Renders a route handler to an HttpServerResponse.
- * Converts the raw handler value to a response based on the route's media type.
- */
-export function render<E, R>(
-  route: Route.Route<any, any, Route.RouteHandler<any, E, R>, any>,
-  context: Route.RouteContext,
-): Effect.Effect<HttpServerResponse.HttpServerResponse, 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.isGenericJsxObject(raw)) {
-          return HttpServerResponse.html(HyperHtml.renderToString(raw))
-        }
-        return HttpServerResponse.html(raw as string)
-
-      case "application/json":
-        return HttpServerResponse.unsafeJson(raw)
-
-      case "*":
-      default:
-        return HttpServerResponse.text(String(raw))
-    }
-  })
-}

package/src/Router.test.ts

@@ -1,375 +0,0 @@
-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.Router.Error<typeof router>
-      type RouterRequirements = Router.Router.Requirements<typeof router>
-
-      const _checkError: RouterError = undefined as never
-      const _checkRequirements: RouterRequirements = 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.Router.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 RouterRequirements = Router.Router.Requirements<typeof router>
-
-      const _checkRequirements: MyService extends RouterRequirements ? 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.Router.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 RouterRequirements = Router.Router.Requirements<typeof router>
-
-      const _checkA: ServiceA extends RouterRequirements ? true : false = true
-      const _checkB: ServiceB extends RouterRequirements ? true : false = true
-
-      t.expect(true).toBe(true)
-    })
-  })
-})

package/src/Router.ts

@@ -1,255 +0,0 @@
-import * as Data from "effect/Data"
-import * as Pipeable from "effect/Pipeable"
-import * as Predicate from "effect/Predicate"
-import * as Route from "./Route.ts"
-
-type RouterModule = typeof import("./Router.ts")
-
-type Self =
-  | Router.Any
-  | RouterModule
-  | undefined
-
-export type RouterErrorReason =
-  | "UnsupportedPattern"
-  | "ProxyError"
-
-export class RouterError extends Data.TaggedError("RouterError")<{
-  reason: RouterErrorReason
-  pattern: string
-  message: string
-}> {}
-
-const TypeId: unique symbol = Symbol.for(
-  "effect-start/Router",
-)
-
-export type RouterEntry = {
-  path: `/${string}`
-  route: Route.RouteSet.Default
-  layers: Route.RouteLayer[]
-}
-
-type Methods = {
-  use: typeof use
-  mount: typeof mount
-}
-
-export interface Router<
-  out E = never,
-  out R = never,
-> extends Pipeable.Pipeable, Methods {
-  [TypeId]: typeof TypeId
-  readonly entries: readonly RouterEntry[]
-  readonly globalLayers: readonly Route.RouteLayer[]
-  readonly mounts: Record<`/${string}`, Route.RouteSet.Default>
-  readonly _E: () => E
-  readonly _R: () => R
-}
-
-export namespace Router {
-  export type Any = Router<any, any>
-  export type Error<T> = T extends Router<infer E, any> ? E : never
-  export type Requirements<T> = T extends Router<any, infer R> ? R : never
-}
-
-const Proto: Methods & {
-  [TypeId]: typeof TypeId
-  pipe: Pipeable.Pipeable["pipe"]
-} = {
-  [TypeId]: TypeId,
-
-  pipe() {
-    return Pipeable.pipeArguments(this, arguments)
-  },
-
-  use,
-  mount,
-}
-
-type ExtractRouteSetError<T> = T extends Route.RouteSet<infer Routes, any>
-  ? Routes[number] extends Route.Route<any, any, infer H, any>
-    ? H extends Route.RouteHandler<any, infer E, any> ? E : never
-  : never
-  : never
-
-type ExtractRouteSetContext<T> = T extends Route.RouteSet<infer Routes, any>
-  ? Routes[number] extends Route.Route<any, any, infer H, any>
-    ? H extends Route.RouteHandler<any, any, infer R> ? R : never
-  : never
-  : never
-
-function addRoute<
-  E,
-  R,
-  RouteE,
-  RouteR,
->(
-  builder: Router<E, R>,
-  path: `/${string}`,
-  route: Route.RouteSet.Default,
-): Router<E | RouteE, R | RouteR> {
-  const existingEntry = builder.entries.find((e) => e.path === path)
-  if (existingEntry) {
-    const updatedEntry: RouterEntry = {
-      ...existingEntry,
-      route: Route.merge(existingEntry.route, route),
-    }
-    return make(
-      builder.entries.map((e) => (e.path === path ? updatedEntry : e)),
-      builder.globalLayers,
-    )
-  }
-
-  const newEntry: RouterEntry = {
-    path,
-    route,
-    layers: [...builder.globalLayers],
-  }
-
-  return make([...builder.entries, newEntry], builder.globalLayers)
-}
-
-function addGlobalLayer<E, R>(
-  builder: Router<E, R>,
-  layerRoute: Route.RouteLayer,
-): Router<E, R> {
-  const newGlobalLayers = [...builder.globalLayers, layerRoute]
-  return make(builder.entries, newGlobalLayers)
-}
-
-function findMatchingLayerRoutes(
-  route: Route.Route.Default,
-  layers: readonly Route.RouteLayer[],
-): Route.Route.Default[] {
-  const matchingRoutes: Route.Route.Default[] = []
-  for (const layer of layers) {
-    for (const layerRoute of layer.set) {
-      if (Route.matches(layerRoute, route)) {
-        matchingRoutes.push(layerRoute)
-      }
-    }
-  }
-  return matchingRoutes
-}
-
-function wrapWithLayerRoute(
-  innerRoute: Route.Route.Default,
-  layerRoute: Route.Route.Default,
-): Route.Route.Default {
-  const handler: Route.RouteHandler = (context) => {
-    const contextWithNext: Route.RouteContext = {
-      ...context,
-      next: () => innerRoute.handler(context),
-    }
-    return layerRoute.handler(contextWithNext)
-  }
-
-  return Route.make({
-    method: layerRoute.method,
-    media: layerRoute.media,
-    handler,
-    schemas: {},
-  })
-}
-
-function applyLayersToRoute(
-  route: Route.Route.Default,
-  layers: readonly Route.RouteLayer[],
-): Route.Route.Default {
-  const matchingLayerRoutes = findMatchingLayerRoutes(route, layers)
-  let wrappedRoute = route
-
-  for (const layerRoute of matchingLayerRoutes.reverse()) {
-    wrappedRoute = wrapWithLayerRoute(wrappedRoute, layerRoute)
-  }
-
-  return wrappedRoute
-}
-
-function applyLayersToRouteSet(
-  routeSet: Route.RouteSet.Default,
-  layers: readonly Route.RouteLayer[],
-): Route.RouteSet.Default {
-  if (layers.length === 0) {
-    return routeSet
-  }
-
-  const wrappedRoutes = routeSet.set.map((route) =>
-    applyLayersToRoute(route, layers)
-  )
-
-  return {
-    set: wrappedRoutes,
-    schema: routeSet.schema,
-  } as unknown as Route.RouteSet.Default
-}
-
-export function make<E, R>(
-  entries: readonly RouterEntry[],
-  globalLayers: readonly Route.RouteLayer[] = [],
-): Router<E, R> {
-  const mounts: Record<`/${string}`, Route.RouteSet.Default> = {}
-
-  for (const entry of entries) {
-    if (entry.route.set.length > 0) {
-      mounts[entry.path] = applyLayersToRouteSet(entry.route, entry.layers)
-    }
-  }
-
-  return Object.assign(
-    Object.create(Proto),
-    {
-      entries,
-      globalLayers,
-      mounts,
-    },
-  )
-}
-
-export function isRouter(input: unknown): input is Router.Any {
-  return Predicate.hasProperty(input, TypeId)
-}
-
-export function use<
-  S extends Self,
->(
-  this: S,
-  layerRoute: Route.RouteLayer,
-): S extends Router<infer E, infer R> ? Router<E, R>
-  : Router<never, never>
-{
-  const router = isRouter(this)
-    ? this
-    : make<never, never>([], [])
-
-  return addGlobalLayer(router, layerRoute) as any
-}
-
-export function mount<
-  S extends Self,
-  Routes extends Route.Route.Tuple,
-  Schemas extends Route.RouteSchemas,
->(
-  this: S,
-  path: `/${string}`,
-  route: Route.RouteSet<Routes, Schemas>,
-): S extends Router<infer E, infer R> ? Router<
-    E | ExtractRouteSetError<Route.RouteSet<Routes, Schemas>>,
-    R | ExtractRouteSetContext<Route.RouteSet<Routes, Schemas>>
-  >
-  : Router<
-    ExtractRouteSetError<Route.RouteSet<Routes, Schemas>>,
-    ExtractRouteSetContext<Route.RouteSet<Routes, Schemas>>
-  >
-{
-  const router = isRouter(this)
-    ? this
-    : make<never, never>([], [])
-
-  return addRoute(
-    router,
-    path,
-    route as Route.RouteSet.Default,
-  ) as any
-}