effect-start 0.9.0 → 0.11.0

package/src/FileHttpRouter.ts

@@ -3,9 +3,14 @@ import * as HttpApp from "@effect/platform/HttpApp"
 import * as HttpMiddleware from "@effect/platform/HttpMiddleware"
 import * as HttpRouter from "@effect/platform/HttpRouter"
 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 HttpUtils from "./HttpUtils.ts"
+import * as Route from "./Route.ts"
 import * as Router from "./Router.ts"
+import * as RouteRender from "./RouteRender.ts"
+import * as RouterPattern from "./RouterPattern.ts"
 
 /**
  * Combines Effect error channel from a record of effects.
@@ -54,52 +59,133 @@ export type HttpRouterFromServerRoutes<
 >
 
 /**
- * Converts file-based route path format to HttpRouter path format.
- * Examples:
- *   /movies/[id] -> /movies/:id
- *   /docs/[[...slug]] -> /docs/*
- *   /api/[...path] -> /api/*
+ * Find layer routes that match a given route's method and media type.
  */
-function convertPathFormat(path: string): string {
-  return path
-    // Convert required params: [id] -> :id
-    .replace(/\[([^\]\.]+)\]/g, ":$1")
-    // Convert optional rest params: [[...slug]] -> *
-    .replace(/\[\[\.\.\.([^\]]+)\]\]/g, "*")
-    // Convert required rest params: [...path] -> *
-    .replace(/\[\.\.\.([^\]]+)\]/g, "*")
+function findMatchingLayerRoutes(
+  route: Route.Route.Default,
+  layers: 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
+}
+
+/**
+ * Wrap an inner route with a layer route.
+ * Returns a new route that, when executed, provides next() to call the inner route.
+ */
+function wrapWithLayerRoute(
+  innerRoute: Route.Route.Default,
+  layerRoute: Route.Route.Default,
+): Route.Route.Default {
+  const handler: Route.RouteHandler = (context) => {
+    const innerNext = () => innerRoute.handler(context)
+
+    const contextWithNext: Route.RouteContext = {
+      ...context,
+      next: innerNext,
+    }
+
+    return layerRoute.handler(contextWithNext)
+  }
+
+  return Route.make({
+    method: layerRoute.method,
+    media: layerRoute.media,
+    handler,
+    schemas: {},
+  })
 }
 
 /**
  * Makes a HttpRouter from file-based routes.
  */
