effect-start 0.10.0 → 0.11.0

package/src/Router.ts

@@ -1,10 +1,23 @@
 import * as Context from "effect/Context"
+import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Function from "effect/Function"
 import * as Layer from "effect/Layer"
+import * as Pipeable from "effect/Pipeable"
+import * as Predicate from "effect/Predicate"
 import * as FileRouter from "./FileRouter.ts"
 import * as Route from "./Route"
 
+export type RouterErrorReason =
+  | "UnsupportedPattern"
+  | "ProxyError"
+
+export class RouterError extends Data.TaggedError("RouterError")<{
+  reason: RouterErrorReason
+  pattern: string
+  message: string
+}> {}
+
 export type ServerModule = {
   default: Route.RouteSet.Default
 }
@@ -56,3 +69,269 @@ export function layerPromise(
     }),
   )
 }
+
+const RouterBuilderTypeId: unique symbol = Symbol.for(
+  "effect-start/RouterBuilder",
+)
+
+type RouterModule = typeof import("./Router.ts")
+
+type Self =
+  | RouterBuilder<any, any>
+  | RouterModule
+  | undefined
+
+export type RouterEntry = {
+  path: `/${string}`
+  route: Route.RouteSet.Default
+  layers: Route.RouteLayer[]
+}
+
+type RouterBuilderMethods = {
+  use: typeof use
+  mount: typeof mount
+}
+
+export interface RouterBuilder<
+  out E = never,
+  out R = never,
+> extends Pipeable.Pipeable, RouterBuilderMethods {
+  [RouterBuilderTypeId]: typeof RouterBuilderTypeId
+  readonly entries: readonly RouterEntry[]
+  readonly globalLayers: readonly Route.RouteLayer[]
+  readonly mounts: Record<`/${string}`, Route.RouteSet.Default>
+  readonly _E: () => E
+  readonly _R: () => R
+}
+
+export namespace RouterBuilder {
+  export type Any = RouterBuilder<any, any>
+
+  export type Error<T> = T extends RouterBuilder<infer E, any> ? E : never
+  export type Context<T> = T extends RouterBuilder<any, infer R> ? R : never
+}
+
+const RouterBuilderProto: RouterBuilderMethods & {
+  [RouterBuilderTypeId]: typeof RouterBuilderTypeId
+  pipe: Pipeable.Pipeable["pipe"]
+} = {
+  [RouterBuilderTypeId]: RouterBuilderTypeId,
+
+  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: RouterBuilder<E, R>,
+  path: `/${string}`,
+  route: Route.RouteSet.Default,
+): RouterBuilder<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 makeBuilder(
+      builder.entries.map((e) => (e.path === path ? updatedEntry : e)),
+      builder.globalLayers,
+    )
+  }
+
+  const newEntry: RouterEntry = {
+    path,
+    route,
+    layers: [...builder.globalLayers],
+  }
+
+  return makeBuilder([...builder.entries, newEntry], builder.globalLayers)
+}
+
+function addGlobalLayer<E, R>(
+  builder: RouterBuilder<E, R>,
+  layerRoute: Route.RouteLayer,
+): RouterBuilder<E, R> {
+  const newGlobalLayers = [...builder.globalLayers, layerRoute]
+  return makeBuilder(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
+}
+
+function makeBuilder<E, R>(
+  entries: readonly RouterEntry[],
+  globalLayers: readonly Route.RouteLayer[] = [],
+): RouterBuilder<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(RouterBuilderProto), {
+    entries,
+    globalLayers,
+    mounts,
+  })
+}
+
+export function isRouterBuilder(input: unknown): input is RouterBuilder.Any {
+  return Predicate.hasProperty(input, RouterBuilderTypeId)
+}
+
+export function use<
+  S extends Self,
+>(
+  this: S,
+  layerRoute: Route.RouteLayer,
+): S extends RouterBuilder<infer E, infer R> ? RouterBuilder<E, R>
+  : RouterBuilder<never, never>
+{
+  const builder = isRouterBuilder(this)
+    ? this
+    : makeBuilder<never, never>([], [])
+  return addGlobalLayer(builder, 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 RouterBuilder<infer E, infer R> ? RouterBuilder<
+    E | ExtractRouteSetError<Route.RouteSet<Routes, Schemas>>,
+    R | ExtractRouteSetContext<Route.RouteSet<Routes, Schemas>>
+  >
+  : RouterBuilder<
+    ExtractRouteSetError<Route.RouteSet<Routes, Schemas>>,
+    ExtractRouteSetContext<Route.RouteSet<Routes, Schemas>>
+  >
+{
+  const builder = isRouterBuilder(this)
+    ? this
+    : makeBuilder<never, never>([], [])
+  return addRoute(builder, path, route as Route.RouteSet.Default) as any
+}
+
+export function fromManifest(
+  manifest: RouterManifest,
+): Effect.Effect<RouterBuilder.Any> {
+  return Effect.gen(function*() {
+    const loadedEntries = yield* Effect.forEach(
+      manifest.routes,
+      (lazyRoute) =>
+        Effect.gen(function*() {
+          const routeModule = yield* Effect.promise(() => lazyRoute.load())
+          const layerModules = lazyRoute.layers
+            ? yield* Effect.forEach(
+              lazyRoute.layers,
+              (loadLayer) => Effect.promise(() => loadLayer()),
+            )
+            : []
+
+          const layers = layerModules
+            .map((m: any) => m.default)
+            .filter(Route.isRouteLayer)
+
+          return {
+            path: lazyRoute.path,
+            route: routeModule.default,
+            layers,
+          }
+        }),
+    )
+
+    return makeBuilder(loadedEntries, [])
+  })
+}

package/src/RouterPattern.test.ts

@@ -213,10 +213,36 @@ t.describe(`${RouterPattern.toColon.name}`, () => {
       "/files/file_:id.txt",
     ])
   })
