nyxa-forms 0.0.1__tar.gz

nyxa_forms-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NyxaDev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nyxa_forms-0.0.1/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: nyxa-forms
+Version: 0.0.1
+Summary: Form requests + web validation for Nyxa — rule strings, error bags, old input
+Author-email: Al-Amin Islam Nerob <alamin@aincoder.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/NyxaDev/Nyxa
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: nyxa>=0.0.1
+Dynamic: license-file
+
+# nyxa-forms
+
+Web validation for the Nyxa framework — injectable `FormRequest`
+classes, ~115 pipe-separated string rules, custom rules via `@rule`,
+error bags + old input flashing, and redirect-back semantics for HTML
+forms.
+
+## Features
+
+- **`FormRequest`** — self-validating request classes injected by type
+  into handlers: `rules()`, `authorize(ctx)`, `messages()`,
+  `attributes()`, `prepare_for_validation()`, `with_validator()`,
+  `after()`, `validated(*keys)`, `errors()`, `input(key)`.
+- **`Validator`** — `Validator(data, rules, app=, ctx=)`;
+  `await v.validate()`, `v.validated()`, plus `validate_sync` for
+  non-async paths. Dot-key paths reach into nested payloads.
+- **~115 built-in rules** — presence (`required`, `filled`,
+  `present`, `missing`, `prohibited` and their `*_if`/`*_unless`/
+  `*_with`/`*_without` variants), exclusion (`exclude*`), comparison
+  (`same`, `different`, `gt`/`gte`/`lt`/`lte`, `between`,
+  `in`/`not_in`/`in_array`/`any_of`, `multiple_of`), strings
+  (`alpha*`, `ascii`, `starts_with`/`ends_with`/`contains`(+`doesnt_*`),
+  `regex`/`not_regex`, `lowercase`/`uppercase`, `hex_color`), types
+  (`string`, `boolean`, `integer`, `numeric`, `decimal`, `list`,
+  `array`, `json`, `file`, `image`, `mimes`/`mimetypes`,
+  `extensions`, `dimensions`), numerics (`min`/`max`/`size`,
+  `digits*`), dates (`date`, `before`/`after`(+`_or_equal`),
+  `date_equals`, `date_format`, `timezone`), network (`url`,
+  `active_url`, `ip`/`ipv4`/`ipv6`, `mac_address`), identifiers
+  (`uuid`, `ulid`, `email`, `name`, `encoding`), database (`exists`,
+  `unique`, `current_password`), and `confirmed`/`nullable`/
+  `distinct`/`prohibits`/`enum`.
+- **Rule objects** — `Password(min=8, letters=…, mixed_case=…,
+  numbers=…, symbols=…)` (alias `PasswordRule`) and `Enum(MyEnum)`
+  mix into rule specs alongside strings.
+- **`@rule`** — register custom rules:
+  `@rule` / `@rule("name")` / `@rule(implicit=True, exclude=True,
+  needs_field=True)`; custom rules can shadow built-in names.
+- **HTML form semantics** — `FormsExceptionHandler` wraps the app's
+  handler: a `ValidationException` on a non-JSON request redirects
+  back (303) with errors + old input flashed; JSON requests get 422.
+- **`ctx` macros** — `ctx.validate_web(rules)`, `ctx.old(key)`,
+  `ctx.errors([key])`, `ctx.back(fallback="/")`.
+- **Helpers** — `old(ctx, key)`, `errors(ctx[, key])`,
+  `with_errors(ctx, bag)`, `flash_old(ctx, data)`,
+  `back(ctx, fallback="/")` from `nyxa_forms.helpers`.
+- **`make:request`** — `nyxa make:request StorePostRequest` scaffolds
+  a `FormRequest` (`--fields name:type[:rules]`, `--update`,
+  `--describe`, `--force`).
+
+## Install
+
+```bash
+nyxa add nyxa-forms   # writes config/forms.py
+```
+
+## Usage
+
+```python
+from nyxa_forms import FormRequest, Password
+
+
+class StorePost(FormRequest):
+    def rules(self):
+        return {"title": "required|string|max:255", "password": ["required", Password(min=12, numbers=True)]}
+
+    def authorize(self, ctx):
+        return ctx.user is not None
+
+
+async def store(ctx, request: StorePost):
+    data = request.validated()  # only keys that passed rules
+```
+
+Inline validation + manual error handling:
+
+```python
+async def handler(ctx):
+    data = await ctx.validate_web({"email": "required|email"})
+```
+
+Custom rule:
+
+```python
+from nyxa_forms import rule
+
+
+@rule
+def strong(value, params, data, validator):
+    return isinstance(value, str) and len(value) >= 12 or "Too weak."
+```
+
+## Public API
+
+- **`FormRequest`** — injectable base (see Usage). Handler params
+  typed to a subclass are decoded, authorized, and validated by the
+  `FormRequestKind` contract.
+- **`Validator`** — `Validator(data, rules, app=None, ctx=None)`;
+  `await v.validate() -> dict`, `v.validated() -> dict`,
+  `v.errors`, `v.messages`/`v.attributes` overrides.
+- **`ValidationException`** — raised on failure (HTTP 422):
+  `exc.bag` (`{field: [messages]}`), `exc.data` (submitted payload).
+- **`rule`** — decorator registering a rule function
+  `(value, params, data, validator) -> bool | str`; keyword flags
+  `implicit`, `exclude`, `needs_field`.
+- **`Password`** — password-policy rule object:
+  `Password(min=8, letters=False, mixed_case=False, numbers=False,
+  symbols=False)`; `Password.defaults()`.
+- **`PasswordRule`** — alias of `Password`.
+- **`Enum`** — enum rule object: `Enum(MyEnum)` accepts member
+  instances, backing values, and names.
+- **`FormsProvider`** — registers the `FormRequest` contract kind,
+  wraps the exception handler, adds the `ctx` macros, contributes
+  `make:request`, and writes `config/forms.py` on `nyxa add`.
+
+## Configuration
+
+`nyxa add nyxa-forms` writes `config/forms.py` (`FORMS = {}` —
+reserved for validation behavior overrides).
+
+## Testing
+
+```python
+v = Validator({"email": "nope"}, {"email": "required|email"})
+try:
+    await v.validate()
+except ValidationException as e:
+    assert "email" in e.bag
+```
+
+## License
+
+MIT

