hap-cli 0.8.18__tar.gz → 0.8.20__tar.gz

{hap_cli-0.8.18 → hap_cli-0.8.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hap-cli
-Version: 0.8.18
+Version: 0.8.20
 Summary: CLI harness for Mingdao HAP - Enterprise no-code platform
 Author: hap-cli
 License: Apache-2.0

{hap_cli-0.8.18 → hap_cli-0.8.20}/hap_cli/__init__.py

@@ -1,3 +1,3 @@
 """CLI harness for Mingdao HAP (hap-cli)."""
 
-__version__ = "0.8.18"
+__version__ = "0.8.20"

{hap_cli-0.8.18 → hap_cli-0.8.20}/hap_cli/core/record.py

@@ -1,6 +1,7 @@
 """Record CRUD module for Mingdao HAP."""
 
 import json
+import logging
 import uuid
 from typing import Any, Optional
 
@@ -8,6 +9,8 @@ from hap_cli.core.session import Session, APIError
 from hap_cli.core import worksheet as ws_mod
 from hap_cli.core import global_meta as gm
 
+logger = logging.getLogger("hap_cli.record")
+
 # Discussion source types — pd-openweb src/components/comment/config.js
 #   WORKSHEET    = 7  whole-worksheet discussion
 #   WORKSHEETROW = 8  single record/row discussion
@@ -259,6 +262,67 @@ def _legacy_cell_entry(
     return {"value": _legacy_cell_value(ctrl, value)}
 
 
+def _coerce_entity_ids(
+    value: Any, id_keys: tuple[str, ...], *, field_label: str,
+) -> list[str]:
+    """Flatten a member / department / org-role / relation cell value to a
+    list of id strings, ready to be wrapped as ``[{idKey: id}, ...]``.
+
+    Accepts every realistic input shape so callers never have to pre-shape:
+      * a scalar id, or comma-separated ids (``"a,b"``);
+      * a list/tuple mixing ids and ``{idKey: ...}`` objects;
+      * a single ``{idKey: ...}`` object — the ``get_records`` read-back
+        shape carries display fields (``fullname`` / ``avatar`` / ``name``)
+        too, so only the id is kept;
+      * a JSON-array/object *string* of the above (e.g. a value copied
+        straight out of a record dump).
+
+    ``id_keys`` lists the accepted id field names in priority order, e.g.
+    ``("accountId", "aid")`` for USER_PICKER. An object that carries none of
+    them fails loudly instead of being ``str()``-mangled into a junk id —
+    that silent mangling sent garbage members to the server before.
+    """
+    if value is None or value == "":
+        return []
+    # A JSON-array/object string is parsed structurally rather than
+    # comma-split (a member object's JSON has commas inside it).
+    if isinstance(value, str):
+        s = value.strip()
+        if s[:1] in ("[", "{"):
+            try:
+                value = json.loads(s)
+            except (ValueError, TypeError):
+                pass
+    if isinstance(value, dict):
+        items: list[Any] = [value]
+    elif isinstance(value, (list, tuple)):
+        items = list(value)
+    else:
+        items = [p for p in str(value).split(",") if p.strip() != ""]
+    out: list[str] = []
+    for it in items:
+        if isinstance(it, dict):
+            rid = next(
+                (str(it[k]) for k in id_keys if it.get(k) not in (None, "")),
+                None,
+            )
+            if rid is None:
+                raise ValueError(
+                    f"Field '{field_label}': object value is missing an id "
+                    f"field ({'/'.join(id_keys)}): {it!r}"
+                )
+            out.append(rid)
+        elif isinstance(it, (list, tuple)):
+            raise ValueError(
+                f"Field '{field_label}': nested array is not a valid id: {it!r}"
+            )
+        else:
+            s2 = str(it).strip()
+            if s2:
+                out.append(s2)
+    return out
+
+
 def _legacy_cell_value(ctrl: dict[str, Any], value: Any) -> str:
     """Serialize one cell to the legacy receiveControls `value`
     string, per the shapes proven in
@@ -271,14 +335,15 @@ def _legacy_cell_value(ctrl: dict[str, Any], value: Any) -> str:
     if t == 10:  # MULTI_SELECT
         return json.dumps(_resolve_option_keys(ctrl, value), ensure_ascii=False)
 
+    label = _option_field_label(ctrl)
+
     if t in (29, 35):  # RELATE_SHEET / CASCADING_SELECT -> [{"sid": rowId}, ...]
         # Cascade (35) is a relation to a row in another worksheet, persisted
         # the same way as a plain relate (29): an array of {"sid": rowId}. A
-        # bare rowId makes the server answer "服务异常" (bug #642cc8).
-        if isinstance(value, (list, tuple)):
-            ids = [str(v) for v in value]
-        else:
-            ids = [s for s in str(value).split(",") if s != ""]
+        # bare rowId makes the server answer "服务异常" (bug #642cc8). Object
+        # inputs ({"sid": rowId, ...} read-back shape) keep only the sid.
+        ids = _coerce_entity_ids(value, ("sid", "rowid", "rowId"),
+                                 field_label=label)
         return json.dumps([{"sid": rid} for rid in ids], ensure_ascii=False)
 
     if t == 48:  # ORG_ROLE -> [{"organizeId": id}, ...]
@@ -286,20 +351,21 @@ def _legacy_cell_value(ctrl: dict[str, Any], value: Any) -> str:
         # of {"organizeId": id} objects; organizeName is display-only and the
         # server resolves it from the id. A bare organizeId is rejected with
         # "服务异常" (bug #642cc8). See pd-openweb CellControls/OrgRole.jsx.
-        ids = value if isinstance(value, (list, tuple)) else \
-            [s for s in str(value).split(",") if s != ""]
-        return json.dumps([{"organizeId": str(i)} for i in ids],
-                          ensure_ascii=False)
-
-    if t == 26:  # USER_PICKER
-        ids = value if isinstance(value, (list, tuple)) else \
-            [s for s in str(value).split(",") if s != ""]
-        return json.dumps([{"accountId": str(i)} for i in ids],
-                          ensure_ascii=False)
-    if t == 27:  # DEPARTMENT
-        ids = value if isinstance(value, (list, tuple)) else \
-            [s for s in str(value).split(",") if s != ""]
-        return json.dumps([{"departmentId": str(i)} for i in ids],
+        ids = _coerce_entity_ids(value, ("organizeId", "id"),
+                                 field_label=label)
+        return json.dumps([{"organizeId": i} for i in ids], ensure_ascii=False)
+
+    if t == 26:  # USER_PICKER -> always an array of {"accountId": id}, even
+        # for a single member. Object inputs (the full member object the UI
+        # holds / get_records returns: {accountId, fullname, avatar, ...})
+        # are reduced to their accountId — a bare object would fail the save.
+        ids = _coerce_entity_ids(value, ("accountId", "aid"),
+                                 field_label=label)
+        return json.dumps([{"accountId": i} for i in ids], ensure_ascii=False)
+    if t == 27:  # DEPARTMENT -> [{"departmentId": id}, ...]
+        ids = _coerce_entity_ids(value, ("departmentId", "id"),
+                                 field_label=label)
+        return json.dumps([{"departmentId": i} for i in ids],
                           ensure_ascii=False)
 
     if t == 36:  # SWITCH / checkbox
@@ -320,6 +386,41 @@ def _legacy_cell_value(ctrl: dict[str, Any], value: Any) -> str:
     return "" if value is None else str(value)
 
 
+def _controls_for_write(
+    session: Session, worksheet_id: str,
+) -> list[dict[str, Any]]:
+    """Fetch the worksheet's controls for a write, refusing an empty list.
+
+    Every write path type-encodes its cells against this metadata, so an
+    empty list silently disables the encoder: option/member/relation/
+    sub-table values would all take the "unknown field -> send the raw
+    value" fallback and reach the server in whatever shape the caller
+    happened to type. That is how a hand-written 1-D sub-table value
+    (``[{childControlId: value}, ...]``) escaped to the server and failed
+    deserialization into ``List<Cell>`` — the encoder would otherwise have
+    rewritten it to the 2-D form.
+
+    ``get_worksheet_controls`` answers ``[]`` for any response that does
+    not carry a ``controls`` list — a soft failure, ``data: null``, or a
+    permission-degraded envelope — none of which raise. A real worksheet
+    always has controls, so an empty list means "we could not read the
+    fields", never "this worksheet has none". Abort before writing.
+    """
+    controls = ws_mod.get_worksheet_controls(session, worksheet_id)
+    if not controls:
+        logger.warning(
+            "GetWorksheetControls returned no fields for worksheet %s; "
+            "aborting the write instead of sending unencoded cells",
+            worksheet_id,
+        )
+        raise ValueError(
+            f"Could not read the fields of worksheet {worksheet_id}, so "
+            "nothing was written. Check the worksheet id and that your "
+            "account can open it, then try again."
+        )
+    return controls
+
+
 def encode_controls_by_id(
     session: Session,
     worksheet_id: str,
@@ -356,7 +457,7 @@ def encode_controls_by_id(
     (in-place edits keyed by ``rowid``, fresh adds, and deletes — see
     :func:`_sublist_update_value`).
     """
-    controls = ws_mod.get_worksheet_controls(session, worksheet_id)
+    controls = _controls_for_write(session, worksheet_id)
     by_id: dict[str, dict[str, Any]] = {
         c.get("controlId"): c for c in controls if c.get("controlId")
     }
@@ -371,6 +472,14 @@ def encode_controls_by_id(
         raw = rc.get("value")
         ctrl = by_id.get(cid) or by_ref.get(cid)
         if ctrl is None:
+            # Deliberate escape hatch (see docstring), but a value that
+            # skips the type encoder is exactly how a malformed cell
+            # reaches the server, so leave a trace: this is the only
+            # place a write can go out unencoded.
+            logger.warning(
+                "Field %r is not on worksheet %s; its value is sent "
+                "unencoded (no type conversion applied)", cid, worksheet_id,
+            )
             out.append({"controlId": cid, "value": raw})
             continue
         out.append({
@@ -540,7 +649,7 @@ def batch_create_by_name(
     by child controlId; single/multi select -> option keys; etc.).
     Evidence: hap_cli/tests/answer_create_record.md.
     """
-    controls = ws_mod.get_worksheet_controls(session, worksheet_id)
+    controls = _controls_for_write(session, worksheet_id)
     by_name: dict[str, dict[str, Any]] = {}
     for c in controls:
         for key in (c.get("controlName"), c.get("alias"),
@@ -599,7 +708,7 @@ def batch_update_by_name(
     :func:`_sublist_update_value`). Record updates never use the V3
     rows endpoint — V3 silently drops relation / sub-table cells.
     """
-    controls = ws_mod.get_worksheet_controls(session, worksheet_id)
+    controls = _controls_for_write(session, worksheet_id)
     by_name: dict[str, dict[str, Any]] = {}
     for c in controls:
         for key in (c.get("controlName"), c.get("alias"),

{hap_cli-0.8.18 → hap_cli-0.8.20}/hap_cli/core/session.py

@@ -529,28 +529,39 @@ class Session:
         # Detect each and unwrap accordingly.
         if not isinstance(result, dict):
             return result
+        # A non-empty ``exception`` means the call failed, whatever envelope
+        # it arrived in. This is the frontend's own and only test — mdyAPI
+        # rejects on ``if (responseData.exception)`` alone and never looks at
+        # ``status`` (pd-openweb src/common/global.js:846-849). Checking it
+        # before any unwrapping is what makes workflow failures visible: the
+        # workflow envelope has no ``state``, so it used to skip the error
+        # branch entirely and hand the caller a "successful" empty result.
+        exception_msg = str(result.get("exception", "") or "")
+        if exception_msg:
+            code = result.get("code", result.get("state"))
+            # Some HAP deployments tunnel auth failures through the exception
+            # text/code instead of HTTP 401. Surface those as
+            # AuthenticationError so the CLI shows the login hint.
+            if _looks_like_auth_failure(code, exception_msg):
+                raise AuthenticationError(exception_msg, status_code=None)
+            raise APIError(exception_msg, code=code)
         if "status" in result and "data" in result and "state" not in result:
-            # Workflow envelope. status==0 is "ok" here historically; we
-            # don't have a clean way to detect failures via status alone,
-            # so we just unwrap data and trust HTTP status for errors.
+            # Workflow envelope: ``status`` carries no success/failure
+            # semantics (the frontend ignores it), and a failure would have
+            # been caught by the exception check above.
             return result.get("data", result)
         if "state" not in result:
             return result
         if result.get("state") == 0:
-            exception_msg = str(result.get("exception", "") or "")
             code = result.get("code")
-            # Some HAP deployments tunnel auth failures through state=0 with
-            # specific codes/messages instead of HTTP 401. Surface those as
-            # AuthenticationError too so the CLI shows the login hint.
-            if _looks_like_auth_failure(code, exception_msg):
+            # state=0 with no exception text — still a failure, just an
+            # unlabelled one.
+            if _looks_like_auth_failure(code, ""):
                 raise AuthenticationError(
-                    exception_msg or "Authentication failed (upstream reported login required).",
+                    "Authentication failed (upstream reported login required).",
                     status_code=None,
                 )
-            raise APIError(
-                exception_msg or "Unknown API error",
-                code=code,
-            )
+            raise APIError("Unknown API error", code=code)
         return result.get("data", result)
 
     # ── API Call Methods ──────────────────────────────────────────────────

{hap_cli-0.8.18 → hap_cli-0.8.20}/hap_cli/core/worksheet.py

@@ -68,10 +68,25 @@ def get_worksheet_controls(
     if isinstance(result, dict):
         inner = result.get("data")
         if isinstance(inner, dict):
-            return inner.get("controls", [])
-        if isinstance(inner, list):
-            return inner
-    return result.get("controls", [])
+            controls = inner.get("controls", [])
+        elif isinstance(inner, list):
+            controls = inner
+        else:
+            controls = result.get("controls", [])
+    else:
+        controls = []
+    if not controls:
+        # A real worksheet always has controls, so an empty result means
+        # the envelope was not the expected shape (soft failure, data:
+        # null, permission-degraded response). Callers that type-encode
+        # cells against this metadata silently lose their encoding when
+        # it comes back empty, so leave a trace at the source.
+        logger.warning(
+            "GetWorksheetControls returned no fields for worksheet %s "
+            "(response keys: %s)", worksheet_id,
+            sorted(result) if isinstance(result, dict) else type(result).__name__,
+        )
+    return controls
 
 
 def get_worksheet_views(

hap_cli-0.8.20/hap_cli/tests/test_control_lookup_guard.py

@@ -0,0 +1,179 @@
+"""A record write must abort when the worksheet's fields can't be read.
+
+Traced from a live backend error on ``Worksheet.AddWSRowData.DetailTable
+.Details``:
+
+    Cannot deserialize the current JSON object (e.g. {"name":"value"})
+    into type 'System.Collections.Generic.List`1[MD.Entity.Worksheet.Cell]'
+    ... Path '[0].66961f256a6cbc06cce98326'
+
+The server had received a sub-table cell whose value was a *1-D* array of
+``{childControlId: value}`` maps instead of the 2-D
+``[[{controlId, value}, ...], ...]`` array it deserializes into
+``List<Cell>``.
+
+``encode_controls_by_id`` normally rewrites exactly that mistake: it looks
+the sub-table control up, runs ``_legacy_cell_value`` (type 34) over the
+value and re-emits the 2-D form with a ``tempRowId`` cell per row. The one
+way the wrong shape can escape is the "control not found -> send the raw
+value" fallback. And because ``get_worksheet_controls`` returns ``[]``
+whenever the response doesn't carry a ``controls`` list (soft failure,
+``data: null``, permission-degraded envelope), *every* cell of that write
+silently took the fallback — the type encoder was effectively switched
+off with no signal to the user.
+
+Two guards, both exercised here:
+  * an empty control list on a write path fails loudly, and
+  * an individual unresolved field reference is logged before its value
+    is passed through.
+"""
+
+import json
+import logging
+
+import pytest
+
+from hap_cli.core import record as rec_mod
+
+
+_SUB_CTRL = {
+    "controlId": "66962b546c73406b9268582d",
+    "controlName": "明细",
+    "type": 34,
+    "relationControls": [
+        {"controlId": "66961f256a6cbc06cce98326", "controlName": "编号",
+         "type": 2},
+        {"controlId": "66962af95957d709b346d1ad", "controlName": "数量",
+         "type": 6},
+    ],
+}
+
+# The shape an LLM / hand-written payload typically produces: one map per
+# child row, keyed by child controlId, values left in their native JSON
+# types. This is what the server choked on.
+_MAP_SHAPED_ROWS = json.dumps([
+    {"66961f256a6cbc06cce98326": "WL001238",
+     "66962af95957d709b346d1ad": 2},
+])
+
+
+@pytest.fixture
+def controls(monkeypatch):
+    """Stub the worksheet control fetch; assign to the list to change it."""
+    holder = [_SUB_CTRL]
+
+    def _fake(session, worksheet_id, app_id=""):
+        return holder[0] if isinstance(holder[0], list) else holder
+
+    monkeypatch.setattr(rec_mod.ws_mod, "get_worksheet_controls", _fake)
+    return holder
+
+
+def _set(holder, value):
+    holder[0] = value
+
+
+@pytest.fixture
+def warnings():
+    """Collect this module's warnings off its own logger.
+
+    ``caplog`` listens on the root logger, and ``hap config log on``
+    detaches ``hap_cli`` from root (``propagate = False``), so a test that
+    happens to run after one is deaf to these records. Attaching here is
+    independent of that.
+    """
+    records: list[logging.LogRecord] = []
+
+    class _Collect(logging.Handler):
+        def emit(self, record):
+            records.append(record)
+
+    handler = _Collect(level=logging.WARNING)
+    log = logging.getLogger("hap_cli.record")
+    log.addHandler(handler)
+    try:
+        yield records
+    finally:
+        log.removeHandler(handler)
+
+
+class TestEmptyControlListAborts:
+    def test_encode_controls_by_id_raises(self, controls):
+        _set(controls, [])
+        with pytest.raises(ValueError, match="ws_1"):
+            rec_mod.encode_controls_by_id(
+                None, "ws_1",
+                [{"controlId": _SUB_CTRL["controlId"],
+                  "value": _MAP_SHAPED_ROWS}],
+            )
+
+    def test_update_path_raises_too(self, controls):
+        _set(controls, [])
+        with pytest.raises(ValueError):
+            rec_mod.encode_controls_by_id(
+                None, "ws_1",
+                [{"controlId": _SUB_CTRL["controlId"], "value": "x"}],
+                for_update=True,
+            )
+
+    def test_batch_create_by_name_raises(self, controls):
+        _set(controls, [])
+        with pytest.raises(ValueError, match="ws_1"):
+            rec_mod.batch_create_by_name(None, "ws_1", [{"明细": []}])
+
+    def test_batch_update_by_name_raises(self, controls):
+        _set(controls, [])
+        with pytest.raises(ValueError, match="ws_1"):
+            rec_mod.batch_update_by_name(
+                None, "ws_1", [{"rowid": "r1", "明细": []}])
+
+    def test_error_names_the_worksheet_not_the_field(self, controls):
+        """The old message blamed the field ("Field '明细' not found").
+
+        With no controls at all the field is not the problem — say so, or
+        the user goes hunting for a field that exists.
+        """
+        _set(controls, [])
+        with pytest.raises(ValueError) as exc:
+            rec_mod.batch_create_by_name(None, "ws_1", [{"明细": []}])
+        assert "not found" not in str(exc.value)
+
+
+class TestUnresolvedFieldIsLogged:
+    def test_warning_names_the_field(self, controls, warnings):
+        out = rec_mod.encode_controls_by_id(
+            None, "ws_1", [{"controlId": "c_nope", "value": "v"}])
+        # Still passed through — explicit ids must keep reaching the server.
+        assert out == [{"controlId": "c_nope", "value": "v"}]
+        assert any("c_nope" in r.getMessage() for r in warnings)
+
+    def test_no_warning_when_resolved(self, controls, warnings):
+        rec_mod.encode_controls_by_id(
+            None, "ws_1",
+            [{"controlId": _SUB_CTRL["controlId"], "value": "[]"}])
+        assert warnings == []
+
+    def test_empty_control_list_is_logged_before_the_abort(
+            self, controls, warnings):
+        _set(controls, [])
+        with pytest.raises(ValueError):
+            rec_mod.encode_controls_by_id(
+                None, "ws_1", [{"controlId": "c_any", "value": "v"}])
+        assert any("ws_1" in r.getMessage() for r in warnings)
+
+
+class TestMapShapedSubTableIsStillNormalized:
+    """The guards must not weaken the repair that already works."""
+
+    def test_map_rows_become_2d_cell_lists(self, controls):
+        out = rec_mod.encode_controls_by_id(
+            None, "ws_1",
+            [{"controlId": _SUB_CTRL["controlId"],
+              "value": _MAP_SHAPED_ROWS}],
+        )
+        rows = json.loads(out[0]["value"])
+        assert isinstance(rows, list) and isinstance(rows[0], list)
+        cells = {c["controlId"]: c["value"] for c in rows[0]}
+        assert cells["66961f256a6cbc06cce98326"] == "WL001238"
+        assert cells["66962af95957d709b346d1ad"] == "2"  # stringified
+        assert "tempRowId" in cells

hap_cli-0.8.20/hap_cli/tests/test_member_relation_array_wrap.py

@@ -0,0 +1,103 @@
+"""Member / department / org-role / relation cells must always serialize
+to a JSON *array* of id objects, and must accept object-shaped inputs.
+
+A USER_PICKER (26) cell is always an array, even for a single member
+(evidence: a bare ``{"accountId":...}`` object on AddWorksheetRow fails
+server-side). hap-cli's encoder already wraps scalars in an array, but it
+mangled object-shaped inputs: ``[{"accountId": str(i)} for i in value]``
+ran ``str()`` over a whole member dict when the value was a member object
+or — the natural ``get_records`` read-back shape — a list of member
+objects ``[{"accountId","fullname","avatar",...}]``. The id is now
+extracted from such objects and the cell is always emitted as an array.
+
+The same fix covers DEPARTMENT (27, ``departmentId``), ORG_ROLE
+(48, ``organizeId``) and RELATE_SHEET/CASCADING (29/35, ``sid``).
+"""
+
+import json
+
+import pytest
+
+from hap_cli.core import record as rec_mod
+
+
+def _val(type_code, value):
+    return rec_mod._legacy_cell_value({"type": type_code, "controlName": "f"}, value)
+
+
+class TestUserPickerAlwaysArray:
+    def test_single_account_id_string(self):
+        assert _val(26, "a1") == '[{"accountId": "a1"}]'
+
+    def test_comma_separated_ids(self):
+        assert _val(26, "a1,a2") == '[{"accountId": "a1"}, {"accountId": "a2"}]'
+
+    def test_list_of_ids(self):
+        assert _val(26, ["a1", "a2"]) == \
+            '[{"accountId": "a1"}, {"accountId": "a2"}]'
+
+    def test_single_member_object_keeps_only_account_id(self):
+        v = {"accountId": "a1", "fullname": "林梦阳", "name": "林梦阳",
+             "avatar": "https://x", "avatarMiddle": "https://y"}
+        assert _val(26, v) == '[{"accountId": "a1"}]'
+
+    def test_list_of_member_objects_readback_shape(self):
+        v = [{"accountId": "a1", "fullname": "甲", "avatar": "u1"},
+             {"accountId": "a2", "fullname": "乙", "avatar": "u2"}]
+        assert _val(26, v) == \
+            '[{"accountId": "a1"}, {"accountId": "a2"}]'
+
+    def test_json_array_of_objects_string(self):
+        v = json.dumps([{"accountId": "a1", "fullname": "甲"}])
+        assert _val(26, v) == '[{"accountId": "a1"}]'
+
+    def test_json_object_string(self):
+        v = json.dumps({"accountId": "a1", "fullname": "甲"})
+        assert _val(26, v) == '[{"accountId": "a1"}]'
+
+    def test_member_object_without_account_id_rejected(self):
+        with pytest.raises(ValueError):
+            _val(26, {"fullname": "甲", "avatar": "u"})
+
+    def test_empty_is_empty_array(self):
+        assert _val(26, "") == "[]"
+        assert _val(26, None) == "[]"
+
+
+class TestDepartmentObjectShape:
+    def test_object_keeps_department_id(self):
+        v = {"departmentId": "d1", "departmentName": "研发"}
+        assert _val(27, v) == '[{"departmentId": "d1"}]'
+
+    def test_list_of_objects(self):
+        v = [{"departmentId": "d1"}, {"departmentId": "d2"}]
+        assert _val(27, v) == \
+            '[{"departmentId": "d1"}, {"departmentId": "d2"}]'
+
+    def test_plain_id_still_works(self):
+        assert _val(27, "d1") == '[{"departmentId": "d1"}]'
+
+
+class TestOrgRoleObjectShape:
+    def test_object_keeps_organize_id(self):
+        v = {"organizeId": "o1", "organizeName": "主管"}
+        assert _val(48, v) == '[{"organizeId": "o1"}]'
+
+    def test_plain_id_still_works(self):
+        assert _val(48, "o1") == '[{"organizeId": "o1"}]'
+
+
+class TestRelateObjectShape:
+    def test_relate_object_keeps_sid(self):
+        v = {"sid": "row1", "name": "记录甲"}
+        assert _val(29, v) == '[{"sid": "row1"}]'
+
+    def test_relate_list_of_objects_readback(self):
+        v = [{"sid": "row1", "name": "甲"}, {"sid": "row2", "name": "乙"}]
+        assert _val(29, v) == '[{"sid": "row1"}, {"sid": "row2"}]'
+
+    def test_relate_plain_rowid_still_works(self):
+        assert _val(29, "row1") == '[{"sid": "row1"}]'
+
+    def test_cascading_object_keeps_sid(self):
+        assert _val(35, {"sid": "row1"}) == '[{"sid": "row1"}]'