+})
+
+t.describe(`${RouterPattern.toBun.name}`, () => {
+  t.test("literal path unchanged", () => {
+    t.expect(RouterPattern.toBun("/")).toEqual(["/"])
+    t.expect(RouterPattern.toBun("/about")).toEqual(["/about"])
+  })
+
+  t.test("param [param] -> :param", () => {
+    t.expect(RouterPattern.toBun("/users/[id]")).toEqual(["/users/:id"])
+  })
+
+  t.test("optional param [[param]] -> two routes", () => {
+    t.expect(RouterPattern.toBun("/users/[[id]]")).toEqual([
+      "/users",
+      "/users/:id",
+    ])
+    t.expect(RouterPattern.toBun("/[[id]]")).toEqual(["/", "/:id"])
+  })
+
+  t.test("rest param [...param] -> *", () => {
+    t.expect(RouterPattern.toBun("/docs/[...path]")).toEqual(["/docs/*"])
+  })
 
-  t.test("toHono and toBun are aliases", () => {
-    t.expect(RouterPattern.toHono).toBe(RouterPattern.toColon)
-    t.expect(RouterPattern.toBun).toBe(RouterPattern.toColon)
+  t.test("optional rest param [[...param]] -> two routes", () => {
+    t.expect(RouterPattern.toBun("/docs/[[...path]]")).toEqual([
+      "/docs",
+      "/docs/*",
+    ])
+    t.expect(RouterPattern.toBun("/[[...path]]")).toEqual(["/", "/*"])
   })
 })
 

package/src/RouterPattern.ts

@@ -365,13 +365,38 @@ export function toRemix(path: Route.RoutePattern): string[] {
   return [joined ? "/" + joined : "/"]
 }
 
-export const toBun = toColon
-
 /**
- * @deprecated Use toEffectHttpRouterPath instead
+ * Converts to Bun.serve path pattern.
+ *
+ * Since Bun doesn't support optional params (`:param?`), optional segments
+ * are expanded into multiple routes recursively.
+ *
+ * - `[param]` → `:param`
+ * - `[[param]]` → `/`, `/:param` (two routes)
+ * - `[...param]` → `*`
+ * - `[[...param]]` → `/`, `/*` (two routes)
+ * - `pk_[id]` → `pk_:id`
  */
-export function toHttpPath(path: Route.RoutePattern): string {
-  return toEffect(path)[0]
+export function toBun(path: Route.RoutePattern): string[] {
+  const segments = parse(path)
+
+  const optionalIndex = segments.findIndex(
+    (s) =>
+      (s._tag === "ParamSegment" || s._tag === "RestSegment") && s.optional,
+  )
+
+  if (optionalIndex === -1) {
+    return buildPaths(segments, colonParamSegment, "/*")
+  }
+
+  const before = segments.slice(0, optionalIndex)
+  const optional = { ...segments[optionalIndex], optional: false }
+  const after = segments.slice(optionalIndex + 1)
+
+  return [
+    ...toBun(format(before)),
+    ...toBun(format([...before, optional, ...after])),
+  ]
 }
 
 type ExtractSegment<S extends string> = S extends `[[...${infer Name}]]`

package/src/TestHttpClient.test.ts

@@ -52,3 +52,32 @@ t.it("not found", () =>
       )
       .toEqual("Not Found")
   }))
