pyfect-dev 0.1.0__py3-none-any.whl

pyfect/http_api/_media_type.py

@@ -0,0 +1,6 @@
+"""Media types compared without case, parameters or surrounding space."""
+
+
+def normalize(content_type: str) -> str:
+    """``"Application/JSON; charset=utf-8"`` is ``"application/json"``."""
+    return content_type.lower().strip().split(";", 1)[0].strip()

pyfect/http_api/_openapi_responses.py

@@ -0,0 +1,164 @@
+"""An operation's ``responses`` (Effect's ``OpenApi`` response bodies):
+for each status its description, headers and content by media type."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+from pyfect import schema as S
+from pyfect.http_api import schema as api_schema
+from pyfect.http_api._openapi_schemas import SchemaOps
+from pyfect.http_api.endpoint import AnyEndpoint, error_schemas, success_schemas
+from pyfect.schema import Top, ast
+
+type Json = dict[str, Any]
+
+
+@dataclass(slots=True)
+class _Body:
+    descriptions: list[str] = field(default_factory=list[str])
+    content: dict[str, dict[str, list[Top]]] | None = None
+    """Schemas by encoding tag, then content type."""
+    headers: list[Top] = field(default_factory=list[Top])
+    streams: dict[str, api_schema.StreamSchema] | None = None
+
+    def describe(self, description: str | None) -> None:
+        if description is not None and description not in self.descriptions:
+            self.descriptions.append(description)
+
+
+def response_bodies(op: Json, ops: SchemaOps, endpoint: AnyEndpoint) -> None:
+    successes = _bodies(success_schemas(endpoint), api_schema.get_status_success_schema)
+    _process(op, ops, successes, "Success")
+    errors = _bodies(error_schemas(endpoint), api_schema.get_status_error_schema)
+    _process(op, ops, errors, "Error")
+
+
+def _description(node: ast.AST) -> str | None:
+    annotations = node.resolve() or {}
+    for key in ("description", "identifier"):
+        value = annotations.get(key)
+        if isinstance(value, str):
+            return value
+    return None
+
+
+def _upgrade_headers(protocol: str) -> Top:
+    return S.Bottom(
+        ast.Objects(
+            (
+                ast.PropertySignature("connection", ast.Literal("Upgrade")),
+                ast.PropertySignature("upgrade", ast.Literal(protocol)),
+            )
+        )
+    )
+
+
+def _parts(schema: Top) -> tuple[Top, Top | None]:
+    """The body and headers schemas of a response schema."""
+    if api_schema.is_with_headers(schema):
+        return schema.schema, schema.headers
+    annotation = api_schema.get_with_headers_annotation(schema.__codec__().ast)
+    if annotation is not None:
+        return annotation.body, annotation.headers_codec
+    return schema, None
+
+
+def _bodies(schemas: tuple[Top, ...], get_status: Callable[[Top], int]) -> dict[int, _Body]:
+    bodies: dict[int, _Body] = {}
+    for schema in schemas:
+        body, headers = _parts(schema)
+        status = get_status(schema)
+        body_node = body.__codec__().ast
+        if api_schema.is_upgrade(body):
+            entry = _no_content(bodies, status, _description(body_node) or "Switching Protocols")
+            entry.headers.append(_upgrade_headers(body.protocol))
+            if body.headers is not None:
+                entry.headers.append(body.headers)
+        elif api_schema.is_stream_schema(body):
+            entry = bodies.setdefault(status, _Body())
+            entry.streams = {**(entry.streams or {}), body.content_type: body}
+        elif api_schema.is_no_content(body_node):
+            node = schema.__codec__().ast
+            description = _description(node) or _description(body_node) or "<No Content>"
+            _no_content(bodies, status, description)
+        else:
+            _add_content(bodies.setdefault(status, _Body()), schema, body)
+        if headers is not None:
+            bodies[status].headers.append(headers)
+    return bodies
+
+
+def _add_content(entry: _Body, schema: Top, body: Top) -> None:
+    encoding = api_schema.get_response_encoding_schema(schema)
+    entry.describe(_description(schema.__codec__().ast) or _description(body.__codec__().ast))
+    if entry.content is None:
+        entry.content = {}
+    listed = entry.content.setdefault(encoding.tag, {}).setdefault(encoding.content_type, [])
+    if all(s is not body for s in listed):
+        listed.append(body)
+
+
+def _no_content(bodies: dict[int, _Body], status: int, description: str) -> _Body:
+    entry = bodies.get(status)
+    if entry is None:
+        entry = bodies[status] = _Body(descriptions=[description])
+    else:
+        entry.describe(description)
+    return entry
+
+
+def _process(op: Json, ops: SchemaOps, bodies: dict[int, _Body], default: str) -> None:
+    responses: Json = op["responses"]
+    for status, entry in bodies.items():
+        key = str(status)
+        response: Json = {
+            "description": " | ".join(entry.descriptions) if entry.descriptions else default
+        }
+        responses[key] = response
+        for headers in entry.headers:
+
+            def apply(name: str, optional: bool, schema: Json, response: Json = response) -> None:
+                response.setdefault("headers", {})[name.lower()] = {
+                    "schema": schema,
+                    "required": not optional,
+                }
+
+            ops.properties(
+                headers.__codec__().ast, apply, select=lambda name: name.lower() != "content-type"
+            )
+        for tag, by_type in (entry.content or {}).items():
+            for content_type, schemas in by_type.items():
+                nodes = tuple(s.__codec__().ast for s in schemas)
+                node = nodes[0] if len(nodes) == 1 else ast.Union(nodes)
+                response.setdefault("content", {})[content_type] = {"schema": ops.schema(node, tag)}
+        for content_type, stream in (entry.streams or {}).items():
+            response.setdefault("content", {})[content_type] = stream_media_type(ops, stream)
+
+
+def stream_media_type(ops: SchemaOps, stream: api_schema.StreamSchema) -> Json:
+    if isinstance(stream, api_schema.StreamSseSchema):
+        return {
+            "schema": ops.schema(stream.events.__codec__().ast),
+            "x-effect-stream": {
+                "encoding": "sse",
+                "causeSchema": ops.schema(S.Cause(stream.error, S.Defect()).__codec__().ast),
+                "errorSchema": ops.schema(stream.error.__codec__().ast),
+                "failureEvent": api_schema.RESERVED_STREAM_FAILURE_EVENT,
+            },
+        }
+    if isinstance(stream, api_schema.StreamNdjsonSchema):
+        # Each line is one element, so the media type documents the element schema.
+        return {
+            "schema": ops.schema(stream.schema.__codec__().ast),
+            "x-effect-stream": {"encoding": "ndjson"},
+        }
+    return {
+        "schema": {"type": "string", "format": "binary"},
+        "x-effect-stream": {"encoding": "uint8array"},
+    }
+
+
+__all__ = ["response_bodies", "stream_media_type"]

pyfect/http_api/_openapi_schemas.py

@@ -0,0 +1,163 @@
+"""The JSON Schemas of an OpenAPI document, compiled together so they
+share ``components.schemas`` (Effect's ``OpenApi`` schema operations).
+
+``schema(node)`` gives a dict filled in by ``compile``; ``properties``
+gives each property of an object schema (a parameter or a header) to a
+function once compiled.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, replace
+from typing import Any, cast
+
+from pyfect import schema as S
+from pyfect.http import multipart
+from pyfect.http_api import schema as api_schema
+from pyfect.json_schema import MultiDocument, to_multi_document_open_api_3_1
+from pyfect.schema import ast
+from pyfect.schema._jsonschema._annotations import Options, ReferencePolicy
+from pyfect.schema._jsonschema._compile import Compiler
+from pyfect.schema._jsonschema._references import References, encoded_node
+from pyfect.schema._to_codec_json import to_codec_json_asts
+
+type Json = dict[str, Any]
+type ApplyProperty = Callable[[str, bool, Json], None]
+
+_BINARY = S.String.annotate(format="binary").__codec__().ast
+_STRING = S.String.__codec__().ast
+
+
+@dataclass(frozen=True, slots=True)
+class _Schema:
+    node: ast.AST
+    target: Json
+
+
+@dataclass(frozen=True, slots=True)
+class _Properties:
+    node: ast.Objects
+    apply: ApplyProperty
+
+
+class SchemaOps:
+    __slots__ = ("_ops",)
+
+    def __init__(self) -> None:
+        self._ops: list[_Schema | _Properties] = []
+
+    def schema(self, node: ast.AST, encoding: str = "Json") -> Json:
+        """The schema of a body of ``node`` sent with ``encoding``."""
+        # Text bodies remain strings even when an opaque schema compiles to {}.
+        target: Json = {"type": "string"} if encoding == "Text" else {}
+        self._ops.append(_Schema(_encoding_node(node, encoding), target))
+        return target
+
+    def properties(
+        self,
+        node: ast.AST,
+        apply: ApplyProperty,
+        select: Callable[[str], bool] | None = None,
+    ) -> None:
+        """Each property of ``node``'s encoded object (those ``select``
+        keeps) to ``apply(name, optional, schema)``."""
+        objects = _resolve_objects(node)
+        kept = tuple(
+            p
+            for p in (objects.properties if objects is not None else ())
+            if select is None or select(str(p.name))
+        )
+        self._ops.append(_Properties(ast.Objects(kept), apply))
+
+    def compile(
+        self,
+        components: Json,
+        include: Callable[[str], bool] | None,
+        policy: ReferencePolicy | None,
+    ) -> None:
+        if not self._ops:
+            return
+        schema_ops = [op for op in self._ops if isinstance(op, _Schema)]
+        derived = iter(to_codec_json_asts([op.node for op in schema_ops]))
+        nodes = [next(derived) if isinstance(op, _Schema) else op.node for op in self._ops]
+        compiler = Compiler(References(nodes, policy), Options("error", False, include))
+        roots = [compiler.recur(node, []) for node in nodes]
+        out, definitions = compiler.finish(roots)
+        document = to_multi_document_open_api_3_1(
+            MultiDocument("draft-2020-12", tuple(out), definitions)
+        )
+        for op, schema in zip(self._ops, document.schemas, strict=True):
+            if isinstance(op, _Schema):
+                op.target.update(schema)
+                continue
+            properties = cast("Json", schema.get("properties", {}))
+            for p in op.node.properties:
+                name = str(p.name)
+                op.apply(name, _encoded_optional(p), properties[name])
+        components.update(document.definitions)
+
+
+def _encoded_optional(p: ast.PropertySignature) -> bool:
+    if p.encoded_optional is not None:
+        return p.encoded_optional
+    return p.optional or p.default is not None or p.type.flip().optional_key
+
+
+def _resolve_objects(node: ast.AST) -> ast.Objects | None:
+    node = encoded_node(node)
+    while isinstance(node, ast.Suspend):
+        node = encoded_node(node.target)
+    return node if isinstance(node, ast.Objects) else None
+
+
+def _encoding_node(node: ast.AST, encoding: str) -> ast.AST:
+    match encoding:
+        case "Uint8Array":
+            return _BINARY
+        case "Text":
+            return _STRING if isinstance(node, ast.Declaration) and node.encoding is None else node
+        case "Multipart":
+            return _files_as_binary(api_schema.documented_node(node))
+        case _:
+            return node
+
+
+_PERSISTED_FILE = multipart.PersistedFileSchema.__codec__().ast
+_PERSISTED_FILE_CODEC = (_PERSISTED_FILE.annotations or {})["to_codec_json"]
+
+
+def _is_persisted_file(node: ast.AST) -> bool:
+    """A file, or a schema decoding to one (``SingleFileSchema``): the
+    file's declaration, whatever its encoding and annotations."""
+    return (
+        isinstance(node, ast.Declaration)
+        and (node.annotations or {}).get("to_codec_json") is _PERSISTED_FILE_CODEC
+    )
+
+
+def _files_as_binary(node: ast.AST) -> ast.AST:
+    """``node`` with each persisted file a binary string."""
+    if _is_persisted_file(node):
+        return _BINARY
+    match node:
+        case ast.Objects():
+            return replace(
+                node,
+                properties=tuple(
+                    replace(p, type=_files_as_binary(p.type)) for p in node.properties
+                ),
+            )
+        case ast.Arrays():
+            return replace(
+                node,
+                elements=tuple(replace(e, type=_files_as_binary(e.type)) for e in node.elements),
+                rest=tuple(_files_as_binary(r) for r in node.rest),
+            )
+        case ast.Union():
+            return replace(node, types=tuple(_files_as_binary(t) for t in node.types))
+        case _:
+            return node
+
+
+__all__ = ["SchemaOps"]

pyfect/http_api/_path.py

@@ -0,0 +1,102 @@
+"""Endpoint paths: the router path of an endpoint and the URL a client
+builds from its path parameters (Effect's ``internal/path``)."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable, Set
+
+from pyfect.http.find_my_way._paths import closing_parenthesis
+from pyfect.schema import Top, ast
+
+_EMPTY: frozenset[str] = frozenset()
+_PARAM = re.compile(r":(\w+)", re.ASCII)
+_PARAMS = re.compile(r"::|:(\w+)", re.ASCII)
+
+
+def last_encoding(node: ast.AST) -> ast.AST:
+    """The node a value is finally encoded to."""
+    while node.encoding is not None:
+        node = node.encoding[-1].to
+    return node
+
+
+def param_names(schema: Top | None) -> Set[str] | None:
+    """The keys of a params struct; ``None`` when the schema is not a plain
+    struct (any parameter may be one)."""
+    if schema is None:
+        return _EMPTY
+    node = last_encoding(schema.__codec__().ast)
+    if isinstance(node, ast.Objects) and not node.index_signatures:
+        return frozenset(str(p.name) for p in node.properties)
+    return None
+
+
+def to_router_path(path: str, schema: Top | None) -> str:
+    """``path`` with the parameters ``schema`` does not declare escaped
+    (``::``), so they match literally."""
+    if schema is None or ":" not in path:
+        return path
+    names = param_names(schema)
+    if names is None:
+        return path
+    out: list[str] = []
+    i = 0
+    while i < len(path):
+        char = path[i]
+        if char != ":":
+            out.append(char)
+            i += 1
+            continue
+        if path[i + 1 : i + 2] == ":":
+            out.append("::")
+            i += 2
+            continue
+        param = _PARAM.match(path, i)
+        if param is not None and param.group(1) in names:
+            out.append(param.group(0))
+            i = param.end()
+            following = path[i : i + 1]
+            if following == "(":
+                end = closing_parenthesis(path, i)
+                out.append(path[i : end + 1])
+                i = end + 1
+            elif following and following not in "/.-?":
+                # find-my-way needs a regex to end the parameter name here.
+                out.append("(.*?)")
+        else:
+            out.append("::")
+            i += 1
+    return "".join(out)
+
+
+def replace_params(
+    path: str,
+    names: Set[str] | None,
+    replace: Callable[[str, bool], str | None],
+) -> str:
+    """``path`` with each declared parameter replaced by ``replace(name,
+    optional)``; ``None`` drops an optional parameter and its slash."""
+    out: list[str] = []
+    last = 0
+    position = 0
+    while (param := _PARAMS.search(path, position)) is not None:
+        position = param.end()
+        name = param.group(1)
+        if name is None or (names is not None and name not in names):
+            continue
+        end = param.end()
+        if path[end : end + 1] == "(":
+            end = closing_parenthesis(path, end) + 1
+        optional = path[end : end + 1] == "?"
+        if optional:
+            end += 1
+        value = replace(name, optional)
+        start = param.start()
+        if value is None and path[start - 1 : start] == "/":
+            start -= 1
+        out.append(path[last:start] + (value or ""))
+        position = end
+        last = end
+    out.append(path[last:])
+    return "".join(out)

pyfect/http_api/_payload.py

@@ -0,0 +1,260 @@
+"""Reading a request's payload by its content type (Effect's
+``HttpApiBuilder`` payload decoders): JSON, a form, text, bytes,
+multipart, or a stream handed to the handler unread."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from typing import Any, Literal, cast
+
+from pyfect import schema as S
+from pyfect._core import Effect
+from pyfect._digits import parse_digits
+from pyfect._json_text import PARSE_ERRORS, parse
+from pyfect.effect import context, fail, provide_context, succeed
+from pyfect.encoding import ndjson
+from pyfect.http.method import has_body
+from pyfect.http.multipart import Limits, limits_context
+from pyfect.http.server_request import ServerRequest
+from pyfect.http.server_response import HttpServerResponse, empty
+from pyfect.http.server_response import text as text_response
+from pyfect.http_api import _media_type as media_type
+from pyfect.http_api import schema as api_schema
+from pyfect.http_api.endpoint import BufferedPayload, PayloadMap
+from pyfect.http_api.error import HttpApiPayloadTooLarge, HttpApiSchemaError
+from pyfect.schema import ParseOptions, SchemaError
+from pyfect.schema import ast as A
+from pyfect.schema import issue as I
+from pyfect.stream import Stream
+from pyfect.stream import provide_context as stream_provide_context
+from pyfect.stream import suspend as stream_suspend
+
+type Decode = Callable[[object], Effect[Any, SchemaError, Any]]
+
+
+@dataclass(frozen=True, slots=True)
+class _Buffered:
+    tag: Literal["Json", "FormUrlEncoded", "Uint8Array", "Text"]
+    decode: Decode
+    null_on_empty: bool
+
+
+@dataclass(frozen=True, slots=True)
+class _Multipart:
+    mode: Literal["buffered", "stream"]
+    limits: Limits | None
+    decode: Decode
+
+
+@dataclass(frozen=True, slots=True)
+class _Stream:
+    max_bytes: int | None
+    decode: Callable[[ServerRequest], Stream[Any, Any, Any]]
+
+
+type PayloadDecoder = _Buffered | _Multipart | _Stream
+type PayloadDecoders = Mapping[str, PayloadDecoder]
+
+
+def payload_decoders(payload: PayloadMap, options: ParseOptions) -> PayloadDecoders:
+    """A decoder for each payload content type."""
+    result: dict[str, PayloadDecoder] = {}
+    for content_type, entry in payload.items():
+        if not isinstance(entry, BufferedPayload):
+            max_bytes = entry.schema.max_bytes
+            result[content_type] = _Stream(max_bytes, _stream_decoder(entry.schema, options))
+            continue
+        schemas = entry.schemas
+        schema = schemas[0] if len(schemas) == 1 else S.Union(*schemas)
+        encoding = entry.encoding
+        if isinstance(encoding, api_schema.MultipartEncoding):
+            decode = S.decode_unknown_effect(schema, **options)
+            result[content_type] = _Multipart(encoding.mode, encoding.limits, decode)
+            continue
+        if encoding.tag == "FormUrlEncoded":
+            schema = S.to_codec_array_from_single(schema)
+        result[content_type] = _Buffered(
+            encoding.tag,
+            S.decode_unknown_effect(schema, **options),
+            any(isinstance(A.to_encoded(s.__codec__().ast), A.Null) for s in schemas),
+        )
+    return result
+
+
+_PAYLOAD_TOO_LARGE = empty(status=413, headers={"connection": "close"})
+
+
+def decode_payload(
+    decoders: PayloadDecoders, request: ServerRequest, query: Mapping[str, object]
+) -> Effect[Any, SchemaError, Any]:
+    """The payload, or the response refusing the request."""
+    body = has_body(request.method)
+    declared = request.headers.get("content-type")
+    content_type = (
+        media_type.normalize(declared or "application/json")
+        if body
+        else "application/x-www-form-urlencoded"
+    )
+    decoder = decoders.get(content_type)
+    if decoder is None:
+        return succeed(_unsupported(content_type))
+    if body and not declared:
+        return _undeclared(decoder, request, query)
+    match decoder:
+        case _Stream():
+            length = _content_length(request)
+            if decoder.max_bytes is not None and length is not None and length > decoder.max_bytes:
+                return succeed(_PAYLOAD_TOO_LARGE)
+            # The stream can be read after the handler returns, inside a
+            # streaming response, so it carries the services with it.
+            stream_decode = decoder.decode
+            return context().map(
+                lambda services: stream_decode(request).pipe(stream_provide_context(services))
+            )
+        case _Multipart():
+            return _multipart(decoder, request)
+        case _Buffered():
+            return _buffered(decoder, request, query, body)
+
+
+def _undeclared(
+    decoder: PayloadDecoder, request: ServerRequest, query: Mapping[str, object]
+) -> Effect[Any, SchemaError, Any]:
+    """A body with no content-type. Effect decodes it as JSON; pyfect takes
+    only an empty one, as a cross-site "simple" request may carry a body
+    without a content-type and must not reach a JSON endpoint."""
+    unsupported = _unsupported("")
+    if not isinstance(decoder, _Buffered):
+        return succeed(unsupported)
+    return request.text.or_die().flat_map(
+        lambda text: (
+            _buffered(decoder, request, query, True) if text == "" else succeed(unsupported)
+        )
+    )
+
+
+def _unsupported(content_type: str) -> HttpServerResponse:
+    return text_response(f"Unsupported content-type: {content_type}", status=415)
+
+
+def _content_length(request: ServerRequest) -> int | None:
+    return parse_digits(request.headers.get("content-length") or "")
+
+
+def _multipart(decoder: _Multipart, request: ServerRequest) -> Effect[Any, SchemaError, Any]:
+    limits = decoder.limits
+    if decoder.mode == "buffered":
+        read: Effect[Any, Any, Any] = request.multipart.or_die()
+        if limits:
+            read = read.pipe(provide_context(limits_context(**limits)))
+        return read.flat_map(decoder.decode)
+    parts = request.multipart_stream
+    if limits:
+        parts = parts.pipe(stream_provide_context(limits_context(**limits)))
+    return succeed(parts)
+
+
+_INVALID_JSON = SchemaError(I.InvalidValue({"message": "Expected a valid JSON body"}))
+
+
+def _buffered(
+    decoder: _Buffered, request: ServerRequest, query: Mapping[str, object], body: bool
+) -> Effect[Any, SchemaError, Any]:
+    decode = decoder.decode
+    match decoder.tag:
+        case "Json":
+
+            def json(text: str) -> Effect[Any, SchemaError, Any]:
+                if text == "":
+                    return decode(None)
+                try:
+                    value = parse(text)
+                except PARSE_ERRORS:
+                    return fail(_INVALID_JSON)
+                return decode(value)
+
+            return request.text.or_die().flat_map(json)
+        case "Text":
+            return request.text.or_die().flat_map(decode)
+        case "FormUrlEncoded":
+            source: Effect[Mapping[str, object], Any, Any] = (
+                request.url_params_body.or_die().map(lambda params: params.to_record())
+                if body
+                else succeed(query)
+            )
+            return source.flat_map(decode)
+        case "Uint8Array":
+            return request.bytes_.or_die().flat_map(decode)
+
+
+# --- streams -------------------------------------------------------------------------
+
+
+def _stream_decoder(
+    schema: api_schema.StreamUint8ArraySchema | api_schema.StreamNdjsonSchema[Any],
+    options: ParseOptions,
+) -> Callable[[ServerRequest], Stream[Any, Any, Any]]:
+    """The handler pulls the body itself, so nothing is read ahead of it;
+    a failure to read the body stays a defect, as for buffered payloads."""
+    max_bytes = schema.max_bytes
+
+    def read_body(request: ServerRequest) -> Stream[bytes, Any, Any]:
+        stream = request.stream.or_die()
+        return stream if max_bytes is None else _limit_bytes(stream, max_bytes)
+
+    if isinstance(schema, api_schema.StreamUint8ArraySchema):
+        return read_body
+    decode_element = S.decode_unknown_effect(S.to_codec_json(schema.schema), **options)
+    max_element_bytes = schema.max_element_bytes
+    element_too_large = HttpApiPayloadTooLarge("maxElementBytes", max_element_bytes)
+
+    def to_error(error: object) -> object:
+        if isinstance(error, HttpApiPayloadTooLarge):
+            return error
+        if not isinstance(error, ndjson.NdjsonError):
+            return HttpApiSchemaError("Payload", cast("SchemaError", error))
+        if error.reason == "LineTooLarge":
+            return element_too_large
+        return HttpApiSchemaError("Payload", _ndjson_schema_error(error))
+
+    def decode(request: ServerRequest) -> Stream[Any, Any, Any]:
+        return (
+            read_body(request)
+            .pipe_through_channel(
+                ndjson.decode(ignore_empty_lines=True, max_line_bytes=max_element_bytes)
+            )
+            .map_effect(decode_element)
+            .map_error(to_error)
+        )
+
+    return decode
+
+
+def _ndjson_schema_error(error: ndjson.NdjsonError) -> SchemaError:
+    if error.reason == "InvalidUtf8":
+        message = "Expected valid UTF-8"
+    elif error.unterminated:
+        message = "Expected a valid JSON line, got an unterminated final line"
+    else:
+        message = "Expected a valid JSON line"
+    return SchemaError(I.InvalidValue({"message": message}))
+
+
+def _limit_bytes(stream: Stream[bytes, Any, Any], max_bytes: int) -> Stream[bytes, Any, Any]:
+    error = HttpApiPayloadTooLarge("maxBytes", cast("Any", max_bytes))
+
+    def limited() -> Stream[bytes, Any, Any]:
+        total = 0
+
+        def count(chunks: tuple[bytes, ...]) -> Effect[tuple[bytes, ...], HttpApiPayloadTooLarge]:
+            nonlocal total
+            total += sum(len(chunk) for chunk in chunks)
+            return fail(error) if total > max_bytes else succeed(chunks)
+
+        return stream.map_array_effect(count)
+
+    return stream_suspend(limited)
+
+
+__all__ = ["PayloadDecoders", "decode_payload", "payload_decoders"]