pyfect-dev 0.1.0__py3-none-any.whl

pyfect/http/router/_middleware.py

@@ -0,0 +1,181 @@
+"""Router middleware: per-route (``Middleware.layer``) or global."""
+
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from typing import Any, Literal, Never, TypedDict, Unpack, cast, overload
+
+from pyfect._core import Effect, _WithFiber
+from pyfect._fiber import Fiber
+from pyfect._layer_core import CurrentMemoMap, Layer, effect_context, fork_or_create, require_layer
+from pyfect.context import Context
+from pyfect.effect import succeed
+from pyfect.http import middleware as http_middleware
+from pyfect.http.middleware._cors import AllowedOrigins
+from pyfect.http.router._markers import GlobalRaises, GlobalRequires, Raises, Requires, Unhandled
+from pyfect.http.router._middleware_stack import (
+    MiddlewareFn,
+    MiddlewareFnTag,
+    middleware_of,
+    new_stack_tag,
+)
+from pyfect.http.router._provided import GlobalProvided, Provided
+from pyfect.http.router._router import HttpRouter
+from pyfect.http.server_response import HttpServerResponse
+from pyfect.layer import effect_discard, provide, provide_merge, succeed_context
+from pyfect.scope import Scope
+
+
+class CorsOptions(TypedDict, total=False):
+    allowed_origins: AllowedOrigins
+    allowed_methods: Sequence[str]
+    allowed_headers: Sequence[str]
+    exposed_headers: Sequence[str]
+    max_age: int | None
+    credentials: bool
+
+
+type _In = Effect[HttpServerResponse, Unhandled]
+type MiddlewareFunction[E, R] = Callable[[_In], Effect[HttpServerResponse, E | Unhandled, R]]
+
+
+class Middleware[E = Never, R = Never, LE = Never, LR = Never]:
+    """Route middleware. Provide ``layer`` to the route layers it wraps;
+    it runs inside the global middleware, for matched routes only.
+
+    ``E`` and ``R`` are what it adds to each route's errors and
+    requirements; ``LE`` and ``LR`` what building it may fail with and
+    needs."""
+
+    __slots__ = ("_dependencies", "_fn_layer", "layer")
+
+    def __init__(
+        self,
+        fn_layer: Layer[Any, Any, Any],
+        dependencies: Layer[Any, Any, Any] | None = None,
+    ) -> None:
+        self._fn_layer = fn_layer
+        self._dependencies = dependencies
+        stack_tag = new_stack_tag()
+
+        def build(fiber: Fiber[Any, Any]) -> Effect[Context[Any], Any, Any]:
+            context = fiber._context
+            stack: list[MiddlewareFn] = [context.get_unsafe(MiddlewareFnTag)]
+            if dependencies is None:
+                return succeed(Context({stack_tag: stack}))
+            found, memo = context.lookup(CurrentMemoMap)
+            built = dependencies.build_with_memo_map(
+                memo if found else fork_or_create(context), context.get_unsafe(Scope)
+            )
+            return built.map(lambda deps: Context({stack_tag: [*stack, *middleware_of(deps)]}))
+
+        stacked: Layer[Any, Any, Any] = effect_context(_WithFiber(build))
+        self.layer: Layer[Never, LE, LR | Requires[R] | Raises[E]] = stacked.pipe(provide(fn_layer))
+
+    def combine[E2, R2, LE2, LR2](
+        self, other: Middleware[E2, R2, LE2, LR2]
+    ) -> Middleware[E | E2, R | R2, LE | LE2, LR | LR2]:
+        """This middleware, running inside ``other``."""
+        dependencies = (
+            other.layer
+            if self._dependencies is None
+            else self._dependencies.pipe(provide_merge(other.layer))
+        )
+        return Middleware(self._fn_layer, dependencies)
+
+
+def _fn_layer(fn: object) -> Layer[Any, Any, Any]:
+    if isinstance(fn, Effect):
+        made = cast("Effect[Any, Any, Any]", fn)
+        return effect_context(made.map(lambda f: Context({MiddlewareFnTag: f})))
+    return succeed_context(Context({MiddlewareFnTag: fn}))
+
+
+def _global_layer(fn: object) -> Layer[Never, Any, Any]:
+    made = cast("Effect[Any, Any, Any]", fn if isinstance(fn, Effect) else succeed(fn))
+    return effect_discard(
+        HttpRouter().flat_map(lambda router: made.flat_map(router.add_global_middleware))
+    )
+
+
+# Requirements only the router provides (or none) come first: pyright cannot
+# solve ``R`` in ``R | Provided`` from ``Never``.
+@overload
+def middleware[E = Never](
+    fn: Callable[[_In], Effect[HttpServerResponse, E | Unhandled, Provided]],
+    /,
+    *,
+    global_: Literal[False] = False,
+) -> Middleware[E]: ...
+@overload
+def middleware[E = Never, R = Never](
+    fn: Callable[[_In], Effect[HttpServerResponse, E | Unhandled, R | Provided]],
+    /,
+    *,
+    global_: Literal[False] = False,
+) -> Middleware[E, R]: ...
+@overload
+def middleware[LE, LR, E = Never, R = Never](
+    fn: Effect[Callable[[_In], Effect[HttpServerResponse, E | Unhandled, R | Provided]], LE, LR],
+    /,
+    *,
+    global_: Literal[False] = False,
+) -> Middleware[E, R, LE, LR]: ...
+@overload
+def middleware[E = Never](
+    fn: Callable[[_In], Effect[HttpServerResponse, E | Unhandled, GlobalProvided]],
+    /,
+    *,
+    global_: Literal[True],
+) -> Layer[Never, Never, HttpRouter | GlobalRaises[E]]: ...
+@overload
+def middleware[E = Never, R = Never](
+    fn: Callable[[_In], Effect[HttpServerResponse, E | Unhandled, R | GlobalProvided]],
+    /,
+    *,
+    global_: Literal[True],
+) -> Layer[Never, Never, HttpRouter | GlobalRequires[R] | GlobalRaises[E]]: ...
+@overload
+def middleware[LE, LR, E = Never, R = Never](
+    fn: Effect[
+        Callable[[_In], Effect[HttpServerResponse, E | Unhandled, R | GlobalProvided]], LE, LR
+    ],
+    /,
+    *,
+    global_: Literal[True],
+) -> Layer[Never, LE, HttpRouter | LR | GlobalRequires[R] | GlobalRaises[E]]: ...
+def middleware(fn: object, /, *, global_: bool = False) -> Any:
+    """Middleware from a function of the handler (or an effect making
+    one). The handler's own errors arrive as ``Unhandled``, which the
+    result must keep.
+
+    ``global_=True`` gives a layer wrapping every request, matched or not,
+    instead."""
+    return _global_layer(fn) if global_ else Middleware(_fn_layer(fn))
+
+
+def cors(**options: Unpack[CorsOptions]) -> Layer[Never, Never, HttpRouter]:
+    """``http.middleware.cors`` for every request, as global middleware."""
+    return _global_layer(http_middleware.cors(**options))
+
+
+disable_logger: Layer[Never, Never, Requires[Never] | Raises[Never]] = Middleware[Never, Never](
+    _fn_layer(http_middleware.with_logger_disabled)
+).layer
+"""Route middleware turning off the request log for the routes it wraps."""
+
+
+def provide_request[A2, E2, R2](
+    services: Layer[A2, E2, R2],
+) -> Callable[[Layer[Any, Any, Any]], Layer[Any, Any, Any]]:
+    """Build ``services`` once and provide them to every request of the
+    route layers this wraps. Use with ``.pipe``."""
+    require_layer(services, "services")
+
+    def fn(context: Context[Any]) -> Callable[[_In], Effect[HttpServerResponse, Unhandled]]:
+        return lambda eff: eff.pipe(provide(context))
+
+    made: Effect[Any, Any, Any] = services.build().map(fn)
+    return provide(Middleware(_fn_layer(made)).layer)