+
+t.describe("FetchHandler", () => {
+  const FetchClient = TestHttpClient.make((req) =>
+    new Response(`Hello from ${req.url}`, { status: 200 })
+  )
+
+  t.it("works with sync handler", () =>
+    effect(function*() {
+      const res = yield* FetchClient.get("/test")
+
+      t.expect(res.status).toEqual(200)
+      t.expect(yield* res.text).toContain("/test")
+    }))
+
+  const AsyncFetchClient = TestHttpClient.make(async (req) => {
+    await Promise.resolve()
+    return new Response(`Async: ${req.method} ${new URL(req.url).pathname}`, {
+      status: 201,
+    })
+  })
+
+  t.it("works with async handler", () =>
+    effect(function*() {
+      const res = yield* AsyncFetchClient.post("/async-path")
+
+      t.expect(res.status).toEqual(201)
+      t.expect(yield* res.text).toEqual("Async: POST /async-path")
+    }))
+})

package/src/TestHttpClient.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import * as HttpApp from "@effect/platform/HttpApp"
 import * as HttpClient from "@effect/platform/HttpClient"
 import * as HttpClientError from "@effect/platform/HttpClientError"
@@ -7,15 +6,38 @@ 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 UrlParams from "@effect/platform/UrlParams"
 import * as Effect from "effect/Effect"
+import * as Either from "effect/Either"
 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>,
+export type FetchHandler = (req: Request) => Response | Promise<Response>
+
+export const isFetchHandler = (
+  app: unknown,
+): app is FetchHandler => typeof app === "function" && !Effect.isEffect(app)
+
+const fromFetchHandler = (
+  handler: FetchHandler,
+): HttpApp.Default<never, never> =>
+  Effect.gen(function*() {
+    const serverRequest = yield* HttpServerRequest.HttpServerRequest
+    const webRequest = serverRequest.source as Request
+    const response = yield* Effect.promise(async () => handler(webRequest))
+    const body = yield* Effect.promise(() => response.arrayBuffer())
+    return HttpServerResponse.raw(new Uint8Array(body), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: Object.fromEntries(response.headers.entries()),
+    })
+  })
+
+export const make = <E, R>(
+  appOrHandler: HttpApp.Default<E, R> | FetchHandler,
   opts?: {
     baseUrl?: string | null
     handleRouteNotFound?: (
@@ -24,77 +46,104 @@ export const make = <E = any, R = any>(
   },
 ): 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),
-          )
+  Exclude<R, HttpServerRequest.HttpServerRequest>
+> => {
+  const httpApp: HttpApp.Default<E, R> = isFetchHandler(appOrHandler)
+    ? fromFetchHandler(appOrHandler) as HttpApp.Default<E, R>
+    : appOrHandler
 
-          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,
-                    }),
-                  ))),
-          )
-        }
+  const execute = (
+    request: HttpClientRequest.HttpClientRequest,
+  ): Effect.Effect<
+    HttpClientResponse.HttpClientResponse,
+    HttpClientError.HttpClientError | E,
+    Exclude<R, HttpServerRequest.HttpServerRequest>
+  > => {
+    const urlResult = UrlParams.makeUrl(
+      request.url,
+      request.urlParams,
+      request.hash,
+    )
+    if (Either.isLeft(urlResult)) {
+      return Effect.die(urlResult.left)
+    }
+    const url = urlResult.right
+    const controller = new AbortController()
+    const signal = controller.signal
 
-        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,
-            )
-        }
+    const send = (
+      body: BodyInit | undefined,
+    ): Effect.Effect<
+      HttpClientResponse.HttpClientResponse,
+      E,
+      Exclude<R, HttpServerRequest.HttpServerRequest>
+    > => {
+      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 RequestInit),
+      )
 