nyxa_forms-0.0.1/README.md

@@ -0,0 +1,133 @@
+# nyxa-forms
+
+Web validation for the Nyxa framework — injectable `FormRequest`
+classes, ~115 pipe-separated string rules, custom rules via `@rule`,
+error bags + old input flashing, and redirect-back semantics for HTML
+forms.
+
+## Features
+
+- **`FormRequest`** — self-validating request classes injected by type
+  into handlers: `rules()`, `authorize(ctx)`, `messages()`,
+  `attributes()`, `prepare_for_validation()`, `with_validator()`,
+  `after()`, `validated(*keys)`, `errors()`, `input(key)`.
+- **`Validator`** — `Validator(data, rules, app=, ctx=)`;
+  `await v.validate()`, `v.validated()`, plus `validate_sync` for
+  non-async paths. Dot-key paths reach into nested payloads.
+- **~115 built-in rules** — presence (`required`, `filled`,
+  `present`, `missing`, `prohibited` and their `*_if`/`*_unless`/
+  `*_with`/`*_without` variants), exclusion (`exclude*`), comparison
+  (`same`, `different`, `gt`/`gte`/`lt`/`lte`, `between`,
+  `in`/`not_in`/`in_array`/`any_of`, `multiple_of`), strings
+  (`alpha*`, `ascii`, `starts_with`/`ends_with`/`contains`(+`doesnt_*`),
+  `regex`/`not_regex`, `lowercase`/`uppercase`, `hex_color`), types
+  (`string`, `boolean`, `integer`, `numeric`, `decimal`, `list`,
+  `array`, `json`, `file`, `image`, `mimes`/`mimetypes`,
+  `extensions`, `dimensions`), numerics (`min`/`max`/`size`,
+  `digits*`), dates (`date`, `before`/`after`(+`_or_equal`),
+  `date_equals`, `date_format`, `timezone`), network (`url`,
+  `active_url`, `ip`/`ipv4`/`ipv6`, `mac_address`), identifiers
+  (`uuid`, `ulid`, `email`, `name`, `encoding`), database (`exists`,
+  `unique`, `current_password`), and `confirmed`/`nullable`/
+  `distinct`/`prohibits`/`enum`.
+- **Rule objects** — `Password(min=8, letters=…, mixed_case=…,
+  numbers=…, symbols=…)` (alias `PasswordRule`) and `Enum(MyEnum)`
+  mix into rule specs alongside strings.
+- **`@rule`** — register custom rules:
+  `@rule` / `@rule("name")` / `@rule(implicit=True, exclude=True,
+  needs_field=True)`; custom rules can shadow built-in names.
+- **HTML form semantics** — `FormsExceptionHandler` wraps the app's
+  handler: a `ValidationException` on a non-JSON request redirects
+  back (303) with errors + old input flashed; JSON requests get 422.
+- **`ctx` macros** — `ctx.validate_web(rules)`, `ctx.old(key)`,
+  `ctx.errors([key])`, `ctx.back(fallback="/")`.
+- **Helpers** — `old(ctx, key)`, `errors(ctx[, key])`,
+  `with_errors(ctx, bag)`, `flash_old(ctx, data)`,
+  `back(ctx, fallback="/")` from `nyxa_forms.helpers`.
+- **`make:request`** — `nyxa make:request StorePostRequest` scaffolds
+  a `FormRequest` (`--fields name:type[:rules]`, `--update`,
+  `--describe`, `--force`).
+
+## Install
+
+```bash
+nyxa add nyxa-forms   # writes config/forms.py
+```
+
+## Usage
+
+```python
+from nyxa_forms import FormRequest, Password
+
+
+class StorePost(FormRequest):
+    def rules(self):
+        return {"title": "required|string|max:255", "password": ["required", Password(min=12, numbers=True)]}
+
+    def authorize(self, ctx):
+        return ctx.user is not None
+
+
+async def store(ctx, request: StorePost):
+    data = request.validated()  # only keys that passed rules
+```
+
+Inline validation + manual error handling:
+
+```python
+async def handler(ctx):
+    data = await ctx.validate_web({"email": "required|email"})
+```
+
+Custom rule:
+
+```python
+from nyxa_forms import rule
+
+
+@rule
+def strong(value, params, data, validator):
+    return isinstance(value, str) and len(value) >= 12 or "Too weak."
+```
+
+## Public API
+
+- **`FormRequest`** — injectable base (see Usage). Handler params
+  typed to a subclass are decoded, authorized, and validated by the
+  `FormRequestKind` contract.
+- **`Validator`** — `Validator(data, rules, app=None, ctx=None)`;
+  `await v.validate() -> dict`, `v.validated() -> dict`,
+  `v.errors`, `v.messages`/`v.attributes` overrides.
+- **`ValidationException`** — raised on failure (HTTP 422):
+  `exc.bag` (`{field: [messages]}`), `exc.data` (submitted payload).
+- **`rule`** — decorator registering a rule function
+  `(value, params, data, validator) -> bool | str`; keyword flags
+  `implicit`, `exclude`, `needs_field`.
+- **`Password`** — password-policy rule object:
+  `Password(min=8, letters=False, mixed_case=False, numbers=False,
+  symbols=False)`; `Password.defaults()`.
+- **`PasswordRule`** — alias of `Password`.
+- **`Enum`** — enum rule object: `Enum(MyEnum)` accepts member
+  instances, backing values, and names.
+- **`FormsProvider`** — registers the `FormRequest` contract kind,
+  wraps the exception handler, adds the `ctx` macros, contributes
+  `make:request`, and writes `config/forms.py` on `nyxa add`.
+
+## Configuration
+
+`nyxa add nyxa-forms` writes `config/forms.py` (`FORMS = {}` —
+reserved for validation behavior overrides).
+
+## Testing
+
+```python
+v = Validator({"email": "nope"}, {"email": "required|email"})
+try:
+    await v.validate()
+except ValidationException as e:
+    assert "email" in e.bag
+```
+
+## License
+
+MIT

