hap-cli 0.8.17__tar.gz → 0.8.19__tar.gz

{hap_cli-0.8.17 → hap_cli-0.8.19}/PKG-INFO

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

{hap_cli-0.8.17 → hap_cli-0.8.19}/hap_cli/__init__.py

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

{hap_cli-0.8.17 → hap_cli-0.8.19}/hap_cli/core/app_creator/_hapmeta/worksheet_templates.py

@@ -486,6 +486,34 @@ def build_control(
     return ctrl
 
 
+# The fields a HAP select option may legitimately carry. The base shape
+# is {key, value, isDeleted, index, checked, color} (pd-openweb
+# src/pages/widgetConfig/util/setting.js getDefaultOptions); ``score`` is
+# the optional NPS/scoring weight (OptionList/AssignValue.jsx). There is
+# no ``type`` field — an option carrying one is malformed input, not a HAP
+# shape, so it is rejected rather than silently dropped.
+_ALLOWED_OPTION_FIELDS = frozenset(
+    {"key", "value", "isDeleted", "index", "checked", "color", "score"}
+)
+
+
+def _option_value_is_object_shaped(v: Any) -> bool:
+    """True when an option key/value is a relation/member/object shape
+    (``[{"sid": …}]`` / ``{...}``) instead of plain text — which would
+    only surface server-side as a ``ControlOptions`` deserialization
+    failure on the batch save."""
+    if isinstance(v, (list, tuple, dict)):
+        return True
+    if isinstance(v, str):
+        s = v.strip()
+        if s[:1] in ("[", "{"):
+            try:
+                return isinstance(json.loads(s), (list, dict))
+            except (ValueError, TypeError):
+                return False
+    return False
+
+
 def _normalize_options(
     opts: list[str] | list[dict[str, Any]],
 ) -> list[dict[str, Any]]:
@@ -493,6 +521,10 @@ def _normalize_options(
 
     First item is marked as the default selection (checked=True) unless
     any caller-supplied dict already sets it.
+
+    Option ``value``/``key`` must be plain text; a relation/object shape
+    or an unsupported field (e.g. ``type``) is rejected up front rather
+    than silently mangled or dropped.
     """
     colors = [
         "#C9E6FC", "#C3F2F2", "#C2F1D2", "#FFE7B1", "#FBD2BF",
@@ -502,6 +534,27 @@ def _normalize_options(
     any_default = any(isinstance(o, dict) and o.get("checked") for o in opts)
     for i, o in enumerate(opts):
         if isinstance(o, dict):
+            unknown = set(o) - _ALLOWED_OPTION_FIELDS
+            if unknown:
+                raise ValueError(
+                    f"Select option {o!r} has unsupported field(s) "
+                    f"{sorted(unknown)}; an option only accepts "
+                    f"{sorted(_ALLOWED_OPTION_FIELDS)}."
+                )
+            if o.get("value") in (None, ""):
+                raise ValueError(
+                    f"Select option {o!r} is missing a non-empty 'value'."
+                )
+            if _option_value_is_object_shaped(o.get("value")):
+                raise ValueError(
+                    f"Select option 'value' must be plain text, got a "
+                    f"relation/object-shaped value: {o.get('value')!r}."
+                )
+            if o.get("key") is not None and _option_value_is_object_shaped(o.get("key")):
+                raise ValueError(
+                    f"Select option 'key' must be a string, got a "
+                    f"relation/object-shaped value: {o.get('key')!r}."
+                )
             entry = {
                 "key": o.get("key") or str(uuid.uuid4()),
                 "value": o["value"],
@@ -510,6 +563,8 @@ def _normalize_options(
                 "checked": o.get("checked", False),
                 "color": o.get("color", colors[i % len(colors)]),
             }
+            if "score" in o:
+                entry["score"] = o["score"]
         else:
             entry = {
                 "key": str(uuid.uuid4()),

{hap_cli-0.8.17 → hap_cli-0.8.19}/hap_cli/core/record.py

@@ -22,13 +22,56 @@ DISCUSSION_SOURCE_WORKSHEET_ROW = 8
 _LEGACY_SKIP_TYPES = {30, 31, 32, 33, 37, 38, 53}
 
 
+def _option_field_label(ctrl: dict[str, Any]) -> str:
+    return str(ctrl.get("controlName") or ctrl.get("controlId") or "option field")
+
+
+def _reject_relation_shaped_option(ctrl: dict[str, Any], item: Any) -> None:
+    """Fail loudly when a select cell is handed a relation/member/sub-table
+    *object* shape instead of an option value.
+
+    A single/multi-select cell legitimately carries only an option key, a
+    known label, or an ``add_<text>`` new-option directive — never a
+    ``[{"sid": rowId}]`` / ``{...}`` structure. When such a value slips
+    through (e.g. row data maps a relation value to the wrong child field),
+    the old code passed it straight to the server, which then failed
+    deserializing ``ControlOptions`` on the batch save. Catching it here
+    points the blame at the offending field instead of a generic 500.
+    """
+    looks_object = isinstance(item, (list, tuple, dict))
+    if not looks_object and isinstance(item, str):
+        stripped = item.strip()
+        if stripped[:1] in ("[", "{"):
+            try:
+                parsed = json.loads(stripped)
+            except (ValueError, TypeError):
+                parsed = None
+            looks_object = isinstance(parsed, (list, dict))
+    if looks_object:
+        raise ValueError(
+            f"Field '{_option_field_label(ctrl)}' is a select field and "
+            f"expects an option key, a label, or an 'add_<text>' new-option "
+            f"value, but got a relation/object-shaped value: {item!r}. "
+            f"This value belongs to a relation or member field, not this "
+            f"select field — check the field mapping."
+        )
+
+
 def _resolve_option_keys(ctrl: dict[str, Any], raw: Any) -> list[str]:
     """Map option labels (or already-keys) to the option `key` values
-    the legacy AddWorksheetRow expects (it takes keys, not labels)."""
+    the legacy AddWorksheetRow expects (it takes keys, not labels).
+
+    Relation/member/sub-table *object* shapes (``[{"sid": …}]`` etc.) are
+    rejected up front — they are never valid option values and would only
+    surface server-side as a ``ControlOptions`` deserialization failure on
+    the batch save.
+    """
     if raw is None or raw == "":
         return []
     if isinstance(raw, (list, tuple)):
-        items = [str(v) for v in raw]
+        items: list[Any] = list(raw)
+    elif isinstance(raw, dict):
+        items = [raw]
     else:
         items = [s for s in str(raw).split(",") if s != ""]
     by_label: dict[str, str] = {}
@@ -40,7 +83,9 @@ def _resolve_option_keys(ctrl: dict[str, Any], raw: Any) -> list[str]:
             by_label[str(opt.get("value", ""))] = key
     out: list[str] = []
     for it in items:
-        out.append(it if it in valid_keys else by_label.get(it, it))
+        _reject_relation_shaped_option(ctrl, it)
+        s = str(it)
+        out.append(s if s in valid_keys else by_label.get(s, s))
     return out
 
 
@@ -214,6 +259,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
@@ -226,14 +332,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}, ...]
@@ -241,20 +348,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

