metaobjects 0.13.0__tar.gz → 0.14.0__tar.gz

{metaobjects-0.13.0 → metaobjects-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metaobjects
-Version: 0.13.0
+Version: 0.14.0
 Summary: Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port.
 Project-URL: Homepage, https://metaobjects.dev
 Project-URL: Repository, https://github.com/metaobjectsdev/metaobjects

{metaobjects-0.13.0 → metaobjects-0.14.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.13.0"
+version = "0.14.0"
 description = "Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port."
 readme = "README.md"
 requires-python = ">=3.11"

{metaobjects-0.13.0 → metaobjects-0.14.0}/src/metaobjects/cli.py

@@ -103,15 +103,33 @@ def _default_generators() -> list[Generator]:
     ]
 
 
-def _load_root(metadata_dir: str) -> tuple[MetaData | None, list[str]]:
-    """Load metadata; return ``(root, error_messages)``. ``root`` is None on error."""
-    result = MetaDataLoader.from_directory(metadata_dir)
+def _load_root(
+    metadata_dir: str, strict: bool = False
+) -> tuple[MetaData | None, list[str]]:
+    """Load metadata; return ``(root, error_messages)``. ``root`` is None on error.
+
+    ``strict`` (ADR-0023, #96) — when True, an undeclared own ``@attr`` →
+    ``ERR_UNKNOWN_ATTR``. Defaults False so ``gen`` / ``docs`` keep the legacy
+    open-attr load; only ``verify`` opts in (strict-by-default with a ``--lax``
+    escape).
+    """
+    result = MetaDataLoader.from_directory(metadata_dir, strict=strict)
     if result.errors:
         msgs = [f"{e.code}: {e.message}" for e in result.errors]
         return None, msgs
     return result.root, []
 
 
+def _strict_load_hint() -> str:
+    """Actionable next-steps when strict verify rejects an undeclared @attr."""
+    return (
+        "verify is strict (ADR-0023): every authored @attr must be declared. Fix: "
+        "register the attr on a metadata provider, OR move arbitrary author-supplied "
+        "properties into an `attr.properties` bag, OR re-run with `--lax` to keep the "
+        "legacy open-attr load."
+    )
+
+
 def _resolve_generators(names: str) -> tuple[list[Generator], list[str]]:
     """Resolve a comma-separated list of STABLE generator names via the registry.
 
@@ -174,6 +192,7 @@ def _generate(
     generators: list[Generator] | None = None,
     entity_filter: list[str] | None = None,
     emit_package_init: bool = True,
+    strict: bool = False,
 ) -> tuple[list[str], list[str]]:
     """Run the generator suite into ``out_dir``.
 
@@ -186,9 +205,10 @@ def _generate(
     output is text/markdown/csv/json/xml/html, never a Python package) so no
     spurious ``__init__.py`` is scattered through their output tree. Returns
     ``(written_paths, errors)``. On a load error, ``errors`` is non-empty and no
-    files are written.
+    files are written. ``strict`` (ADR-0023, #96) is threaded to the load — the
+    ``verify --codegen`` caller passes True; ``gen`` keeps the default False.
     """
-    root, errors = _load_root(metadata_dir)
+    root, errors = _load_root(metadata_dir, strict=strict)
     if root is None:
         return [], errors
     return _run_suite(root, out_dir, generators, entity_filter, emit_package_init), []
@@ -408,13 +428,20 @@ def _verify_codegen(args: argparse.Namespace) -> int:
     # Reuse the exact gen code path — regenerate into a throwaway temp dir. The
     # --entities filter must match the `gen` that produced --out, or the diff
     # reports the un-emitted entities as spurious drift.
+    # ADR-0023 strict-by-default (#96): verify loads strict unless --lax is given,
+    # so an undeclared/typo'd own @attr fails verify (matching Java's Maven goal).
+    strict = not getattr(args, "lax", False)
     with tempfile.TemporaryDirectory() as tmp:
         entities = _parse_entities(getattr(args, "entities", None))
-        written, errors = _generate(args.metadata_dir, tmp, None, entities)
+        written, errors = _generate(
+            args.metadata_dir, tmp, None, entities, strict=strict
+        )
         if errors:
             print("error: failed to load metadata:", file=sys.stderr)
             for msg in errors:
                 print(f"  {msg}", file=sys.stderr)
+            if strict and any("ERR_UNKNOWN_ATTR" in m for m in errors):
+                print(_strict_load_hint(), file=sys.stderr)
             return 1
 
         expected = _relative_set(Path(tmp))
@@ -478,11 +505,16 @@ def _verify_templates(args: argparse.Namespace) -> int:
         )
         return 2
 
-    root, errors = _load_root(args.metadata_dir)
+    # ADR-0023 strict-by-default (#96) — same as --codegen: an undeclared @attr
+    # fails verify unless --lax is passed.
+    strict = not getattr(args, "lax", False)
+    root, errors = _load_root(args.metadata_dir, strict=strict)
     if root is None:
         print("error: failed to load metadata:", file=sys.stderr)
         for msg in errors:
             print(f"  {msg}", file=sys.stderr)
+        if strict and any("ERR_UNKNOWN_ATTR" in m for m in errors):
+            print(_strict_load_hint(), file=sys.stderr)
         return 1
 
     provider = FilesystemProvider(template_root)
@@ -760,6 +792,15 @@ def _build_parser() -> argparse.ArgumentParser:
         default=None,
         help="comma-separated entity allowlist for --codegen drift (match `gen --entities`)",
     )
+    verify.add_argument(
+        "--lax",
+        action="store_true",
+        help=(
+            "opt out of strict-attr load (ADR-0023, #96): verify is strict by "
+            "default — an undeclared/typo'd @attr fails. --lax restores the legacy "
+            "open-attr load."
+        ),
+    )
     verify.set_defaults(func=_cmd_verify)
 
     agent_docs = sub.add_parser(

{metaobjects-0.13.0 → metaobjects-0.14.0}/src/metaobjects/codegen/type_map.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass
 
 from metaobjects.meta.core.field.meta_field import MetaField
 from metaobjects.meta.core.field import field_constants as fc
+from metaobjects.meta.persistence.db import db_constants as dbc
 from metaobjects.shared.structural import KEY_IS_ARRAY
 
 
@@ -94,6 +95,17 @@ def py_type_for(field: MetaField) -> PyType:
             base = PyType(f"Literal[{members}]", ("from typing import Literal",))
         else:
             base = PyType("str")
+    elif (
+        field.sub_type == fc.FIELD_SUBTYPE_STRING
+        and field.attrs().get(dbc.FIELD_ATTR_DB_COLUMN_TYPE) == dbc.DB_COLUMN_TYPE_JSONB
+    ):
+        # Issue #98 — a field.string carrying @dbColumnType:jsonb is the escape hatch
+        # for a genuinely-open JSON column (ADR-0013). pg8000 auto-decodes a jsonb
+        # column to a native Python object (dict/list/scalar) at read time, so a `str`
+        # annotation is a type lie. Bind ``Any`` — the Python analogue of TS's
+        # z.unknown() (#97) — since jsonb can hold any JSON value. (Other ports whose
+        # drivers return jsonb as raw text correctly keep their string type.)
+        base = PyType("Any", ("from typing import Any",))
     else:
         base = _SCALAR.get(field.sub_type, PyType("str"))
     if field_is_array(field):

metaobjects-0.14.0/tests/codegen/test_cli_verify_strict.py

@@ -0,0 +1,139 @@
+"""Issue #96 — `metaobjects verify` is strict-by-default (ADR-0023 cross-port).
+
+Under strict load an authored own ``@attr`` that no provider declares is an
+``ERR_UNKNOWN_ATTR``. Java's Maven verify goal already forces strict; this brings
+the Python (and TS) CLI verify in line: verify FAILS on an undeclared attr unless
+``--lax`` is passed. ``gen`` keeps loading lax (only verify defaults strict).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from metaobjects.cli import main
+
+# Shared cross-port fixture (also asserted by the TS CLI verify-strict test):
+# a registered field.string carrying one undeclared own @attr.
+_FIXTURE = (
+    Path(__file__).parents[4]
+    / "fixtures"
+    / "verify-strict-conformance"
+    / "unregistered-attr"
+    / "input"
+    / "meta.users.json"
+)
+_MADE_UP = _FIXTURE.read_text()
+
+_CLEAN = """\
+{
+  "metadata.root": {
+    "package": "acme::users",
+    "children": [
+      {
+        "object.entity": {
+          "name": "Account",
+          "children": [
+            { "field.long": { "name": "id" } },
+            { "field.string": { "name": "email", "@description": "the email" } },
+            { "identity.primary": { "name": "pk", "@fields": ["id"] } }
+          ]
+        }
+      }
+    ]
+  }
+}
+"""
+
+
+def _meta_dir(tmp_path: Path, body: str) -> str:
+    d = tmp_path / "meta"
+    d.mkdir()
+    (d / "meta.json").write_text(body)
+    return str(d)
+
+
+# --- verify --codegen ------------------------------------------------------
+
+
+def test_verify_codegen_fails_on_undeclared_attr_by_default(
+    tmp_path: Path, capsys
+) -> None:
+    meta_dir = _meta_dir(tmp_path, _MADE_UP)
+    out = tmp_path / "out"
+    rc = main(["verify", "--codegen", meta_dir, "--out", str(out)])
+    assert rc != 0
+    err = capsys.readouterr().err
+    assert "ERR_UNKNOWN_ATTR" in err
+    # Actionable hint: register a provider / attr.properties bag / --lax.
+    assert "--lax" in err
+    assert "attr.properties" in err
+
+
+def test_verify_codegen_passes_with_lax(tmp_path: Path) -> None:
+    meta_dir = _meta_dir(tmp_path, _MADE_UP)
+    out = tmp_path / "out"
+    # Lax load tolerates the undeclared attr; gen-to-temp + diff (vs --out) is
+    # the codegen drift result, NOT a load failure. First gen (already lax),
+    # then verify --lax against the committed output.
+    assert main(["gen", meta_dir, "--out", str(out)]) == 0
+    assert main(["verify", "--lax", "--codegen", meta_dir, "--out", str(out)]) == 0
+
+
+# --- verify --templates ----------------------------------------------------
+
+_TEMPLATE_META = """\
+{
+  "metadata.root": {
+    "package": "acme::ai",
+    "children": [
+      {
+        "object.value": {
+          "name": "Welcome",
+          "children": [
+            { "field.string": { "name": "name", "@madeUpAttr": "nope" } }
+          ]
+        }
+      },
+      {
+        "template.output": {
+          "name": "WelcomePage",
+          "@kind": "document",
+          "@payloadRef": "Welcome",
+          "@textRef": "pages/welcome",
+          "@format": "html"
+        }
+      }
+    ]
+  }
+}
+"""
+
+
+def test_verify_templates_fails_on_undeclared_attr_by_default(
+    tmp_path: Path, capsys
+) -> None:
+    meta_dir = _meta_dir(tmp_path, _TEMPLATE_META)
+    troot = tmp_path / "templates"
+    (troot / "pages").mkdir(parents=True)
+    (troot / "pages" / "welcome.mustache").write_text("Hello {{name}}")
+    rc = main(["verify", "--templates", meta_dir, "--templates-root", str(troot)])
+    assert rc != 0
+    err = capsys.readouterr().err
+    assert "ERR_UNKNOWN_ATTR" in err
+
+
+# --- gen stays lax (only verify defaults strict) ---------------------------
+
+
+def test_gen_stays_lax_by_default(tmp_path: Path) -> None:
+    meta_dir = _meta_dir(tmp_path, _MADE_UP)
+    out = tmp_path / "out"
+    # gen tolerates the undeclared attr (no strict default for gen).
+    assert main(["gen", meta_dir, "--out", str(out)]) == 0
+
+
+def test_verify_clean_metadata_passes_under_strict(tmp_path: Path) -> None:
+    meta_dir = _meta_dir(tmp_path, _CLEAN)
+    out = tmp_path / "out"
+    assert main(["gen", meta_dir, "--out", str(out)]) == 0
+    assert main(["verify", "--codegen", meta_dir, "--out", str(out)]) == 0

{metaobjects-0.13.0 → metaobjects-0.14.0}/tests/codegen/test_entity_model.py

@@ -175,3 +175,17 @@ def test_field_default_is_emitted_as_literal() -> None:
     assert "n: int = 1" in out
     assert "c: float = 0.5" in out
     assert "s: str = 'approx'" in out
+
+
+def test_dbcolumntype_jsonb_field_is_any_with_import() -> None:
+    """Issue #98 — a field.string @dbColumnType:jsonb stores genuinely-open JSON,
+    which pg8000 decodes to a native Python object at read time. The generated
+    Pydantic field is typed ``Any`` (not the lying ``str``) and the module threads
+    ``from typing import Any`` into its import block."""
+    from metaobjects.meta.persistence.db import db_constants as dbc
+
+    payload = MetaField(TYPE_FIELD, fc.FIELD_SUBTYPE_STRING, "payload")
+    payload.set_attr(dbc.FIELD_ATTR_DB_COLUMN_TYPE, dbc.DB_COLUMN_TYPE_JSONB)
+    out = render_entity_model(_entity("Event", [payload], package="myapp::events"))
+    assert "from typing import Any" in out
+    assert "payload: Any | None = None" in out

{metaobjects-0.13.0 → metaobjects-0.14.0}/tests/codegen/test_type_map.py

@@ -102,3 +102,17 @@ def test_dbcolumntype_uuid_string_stays_str() -> None:
     f = _field(fc.FIELD_SUBTYPE_STRING)
     f.set_attr(dbc.FIELD_ATTR_DB_COLUMN_TYPE, dbc.DB_COLUMN_TYPE_UUID)
     assert py_type_for(f).expr == "str"
+
+
+def test_dbcolumntype_jsonb_string_becomes_any() -> None:
+    # Issue #98 — a field.string carrying @dbColumnType:jsonb stores genuinely-open
+    # JSON; pg8000 auto-decodes a jsonb column to a native Python object (dict/list/
+    # scalar), so `str` is a type lie. Emit `Any` (the Python analogue of TS's
+    # z.unknown(), #97), threading `from typing import Any` into the module imports.
+    from metaobjects.meta.persistence.db import db_constants as dbc
+
+    f = _field(fc.FIELD_SUBTYPE_STRING)
+    f.set_attr(dbc.FIELD_ATTR_DB_COLUMN_TYPE, dbc.DB_COLUMN_TYPE_JSONB)
+    t = py_type_for(f)
+    assert t.expr == "Any"
+    assert "from typing import Any" in t.imports

metaobjects-0.14.0/tests/integration/api_contract_jsonb_server.py

@@ -0,0 +1,160 @@
+"""Hand-rolled reference FastAPI app for the ``Document`` entity from the
+``api-contract-conformance/jsonb/`` corpus.
+
+The contract under test is the ``field.string @dbColumnType:jsonb`` open bag:
+a posted JSON object must round-trip as an object (never a JSON-encoded
+string). Pared down from ``api_contract_server.py`` (the Author reference) —
+the jsonb scenario only POSTs + GETs by id, so this server implements just
+those verbs.
+
+Backend: pg8000 (pure-python DB-API; same driver as ``api_contract_server.py``).
+``payload`` is a bare ``JSONB`` column — the open bag holds any JSON value.
+pg8000 auto-decodes jsonb to a native Python object on read; on write the
+value is ``json.dumps``-serialized and bound with a ``::jsonb`` cast.
+"""
+from __future__ import annotations
+
+import json
+from contextlib import closing
+from typing import Any
+
+import pg8000.dbapi as pg8000
+from fastapi import FastAPI, Request, status
+from fastapi.responses import JSONResponse
+
+from .postgres_container import PostgresInfo
+
+
+class DocumentRepository:
+    """Direct-JDBC-equivalent repo against the test Postgres instance."""
+
+    def __init__(self, info: PostgresInfo) -> None:
+        self._info = info
+
+    def create_schema(self) -> None:
+        self._exec(
+            'CREATE TABLE IF NOT EXISTS "documents" ('
+            "    id BIGSERIAL PRIMARY KEY,"
+            "    title VARCHAR(200) NOT NULL,"
+            "    payload JSONB"
+            ")"
+        )
+
+    def truncate(self) -> None:
+        self._exec('TRUNCATE TABLE "documents" RESTART IDENTITY')
+
+    def apply_seed(self, rows: list[dict[str, Any]]) -> None:
+        """Insert seed rows with explicit ids, then bump the sequence so the
+        next implicit-id POST lands at max(id) + 1 (the GET-after-POST
+        contract relies on a deterministic id)."""
+        self.truncate()
+        with closing(self._connect()) as conn:
+            cur = conn.cursor()
+            try:
+                for r in rows:
+                    cur.execute(
+                        'INSERT INTO "documents" (id, title, payload) '
+                        "VALUES (%s, %s, %s::jsonb)",
+                        (int(r["id"]), r["title"], _dump_payload(r.get("payload"))),
+                    )
+                cur.execute(
+                    "SELECT setval(pg_get_serial_sequence('documents', 'id'), "
+                    "COALESCE((SELECT MAX(id) FROM documents), 1))"
+                )
+                conn.commit()
+            finally:
+                cur.close()
+
+    def find_by_id(self, ident: int) -> dict[str, Any] | None:
+        with closing(self._connect()) as conn:
+            cur = conn.cursor()
+            try:
+                cur.execute(
+                    'SELECT id, title, payload FROM "documents" WHERE id = %s',
+                    (int(ident),),
+                )
+                row = cur.fetchone()
+                return _row_to_dict(row) if row is not None else None
+            finally:
+                cur.close()
+
+    def create(self, dto: dict[str, Any]) -> dict[str, Any]:
+        with closing(self._connect()) as conn:
+            cur = conn.cursor()
+            try:
+                cur.execute(
+                    'INSERT INTO "documents" (title, payload) '
+                    "VALUES (%s, %s::jsonb) RETURNING id",
+                    (dto.get("title"), _dump_payload(dto.get("payload"))),
+                )
+                new_id = int(cur.fetchone()[0])
+                conn.commit()
+            finally:
+                cur.close()
+        created = self.find_by_id(new_id)
+        if created is None:
+            raise RuntimeError("create: row vanished between INSERT and SELECT")
+        return created
+
+    def _connect(self) -> Any:
+        return pg8000.connect(
+            host=self._info.host,
+            port=self._info.port,
+            user=self._info.user,
+            password=self._info.password,
+            database=self._info.database,
+        )
+
+    def _exec(self, sql: str) -> None:
+        with closing(self._connect()) as conn:
+            cur = conn.cursor()
+            try:
+                cur.execute(sql)
+                conn.commit()
+            finally:
+                cur.close()
+
+
+def make_jsonb_app(repo: DocumentRepository) -> FastAPI:
+    app = FastAPI()
+
+    @app.exception_handler(404)
+    async def _default_404(_req: Request, _exc: Any) -> JSONResponse:
+        return JSONResponse(status_code=404, content={"error": "not_found"})
+
+    @app.get("/api/documents/{document_id}")
+    def get_document(document_id: int) -> Any:
+        row = repo.find_by_id(document_id)
+        if row is None:
+            return JSONResponse(status_code=404, content={"error": "not_found"})
+        return row
+
+    @app.post("/api/documents", status_code=status.HTTP_201_CREATED)
+    def create_document(dto: dict[str, Any]) -> Any:
+        return repo.create(dto)
+
+    return app
+
+
+def _dump_payload(value: Any) -> Any:
+    """jsonb bind: a dict/list is ``json.dumps``-serialized for the ``::jsonb``
+    cast; ``None`` stays ``None`` (SQL NULL); a pre-serialized string passes
+    through."""
+    if value is None:
+        return None
+    if isinstance(value, str):
+        return value
+    return json.dumps(value)
+
+
+def _row_to_dict(row: Any) -> dict[str, Any]:
+    ident, title, payload = row
+    # pg8000 auto-decodes jsonb → native Python object; if a driver returned raw
+    # text we'd parse it, but the open-bag contract is "parsed value", so a str
+    # that is JSON is decoded here defensively.
+    if isinstance(payload, str):
+        try:
+            payload = json.loads(payload)
+        except json.JSONDecodeError:
+            pass
+    return {"id": int(ident), "title": title, "payload": payload}

metaobjects-0.14.0/tests/integration/generated_jsonb_app.py

@@ -0,0 +1,135 @@
+"""Boot the GENERATED FastAPI router for the ``Document`` entity over HTTP.
+
+Peer to ``generated_router_app.py`` (the Author generated lane), for the
+``api-contract-conformance/jsonb/`` corpus. Runs the REAL ``render_router``
+output for ``Document`` (whose ``payload`` field is ``field.string
+@dbColumnType:jsonb`` → a Pydantic ``Any`` per #98), imports the emitted module
+UNMODIFIED, and mounts it on a FastAPI app with a minimal in-memory repo behind
+the generated consumer seam. The generated router is the artifact under test:
+its DTO must accept a posted object and surface it back as an object.
+
+No Testcontainers — the controller is the artifact, its persistence seam is
+in-memory. Real DB behavior stays owned by persistence-conformance.
+"""
+from __future__ import annotations
+
+import importlib.util
+import shutil
+import sys
+import tempfile
+import uuid
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI
+
+from metaobjects import MetaDataLoader
+from metaobjects.codegen.generators.filter_allowlist_generator import render_filter_allowlist
+from metaobjects.codegen.generators.router_generator import render_router
+from metaobjects.meta.core.object.meta_object import MetaObject
+from metaobjects.shared.base_types import TYPE_OBJECT
+
+
+def _find_document_entity(meta_json: Path) -> MetaObject:
+    tmp = Path(tempfile.mkdtemp(prefix="apic-jsonb-meta-"))
+    shutil.copy(meta_json, tmp / "meta.json")
+    result = MetaDataLoader.from_directory(str(tmp))
+    if result.errors:
+        msgs = "; ".join(f"{e.code}: {e.message}" for e in result.errors)
+        raise RuntimeError(f"corpus meta.json failed to load: {msgs}")
+    objects = [
+        c for c in result.root.children()
+        if c.type == TYPE_OBJECT and isinstance(c, MetaObject)
+    ]
+    for obj in objects:
+        if obj.name == "Document" or obj.name.endswith("::Document"):
+            return obj
+    raise RuntimeError(f"Document entity not found among {[o.name for o in objects]}")
+
+
+def build_generated_jsonb_app(corpus_root: Path) -> tuple[FastAPI, "InMemoryDocumentRepository"]:
+    """Generate the Document router, import it, mount it, and wire the seam."""
+    document = _find_document_entity(corpus_root / "meta.json")
+
+    router_src = render_router(document)
+    allowlist_src = render_filter_allowlist(document)
+    if router_src is None or allowlist_src is None:
+        raise RuntimeError("router_generator / filter_allowlist_generator returned None for Document")
+
+    pkg_name = f"genjsonb_{uuid.uuid4().hex[:8]}"
+    tmp = Path(tempfile.mkdtemp(prefix="apic-jsonb-gen-"))
+    pkg_dir = tmp / pkg_name
+    pkg_dir.mkdir()
+    (pkg_dir / "__init__.py").write_text("")
+    (pkg_dir / "document_filter_allowlist.py").write_text(allowlist_src)
+    (pkg_dir / "document_router.py").write_text(router_src)
+
+    sys.path.insert(0, str(tmp))
+    pkg_spec = importlib.util.spec_from_file_location(
+        pkg_name, pkg_dir / "__init__.py", submodule_search_locations=[str(pkg_dir)]
+    )
+    pkg_mod = importlib.util.module_from_spec(pkg_spec)
+    sys.modules[pkg_name] = pkg_mod
+    pkg_spec.loader.exec_module(pkg_mod)
+    spec = importlib.util.spec_from_file_location(
+        f"{pkg_name}.document_router", pkg_dir / "document_router.py"
+    )
+    router_mod = importlib.util.module_from_spec(spec)
+    sys.modules[f"{pkg_name}.document_router"] = router_mod
+    spec.loader.exec_module(router_mod)
+
+    repo = InMemoryDocumentRepository()
+    app = FastAPI()
+    app.include_router(router_mod.router)
+    app.dependency_overrides[router_mod.get_repository] = lambda: repo
+    return app, repo
+
+
+class InMemoryDocumentRepository:
+    """In-memory impl of the GENERATED ``DocumentRepository`` Protocol (test seam).
+
+    The jsonb scenario only POSTs + GETs by id, but the generated router's
+    Protocol declares the full CRUD surface, so all verbs are implemented (the
+    payload open bag is stored/echoed verbatim — never serialized to a string).
+    """
+
+    def __init__(self) -> None:
+        self._rows: list[dict[str, Any]] = []
+
+    def reset(self) -> None:
+        self._rows = []
+
+    def seed(self, rows: list[dict[str, Any]]) -> None:
+        self._rows = [dict(r) for r in rows]
+
+    def list(self, limit: int, offset: int, sort: Any, filters: list[Any]) -> list[Any]:
+        rows = sorted(self._rows, key=lambda r: r["id"])
+        return [dict(r) for r in rows[offset : offset + limit]]
+
+    def count(self, filters: list[Any]) -> int:
+        return len(self._rows)
+
+    def find_by_id(self, id: int) -> Any | None:
+        for r in self._rows:
+            if r["id"] == id:
+                return dict(r)
+        return None
+
+    def create(self, dto: Any) -> Any:
+        row = dict(dto)
+        if row.get("id") is None:
+            row["id"] = (max((r["id"] for r in self._rows), default=0)) + 1
+        self._rows.append(dict(row))
+        return row
+
+    def update(self, id: int, dto: Any) -> Any | None:
+        for r in self._rows:
+            if r["id"] == id:
+                r.update({k: v for k, v in dict(dto).items() if k != "id"})
+                return dict(r)
+        return None
+
+    def delete(self, id: int) -> bool:
+        before = len(self._rows)
+        self._rows = [r for r in self._rows if r["id"] != id]
+        return len(self._rows) != before