pyfect/http/router/_middleware_stack.py

@@ -0,0 +1,51 @@
+"""Where route middleware lives while layers build: each ``Middleware``
+layer adds a stack (its function, then its dependencies' functions)
+under a tag of its own, and ``add_all`` wraps routes with every stack in
+the context."""
+
+from __future__ import annotations
+
+import itertools
+import types
+from collections.abc import Callable
+from typing import Any
+
+from pyfect._core import Effect
+from pyfect.context import Context, Tag
+from pyfect.http.server_response import HttpServerResponse
+
+type MiddlewareFn = Callable[
+    [Effect[HttpServerResponse, Any, Any]], Effect[HttpServerResponse, Any, Any]
+]
+
+
+class MiddlewareFnTag(Tag[MiddlewareFn], key="effect/http/HttpRouter/MiddlewareFn"):
+    """The function a ``Middleware`` layer wraps routes with."""
+
+
+class MiddlewareStack(Tag[list[MiddlewareFn]], key="effect/http/HttpRouter/Middleware", base=True):
+    """The base of each middleware's own stack tag."""
+
+
+_ids = itertools.count(1)
+
+
+def new_stack_tag() -> type[MiddlewareStack]:
+    key = f"effect/http/HttpRouter/Middleware-{next(_ids)}"
+    return types.new_class(key.rsplit("/", 1)[1], (MiddlewareStack,), {"key": key})
+
+
+def middleware_of(context: Context[Any]) -> list[MiddlewareFn]:
+    """Every stack's functions, innermost first, each once: a function
+    shared by several stacks runs at its outermost position."""
+    stacks = [
+        value for tag, value in context.map_unsafe.items() if issubclass(tag, MiddlewareStack)
+    ]
+    if not stacks:
+        return []
+    seen: dict[MiddlewareFn, None] = {}
+    for depth in range(max(map(len, stacks)) - 1, -1, -1):
+        for stack in stacks:
+            if depth < len(stack):
+                seen.setdefault(stack[depth])
+    return list(reversed(seen))