nyxa_forms-0.0.1/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=75"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nyxa-forms"
+version = "0.0.1"
+description = "Form requests + web validation for Nyxa — rule strings, error bags, old input"
+readme = "README.md"
+authors = [{ name = "Al-Amin Islam Nerob", email = "alamin@aincoder.com" }]
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.13"
+dependencies = ["nyxa>=0.0.1"]
+
+[project.urls]
+Repository = "https://github.com/NyxaDev/Nyxa"
+
+[project.entry-points."nyxa.plugins"]
+forms = "nyxa_forms.provider:FormsProvider"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+nyxa_forms = ["stubs/*.stub"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

nyxa_forms-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

nyxa_forms-0.0.1/src/nyxa_forms/__init__.py

@@ -0,0 +1,23 @@
+"""nyxa-forms — web validation: FormRequest, rule strings, error bags, old input."""
+
+from nyxa_forms.provider import FormsProvider
+from nyxa_forms.request import FormRequest
+from nyxa_forms.validator import (
+    Enum,
+    Password,
+    PasswordRule,
+    ValidationException,
+    Validator,
+    rule,
+)
+
+__all__ = [
+    "Enum",
+    "FormRequest",
+    "FormsProvider",
+    "Password",
+    "PasswordRule",
+    "ValidationException",
+    "Validator",
+    "rule",
+]

nyxa_forms-0.0.1/src/nyxa_forms/commands.py

@@ -0,0 +1,71 @@
+"""``make:request`` — scaffold a FormRequest under ``app/requests/``."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from nyxa.command import Command
+
+
+class MakeRequestCommand(Command):
+    """``nyxa make:request`` — generate a FormRequest class."""
+
+    signature = (
+        "make:request {name : resource/module name (post → app/requests/post.py)} "
+        "{--fields= : field specs name:type[:rules…],comma-separated} "
+        "{--update : emit only the Update class} "
+        "{--describe= : natural-language intent — AI/fallback fills rules} "
+        "{--force : overwrite existing}"
+    )
+    help = "Generate a FormRequest under app/requests/ (--fields for rule bodies)."
+    needs_app = False
+
+    def handle(
+        self,
+        name: str,
+        fields: str | None = None,
+        update: bool = False,
+        describe: str | None = None,
+        force: bool = False,
+    ) -> int:
+        """Write ``app/requests/<name>.py`` (optionally field-driven rules).
+
+        ``name`` is the resource/module name: ``post`` writes
+        ``app/requests/post.py`` holding the ``Store`` and ``Update``
+        FormRequest classes.
+
+        Args:
+            name: Resource/module name (must be a valid identifier).
+            fields: Optional ``name:type[:rules…]`` specs; when set, rules are
+                generated via the shared field grammar for both classes.
+            update: Emit only the ``Update`` class.
+            describe: Natural-language AI fill of the request rules.
+            force: Overwrite an existing file.
+
+        Returns:
+            ``0`` on success, ``1`` on invalid name or refusal to overwrite.
+        """
+        import re
+
+        if not re.fullmatch(r"[A-Za-z][A-Za-z0-9_]*", name):
+            self.error(f"invalid resource name {name!r}")
+            return 1
+        from nyxa.cli.make import make_form_request
+
+        make_form_request(
+            name,
+            fields,
+            for_update=update,
+            io=self.io,
+            force=force,
+        )
+        if describe:
+            from nyxa.cli.ai_scaffold import fill
+
+            root = Path.cwd()
+            snake = "".join(f"_{c.lower()}" if c.isupper() else c for c in name).lstrip("_")
+            target = root / "app" / "requests" / f"{snake}.py"
+            if target.is_file():
+                body = fill(describe, "form request", name, target.read_text())
+                target.write_text(body)
+        return 0

nyxa_forms-0.0.1/src/nyxa_forms/handler.py

@@ -0,0 +1,35 @@
+"""``FormsExceptionHandler`` — HTML redirect-back vs JSON 422 for validation."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, override
+
+from nyxa.exceptions import ExceptionHandler
+
+if TYPE_CHECKING:
+    from nyxa.http.context import HttpContext
+    from nyxa.http.response import Response
+
+
+class FormsExceptionHandler(ExceptionHandler):
+    """Wraps the app's handler — ``ValidationException`` becomes a
+    redirect-back + flashed errors/old-input for HTML requests, 422
+    JSON otherwise. Everything else delegates to the previous handler.
+    """
+
+    def __init__(self, inner: ExceptionHandler) -> None:
+        """Wrap ``inner`` — the app's previous handler."""
+        self.inner = inner
+
+    @override
+    async def handle(self, error: Exception, ctx: HttpContext) -> Response:
+        """Redirect-back with flash for HTML validation failures."""
+        from nyxa.http.response import Response
+        from nyxa_forms.helpers import flash_old, with_errors
+        from nyxa_forms.validator import ValidationException
+
+        if isinstance(error, ValidationException) and not ctx.request.wants_json():
+            with_errors(ctx, error.bag)
+            flash_old(ctx, error.data)
+            return Response.redirect(ctx.request.header("referer") or "/", status=303)
+        return await self.inner.handle(error, ctx)

nyxa_forms-0.0.1/src/nyxa_forms/helpers.py

@@ -0,0 +1,134 @@
+"""Flash/old-input + redirect helpers layered on ``nyxa-session``."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Protocol, TypeGuard, overload, runtime_checkable
+
+if TYPE_CHECKING:
+    from nyxa.http.context import HttpContext
+    from nyxa.http.response import Response
+
+
+@runtime_checkable
+class _FlashSession(Protocol):
+    """Session bag surface used for one-request form flashes."""
+
+    def get(self, key: str, default: object = None) -> object:
+        """Read one session value."""
+        ...
+
+    def flash(self, key: str, value: object) -> None:
+        """Persist one value for the next request."""
+        ...
+
+
+def _session(ctx: HttpContext) -> _FlashSession | None:
+    """Narrow the optional session-store object held in request state.
+
+    Args:
+        ctx: Request context whose session middleware may have populated state.
+
+    Returns:
+        A compatible flash session, or ``None`` when unavailable.
+    """
+    value: object = ctx.state.get("session")
+    return value if isinstance(value, _FlashSession) else None
+
+
+def _object_dict(value: object) -> TypeGuard[dict[str, object]]:
+    """Validate a dynamic form bag as a string-keyed mapping."""
+    return isinstance(value, dict) and all(isinstance(key, str) for key in value)
+
+
+def _object_list(value: object) -> TypeGuard[list[object]]:
+    """Narrow one field's dynamic error messages to a list."""
+    return isinstance(value, list)
+
+
+def old(ctx: HttpContext, key: str, default: object = "") -> object:
+    """Return a prior request's flashed value for one field.
+
+    Args:
+        ctx: Current request context.
+        key: Field name whose old input is requested.
+        default: Value returned when the field was not flashed.
+
+    Returns:
+        Flashed field value or ``default``.
+    """
+    session = _session(ctx)
+    if session is None:
+        return default
+    bag: object = session.get("_old", {})
+    return bag.get(key, default) if _object_dict(bag) else default
+
+
+@overload
+def errors(ctx: HttpContext, key: None = None) -> dict[str, object]: ...
+
+
+@overload
+def errors(ctx: HttpContext, key: str) -> list[object]: ...
+
+
+def errors(ctx: HttpContext, key: str | None = None) -> dict[str, object] | list[object]:
+    """Return the flashed validation bag or messages for one field.
+
+    Args:
+        ctx: Current request context.
+        key: Optional field whose validation messages are requested.
+
+    Returns:
+        A copied error bag or a field's message list; malformed state yields empty data.
+    """
+    session = _session(ctx)
+    if session is None:
+        return {} if key is None else []
+    raw_bag: object = session.get("errors", {})
+    if not _object_dict(raw_bag):
+        return {} if key is None else []
+    if key is None:
+        return raw_bag
+    raw_messages: object = raw_bag.get(key, [])
+    return raw_messages if _object_list(raw_messages) else []
+
+
+def with_errors(ctx: HttpContext, bag: Mapping[str, object]) -> None:
+    """Flash a validation error bag for the next request.
+
+    Args:
+        ctx: Current request context.
+        bag: Field names mapped to their validation messages.
+    """
+    session = _session(ctx)
+    if session is not None:
+        session.flash("errors", dict(bag))
+
+
+def flash_old(ctx: HttpContext, data: Mapping[str, object]) -> None:
+    """Flash request input for ``old()`` repopulation.
+
+    Args:
+        ctx: Current request context.
+        data: Input fields to make available to the next request.
+    """
+    session = _session(ctx)
+    if session is not None:
+        session.flash("_old", dict(data))
+
+
+def back(ctx: HttpContext, *, fallback: str = "/") -> Response:
+    """Redirect to the referer, using ``fallback`` when none is present.
+
+    Args:
+        ctx: Current request context.
+        fallback: Relative URL used when the request has no referer.
+
+    Returns:
+        Redirect response to the request referer or fallback URL.
+    """
+    from nyxa.http.response import Response
+
+    url = ctx.request.header("referer") or fallback
+    return Response.redirect(url)

nyxa_forms-0.0.1/src/nyxa_forms/kind.py

@@ -0,0 +1,58 @@
+"""``FormRequest`` contract kind — route injection via contract_kinds()."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from nyxa_forms.request import FormRequest
+
+if TYPE_CHECKING:
+    from nyxa.contracts import Decoder, Encoder
+    from nyxa.http.request import Request
+    from nyxa.types import JSONValue
+
+
+class FormRequestKind:
+    """Contract kind resolving ``FormRequest`` subclasses on routes."""
+
+    name = "form_request"
+
+    def matches(self, model: object) -> bool:
+        """Whether ``model`` is a ``FormRequest`` subclass."""
+        return isinstance(model, type) and issubclass(model, FormRequest)
+
+    def request_decoder(self, model: type) -> Decoder:
+        """Build a decoder returning a validated ``FormRequest``."""
+        assert issubclass(model, FormRequest)
+
+        async def decode(request: Request) -> FormRequest:
+            """Validate the request payload into a FormRequest.
+
+            Awaitable by design — ``serve._dispatch`` awaits decoders that
+            return coroutines, which is how db-aware rules work.
+            """
+            from nyxa.http.context import current_ctx
+
+            ctx = current_ctx()
+            payload = request._payload()
+            data = dict(payload) if isinstance(payload, dict) else {}
+            instance = model()
+            await instance.validate_against(ctx, data)
+            return instance
+
+        return decode
+
+    def encoder(self, model: type) -> Encoder:
+        """Encode (unused — FormRequests are input contracts)."""
+
+        def encode(value: object) -> bytes:
+            """Serialize a value — FormRequests are input-only contracts."""
+            import orjson
+
+            return orjson.dumps(value)
+
+        return encode
+
+    def schema(self, model: type) -> dict[str, JSONValue]:
+        """No OpenAPI schema for rule-string contracts."""
+        return {}