effect-start 0.30.1 → 0.32.0

package/src/RouteSse.ts

@@ -12,10 +12,9 @@ const HEARTBEAT_INTERVAL = Duration.seconds(5)
 const HEARTBEAT = ": <3\n\n"
 
 interface SseEvent {
-  readonly [key: string]: unknown
   readonly _tag?: string
   readonly data?: string | undefined
-  readonly type?: string
+  readonly event?: string
   readonly retry?: number
 }
 
@@ -26,8 +25,8 @@ function formatSseEvent(event: SseEvent): string {
   }
 
   let result = ""
-  if (event.type) {
-    result += `event: ${event.type}\n`
+  if (event.event) {
+    result += `event: ${event.event}\n`
   }
   if (typeof event.data === "string") {
     for (const line of event.data.split("\n")) {
@@ -48,6 +47,7 @@ type SseHandlerInput<B, E, R> =
   | Effect.Effect<Stream.Stream<SseEvent, E, R>, E, R>
   | ((
       context: Values.Simplify<B>,
+      // TODO: typing is super loose here
       next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<string>,
     ) =>
       | Stream.Stream<SseEvent, E, R>
@@ -64,10 +64,10 @@ export function sse<
   I extends Route.Route.Tuple,
   E = never,
   R = never,
->(handler: SseHandlerInput<NoInfer<D & B & Route.ExtractBindings<I> & { format: "text" }>, E, R>) {
+>(handler: SseHandlerInput<NoInfer<D & B & Route.ExtractBindings<I> & { format: "sse" }>, E, R>) {
   return function (self: Route.RouteSet.RouteSet<D, B, I>) {
     const sseHandler: Route.Route.Handler<
-      D & B & Route.ExtractBindings<I> & { format: "text" },
+      D & B & Route.ExtractBindings<I> & { format: "sse" },
       Stream.Stream<string, E, R>,
       E,
       R
@@ -113,20 +113,20 @@ export function sse<
       })
     }
 
-    const route = Route.make<{ format: "text" }, {}, Stream.Stream<string, E, R>, E, R>(
+    const route = Route.make<{ format: "sse" }, {}, Stream.Stream<string, E, R>, E, R>(
       sseHandler as any,
-      { format: "text" },
+      { format: "sse" },
     )
 
     const items: [
       ...I,
-      Route.Route.Route<{ format: "text" }, {}, Stream.Stream<string, E, R>, E, R>,
+      Route.Route.Route<{ format: "sse" }, {}, Stream.Stream<string, E, R>, E, R>,
     ] = [...Route.items(self), route]
 
     return Route.set<
       D,
       B,
-      [...I, Route.Route.Route<{ format: "text" }, {}, Stream.Stream<string, E, R>, E, R>]
+      [...I, Route.Route.Route<{ format: "sse" }, {}, Stream.Stream<string, E, R>, E, R>]
     >(items, Route.descriptor(self))
   }
 }

package/src/RouteTree.ts

@@ -1,10 +1,11 @@
 import * as Predicate from "effect/Predicate"
-import * as PathPattern from "./_PathPattern.ts"
+import type * as PathPattern from "./_PathPattern.ts"
 import * as Route from "./Route.ts"
 import type * as RouteMount from "./RouteMount.ts"
 
 const TypeId = "~effect-start/RouteTree" as const
 const RouteTreeRoutes: unique symbol = Symbol()
+const CompiledRoutesKey: unique symbol = Symbol()
 
 type MethodRoute = Route.Route.With<{ method: string }>
 
@@ -27,40 +28,25 @@ export type RouteMap = {
 
 export type Routes<T extends RouteTree> = T[typeof RouteTreeRoutes]
 
-export interface RouteTree<Routes extends RouteMap = RouteMap> {
-  [TypeId]: typeof TypeId
-  [RouteTreeRoutes]: Routes
+interface CompiledMethod {
+  regex: RegExp
+  table: Array<{
+    path: PathPattern.PathPattern
+    routes: Array<RouteMount.MountedRoute>
+    paramNames: Array<string>
+    paramGroupIndices: Array<number>
+    sentinelIndex: number
+  }>
 }
 
-function routes<Routes extends RouteMap>(tree: RouteTree<Routes>): Routes {
-  return tree[RouteTreeRoutes]
+interface CompiledRoutes {
+  methods: Record<string, CompiledMethod>
 }
 
-// segment priority: static (0) < :param (1) < :param? (2) < :param+ (3) < :param* (4)
-function sortScore(path: string): number {
-  const segments = path.split("/")
-  const greedyIdx = segments.findIndex((s) => s.endsWith("*") || s.endsWith("+"))
-  const maxPriority = Math.max(
-    ...segments.map((s) =>
-      !s.startsWith(":") ? 0 : s.endsWith("*") ? 4 : s.endsWith("+") ? 3 : s.endsWith("?") ? 2 : 1,
-    ),
-    0,
-  )
-
-  return greedyIdx === -1
-    ? // non-greedy: sort by depth, then by max segment priority
-      (segments.length << 16) + (maxPriority << 8)
-    : // greedy: sort after non-greedy, by greedy position (later = first), then priority
-      (1 << 24) + ((16 - greedyIdx) << 16) + (maxPriority << 8)
-}
-
-function sortRoutes(input: RouteMap): RouteMap {
-  const keys = Object.keys(input).sort((a, b) => sortScore(a) - sortScore(b) || a.localeCompare(b))
-  const sorted: RouteMap = {}
-  for (const key of keys) {
-    sorted[key as PathPattern.PathPattern] = input[key as PathPattern.PathPattern]
-  }
-  return sorted
+export interface RouteTree<Routes extends RouteMap = RouteMap> {
+  [TypeId]: typeof TypeId
+  [RouteTreeRoutes]: Routes
+  [CompiledRoutesKey]?: CompiledRoutes
 }
 
 type PrefixKeys<T, Prefix extends string> = {
@@ -92,6 +78,16 @@ type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (
   ? I
   : never
 
+export type WalkDescriptor = {
+  path: PathPattern.PathPattern
+  method: string
+} & Route.RouteDescriptor.Any
+
+export interface LookupResult {
+  route: RouteMount.MountedRoute
+  params: Record<string, string>
+}
+
 export function make<const Routes extends InputRouteMap>(
   input: Routes,
 ): RouteTree<FlattenRouteMap<Routes>> {
@@ -115,30 +111,13 @@ export function make<const Routes extends InputRouteMap>(
 
   flatten(input, "", layerRoutes)
 
+  const sorted = sortRoutes(merged)
   return {
     [TypeId]: TypeId,
-    [RouteTreeRoutes]: sortRoutes(merged),
+    [RouteTreeRoutes]: sorted,
   } as RouteTree<FlattenRouteMap<Routes>>
 }
 
-export type WalkDescriptor = {
-  path: PathPattern.PathPattern
-  method: string
-} & Route.RouteDescriptor.Any
-
-function* flattenRoutes(
-  path: PathPattern.PathPattern,
-  routes: Iterable<MethodRoute>,
-): Generator<RouteMount.MountedRoute> {
-  for (const route of routes) {
-    const descriptor = {
-      ...route[Route.RouteDescriptor],
-      path,
-    }
-    yield Route.make(route.handler as any, descriptor) as RouteMount.MountedRoute
-  }
-}
-
 export function* walk(tree: RouteTree): Generator<RouteMount.MountedRoute> {
   const _routes = routes(tree) as RouteMap
 
@@ -153,9 +132,10 @@ export function merge(a: RouteTree, b: RouteTree): RouteTree {
     const key = path as PathPattern.PathPattern
     combined[key] = combined[key] ? [...combined[key], ...items] : items
   }
+  const sorted = sortRoutes(combined)
   return {
     [TypeId]: TypeId,
-    [RouteTreeRoutes]: sortRoutes(combined),
+    [RouteTreeRoutes]: sorted,
   } as RouteTree
 }
 
@@ -163,21 +143,232 @@ export function isRouteTree(input: unknown): input is RouteTree {
   return Predicate.hasProperty(input, TypeId)
 }
 
-export interface LookupResult {
-  route: RouteMount.MountedRoute
-  params: Record<string, string>
+export function lookup(tree: RouteTree, method: string, path: string): LookupResult | null {
+  tree[CompiledRoutesKey] ??= compileRoutes(routes(tree))
+  const { methods } = tree[CompiledRoutesKey]
+
+  const wildcard = methods["*"]
+  if (wildcard) {
+    const result = execCompiled(wildcard, path)
+    if (result) return result
+  }
+
+  const specific = methods[method]
+  if (specific) {
+    const result = execCompiled(specific, path)
+    if (result) return result
+  }
+
+  return null
 }
 
-export function lookup(tree: RouteTree, method: string, path: string): LookupResult | null {
-  for (const route of walk(tree)) {
-    const descriptor = Route.descriptor(route)
+function routes<Routes extends RouteMap>(tree: RouteTree<Routes>): Routes {
+  return tree[RouteTreeRoutes]
+}
 
-    if (descriptor.method !== "*" && descriptor.method !== method) continue
+// segment priority: static (0) < :param (1) < :param? (2) < :param+ (3) < :param* (4)
+function sortScore(path: string): number {
+  const segments = path.split("/")
+  const greedyIdx = segments.findIndex((s) => s.endsWith("*") || s.endsWith("+"))
+  const maxPriority = Math.max(
+    ...segments.map((s) =>
+      !s.startsWith(":") ? 0 : s.endsWith("*") ? 4 : s.endsWith("+") ? 3 : s.endsWith("?") ? 2 : 1,
+    ),
+    0,
+  )
+
+  return greedyIdx === -1
+    ? // non-greedy: sort by depth, then by max segment priority
+      (segments.length << 16) + (maxPriority << 8)
+    : // greedy: sort after non-greedy, by greedy position (later = first), then priority
+      (1 << 24) + ((16 - greedyIdx) << 16) + (maxPriority << 8)
+}
+
+function sortRoutes(input: RouteMap): RouteMap {
+  const keys = Object.keys(input).sort((a, b) => sortScore(a) - sortScore(b) || a.localeCompare(b))
+  const sorted: RouteMap = {}
+  for (const key of keys) {
+    sorted[key as PathPattern.PathPattern] = input[key as PathPattern.PathPattern]
+  }
+  return sorted
+}
+
+function* flattenRoutes(
+  path: PathPattern.PathPattern,
+  routes: Iterable<MethodRoute>,
+): Generator<RouteMount.MountedRoute> {
+  for (const route of routes) {
+    const descriptor = {
+      ...route[Route.RouteDescriptor],
+      path,
+    }
+    yield Route.make(route.handler as any, descriptor) as RouteMount.MountedRoute
+  }
+}
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+}
+
+function patternToRegex(pattern: string): {
+  fragment: string
+  paramNames: Array<string>
+  groupCount: number
+} {
+  const segments = pattern.split("/").filter(Boolean)
+  const paramNames: Array<string> = []
+  let fragment = ""
+  let groupCount = 0
+
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i]
+
+    if (seg.startsWith(":")) {
+      const last = seg[seg.length - 1]
+      if (last === "+") {
+        const name = seg.slice(1, -1)
+        paramNames.push(name)
+        fragment += "\\/(.+)"
+        groupCount++
+      } else if (last === "*") {
+        const name = seg.slice(1, -1)
+        paramNames.push(name)
+        fragment += "(?:\\/(.+))?"
+        groupCount++
+      } else if (last === "?") {
+        const name = seg.slice(1, -1)
+        paramNames.push(name)
+        fragment += "(?:\\/([^\\/]+))?"
+        groupCount++
+      } else {
+        const name = seg.slice(1)
+        paramNames.push(name)
+        fragment += "\\/([^\\/]+)"
+        groupCount++
+      }
+    } else {
+      fragment += "\\/" + escapeRegex(seg)
+    }
+  }
+
+  return { fragment, paramNames, groupCount }
+}
+
+function compileRoutes(sortedRoutes: RouteMap): CompiledRoutes {
+  const methodGroups: Record<
+    string,
+    Array<{
+      path: PathPattern.PathPattern
+      route: RouteMount.MountedRoute
+    }>
+  > = {}
+
+  for (const path of Object.keys(sortedRoutes) as Array<PathPattern.PathPattern>) {
+    for (const routeData of sortedRoutes[path]) {
+      const descriptor = {
+        ...routeData[Route.RouteDescriptor],
+        path,
+      }
+      const mounted = Route.make(routeData.handler as any, descriptor) as RouteMount.MountedRoute
+      const method = (descriptor as { method: string }).method
+
+      if (!methodGroups[method]) methodGroups[method] = []
+      methodGroups[method].push({ path, route: mounted })
+    }
+  }
+
+  const pathRoutesByMethod: Record<
+    string,
+    Map<
+      string,
+      {
+        path: PathPattern.PathPattern
+        routes: Array<RouteMount.MountedRoute>
+      }
+    >
+  > = {}
+
+  for (const method of Object.keys(methodGroups)) {
+    const map = new Map<
+      string,
+      {
+        path: PathPattern.PathPattern
+        routes: Array<RouteMount.MountedRoute>
+      }
+    >()
+    for (const { path, route } of methodGroups[method]) {
+      let entry = map.get(path)
+      if (!entry) {
+        entry = { path, routes: [] }
+        map.set(path, entry)
+      }
+      entry.routes.push(route)
+    }
+    pathRoutesByMethod[method] = map
+  }
 
-    const params = PathPattern.match(descriptor.path, path)
-    if (params !== null) {
-      return { route, params }
+  const methods: Record<string, CompiledMethod> = {}
+
+  for (const method of Object.keys(pathRoutesByMethod)) {
+    const pathMap = pathRoutesByMethod[method]
+    const sortedPaths = Object.keys(sortedRoutes) as Array<PathPattern.PathPattern>
+    const orderedPaths = sortedPaths.filter((p) => pathMap.has(p))
+
+    const branches: Array<string> = []
+    const table: CompiledMethod["table"] = []
+    let groupOffset = 1
+
+    for (const path of orderedPaths) {
+      const entry = pathMap.get(path)!
+      const { fragment, paramNames, groupCount } = patternToRegex(path)
+
+      const paramGroupIndices: Array<number> = []
+      for (let i = 0; i < groupCount; i++) {
+        paramGroupIndices.push(groupOffset + i)
+      }
+
+      const sentinelIndex = groupOffset + groupCount
+      branches.push(fragment + "()")
+      groupOffset += groupCount + 1
+
+      table.push({
+        path: entry.path,
+        routes: entry.routes,
+        paramNames,
+        paramGroupIndices,
+        sentinelIndex,
+      })
+    }
+
+    if (branches.length === 0) continue
+
+    const pattern = "^(?:" + branches.join("|") + ")\\/*$"
+    methods[method] = {
+      regex: new RegExp(pattern),
+      table,
     }
   }
+
+  return { methods }
+}
+
+function execCompiled(compiled: CompiledMethod, path: string): LookupResult | null {
+  const match = compiled.regex.exec(path)
+  if (!match) return null
+
+  for (const entry of compiled.table) {
+    if (match[entry.sentinelIndex] === undefined) continue
+
+    const params: Record<string, string> = {}
+    for (let i = 0; i < entry.paramNames.length; i++) {
+      const val = match[entry.paramGroupIndices[i]]
+      if (val !== undefined) {
+        params[entry.paramNames[i]] = val
+      }
+    }
+
+    return { route: entry.routes[0], params }
+  }
+
   return null
 }

package/src/StaticFiles.ts

@@ -0,0 +1,112 @@
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as Schema from "effect/Schema"
+import * as Entity from "./Entity.ts"
+import * as FileSystem from "./FileSystem.ts"
+import * as PathPattern from "./_PathPattern.ts"
+import * as Mime from "./_Mime.ts"
+import * as Route from "./Route.ts"
+import * as RouteSchema from "./RouteSchema.ts"
+import * as RouteTree from "./RouteTree.ts"
+import * as System from "./System.ts"
+
+const defaultMountPath = "/assets"
+const PathParamsSchema = Schema.Struct({
+  path: Schema.optional(Schema.String),
+})
+
+const emptyNotFound = Entity.make(new Uint8Array(0), { status: 404 })
+
+export const make = (directory: string) =>
+  Route.get(
+    RouteSchema.schemaPathParams(PathParamsSchema),
+    Route.render(function* (ctx) {
+      const fs = yield* FileSystem.FileSystem
+      const relativePath =
+        typeof ctx.pathParams.path === "string" ? normalizeRelativePath(ctx.pathParams.path) : null
+
+      if (!relativePath) {
+        return emptyNotFound
+      }
+
+      const absolutePath = `${directory.replace(/[\\/]+$/, "")}/${relativePath}`
+      const info = yield* fs.stat(absolutePath).pipe(
+        Effect.catchAll((error) =>
+          isNotFound(error) ? Effect.succeed(null) : Effect.fail(error),
+        ),
+      )
+
+      if (info === null || info.type !== "File") {
+        return emptyNotFound
+      }
+
+      const headers: Entity.Headers = {
+        "content-length": String(info.size),
+        "content-type": Mime.fromPath(relativePath),
+      }
+
+      if (Option.isSome(info.mtime)) {
+        headers["last-modified"] = info.mtime.value.toUTCString()
+      }
+
+      const bytes = yield* fs.readFile(absolutePath)
+      return Entity.make(bytes, { headers })
+    }),
+  )
+
+export const layer = (options: {
+  directory: string
+  path?: string
+}) =>
+  Layer.effect(
+    Route.Routes,
+    Effect.gen(function* () {
+      const existing = yield* Effect.serviceOption(Route.Routes).pipe(
+        Effect.andThen(Option.getOrUndefined),
+      )
+      const trimmedMountPath = (options.path ?? defaultMountPath).trim().replace(/^\/+|\/+$/g, "")
+      const mountPattern = (
+        trimmedMountPath.length > 0 ? `/${trimmedMountPath}/:path+` : "/:path+"
+      ) as PathPattern.PathPattern
+      const staticFilesTree = Route.tree({
+        [mountPattern]: make(options.directory),
+      })
+      if (!existing) {
+        return staticFilesTree
+      }
+      return RouteTree.merge(existing, staticFilesTree)
+    }),
+  )
+
+function normalizeRelativePath(path: string): string | null {
+  if (path.length === 0 || path.startsWith("/") || path.startsWith("\\")) {
+    return null
+  }
+
+  const segments = path.split(/[\\/]+/)
+  const normalized: Array<string> = []
+
+  for (const segment of segments) {
+    if (segment === "" || segment === ".") {
+      continue
+    }
+    if (segment === ".." || segment.includes("\0")) {
+      return null
+    }
+    normalized.push(segment)
+  }
+
+  return normalized.length > 0 ? normalized.join("/") : null
+}
+
+function isNotFound(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "_tag" in error &&
+    error._tag === "SystemError" &&
+    "reason" in error &&
+    error.reason === "NotFound"
+  )
+}

package/src/_Mime.ts

@@ -0,0 +1,33 @@
+const mediaTypes: Record<string, string> = {
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".css": "text/css",
+  ".csv": "text/csv",
+  ".gif": "image/gif",
+  ".html": "text/html",
+  ".ico": "image/x-icon",
+  ".js": "text/javascript",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".json": "application/json",
+  ".map": "application/json",
+  ".md": "text/markdown",
+  ".mjs": "text/javascript",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain",
+  ".wasm": "application/wasm",
+  ".webm": "video/webm",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".xml": "application/xml",
+}
+
+export function fromPath(path: string): string {
+  const dotIndex = path.lastIndexOf(".")
+  const extension = dotIndex === -1 ? "" : path.slice(dotIndex).toLowerCase()
+  const mediaType = mediaTypes[extension] ?? "application/octet-stream"
+  return mediaType.startsWith("text/") ? `${mediaType}; charset=utf-8` : mediaType
+}

package/src/_PathPattern.ts

@@ -175,7 +175,7 @@ export function match(pattern: string, path: string): Record<string, string> | n
         if (remaining.length === 0) {
           return null
         }
-        params[name] = remaining.join("/")
+        params[name] = remaining.map(decodeURIComponent).join("/")
         return params
       }
 
@@ -183,7 +183,7 @@ export function match(pattern: string, path: string): Record<string, string> | n
         const name = rest.slice(0, -1)
         const remaining = pathSegments.slice(pathIndex)
         if (remaining.length > 0) {
-          params[name] = remaining.join("/")
+          params[name] = remaining.map(decodeURIComponent).join("/")
         }
         return params
       }
@@ -191,7 +191,7 @@ export function match(pattern: string, path: string): Record<string, string> | n
       if (rest.endsWith("?")) {
         const name = rest.slice(0, -1)
         if (pathIndex < pathSegments.length) {
-          params[name] = pathSegments[pathIndex]
+          params[name] = decodeURIComponent(pathSegments[pathIndex])
           pathIndex++
         }
         patternIndex++
@@ -202,7 +202,7 @@ export function match(pattern: string, path: string): Record<string, string> | n
         return null
       }
 
-      params[rest] = pathSegments[pathIndex]
+      params[rest] = decodeURIComponent(pathSegments[pathIndex])
       pathIndex++
       patternIndex++
       continue

package/src/_StreamExtra.ts

@@ -78,7 +78,6 @@ export const toReadableStreamRuntimePatched = Function.dual<
               ),
             ),
           )
-          // --- CHANGES HERE ---
           // In original code, we had fiber.addObserver here that called
           // error() or close() on controller. This patched version removes it.
         },

package/src/bun/BunRoute.ts

@@ -139,6 +139,16 @@ export function htmlBundle(load: () => HTMLBundleModule | Promise<HTMLBundleModu
         const childEntity = yield* next(context).pipe(
           Effect.locally(bundleDepthRef, bundleDepth + 1),
         )
+
+        if (
+          Entity.isEntity(childEntity) &&
+          childEntity.status &&
+          childEntity.status >= 300 &&
+          childEntity.status < 400
+        ) {
+          return childEntity
+        }
+
         const children = childEntity?.body ?? childEntity
 
         let childrenHtml = ""