fix(codegen-python): emit Any (not str) for field.string @dbColumnType:jsonb (#98)

pg8000 auto-decodes a jsonb column to a native Python object (dict/list/
scalar) at read time, so typing a field.string @dbColumnType:jsonb field as
`str` in the generated Pydantic model is a type lie (the runtime return-type
integration test already asserts the value is a dict). Emit `Any` instead —
the Python analogue of the TS z.unknown() fix in #97 — threading
`from typing import Any` into the module imports via the existing PyType
import mechanism. field.object @storage:jsonb (structured VO) and
field.string @dbColumnType:uuid are unaffected.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LuZWKnWzYGVnESijL7uuky

Author: dmealing

server/python/src/metaobjects/codegen/type_map.py

@@ -5,6 +5,7 @@
 
 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):

server/python/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

server/python/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