pyfect/http/router/_provided.py

@@ -0,0 +1,31 @@
+"""The services the router gives every handler."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
+
+from pyfect.context import Tag
+from pyfect.http.server_request import HttpServerRequest, ParsedSearchParams
+from pyfect.scope import Scope
+
+if TYPE_CHECKING:
+    from pyfect.http.router._route import Route
+
+
+class RouteInfo:
+    """The matched route and its path parameters."""
+
+    __slots__ = ("params", "route")
+
+    def __init__(self, route: Route[Any, Any], params: Mapping[str, str]) -> None:
+        self.route = route
+        self.params = params
+
+
+class RouteContext(Tag[RouteInfo], key="effect/http/HttpRouter/RouteContext"):
+    pass
+
+
+type Provided = HttpServerRequest | Scope | ParsedSearchParams | RouteContext
+type GlobalProvided = HttpServerRequest | Scope

pyfect/http/router/_route.py

@@ -0,0 +1,114 @@
+"""Routes: a method, a path and a handler, maybe under a prefix."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, replace
+from typing import Any, Literal, Never, Self, cast, overload
+
+from pyfect._core import Effect
+from pyfect.effect import succeed
+from pyfect.http.router._provided import Provided
+from pyfect.http.server_request import HttpServerRequest, ServerRequest
+from pyfect.http.server_response import HttpServerResponse
+
+type Method = Literal["*", "GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "QUERY", "HEAD"]
+
+
+@dataclass(frozen=True, slots=True)
+class Route[E = Never, R = Never]:
+    """``method`` ``"*"`` matches every method, and a ``path`` ending in
+    ``/*`` matches its prefix too. ``prefix`` is the mount point removed
+    from the request URL before the handler runs."""
+
+    method: Method
+    path: str
+    handler: Effect[HttpServerResponse, E, R]
+    uninterruptible: bool = False
+    prefix: str | None = None
+
+    def pipe[B](self, f: Callable[[Self], B], /) -> B:
+        return f(self)
+
+
+type Handler[E, R] = (
+    HttpServerResponse
+    | Effect[HttpServerResponse, E, R]
+    | Callable[[ServerRequest], Effect[HttpServerResponse, E, R]]
+)
+
+
+def to_effect(handler: Handler[Any, Any]) -> Effect[HttpServerResponse, Any, Any]:
+    if isinstance(handler, HttpServerResponse):
+        return succeed(handler)
+    if isinstance(handler, Effect):
+        return cast("Effect[HttpServerResponse, Any, Any]", handler)
+    return HttpServerRequest().flat_map(handler)
+
+
+@overload
+def route(
+    method: Method, path: str, handler: HttpServerResponse, *, uninterruptible: bool = False
+) -> Route: ...
+@overload
+def route[E](
+    method: Method,
+    path: str,
+    handler: Effect[HttpServerResponse, E, Provided]
+    | Callable[[ServerRequest], Effect[HttpServerResponse, E, Provided]],
+    *,
+    uninterruptible: bool = False,
+) -> Route[E]: ...
+@overload
+def route[E, R](
+    method: Method,
+    path: str,
+    handler: Effect[HttpServerResponse, E, R | Provided]
+    | Callable[[ServerRequest], Effect[HttpServerResponse, E, R | Provided]],
+    *,
+    uninterruptible: bool = False,
+) -> Route[E, R]: ...
+def route(
+    method: Method,
+    path: str,
+    # Spelled out (not ``Handler``): a function is a valid handler.
+    handler: HttpServerResponse
+    | Effect[HttpServerResponse, Any, Any]
+    | Callable[[ServerRequest], Effect[HttpServerResponse, Any, Any]],
+    *,
+    uninterruptible: bool = False,
+) -> Route[Any, Any]:
+    """A route for ``add_all``. ``handler`` is a response, an effect, or a
+    function of the request. Handlers run interruptibly unless
+    ``uninterruptible``."""
+    return Route(method, path, to_effect(handler), uninterruptible)
+
+
+def remove_trailing_slash(path: str) -> str:
+    return path.removesuffix("/")
+
+
+def prefix_path(path: str, prefix: str) -> str:
+    """``path`` under ``prefix``: ``"*"`` becomes ``prefix + "/*"`` and
+    ``"/"`` the prefix itself."""
+    prefix = remove_trailing_slash(prefix)
+    if path == "*":
+        return f"{prefix}/*"
+    if path == "/":
+        return prefix
+    return prefix + path
+
+
+def prefix_route[E, R](prefix: str) -> Callable[[Route[E, R]], Route[E, R]]:
+    """Mount a route under ``prefix``. Use with ``.pipe``."""
+
+    def apply(self: Route[E, R]) -> Route[E, R]:
+        return replace(
+            self,
+            path=prefix_path(self.path, prefix),
+            prefix=remove_trailing_slash(prefix)
+            if self.prefix is None
+            else prefix_path(self.prefix, prefix),
+        )
+
+    return apply

pyfect/http/router/_router.py

@@ -0,0 +1,308 @@
+"""The ``HttpRouter`` service: routes added while layers build, found per
+request with find-my-way."""
+
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass, field, replace
+from typing import Any, Never, overload
+
+from pyfect._core import Effect, _WithFiber
+from pyfect._fiber import Fiber
+from pyfect._primitives import _Locally
+from pyfect._tracer_ref import CurrentTracer
+from pyfect.context import Context, Reference, Tag
+from pyfect.effect import fail, sync, void
+from pyfect.http import find_my_way
+from pyfect.http.find_my_way._paths import closing_parenthesis
+from pyfect.http.router._markers import Raises, Requires, Unhandled
+from pyfect.http.router._middleware_stack import MiddlewareFn, middleware_of
+from pyfect.http.router._provided import Provided, RouteContext, RouteInfo
+from pyfect.http.router._route import (
+    Method,
+    Route,
+    prefix_path,
+    prefix_route,
+    remove_trailing_slash,
+    to_effect,
+)
+from pyfect.http.server_error import HttpServerError, RouteNotFound
+from pyfect.http.server_request import HttpServerRequest, ParsedSearchParams, ServerRequest
+from pyfect.http.server_response import HttpServerResponse
+from pyfect.tracer import ExternalSpan, ParentSpan, native_tracer
+
+type GlobalMiddlewareFn = Callable[
+    [Effect[HttpServerResponse, Unhandled]], Effect[HttpServerResponse, Any, Any]
+]
+
+
+class RouterConfig(Reference[find_my_way.RouterConfig], key="effect/http/HttpRouter/RouterConfig"):
+    """How routes match: trailing and duplicate slashes, case, and the
+    longest path parameter."""
+
+    @classmethod
+    def default(cls) -> find_my_way.RouterConfig:
+        return find_my_way.RouterConfig()
+
+
+@dataclass(frozen=True, slots=True)
+class _Entry:
+    route: Route[Any, Any]
+    prefix_segments: int | None
+
+
+def count_segments(prefix: str, ignore_duplicate_slashes: bool) -> int:
+    """The number of path segments ``prefix`` matches; slashes inside a
+    parameter's regex do not count."""
+    count = 0
+    in_param = False
+    i = 0
+    while i < len(prefix):
+        char = prefix[i]
+        if char == "/":
+            if not ignore_duplicate_slashes or prefix[i - 1 : i] != "/":
+                count += 1
+            in_param = False
+        elif char == ":":
+            if prefix[i + 1 : i + 2] == ":":
+                i += 1
+            else:
+                in_param = True
+        elif char in "-.":
+            in_param = False
+        elif char == "(" and in_param:
+            i = closing_parenthesis(prefix, i)
+            in_param = False
+        i += 1
+    return count
+
+
+def slice_request_url(
+    request: ServerRequest, prefix_segments: int, ignore_duplicate_slashes: bool
+) -> ServerRequest:
+    """``request`` with its first ``prefix_segments`` path segments
+    removed from the URL."""
+    url = request.url
+    index = 0
+    for _ in range(prefix_segments):
+        if ignore_duplicate_slashes:
+            while url[index : index + 1] == "/":
+                index += 1
+        elif url[index : index + 1] == "/":
+            index += 1
+        while index < len(url) and url[index] not in "/?;#":
+            index += 1
+    rest = url[index:]
+    return request.modify(url=rest if rest.startswith("/") else "/" + rest)
+
+
+@dataclass(eq=False)
+class _Core:
+    config: find_my_way.RouterConfig
+    router: find_my_way.Router[_Entry]
+    global_middleware: list[GlobalMiddlewareFn] = field(default_factory=list[GlobalMiddlewareFn])
+
+    def add_all(self, routes: Sequence[Route[Any, Any]]) -> Effect[None]:
+        def body(fiber: Fiber[Any, Any]) -> Effect[None]:
+            middleware = middleware_of(fiber._context)
+            for route in routes:
+                self._add(route if not middleware else _with_middleware(route, middleware))
+            return void
+
+        return _WithFiber(body)
+
+    def _add(self, route: Route[Any, Any]) -> None:
+        entry = _Entry(
+            route,
+            None
+            if route.prefix is None
+            else count_segments(route.prefix, self.config.ignore_duplicate_slashes),
+        )
+        paths = [route.path]
+        if route.path.endswith("/*"):
+            paths.append(route.path[:-2])
+        for path in paths:
+            if route.method == "*":
+                self.router.all(path, entry)
+            else:
+                self.router.on(route.method, path, entry)
+
+    def as_http_effect(self) -> Effect[HttpServerResponse, Any, HttpServerRequest]:
+        handler: Effect[HttpServerResponse, Any, Any] = _WithFiber(self._dispatch)
+        for fn in reversed(self.global_middleware):
+            handler = fn(handler)
+        return handler
+
+    def _find(self, request: ServerRequest) -> tuple[find_my_way.FindResult[_Entry] | None, bool]:
+        result = self.router.find(request.method, request.url)
+        exceeded = result is None and self.router.max_param_length_exceeded
+        if result is None and request.method == "HEAD":
+            result = self.router.find("GET", request.url)
+            exceeded = exceeded or (result is None and self.router.max_param_length_exceeded)
+        return result, exceeded
+
+    def _dispatch(self, fiber: Fiber[Any, Any]) -> Effect[HttpServerResponse, Any, Any]:
+        request = fiber._context.get_unsafe(HttpServerRequest)
+        result, exceeded = self._find(request)
+        if result is None:
+            limit = self.config.max_param_length
+            description = (
+                f"path parameter is longer than maxParamLength ({limit})" if exceeded else None
+            )
+            return fail(HttpServerError(RouteNotFound(request, description)))
+        route = result.handler.route
+        segments = result.handler.prefix_segments
+        routed = (
+            request
+            if segments is None
+            else slice_request_url(request, segments, self.config.ignore_duplicate_slashes)
+        )
+        if fiber.get_ref(CurrentTracer) is not native_tracer:
+            span = fiber.get_ref(ParentSpan)
+            if span is not None and not isinstance(span, ExternalSpan) and span.sampled:
+                span.attribute("http.route", route.path)
+        info = RouteInfo(route, result.params)
+        search_params = result.search_params
+
+        def provide(ctx: Context[Any]) -> Context[Any]:
+            return (
+                ctx.add(HttpServerRequest, routed)
+                .add(ParsedSearchParams, search_params)
+                .add(RouteContext, info)
+            )
+
+        handler = route.handler if route.uninterruptible else route.handler.interruptible()
+        return _Locally(handler, provide)
+
+
+def _with_middleware(route: Route[Any, Any], middleware: Sequence[MiddlewareFn]) -> Route[Any, Any]:
+    handler = route.handler
+    for fn in middleware:
+        handler = fn(handler)
+    return replace(route, handler=handler)
+
+
+@dataclass(frozen=True, slots=True)
+class HttpRouterService:
+    """Add routes while layers build; ``as_http_effect`` serves them."""
+
+    _core: _Core
+    _prefix: str | None = None
+
+    def prefixed(self, prefix: str) -> HttpRouterService:
+        """This router with every route mounted under ``prefix``."""
+        prefix = remove_trailing_slash(prefix)
+        return HttpRouterService(
+            self._core, prefix if self._prefix is None else prefix_path(prefix, self._prefix)
+        )
+
+    @overload
+    def add(
+        self,
+        method: Method,
+        path: str,
+        handler: HttpServerResponse
+        | Effect[HttpServerResponse, Never, Provided]
+        | Callable[[ServerRequest], Effect[HttpServerResponse, Never, Provided]],
+        *,
+        uninterruptible: bool = False,
+    ) -> Effect[None]: ...
+    @overload
+    def add[E](
+        self,
+        method: Method,
+        path: str,
+        handler: Effect[HttpServerResponse, E, Provided]
+        | Callable[[ServerRequest], Effect[HttpServerResponse, E, Provided]],
+        *,
+        uninterruptible: bool = False,
+    ) -> Effect[None, Never, Raises[E]]: ...
+    @overload
+    def add[R](
+        self,
+        method: Method,
+        path: str,
+        handler: Effect[HttpServerResponse, Never, R | Provided]
+        | Callable[[ServerRequest], Effect[HttpServerResponse, Never, R | Provided]],
+        *,
+        uninterruptible: bool = False,
+    ) -> Effect[None, Never, Requires[R]]: ...
+    @overload
+    def add[E, R](
+        self,
+        method: Method,
+        path: str,
+        handler: Effect[HttpServerResponse, E, R | Provided]
+        | Callable[[ServerRequest], Effect[HttpServerResponse, E, R | Provided]],
+        *,
+        uninterruptible: bool = False,
+    ) -> Effect[None, Never, Requires[R] | Raises[E]]: ...
+    def add(
+        self,
+        method: Method,
+        path: str,
+        # Spelled out (not ``Handler``): a function is a valid handler.
+        handler: HttpServerResponse
+        | Effect[HttpServerResponse, Any, Any]
+        | Callable[[ServerRequest], Effect[HttpServerResponse, Any, Any]],
+        *,
+        uninterruptible: bool = False,
+    ) -> Effect[None, Never, Any]:
+        """Add a route. ``handler`` is a response, an effect, or a function
+        of the request; it runs interruptibly unless ``uninterruptible``."""
+        if self._prefix is None:
+            return self._core.add_all([Route(method, path, to_effect(handler), uninterruptible)])
+        route = Route(
+            method,
+            prefix_path(path, self._prefix),
+            to_effect(handler),
+            uninterruptible,
+            self._prefix,
+        )
+        return self._core.add_all([route])
+
+    @overload
+    def add_all(self, routes: Sequence[Route[Never, Never]], /) -> Effect[None]: ...
+    @overload
+    def add_all[E](
+        self, routes: Sequence[Route[E, Never]], /
+    ) -> Effect[None, Never, Raises[E]]: ...
+    @overload
+    def add_all[R](
+        self, routes: Sequence[Route[Never, R]], /
+    ) -> Effect[None, Never, Requires[R]]: ...
+    @overload
+    def add_all[E, R](
+        self, routes: Sequence[Route[E, R]], /
+    ) -> Effect[None, Never, Requires[R] | Raises[E]]: ...
+    def add_all(self, routes: Sequence[Route[Any, Any]], /) -> Effect[None, Never, Any]:
+        """Add several routes (under this router's prefix)."""
+        if self._prefix is not None:
+            routes = [prefix_route(self._prefix)(route) for route in routes]
+        return self._core.add_all(routes)
+
+    def add_global_middleware(self, middleware: GlobalMiddlewareFn) -> Effect[None]:
+        """Wrap every request, matched or not. Added first is outermost."""
+        return sync(lambda: self._add_global(middleware))
+
+    def _add_global(self, middleware: GlobalMiddlewareFn) -> None:
+        if middleware not in self._core.global_middleware:
+            self._core.global_middleware.append(middleware)
+
+    def as_http_effect(self) -> Effect[HttpServerResponse, Any, HttpServerRequest]:
+        """The app: routes each request, failing with ``RouteNotFound``
+        when nothing matches."""
+        return self._core.as_http_effect()
+
+
+class HttpRouter(Tag[HttpRouterService], key="effect/http/HttpRouter"):
+    pass
+
+
+def _make(config: find_my_way.RouterConfig) -> HttpRouterService:
+    return HttpRouterService(_Core(config, find_my_way.Router[_Entry](config)))
+
+
+make: Effect[HttpRouterService] = RouterConfig().map(_make)