{hap_cli-0.8.17 → hap_cli-0.8.19}/hap_cli/core/worksheet_templates.py

@@ -471,6 +471,34 @@ def build_control(
     return ctrl
 
 
+# The fields a HAP select option may legitimately carry. The base shape
+# is {key, value, isDeleted, index, checked, color} (pd-openweb
+# src/pages/widgetConfig/util/setting.js getDefaultOptions); ``score`` is
+# the optional NPS/scoring weight (OptionList/AssignValue.jsx). There is
+# no ``type`` field — an option carrying one is malformed input, not a HAP
+# shape, so it is rejected rather than silently dropped.
+_ALLOWED_OPTION_FIELDS = frozenset(
+    {"key", "value", "isDeleted", "index", "checked", "color", "score"}
+)
+
+
+def _option_value_is_object_shaped(v: Any) -> bool:
+    """True when an option key/value is a relation/member/object shape
+    (``[{"sid": …}]`` / ``{...}``) instead of plain text — which would
+    only surface server-side as a ``ControlOptions`` deserialization
+    failure on the batch save."""
+    if isinstance(v, (list, tuple, dict)):
+        return True
+    if isinstance(v, str):
+        s = v.strip()
+        if s[:1] in ("[", "{"):
+            try:
+                return isinstance(json.loads(s), (list, dict))
+            except (ValueError, TypeError):
+                return False
+    return False
+
+
 def _normalize_options(
     opts: list[str] | list[dict[str, Any]],
 ) -> list[dict[str, Any]]:
@@ -478,6 +506,10 @@ def _normalize_options(
 
     First item is marked as the default selection (checked=True) unless
     any caller-supplied dict already sets it.
+
+    Option ``value``/``key`` must be plain text; a relation/object shape
+    or an unsupported field (e.g. ``type``) is rejected up front rather
+    than silently mangled or dropped.
     """
     colors = [
         "#C9E6FC", "#C3F2F2", "#C2F1D2", "#FFE7B1", "#FBD2BF",
@@ -487,6 +519,27 @@ def _normalize_options(
     any_default = any(isinstance(o, dict) and o.get("checked") for o in opts)
     for i, o in enumerate(opts):
         if isinstance(o, dict):
+            unknown = set(o) - _ALLOWED_OPTION_FIELDS
+            if unknown:
+                raise ValueError(
+                    f"Select option {o!r} has unsupported field(s) "
+                    f"{sorted(unknown)}; an option only accepts "
+                    f"{sorted(_ALLOWED_OPTION_FIELDS)}."
+                )
+            if o.get("value") in (None, ""):
+                raise ValueError(
+                    f"Select option {o!r} is missing a non-empty 'value'."
+                )
+            if _option_value_is_object_shaped(o.get("value")):
+                raise ValueError(
+                    f"Select option 'value' must be plain text, got a "
+                    f"relation/object-shaped value: {o.get('value')!r}."
+                )
+            if o.get("key") is not None and _option_value_is_object_shaped(o.get("key")):
+                raise ValueError(
+                    f"Select option 'key' must be a string, got a "
+                    f"relation/object-shaped value: {o.get('key')!r}."
+                )
             entry = {
                 "key": o.get("key") or str(uuid.uuid4()),
                 "value": o["value"],
@@ -495,6 +548,8 @@ def _normalize_options(
                 "checked": o.get("checked", False),
                 "color": o.get("color", colors[i % len(colors)]),
             }
+            if "score" in o:
+                entry["score"] = o["score"]
         else:
             entry = {
                 "key": str(uuid.uuid4()),

hap_cli-0.8.19/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"}]'

hap_cli-0.8.19/hap_cli/tests/test_select_rejects_relation_value.py

@@ -0,0 +1,178 @@
+"""A single/multi-select cell must reject relation/object-shaped values.
+
+Traced from a live backend error on ``WorksheetService/AddWSRowsBatch``
+(the batch service the main-site ``Worksheet/AddWorksheetRow`` dispatches
+sub-table child rows to). A single-select child field (Type 11) had been
+handed a RELATE_SHEET-shaped value ``[{"sid": "<rowId>"}]`` instead of an
+option key, and the server failed deserialization:
+
+    Cannot deserialize the current JSON array (e.g. [1,2,3]) into type
+    'MD.Worksheet.Core.Entities.ControlOptions' ...
+
+Before this fix, ``_resolve_option_keys`` passed any value it could not
+map to a known key/label straight through to the server (the same soft
+spot as bug #036430). A select cell legitimately carries only an option
+key, a known label, or an ``add_<text>`` new-option directive (evidence:
+pd-openweb src/components/Form/core/utils.js, formatControlToServer
+case 10/11). An object / array-of-objects value is structurally a
+relation/member/sub-table shape and is always wrong here, so it is now
+rejected loudly at the CLI boundary instead of poisoning the server.
+"""
+
+import json
+
+import pytest
+
+from hap_cli.core import record as rec_mod
+from hap_cli.core import worksheet_templates as wt
+
+
+_SELECT_CTRL = {
+    "controlId": "c_status",
+    "controlName": "状态",
+    "type": 11,
+    "options": [
+        {"key": "k_pass", "value": "已通过"},
+        {"key": "k_reject", "value": "已驳回"},
+    ],
+}
+
+# A sub-table child whose option metadata is NOT carried on the child
+# control (relationControls are often slim) — the structural rejection
+# must still fire without an option set to validate against.
+_SELECT_CTRL_NO_OPTS = {
+    "controlId": "cc_status",
+    "controlName": "子状态",
+    "type": 11,
+}
+
+_RELATION_VALUE = [{"sid": "3587620f-f900-4f9c-9803-43827e69ff21"}]
+_RELATION_JSON = json.dumps(_RELATION_VALUE)  # '[{"sid": "..."}]'
+
+
+class TestResolveOptionKeysRejectsRelationShape:
+    def test_rejects_list_of_dicts(self):
+        with pytest.raises(ValueError, match="状态"):
+            rec_mod._resolve_option_keys(_SELECT_CTRL, _RELATION_VALUE)
+
+    def test_rejects_relation_json_string(self):
+        with pytest.raises(ValueError):
+            rec_mod._resolve_option_keys(_SELECT_CTRL, _RELATION_JSON)
+
+    def test_rejects_single_dict(self):
+        with pytest.raises(ValueError):
+            rec_mod._resolve_option_keys(
+                _SELECT_CTRL, {"sid": "3587620f-f900-4f9c-9803-43827e69ff21"})
+
+    def test_rejects_even_without_option_metadata(self):
+        # No options to validate against, but the shape is still wrong.
+        with pytest.raises(ValueError):
+            rec_mod._resolve_option_keys(_SELECT_CTRL_NO_OPTS, _RELATION_VALUE)
+
+    def test_rejects_json_object_string(self):
+        with pytest.raises(ValueError):
+            rec_mod._resolve_option_keys(_SELECT_CTRL, '{"sid": "abc"}')
+
+
+class TestResolveOptionKeysStillAcceptsLegitValues:
+    def test_valid_key(self):
+        assert rec_mod._resolve_option_keys(_SELECT_CTRL, "k_pass") == ["k_pass"]
+
+    def test_label_maps_to_key(self):
+        assert rec_mod._resolve_option_keys(_SELECT_CTRL, "已通过") == ["k_pass"]
+
+    def test_add_new_option_directive_passes_through(self):
+        # `add_<text>` is how the form encodes "create this option on save".
+        assert rec_mod._resolve_option_keys(
+            _SELECT_CTRL, "add_新选项") == ["add_新选项"]
+
+    def test_unknown_plain_text_passes_through(self):
+        # Plain scalar text is not an object shape — left to the server
+        # (may be a key we cannot see, or a new option). Not our bug.
+        assert rec_mod._resolve_option_keys(
+            _SELECT_CTRL_NO_OPTS, "甲") == ["甲"]
+
+    def test_comma_list_of_keys(self):
+        assert rec_mod._resolve_option_keys(
+            _SELECT_CTRL, "k_pass,k_reject") == ["k_pass", "k_reject"]
+
+    def test_empty_is_cleared(self):
+        assert rec_mod._resolve_option_keys(_SELECT_CTRL, "") == []
+        assert rec_mod._resolve_option_keys(_SELECT_CTRL, None) == []
+
+
+class TestSubTableChildSelectRejectsRelationValue:
+    """The reported scenario: a sub-table (34) child single-select gets a
+    relation-shaped value while the parent record is created — the child
+    row is what the backend batch-saves."""
+
+    def test_sublist_child_select_relation_value_is_rejected(self):
+        sublist_ctrl = {
+            "controlId": "c_sub",
+            "controlName": "明细",
+            "type": 34,
+            "relationControls": [_SELECT_CTRL_NO_OPTS],
+        }
+        rows = [{"子状态": _RELATION_VALUE}]
+        with pytest.raises(ValueError):
+            rec_mod._legacy_cell_value(sublist_ctrl, rows)
+
+
+class TestOptionDefinitionRejectsBadShapes:
+    """The other injection point: defining a select field's *options*.
+
+    A select option is only ``{key, value, isDeleted, index, checked,
+    color}`` (evidence: pd-openweb widgetConfig/util/setting.js). Option
+    ``value`` / ``key`` must be plain text — never a relation/object shape
+    — and an option carries no ``type`` field. Before this fix,
+    ``_normalize_options`` passed any value/key straight through and
+    silently dropped unknown keys like ``type``.
+    """
+
+    def test_option_value_object_shape_rejected(self):
+        with pytest.raises(ValueError):
+            wt.build_control("DROP_DOWN", "状态",
+                             options=[{"value": [{"sid": "abc"}]}])
+
+    def test_option_value_relation_json_string_rejected(self):
+        with pytest.raises(ValueError):
+            wt.build_control("DROP_DOWN", "状态",
+                             options=[{"value": _RELATION_JSON}])
+
+    def test_option_key_object_shape_rejected(self):
+        with pytest.raises(ValueError):
+            wt.build_control("DROP_DOWN", "状态",
+                             options=[{"key": [{"sid": "abc"}], "value": "甲"}])
+
+    def test_option_unknown_type_field_rejected(self):
+        with pytest.raises(ValueError, match="type"):
+            wt.build_control("DROP_DOWN", "状态",
+                             options=[{"value": "甲", "type": 0}])
+
+    def test_option_missing_value_rejected(self):
+        with pytest.raises(ValueError):
+            wt.build_control("DROP_DOWN", "状态", options=[{"key": "k1"}])
+
+    # --- legit option definitions still build ---
+
+    def test_string_options_ok(self):
+        out = wt.build_control("DROP_DOWN", "状态", options=["甲", "乙"])
+        assert [o["value"] for o in out["options"]] == ["甲", "乙"]
+
+    def test_dict_option_with_known_fields_ok(self):
+        out = wt.build_control(
+            "DROP_DOWN", "状态",
+            options=[{"value": "甲", "key": "k1", "checked": True}])
+        assert out["options"][0]["key"] == "k1"
+        assert out["options"][0]["value"] == "甲"
+        assert out["options"][0]["checked"] is True
+
+    def test_scored_option_is_allowed_and_preserved(self):
+        # `score` is a legitimate NPS/scoring field — it must not be
+        # rejected (it is not a relation shape) and must survive to the
+        # wire instead of being silently dropped.
+        out = wt.build_control(
+            "DROP_DOWN", "满意度",
+            options=[{"value": "满意", "score": 5}])
+        assert out["options"][0]["value"] == "满意"
+        assert out["options"][0]["score"] == 5

{hap_cli-0.8.17 → hap_cli-0.8.19}/hap_cli.egg-info/PKG-INFO

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