-export function make<Routes extends Router.ServerRoutes>(
+
+export function make<
+  Routes extends ReadonlyArray<Router.ServerRoute>,
+>(
   routes: Routes,
 ): Effect.Effect<HttpRouterFromServerRoutes<Routes>> {
   return Effect.gen(function*() {
-    const modules = yield* Effect.forEach(
+    const routesWithModules = yield* Effect.forEach(
       routes,
       (route) =>
-        Function.pipe(
-          Effect.tryPromise(() => route.load()),
-          Effect.orDie,
-          Effect.map((module) => ({ path: route.path, module })),
-        ),
+        Effect.gen(function*() {
+          const module = yield* Effect.tryPromise(() => route.load()).pipe(
+            Effect.orDie,
+          )
+
+          const layerModules = route.layers
+            ? yield* Effect.forEach(
+              route.layers,
+              (layerLoad) =>
+                Effect.tryPromise(() => layerLoad()).pipe(Effect.orDie),
+            )
+            : []
+
+          const layers = layerModules
+            .map((mod: any) => mod.default)
+            .filter(Route.isRouteLayer)
+
+          return {
+            path: route.path,
+            routeSet: module.default,
+            layers,
+          }
+        }),
     )
 
     let router: HttpRouter.HttpRouter<any, any> = HttpRouter.empty
 
-    for (const { path, module } of modules) {
-      const routeSet = module.default
-      const httpRouterPath = convertPathFormat(path)
-
+    for (const { path, routeSet, layers } of routesWithModules) {
       for (const route of routeSet.set) {
-        router = HttpRouter.route(route.method)(
-          httpRouterPath,
-          route.handler as any,
-        )(
-          router,
-        )
+        const matchingLayerRoutes = findMatchingLayerRoutes(route, layers)
+
+        let wrappedRoute = route
+        // Reverse so first layer in array becomes outermost wrapper.
+        // Example: [outerLayer, innerLayer] wraps as outer(inner(route))
+        for (const layerRoute of matchingLayerRoutes.reverse()) {
+          wrappedRoute = wrapWithLayerRoute(wrappedRoute, layerRoute)
+        }
+
+        const wrappedHandler: HttpApp.Default = Effect.gen(function*() {
+          const request = yield* HttpServerRequest.HttpServerRequest
+
+          const context: Route.RouteContext = {
+            request,
+            get url() {
+              return HttpUtils.makeUrlFromRequest(request)
+            },
+            slots: {},
+            next: () => Effect.void,
+          }
+
+          return yield* RouteRender.render(wrappedRoute, context)
+        })
+
+        const allMiddleware = layers
+          .map((layer) => layer.httpMiddleware)
+          .filter((m): m is Route.HttpMiddlewareFunction => m !== undefined)
+
+        let finalHandler = wrappedHandler
+        for (const middleware of allMiddleware) {
+          finalHandler = middleware(finalHandler)
+        }
+
+        for (const pattern of RouterPattern.toEffect(path)) {
+          router = HttpRouter.route(route.method)(
+            pattern,
+            finalHandler as any,
+          )(router)
+        }
       }
     }
 
@@ -111,11 +197,12 @@ export function middleware() {
   return HttpMiddleware.make((app) =>
     Effect.gen(function*() {
       const routerContext = yield* Router.Router
-      const router = routerContext.httpRouter
+      const router = yield* make(
+        routerContext.routes as ReadonlyArray<Router.LazyRoute>,
+      )
       const res = yield* router.pipe(
         Effect.catchTag("RouteNotFound", () => app),
       )
-
       return res
     })
   )

package/src/FileRouter.ts

@@ -9,64 +9,25 @@ import * as Stream from "effect/Stream"
 import * as NPath from "node:path"
 import * as NUrl from "node:url"
 import * as FileRouterCodegen from "./FileRouterCodegen.ts"
+import * as FileRouterPattern from "./FileRouterPattern.ts"
 import * as FileSystemExtra from "./FileSystemExtra.ts"
-import { ServerModule } from "./Router.ts"
+import * as Router from "./Router.ts"
 
-type LiteralSegment = {
-  literal: string
-}
-
-type GroupSegment = {
-  group: string
-}
-
-type ParamSegment = {
-  param: string
-  optional?: true
-}
-
-type RestSegment = {
-  rest: string
-  optional?: true
-}
+export type GroupSegment<Name extends string = string> =
+  FileRouterPattern.GroupSegment<Name>
 
-type HandleSegment = {
-  handle: "route" | "layer"
-}
-
-export type Extension = "tsx" | "jsx" | "ts" | "js"
-
-export type Segment =
-  | LiteralSegment
-  | GroupSegment
-  | ParamSegment
-  | RestSegment
-  | HandleSegment
-
-export function isSegmentEqual(a: Segment, b: Segment): boolean {
-  if ("literal" in a && "literal" in b) return a.literal === b.literal
-  if ("group" in a && "group" in b) return a.group === b.group
-  if ("param" in a && "param" in b) return a.param === b.param
-  if ("rest" in a && "rest" in b) return a.rest === b.rest
-  if ("handle" in a && "handle" in b) return a.handle === b.handle
-  return false
-}
-
-export type RouteModule = {
-  path: `/${string}`
-  segments: readonly Segment[]
-  load: () => Promise<ServerModule>
-  layers?: ReadonlyArray<() => Promise<unknown>>
-}
+export type Segment = FileRouterPattern.Segment
 
 export type RouteManifest = {
-  Modules: readonly RouteModule[]
+  routes: readonly Router.LazyRoute[]
 }
 
 export type RouteHandle = {
   handle: "route" | "layer"
-  modulePath: string // eg. `about/route.tsx`, `users/[userId]/route.tsx`, `(admin)/users/route.tsx`
-  routePath: `/${string}` // eg. `/about`, `/users/[userId]`, `/users` (groups stripped)
+  // eg. `about/route.tsx`, `users/[userId]/route.tsx`, `(admin)/users/route.tsx`
+  modulePath: string
+  // eg. `/about`, `/users/[userId]`, `/users` (groups stripped)
+  routePath: `/${string}`
   segments: Segment[]
 }
 
@@ -80,113 +41,31 @@ export type RouteHandle = {
  */
 export type OrderedRouteHandles = RouteHandle[]
 
-const ROUTE_PATH_REGEX = /^\/?(.*\/?)((route|layer))\.(jsx?|tsx?)$/
-
-type RoutePathMatch = [
-  path: string,
-  kind: string,
-  kind: string,
-  ext: string,
-]
-
-export function segmentPath(path: string): Segment[] {
-  const trimmedPath = path.replace(/(^\/)|(\/$)/g, "") // trim leading/trailing slashes
-
-  if (trimmedPath === "") {
-    return [] // Handles "" and "/"
-  }
-
-  const segmentStrings = trimmedPath
-    .split("/")
-    .filter(s => s !== "") // Remove empty segments from multiple slashes, e.g. "foo//bar"
-
-  if (segmentStrings.length === 0) {
-    return []
-  }
-
-  const segments: (Segment | null)[] = segmentStrings.map(
-    (s): Segment | null => {
-      // Check if it's a handle (route.ts, layer.tsx, etc.)
-      const [, handle] = s.match(/^(route|layer)\.(tsx?|jsx?)$/)
-        ?? []
-
-      if (handle) {
-        // @ts-expect-error regexp group ain't typed
-        return { handle }
-      }
-
-      // (group) - Groups
-      const groupMatch = s.match(/^\((\w+)\)$/)
-      if (groupMatch) {
-        return { group: groupMatch[1] }
-      }
-
-      // [[...rest]] - Optional rest parameter
-      const optionalRestMatch = s.match(/^\[\[\.\.\.(\w+)\]\]$/)
-      if (optionalRestMatch) {
-        return {
-          rest: optionalRestMatch[1],
-          optional: true,
-        }
-      }
-
-      // [...rest] - Required rest parameter
-      const requiredRestMatch = s.match(/^\[\.\.\.(\w+)\]$/)
-      if (requiredRestMatch) {
-        return { rest: requiredRestMatch[1] }
-      }
-
-      // [param] - Dynamic parameter
-      const paramMatch = s.match(/^\[(\w+)\]$/)
-      if (paramMatch) {
-        return { param: paramMatch[1] }
-      }
-
-      // Literal segment
-      if (/^[A-Za-z0-9._~-]+$/.test(s)) {
-        return { literal: s }
-      }
-
-      return null
-    },
-  )
-
-  if (segments.some((seg) => seg === null)) {
-    throw new Error(
-      `Invalid path segment in "${path}": contains invalid characters or format`,
-    )
-  }
-
-  return segments as Segment[]
-}
+const ROUTE_PATH_REGEX = /^\/?(.*\/?)(?:route|layer)\.(jsx?|tsx?)$/
 
-function segmentToText(seg: Segment): string {
-  if ("literal" in seg) return seg.literal
-  if ("group" in seg) return `(${seg.group})`
-  if ("param" in seg) return `[${seg.param}]`
-  if ("rest" in seg) {
-    return seg.optional ? `[[...${seg.rest}]]` : `[...${seg.rest}]`
-  }
-  if ("handle" in seg) return seg.handle
-  return ""
-}
+export const parse = FileRouterPattern.parse
+export const formatSegment = FileRouterPattern.formatSegment
+export const format = FileRouterPattern.format
 
 export function parseRoute(
   path: string,
 ): RouteHandle {
-  const segs = segmentPath(path)
+  const segs = parse(path)
 
-  const handle = segs.at(-1)
+  const lastSeg = segs.at(-1)
+  const handleMatch = lastSeg?._tag === "LiteralSegment"
+    && lastSeg.value.match(/^(route|layer)\.(tsx?|jsx?)$/)
+  const handle = handleMatch ? handleMatch[1] as "route" | "layer" : null
 
-  if (!handle || !("handle" in handle)) {
+  if (!handle) {
     throw new Error(
       `Invalid route path "${path}": must end with a valid handle (route or layer)`,
     )
   }
 
-  // Validate Route constraints: rest segments must be the last segment before the handle
+  // rest segments must be the last segment before the handle
   const pathSegments = segs.slice(0, -1) // All segments except the handle
-  const restIndex = pathSegments.findIndex(seg => "rest" in seg)
+  const restIndex = pathSegments.findIndex(seg => seg._tag === "RestSegment")
 
   if (restIndex !== -1) {
     // If there's a rest, it must be the last path segment
@@ -196,19 +75,27 @@ export function parseRoute(
       )
     }
 
-    // Validate that all segments before the rest are literal, param, or group
+    // all segments before the rest must be literal, param, or group
     for (let i = 0; i < restIndex; i++) {
       const seg = pathSegments[i]
-      if (!("literal" in seg) && !("param" in seg) && !("group" in seg)) {
+      if (
+        seg._tag !== "LiteralSegment"
+        && seg._tag !== "ParamSegment"
+        && seg._tag !== "GroupSegment"
+      ) {
         throw new Error(
           `Invalid route path "${path}": segments before rest must be literal, param, or group segments`,
         )
       }
     }
   } else {
-    // No rest: validate that all path segments are literal, param, or group
+    // No rest: all path segments are literal, param, or group
     for (const seg of pathSegments) {
-      if (!("literal" in seg) && !("param" in seg) && !("group" in seg)) {
+      if (
+        seg._tag !== "LiteralSegment"
+        && seg._tag !== "ParamSegment"
+        && seg._tag !== "GroupSegment"
+      ) {
         throw new Error(
           `Invalid route path "${path}": path segments must be literal, param, or group segments`,
         )
@@ -216,37 +103,33 @@ export function parseRoute(
     }
   }
 
-  // Construct routePath from path segments (excluding handle and groups)
-  // Groups like (admin) are stripped from the URL path
-  const routePathSegments = pathSegments
-    .filter(seg => !("group" in seg))
-    .map(segmentToText)
-
-  const routePath = (routePathSegments.length > 0
-    ? `/${routePathSegments.join("/")}`
-    : "/") as `/${string}`
+  const routePathSegments = pathSegments.filter(
+    seg => seg._tag !== "GroupSegment",
+  )
+  const routePath = FileRouterPattern.format(routePathSegments)
 
   return {
-    handle: handle.handle,
+    handle,
     modulePath: path,
     routePath,
-    segments: segs,
+    segments: pathSegments,
   }
 }
 
 /**
- * Generates a file that references all routes.
+ * Generates a manifest file that references all routes.
  */
-export function layer(options: {
+export function layerManifest(options: {
   load: () => Promise<unknown>
   path: string
 }) {
   let manifestPath = options.path
-
-  // handle use of import.meta.resolve
   if (manifestPath.startsWith("file://")) {
     manifestPath = NUrl.fileURLToPath(manifestPath)
   }
+  if (NPath.extname(manifestPath) === "") {
+    manifestPath = NPath.join(manifestPath, "index.ts")
+  }
 
   const routesPath = NPath.dirname(manifestPath)
   const manifestFilename = NPath.basename(manifestPath)
@@ -277,6 +160,19 @@ export function layer(options: {
   )
 }
 
+export function layer(options: {
+  load: () => Promise<Router.RouterManifest>
+  path: string
+}) {
+  return Layer.provide(
+    Layer.effect(
+      Router.Router,
+      Effect.promise(() => options.load()),
+    ),
+    layerManifest(options),
+  )
+}
+
 export function walkRoutesDirectory(
   dir: string,
 ): Effect.Effect<
@@ -299,10 +195,10 @@ export function getRouteHandlesFromPaths(
   paths: string[],
 ): OrderedRouteHandles {
   const handles = paths
-    .map(f => f.match(ROUTE_PATH_REGEX) as RoutePathMatch)
+    .map(f => f.match(ROUTE_PATH_REGEX))
     .filter(Boolean)
     .map(v => {
-      const path = v[0]
+      const path = v![0]
       try {
         return parseRoute(path)
       } catch {
@@ -313,8 +209,8 @@ export function getRouteHandlesFromPaths(
     .toSorted((a, b) => {
       const aDepth = a.segments.length
       const bDepth = b.segments.length
-      const aHasRest = a.segments.some(seg => "rest" in seg)
-      const bHasRest = b.segments.some(seg => "rest" in seg)
+      const aHasRest = a.segments.some(seg => seg._tag === "RestSegment")
+      const bHasRest = b.segments.some(seg => seg._tag === "RestSegment")
 
       return (
         // rest is a dominant factor (routes with rest come last)