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

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

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

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

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

{hap_cli-0.8.16 → hap_cli-0.8.18}/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.16 → hap_cli-0.8.18}/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
 
 

{hap_cli-0.8.16 → hap_cli-0.8.18}/hap_cli/core/workflow_node_dsl.py

@@ -684,17 +684,24 @@ def get_trigger_ref(session, process_id: str) -> dict[str, str]:
 
 
 # Worksheet-event trigger event codes (triggerId on the flowNodeType-0
-# node). Evidence: workflow-nodes-all-types 新增记录触发 capture (triggerId
-# "1") + pd-openweb trigger config.
+# node). Authoritative values from pd-openweb TRIGGER_ID enum
+# (src/pages/workflow/WorkflowSettings/enum.js) and the trigger radio
+# options in Detail/Start/WorksheetContent.jsx:
+#   ADD='1' (仅新增记录), EDIT='2' (当新增或更新记录), DELETE='3' (删除记录),
+#   ONLY_EDIT='4' (仅更新记录).
+# Note the non-sequential mapping: create_or_update is '2' and delete is
+# '3' — do NOT "tidy" these into 1/2/3/4 order. (Earlier code had
+# create_or_update='3', which the backend interprets as 删除记录 — that was
+# the cause of bug: "创建或更新" workflows showing up as 记录删除时触发.)
 WORKSHEET_TRIGGER_EVENTS = {
-    "create": "1",          # 新增记录
-    "update": "2",          # 修改记录
-    "create_or_update": "3",  # 新增或修改
-    "delete": "4",          # 删除记录
+    "create": "1",            # 仅新增记录 (TRIGGER_ID.ADD)
+    "update": "4",            # 仅更新记录 (TRIGGER_ID.ONLY_EDIT)
+    "create_or_update": "2",  # 当新增或更新记录 (TRIGGER_ID.EDIT)
+    "delete": "3",            # 删除记录 (TRIGGER_ID.DELETE)
     # Design-vocabulary aliases (mcp_workflow_build_tool.json#create_process
     # trigger.config.event uses the backend database values).
     "add": "1",
-    "add_or_update": "3",
+    "add_or_update": "2",
 }
 
 

{hap_cli-0.8.16 → hap_cli-0.8.18}/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.16 → hap_cli-0.8.18}/hap_cli/tests/test_core.py

@@ -8820,10 +8820,13 @@ class TestLiveWireFixes:
 
     def test_worksheet_trigger_event_codes(self):
         from hap_cli.core import workflow_node_dsl as dsl
+        # Authoritative TRIGGER_ID enum: ADD=1, EDIT(create_or_update)=2,
+        # DELETE=3, ONLY_EDIT(update)=4. The mapping is intentionally
+        # non-sequential — see WORKSHEET_TRIGGER_EVENTS comment.
         assert dsl.WORKSHEET_TRIGGER_EVENTS["create"] == "1"
-        assert dsl.WORKSHEET_TRIGGER_EVENTS["update"] == "2"
-        assert dsl.WORKSHEET_TRIGGER_EVENTS["create_or_update"] == "3"
-        assert dsl.WORKSHEET_TRIGGER_EVENTS["delete"] == "4"
+        assert dsl.WORKSHEET_TRIGGER_EVENTS["update"] == "4"
+        assert dsl.WORKSHEET_TRIGGER_EVENTS["create_or_update"] == "2"
+        assert dsl.WORKSHEET_TRIGGER_EVENTS["delete"] == "3"
 
 
 class TestRolePermBuilder:

hap_cli-0.8.18/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.16 → hap_cli-0.8.18}/hap_cli/tests/test_workflow_v3_semantic_cli.py

@@ -452,7 +452,7 @@ class TestTriggerSpecLowering:
         assert args["trigger_fields"] == ["f1"]
         assert args["trigger_filter"] == {"logic": "and", "items": []}
         assert dsl.WORKSHEET_TRIGGER_EVENTS["add"] == "1"
-        assert dsl.WORKSHEET_TRIGGER_EVENTS["add_or_update"] == "3"
+        assert dsl.WORKSHEET_TRIGGER_EVENTS["add_or_update"] == "2"
 
     def test_schedule(self):
         args = dsl.v3_trigger_to_batch_args({

{hap_cli-0.8.16 → hap_cli-0.8.18}/hap_cli.egg-info/PKG-INFO

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

{hap_cli-0.8.16 → hap_cli-0.8.18}/hap_cli.egg-info/SOURCES.txt

@@ -177,6 +177,7 @@ hap_cli/tests/test_parameter_mapping_registry.py
 hap_cli/tests/test_record_batch_v3_semantic_cli.py
 hap_cli/tests/test_record_field_alias.py
 hap_cli/tests/test_record_v3_semantic_cli.py
+hap_cli/tests/test_select_rejects_relation_value.py
 hap_cli/tests/test_semantic_types_registry.py
 hap_cli/tests/test_update.py
 hap_cli/tests/test_v3_api_schema_loader.py