hap-cli 0.9.1__tar.gz → 0.9.3__tar.gz

{hap_cli-0.9.1 → hap_cli-0.9.3}/PKG-INFO

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

{hap_cli-0.9.1 → hap_cli-0.9.3}/app_live_tests/smoke.py

@@ -226,6 +226,146 @@ def case_custom_action(app_id: str, section_id: str) -> None:
     hap(["worksheet", "delete", ws_id, "-a", app_id, "-y"], check=False)
 
 
+def case_custom_action_update(app_id: str, section_id: str) -> None:
+    """bug #455751: --action-spec with --btn-id edits the action in place."""
+    print("scenario: custom-action update by id")
+    ws_id = _make_worksheet(app_id, section_id, "LT-action-update")
+    try:
+        ok, res = _try(["worksheet", "create-custom-action", ws_id, "-a",
+                        app_id, "--action-spec", json.dumps(
+                            {"name": "ORIGINAL", "type": "triggerWorkflow",
+                             "color": "#2196F3"})])
+        check("update: workflow action created", ok, str(res)[:160])
+        btn_id = res.get("actionId") if ok else ""
+        proc_id = res.get("processId") if ok else ""
+        ok, res = _try(["worksheet", "create-custom-action", ws_id, "-a",
+                        app_id, "--btn-id", btn_id, "--action-spec",
+                        json.dumps({"name": "UPDATED"})])
+        check("update: edit succeeds", ok, str(res)[:160])
+        check("update: the id is unchanged",
+              ok and res.get("actionId") == btn_id, str(res)[:160])
+        check("update: the same workflow is reported",
+              ok and res.get("processId") == proc_id, str(res)[:160])
+        acts = _actions(ws_id)
+        check("update: still one action", len(acts) == 1,
+              str([(a.get("btnId"), a.get("name")) for a in acts]))
+        got = acts[0] if acts else {}
+        check("update: renamed in place",
+              got.get("btnId") == btn_id and got.get("name") == "UPDATED",
+              str((got.get("btnId"), got.get("name"))))
+        check("update: unnamed settings kept",
+              got.get("color") == "#2196F3" and got.get("clickType") == 1,
+              str((got.get("color"), got.get("clickType"))))
+        wf = [r for r in _workflow_rows(app_id)
+              if r.get("id") == proc_id or r.get("processId") == proc_id]
+        check("update: the action's workflow survives", bool(wf),
+              proc_id)
+
+        # A fill action edited by id stays a fill action and keeps its fields.
+        title = next((c["controlId"] for c in _fields(ws_id)
+                      if c.get("attribute") == 1), "")
+        ok, res = _try(["worksheet", "create-custom-action", ws_id, "-a",
+                        app_id, "--action-spec", json.dumps(
+                            {"name": "FILL", "type": "updateCurrentRecord",
+                             "updateFields": [title]})])
+        fill_id = res.get("actionId") if ok else ""
+        ok, res = _try(["worksheet", "create-custom-action", ws_id, "-a",
+                        app_id, "--btn-id", fill_id, "--action-spec",
+                        json.dumps({"name": "FILL2"})])
+        check("update: fill action edit succeeds", ok, str(res)[:160])
+        acts = _actions(ws_id)
+        fill = next((a for a in acts if a.get("btnId") == fill_id), {})
+        check("update: two actions after editing the second", len(acts) == 2,
+              str([(a.get("btnId"), a.get("name")) for a in acts]))
+        check("update: fill action keeps its kind and field",
+              fill.get("name") == "FILL2" and fill.get("clickType") == 3
+              and [w.get("controlId") for w in fill.get("writeControls")
+                   or []] == [title],
+              str((fill.get("name"), fill.get("clickType"),
+                   fill.get("writeControls"))))
+
+        ok, res = _try(["worksheet", "create-custom-action", ws_id, "-a",
+                        app_id, "--btn-id", "000000000000000000000000",
+                        "--action-spec", json.dumps({"name": "GHOST"})])
+        check("update: unknown id is refused", not ok, str(res)[:160])
+        check("update: nothing created for an unknown id",
+              len(_actions(ws_id)) == 2, str(len(_actions(ws_id))))
+    finally:
+        hap(["worksheet", "delete", ws_id, "-a", app_id, "-y"], check=False)
+
+
+def case_hidden_defaults(app_id: str, section_id: str) -> None:
+    """bug #455757: a hidden field's default goes in with a new record.
+
+    The form submits every non-empty cell on create, hidden ones included,
+    so the defaults the CLI fills in must not be judged as the caller
+    writing a hidden field. Writing one yourself is still refused.
+    """
+    print("scenario: hidden defaults on create")
+    ws_id = _make_worksheet(app_id, section_id, "LT-hidden-defaults")
+
+    def static(value):
+        return {"defsource": json.dumps(
+            [{"cid": "", "rcid": "", "staticValue": value}])}
+    try:
+        ok, res = _try(["worksheet", "add-fields", ws_id, "--controls",
+                        json.dumps([
+                            {"type": 2, "controlName": "Stage",
+                             "fieldPermission": "110",
+                             "advancedSetting": static("Draft")},
+                            {"type": 2, "controlName": "Status",
+                             "fieldPermission": "110",
+                             "advancedSetting": static("Open")}])])
+        check("hidden: fields added", ok, str(res)[:160])
+        ids = {c.get("controlName"): c.get("controlId")
+               for c in _fields(ws_id)}
+        name_id = next((c["controlId"] for c in _fields(ws_id)
+                        if c.get("attribute") == 1), "")
+        stage, status = ids.get("Stage"), ids.get("Status")
+
+        ok, res = _try(["worksheet", "record", "create", ws_id, "-a", app_id,
+                        "--fields-json", json.dumps(
+                            [{"id": name_id, "value": "visible-only"}])])
+        check("hidden: create with only the visible field succeeds", ok,
+              str(res)[:200])
+        row_id = ((res.get("data") or {}).get("rowid")
+                  if ok and isinstance(res, dict) else "")
+        got = (hap(["worksheet", "record", "get", ws_id, row_id, "-a",
+                    app_id]) or {}) if row_id else {}
+        got = got.get("data", got) if isinstance(got, dict) else {}
+        check("hidden: the hidden defaults were stored",
+              got.get(stage) == "Draft" and got.get(status) == "Open",
+              str({k: got.get(k) for k in (name_id, stage, status)}))
+
+        ok, res = _try(["worksheet", "record", "create", ws_id, "-a", app_id,
+                        "--fields-json", json.dumps(
+                            [{"id": name_id, "value": "sneaky"},
+                             {"id": stage, "value": "Won"}])])
+        check("hidden: writing a hidden field yourself is refused",
+              not ok and "Stage" in str(res) and "Status" not in str(res),
+              str(res)[:240])
+
+        rows = json.dumps([{name_id: "batch-1"}, {name_id: "batch-2"}])
+        ok, res = _try(["worksheet", "record", "batch-create", ws_id,
+                        "-a", app_id, "--rows", rows])
+        check("hidden: batch create with only visible fields succeeds", ok,
+              str(res)[:200])
+        rows = json.dumps([{name_id: "batch-3"},
+                           {name_id: "batch-4", stage: "Won"}])
+        ok, res = _try(["worksheet", "record", "batch-create", ws_id,
+                        "-a", app_id, "--rows", rows])
+        check("hidden: batch writing a hidden field is refused on its row",
+              not ok and "row 2" in str(res) and "row 1" not in str(res),
+              str(res)[:240])
+        listed = (hap(["worksheet", "record", "list", ws_id, "-a", app_id])
+                  or {}).get("rows") or []
+        blob = json.dumps(listed, ensure_ascii=False)
+        check("hidden: the refused batch wrote nothing",
+              "batch-3" not in blob and "batch-1" in blob, blob[:200])
+    finally:
+        hap(["worksheet", "delete", ws_id, "-a", app_id, "-y"], check=False)
+
+
 def _items(app_id: str) -> dict[str, str]:
     """All sidebar items (worksheets, pages, chatbots) name -> id."""
     detail = hap(["app", "info", "-a", app_id])
