GitHub

Middleware

API reference for Middleware.

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.

Attributes

AttributeTypeDescription
layerLayer[Never, LE, LR | Requires[R] | Raises[E]]

The layer to provide to the route layers this middleware wraps.

Functions

__init__

__init__(fn_layer, dependencies=None) -> None
ParameterTypeDescription
fn_layerLayer[Any, Any, Any]
dependenciesLayer[Any, Any, Any] | None = None
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)
    )

combine

combine[E2, R2, LE2, LR2](other) -> Middleware[E | E2, R | R2, LE | LE2, LR | LR2]

This middleware, running inside other.

ParameterTypeDescription
otherMiddleware[E2, R2, LE2, LR2]

Returns Middleware[E | E2, R | R2, LE | LE2, LR | LR2]

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)