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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hap-cli
-Version: 0.8.19
+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.19 → hap_cli-0.8.20}/hap_cli/__init__.py

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

{hap_cli-0.8.19 → 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
@@ -383,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,
@@ -419,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")
     }
@@ -434,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({
@@ -603,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"),
@@ -662,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.19 → 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.19 → 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_workflow_envelope_errors.py

@@ -0,0 +1,112 @@
+"""A workflow response carrying an ``exception`` must raise, not unwrap.
+
+Reported from a month of building applications end-to-end: workflow node
+saves and publishes come back green while the node does not exist / the
+field value was never written. Two of the reported symptoms ("the node is
+reported saved but isn't there", "save and publish are all green but the
+value is never written") share one cause in the transport, not in the
+node builders.
+
+``Session._post`` special-cased the workflow envelope
+(``{status, data, msg}``) and unwrapped ``data`` unconditionally, on the
+reasoning that ``status`` alone can't tell success from failure. But
+``status`` is not how the frontend decides either: ``mdyAPI``
+(pd-openweb src/common/global.js:846-849) rejects on one condition —
+
+    if (responseData.exception) { ...; reject({...}) }
+
+— for every envelope it handles, workflow included. ``exception`` is the
+failure marker; ``status`` is not consulted at all. So an errored
+workflow response was the one shape the CLI swallowed.
+
+The check is applied before any unwrapping so it covers the workflow
+envelope, an envelope with no ``data`` key, and a main-site response that
+carries an exception without ``state: 0``.
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from hap_cli.core.session import Session, APIError
+
+
+def _mock_response(payload, status_code=200):
+    resp = MagicMock()
+    resp.status_code = status_code
+    resp.json.return_value = payload
+    resp.text = str(payload)
+    return resp
+
+
+@pytest.fixture
+def session():
+    return Session(server_url="https://test.mingdao.com", auth_token="tok123")
+
+
+class TestWorkflowEnvelopeRaises:
+    def test_exception_raises_instead_of_unwrapping(self, session):
+        with patch("requests.post") as post:
+            post.return_value = _mock_response(
+                {"status": 1, "data": None, "exception": "节点不存在"})
+            with pytest.raises(APIError, match="节点不存在"):
+                session.workflow_call("flowNode/saveNode", {"nodeId": "n1"})
+
+    def test_exception_raises_even_with_data_present(self, session):
+        """A failed save can still echo a data payload — the exception wins."""
+        with patch("requests.post") as post:
+            post.return_value = _mock_response(
+                {"status": 1, "data": {"id": "n1"}, "exception": "参数错误"})
+            with pytest.raises(APIError, match="参数错误"):
+                session.workflow_call("flowNode/saveNode", {"nodeId": "n1"})
+
+    def test_envelope_without_data_key_still_raises(self, session):
+        with patch("requests.post") as post:
+            post.return_value = _mock_response(
+                {"status": 0, "exception": "流程已发布"})
+            with pytest.raises(APIError, match="流程已发布"):
+                session.workflow_call("process/publish", {"processId": "p1"})
+
+    def test_success_still_unwraps_data(self, session):
+        with patch("requests.post") as post:
+            post.return_value = _mock_response(
+                {"status": 1, "data": {"nodeId": "n1"}})
+            assert session.workflow_call(
+                "flowNode/saveNode", {"nodeId": "n1"}) == {"nodeId": "n1"}
+
+    def test_empty_exception_is_not_a_failure(self, session):
+        """The server sends exception: null / "" on success — don't raise."""
+        for empty in (None, "", False):
+            with patch("requests.post") as post:
+                post.return_value = _mock_response(
+                    {"status": 1, "data": {"ok": True}, "exception": empty})
+                assert session.workflow_call("flowNode/saveNode", {}) == {
+                    "ok": True}
+
+
+class TestMainSiteEnvelopeUnaffected:
+    def test_exception_without_state_zero_still_raises(self, session):
+        with patch("requests.post") as post:
+            post.return_value = _mock_response(
+                {"state": 1, "data": None, "exception": "服务异常"})
+            with pytest.raises(APIError, match="服务异常"):
+                session.api_call("Worksheet", "AddWorksheetRow", {})
+
+    def test_state_zero_path_unchanged(self, session):
+        with patch("requests.post") as post:
+            post.return_value = _mock_response(
+                {"state": 0, "exception": "无权限", "code": 5})
+            with pytest.raises(APIError, match="无权限"):
+                session.api_call("Worksheet", "GetWorksheetControls", {})
+
+    def test_plain_success_unchanged(self, session):
+        with patch("requests.post") as post:
+            post.return_value = _mock_response(
+                {"state": 1, "data": {"controls": []}})
+            assert session.api_call("Worksheet", "GetWorksheetControls", {}) \
+                == {"controls": []}
+
+    def test_v3_payload_without_envelope_unchanged(self, session):
+        with patch("requests.post") as post:
+            post.return_value = _mock_response({"rows": [{"rowid": "r1"}]})
+            assert session.api_call("X", "Y", {}) == {"rows": [{"rowid": "r1"}]}

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hap-cli
-Version: 0.8.19
+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.19 → hap_cli-0.8.20}/hap_cli.egg-info/SOURCES.txt

@@ -151,6 +151,7 @@ hap_cli/tests/test_bug_036750.py
 hap_cli/tests/test_chart.py
 hap_cli/tests/test_cli_access.py
 hap_cli/tests/test_config_cmd.py
+hap_cli/tests/test_control_lookup_guard.py
 hap_cli/tests/test_core.py
 hap_cli/tests/test_destructive_confirm_cli.py
 hap_cli/tests/test_full_e2e.py
@@ -186,6 +187,7 @@ hap_cli/tests/test_v3_dispatcher.py
 hap_cli/tests/test_v3_registry_coverage.py
 hap_cli/tests/test_v3_session.py
 hap_cli/tests/test_v3_yaml_translation.py
+hap_cli/tests/test_workflow_envelope_errors.py
 hap_cli/tests/test_workflow_list_cli.py
 hap_cli/tests/test_workflow_v3_semantic_cli.py
 hap_cli/tests/test_worksheet_crud_cli.py