@@ -3397,6 +3537,154 @@ def case_fb_subtable_read(app_id: str, section_id: str) -> None:
         hap(["worksheet", "delete", parent, "--yes"], check=False)
 
 
+def case_editor_inline_subtable(app_id: str, section_id: str) -> None:
+    """Bug #455768: edit-spec field ops on an inline sub-table's own sheet."""
+    print("\nscenario: editor field ops on an inline sub-table (#455768)")
+    import json as _json
+    name = "BUG455768-sub-parent"
+    parent = _make_worksheet(app_id, section_id, name)
+    check("inline-subtable: a throwaway parent was created", bool(parent))
+    if not parent:
+        return
+    try:
+        hap(["worksheet", "update-fields", parent, "--title-name", "名称",
+             "--no-verify", "--fields", _json.dumps([
+                 {"type": "TEXT", "name": "名称"},
+                 {"type": "SUB_LIST", "name": "内嵌明细", "child_fields": [
+                     {"type": "TEXT", "name": "行名称"},
+                     {"type": "NUMBER", "name": "行数量"}]},
+             ], ensure_ascii=False)], check=False)
+        child = next((c.get("dataSource") for c in _fields(parent)
+                      if c.get("type") == 34), "")
+        check("inline-subtable: the parent names its child sheet",
+              bool(child), str(child))
+        if not child:
+            return
+
+        def _child_cols() -> list[dict]:
+            got = hap(["worksheet", "fields", child, "--raw",
+                       "--parent", parent], check=False)
+            return [c for c in got if len(c.get("controlId") or "") == 24] \
+                if isinstance(got, list) else []
+
+        rc, out, err = editor_apply({"app": app_id, "ops": [
+            {"type": "field.update", "worksheet": child, "field": "行名称",
+             "set": {"hint": "按id改"}}]})
+        check("inline-subtable: field.update by sheet id applies", rc == 0,
+              (err or out)[-300:])
+        cols = {c["controlName"]: c for c in _child_cols()}
+        check("inline-subtable: the hint reads back",
+              (cols.get("行名称") or {}).get("hint") == "按id改",
+              str(cols.get("行名称"))[:200])
+
+        rc, out, err = editor_apply({"app": app_id, "ops": [
+            {"type": "field.update", "worksheet": f"{name}/内嵌明细",
+             "field": "行数量", "rename": "数量", "set": {}},
+            {"type": "field.add", "worksheet": child,
+             "field": {"name": "行备注", "type": "Text"}},
+            {"type": "field.reorder", "worksheet": child,
+             "order": ["行备注", "数量"]},
+            {"type": "field.delete", "worksheet": child, "field": "行名称",
+             "confirm": True}]})
+        check("inline-subtable: add / reorder / delete apply", rc == 0,
+              (err or out)[-300:])
+        names = [c["controlName"] for c in
+                 sorted(_child_cols(), key=lambda c: c.get("row", 0))]
+        check("inline-subtable: columns read back renamed, added, "
+              "reordered and deleted", names == ["行备注", "数量"],
+              str(names))
+        sub = next((c for c in _fields(parent) if c.get("type") == 34), {})
+        shown = {c["controlId"]: c["controlName"] for c in _child_cols()}
+        check("inline-subtable: the new column is shown in the sub-table",
+              [shown.get(i) for i in sub.get("showControls") or []]
+              == ["行备注", "数量"], str(sub.get("showControls")))
+    finally:
+        hap(["worksheet", "delete", parent, "-a", app_id, "-y"], check=False)
+
+
+def case_create_partial(app_id: str, section_id: str) -> None:
+    """Bug #455775: a failed `worksheet create --fields` leaves nothing."""
+    print("\nscenario: worksheet create --fields failure (#455775)")
+    import json as _json
+    from hap_cli.core import app as app_mod
+    from hap_cli.core.session import Session
+    session = Session.load()
+    project_id = app_mod.app_project_id(session, app_id)
+    prefix = "QA455775"
+    for leftover in [n for n in _worksheets(app_id) if n.startswith(prefix)]:
+        _ensure_absent(app_id, leftover)
+
+    def _ours() -> list[str]:
+        return [n for n in _worksheets(app_id) if n.startswith(prefix)]
+
+    def _purge(ws_id: str) -> None:
+        try:
+            app_mod.purge_app_item(session, app_id=app_id,
+                                   project_id=project_id,
+                                   section_id=section_id, item_id=ws_id,
+                                   item_type=0)
+        except Exception as exc:  # noqa: BLE001 — reported, not fatal
+            print(f"  note: could not purge {ws_id}: {exc}")
+
+    single = {"source": "static", "value": "DEFAULT-QA"}
+    ok, res = _try(["worksheet", "create", app_id, f"{prefix} Invalid",
+                    "--section-id", section_id, "--fields", _json.dumps([
+                        {"type": "Text", "name": "名称"},
+                        {"type": "Text", "name": "备注",
+                         "defaultValue": single}], ensure_ascii=False)])
+    check("create-partial: a single-object default is refused", not ok,
+          str(res)[:200])
+    check("create-partial: the refusal names the field and the shape",
+          "备注" in str(res) and "list of objects" in str(res),
+          str(res)[:300])
+    check("create-partial: nothing was created", _ours() == [], str(_ours()))
+
+    # Passes every offline check, refused by the server at save time:
+    # an alias the worksheet's own record-id column already holds.
+    ok, res = _try(["worksheet", "create", app_id, f"{prefix} PostFail",
+                    "--section-id", section_id, "--fields", _json.dumps([
+                        {"type": "Text", "name": "名称"},
+                        {"type": "Text", "name": "冲突",
+                         "extra": {"alias": "rowid"}}],
+                        ensure_ascii=False)])
+    check("create-partial: a save rejected after the create fails", not ok,
+          str(res)[:200])
+    check("create-partial: the error says the create was undone",
+          "undone" in str(res), str(res)[:300])
+    check("create-partial: no half-built worksheet is left",
+          _ours() == [], str(_ours()))
+
+    ws_id = ""
+    try:
+        made = hap(["worksheet", "create", app_id, f"{prefix} Array",
+                    "--section-id", section_id, "--fields", _json.dumps([
+                        {"type": "Text", "name": "名称"},
+                        {"type": "Text", "name": "备注",
+                         "defaultValue": [single]}], ensure_ascii=False)],
+                   check=False)
+        ws_id = made.get("worksheetId", "") if isinstance(made, dict) else ""
+        check("create-partial: the list form still creates", bool(ws_id),
+              str(made)[:200])
+        if not ws_id:
+            return
+        note = next((c for c in _fields(ws_id)
+                     if c.get("controlName") == "备注"), {})
+        check("create-partial: its default is stored",
+              "DEFAULT-QA" in str((note.get("advancedSetting") or {})
+                                  .get("defsource")), str(note)[:200])
+        ok, res = _try(["worksheet", "update-fields", ws_id, "--fields",
+                        _json.dumps([{"type": "Text", "name": "名称"},
+                                     {"type": "Text", "name": "备注",
+                                      "defaultValue": single}],
+                                    ensure_ascii=False)])
+        check("create-partial: update-fields refuses it clearly too",
+              not ok and "defaultValue" in str(res)
+              and "AttributeError" not in str(res), str(res)[:300])
+    finally:
+        if ws_id:
+            _purge(ws_id)
+
+
 def case_fb_subgroups(app_id: str, section_id: str) -> None:
     """WO-FB 3.1: the editor can see worksheets in second-level groups."""
     print("\nscenario: sub-group visibility (WO-FB 3.1)")