-        return send(undefined)
-      },
-    )
-    .pipe(
-      opts?.baseUrl === null
-        ? Function.identity
-        : HttpClient.mapRequest(
-          HttpClientRequest.prependUrl(opts?.baseUrl ?? "http://localhost"),
+      return Function.pipe(
+        httpApp,
+        Effect.provideService(
+          HttpServerRequest.HttpServerRequest,
+          serverRequest,
         ),
-    )
+        Effect.andThen(HttpServerResponse.toWeb),
+        Effect.andThen(res => HttpClientResponse.fromWeb(request, res)),
+        opts?.handleRouteNotFound === null
+          ? Function.identity
+          : Effect.catchAll((e) =>
+            e instanceof RouteNotFound
+              ? Effect.succeed(HttpClientResponse.fromWeb(
+                request,
+                new Response("Failed with RouteNotFound", {
+                  status: 404,
+                }),
+              ))
+              : Effect.fail(e)
+          ),
+      ) as Effect.Effect<
+        HttpClientResponse.HttpClientResponse,
+        E,
+        Exclude<R, HttpServerRequest.HttpServerRequest>
+      >
+    }
+
+    switch (request.body._tag) {
+      case "Raw":
+      case "Uint8Array":
+        return send(request.body.body as BodyInit)
+      case "FormData":
+        return send(request.body.formData)
+      case "Stream":
+        return Effect.flatMap(
+          Stream.toReadableStreamEffect(request.body.stream),
+          send,
+        )
+    }
+
+    return send(undefined)
+  }
+
+  const client = HttpClient.makeWith(
+    (requestEffect) => Effect.flatMap(requestEffect, execute),
+    (request) => Effect.succeed(request),
+  )
+
+  return client.pipe(
+    opts?.baseUrl === null
+      ? Function.identity
+      : HttpClient.mapRequest(
+        HttpClientRequest.prependUrl(opts?.baseUrl ?? "http://localhost"),
+      ),
+  ) as HttpClient.HttpClient.With<
+    HttpClientError.HttpClientError | E,
+    Exclude<R, HttpServerRequest.HttpServerRequest>
+  >
+}

package/src/assets.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Allow importing static assets as modules.
+ * Bun/Vite resolves these to file paths.
+ * For WASM you're better of
+ */
+
+declare module "*.png"
+declare module "*.gif"
+declare module "*.webp"
+declare module "*.avif"
+declare module "*.ico"
+declare module "*.bmp"
+declare module "*.tiff"
+declare module "*.svg"
+declare module "*.jpeg"
+declare module "*.jpg"
+
+declare module "*.woff"
+declare module "*.woff2"
+declare module "*.ttf"
+declare module "*.otf"
+declare module "*.eot"
+
+declare module "*.mp4"
+declare module "*.webm"
+declare module "*.ogg"
+declare module "*.mov"
+declare module "*.mp3"
+declare module "*.wav"
+declare module "*.flac"
+declare module "*.aac"
+
+declare module "*.pdf"
+declare module "*.xml"
+declare module "*.csv"
+declare module "*.txt"
+declare module "*.md"
+
+declare module "*.css"