@@ -4546,6 +4834,8 @@ _CASES = {
     "view": case_view,
     "role": case_role,
     "custom-action": case_custom_action,
+    "custom-action-update": case_custom_action_update,
+    "hidden-defaults": case_hidden_defaults,
     "chatbot": case_chatbot,
     "custom-page": case_custom_page,
     "component": case_component,
@@ -4585,6 +4875,8 @@ _CASES = {
     "fb-layout-check": case_fb_layout_check,
     "fb-pair-relation": case_fb_pair_relation,
     "fb-subtable-read": case_fb_subtable_read,
+    "create-partial": case_create_partial,
+    "editor-inline-subtable": case_editor_inline_subtable,
     "fb-subgroups": case_fb_subgroups,
     "fb-button-target": case_fb_button_target,
     "g6-advanced-fields": case_g6_advanced_fields,

{hap_cli-0.9.1 → hap_cli-0.9.3}/hap_cli/__init__.py

@@ -3,7 +3,7 @@
 import sys as _sys
 import types as _types
 
-__version__ = "0.9.1"
+__version__ = "0.9.3"
 
 # The command tree used to live in hap_cli/hap_cli.py. A module named
 # after the package it sits in shadows that package: run python with the

{hap_cli-0.9.1 → hap_cli-0.9.3}/hap_cli/commands/worksheet_cmd.py

@@ -1299,7 +1299,7 @@ def worksheet_save_button(ctx, worksheet_id, btn_config, action_spec,
             eff_app = app_id or getattr(session, "default_app_id", "") or ""
             data = ws_mod.create_custom_action(
                 session, worksheet_id, json.loads(action_spec),
-                app_id=eff_app,
+                app_id=eff_app, btn_id=btn_id,
             )
         else:
             btn_data = json.loads(btn_config)

{hap_cli-0.9.1 → hap_cli-0.9.3}/hap_cli/context.py

@@ -84,6 +84,11 @@ class Context:
         is_auth = isinstance(e, (AuthenticationError, SessionError))
         if self.json_mode:
             payload = {"error": msg, "type": type(e).__name__}
+            # An error may carry state the caller needs to act on, e.g.
+            # the id of a worksheet a failed create left behind.
+            details = getattr(e, "details", None)
+            if isinstance(details, dict):
+                payload.update(details)
             if is_auth:
                 payload["hint"] = NOT_LOGGED_IN_HINT
                 payload["not_logged_in"] = True

{hap_cli-0.9.1 → hap_cli-0.9.3}/hap_cli/core/editor/ops.py

@@ -15,6 +15,8 @@ the plain CLI commands — see ``editspec.RETIRED_OPS``.
 """
 from __future__ import annotations
 
+import json
+import uuid
 from typing import Any, Callable
 
 from hap_cli.core import page as page_mod
@@ -31,6 +33,61 @@ def _ws_field_save(s, ws_id, controls):
     return ws_mod.save_controls(s, ws_id, controls)
 
 
+# ── inline sub-table sheets: written through the parent (bug #455768) ───
+# Such a sheet cannot be saved on its own; the product edits its columns
+# as the parent's sub-table column ``relationControls`` and saves the
+# parent. See ``AppIndex._subtable_map`` for the evidence.
+def _subtable_columns(idx: AppIndex, ws_ref: str):
+    """``(parent_id, parent controls, host column)`` copies, or None.
+
+    The host column and its ``relationControls`` are copied so the
+    mutation never leaks into the index cache.
+    """
+    host = idx.subtable_host(ws_ref)
+    if host is None:
+        return None
+    parent_id, column_id = host
+    controls = [dict(c) for c in idx.controls(parent_id)]
+    column = next((c for c in controls if c.get("controlId") == column_id),
+                  None)
+    if column is None:
+        raise ResolveError(
+            f"the sub-table column hosting worksheet {ws_ref!r} is gone")
+    column["relationControls"] = [dict(r) for r in
+                                  column.get("relationControls") or []]
+    return parent_id, controls, column
+
+
+def _sorts_of(column: dict) -> tuple[dict, list]:
+    adv = column.get("advancedSetting")
+    if isinstance(adv, str):
+        try:
+            adv = json.loads(adv) if adv else {}
+        except ValueError:
+            adv = {}
+    adv = dict(adv or {})
+    try:
+        sorts = json.loads(adv.get("controlssorts") or "[]")
+    except (TypeError, ValueError):
+        sorts = []
+    return adv, sorts if isinstance(sorts, list) else []
+
+
+def _set_display(column: dict, show: list, sorts: list) -> None:
+    """Keep ``showControls`` and ``controlssorts`` in step with the
+    columns — the product updates both on every add/delete/reorder, or
+    the sub-table renders its columns out of order (MDPublic
+    ConfigureControls.jsx ``updateControlsWithSorts``)."""
+    adv, _ = _sorts_of(column)
+    adv["controlssorts"] = json.dumps(sorts)
+    column["advancedSetting"] = adv
+    column["showControls"] = show
+
+
+def _sub_label(ws_ref: str) -> str:
+    return f"'{ws_ref}' (sub-table, saved through its parent)"
+
+
 def _far_worksheet_of(controls: list[dict], bridge_id: str) -> str:
     """The worksheet a bridge column reaches, from its own dataSource."""
     for c in controls:
@@ -144,6 +201,27 @@ def _field_add(op: dict[str, Any], idx: AppIndex) -> list[Action]:
     # place.
     control = lower_field(field)
 
+    sub = _subtable_columns(idx, op["worksheet"])
+    if sub is not None:
+        if control.get("type") == 34:
+            raise ResolveError(
+                f"cannot add sub-table {field.get('name')!r} inside the "
+                f"sub-table {op['worksheet']!r}")
+        parent_id, controls, column = sub
+        control = dict(control)
+        # A dashed placeholder: the server mints the real id and rewrites
+        # it in showControls too (verified live 2026-10-08).
+        control["controlId"] = str(uuid.uuid4())
+        column["relationControls"].append(control)
+        _, sorts = _sorts_of(column)
+        _set_display(column,
+                     list(column.get("showControls") or [])
+                     + [control["controlId"]],
+                     sorts + [control["controlId"]])
+        return [Action(f"add field '{op['field']['name']}' to "
+                       f"{_sub_label(op['worksheet'])}",
+                       lambda s: _ws_field_save(s, parent_id, controls))]
+
     # Mounting an existing worksheet is a two-step handshake — build the
     # SUB_LIST, then wire the child side's back-relation — and
     # `mount_existing_subtable` is the composite that already does both.
@@ -179,11 +257,20 @@ def _match_control(controls: list, ref: str) -> dict:
 
 def _field_update(op: dict[str, Any], idx: AppIndex) -> list[Action]:
     ws_id = idx.worksheet_id(op["worksheet"])
-    controls = [dict(c) for c in idx.controls(op["worksheet"])]
-    target = _match_control(controls, op["field"])
+    sub = _subtable_columns(idx, op["worksheet"])
+    if sub is not None:
+        parent_id, controls, column = sub
+        target = _match_control(column["relationControls"], op["field"])
+    else:
+        controls = [dict(c) for c in idx.controls(op["worksheet"])]
+        target = _match_control(controls, op["field"])
     if op.get("rename"):
         target["controlName"] = op["rename"]
     target.update(op.get("set", {}))
+    if sub is not None:
+        return [Action(f"update field '{op['field']}' on "
+                       f"{_sub_label(op['worksheet'])}",
+                       lambda s: _ws_field_save(s, parent_id, controls))]
     return [Action(f"update field '{op['field']}' on '{op['worksheet']}' "
                    f"(write-back {len(controls)} controls)",
                    lambda s: _ws_field_save(s, ws_id, controls))]
@@ -191,6 +278,21 @@ def _field_update(op: dict[str, Any], idx: AppIndex) -> list[Action]:
 
 def _field_delete(op: dict[str, Any], idx: AppIndex) -> list[Action]:
     ws_id = idx.worksheet_id(op["worksheet"])
+    sub = _subtable_columns(idx, op["worksheet"])
+    if sub is not None:
+        parent_id, controls, column = sub
+        gone = _match_control(column["relationControls"],
+                              op["field"]).get("controlId")
+        column["relationControls"] = [r for r in column["relationControls"]
+                                      if r.get("controlId") != gone]
+        _, sorts = _sorts_of(column)
+        _set_display(column,
+                     [i for i in column.get("showControls") or []
+                      if i != gone],
+                     [i for i in sorts if i != gone])
+        return [Action(f"delete field '{op['field']}' from "
+                       f"{_sub_label(op['worksheet'])}",
+                       lambda s: _ws_field_save(s, parent_id, controls))]
     controls = idx.controls(op["worksheet"])
     target = _match_control(controls, op["field"])
     remaining = [c for c in controls
@@ -202,7 +304,12 @@ def _field_delete(op: dict[str, Any], idx: AppIndex) -> list[Action]:
 
 def _field_reorder(op: dict[str, Any], idx: AppIndex) -> list[Action]:
     ws_id = idx.worksheet_id(op["worksheet"])
-    controls = [dict(c) for c in idx.controls(op["worksheet"])]
+    sub = _subtable_columns(idx, op["worksheet"])
+    if sub is not None:
+        parent_id, parent_controls, column = sub
+        controls = column["relationControls"]
+    else:
+        controls = [dict(c) for c in idx.controls(op["worksheet"])]
     by_ref: dict[str, dict] = {}
     for c in controls:
         for k in (c.get("controlId"), c.get("controlName"), c.get("alias")):
@@ -225,6 +332,15 @@ def _field_reorder(op: dict[str, Any], idx: AppIndex) -> list[Action]:
     for i, c in enumerate(ordered):
         c["row"] = i
         c["col"] = 0
+    if sub is not None:
+        column["relationControls"] = ordered
+        ids = [c.get("controlId") for c in ordered]
+        shown = set(column.get("showControls") or [])
+        _set_display(column, [i for i in ids if i in shown], ids)
+        return [Action(f"reorder {len(op['order'])} field(s) on "
+                       f"{_sub_label(op['worksheet'])}",
+                       lambda s: _ws_field_save(s, parent_id,
+                                                parent_controls))]
     return [Action(f"reorder {len(op['order'])} field(s) on '{op['worksheet']}'",
                    lambda s: _ws_field_save(s, ws_id, ordered))]