@josephyan/qingflow-app-user-mcp 0.2.0-beta.92 → 0.2.0-beta.94

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-app-user-mcp@0.2.0-beta.92
+npm install @josephyan/qingflow-app-user-mcp@0.2.0-beta.94
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-app-user-mcp@0.2.0-beta.92 qingflow-app-user-mcp
+npx -y -p @josephyan/qingflow-app-user-mcp@0.2.0-beta.94 qingflow-app-user-mcp
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-user-mcp",
-  "version": "0.2.0-beta.92",
+  "version": "0.2.0-beta.94",
   "description": "Operational end-user MCP for Qingflow records, tasks, comments, and directory workflows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qingflow-mcp"
-version = "0.2.0b92"
+version = "0.2.0b94"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/__init__.py

@@ -5,7 +5,7 @@ from pathlib import Path
 
 __all__ = ["__version__"]
 
-_FALLBACK_VERSION = "0.2.0b92"
+_FALLBACK_VERSION = "0.2.0b94"
 
 
 def _resolve_local_pyproject_version() -> str | None:

package/src/qingflow_mcp/builder_facade/service.py

@@ -12813,6 +12813,344 @@ def _row_needs_width_reflow(expected_template_lengths: list[int], current_row_le
     return any(length != current_row_length for length in expected_template_lengths)
 
 
+_FORM_SAVE_BASE_KEYS = (
+    "formDesc",
+    "formTheme",
+    "formAttach",
+    "formStyle",
+    "serialNumType",
+    "serialNumConfig",
+    "attachVisibleOnlyConfig",
+    "externalLang",
+    "hideCopyright",
+)
+
+_QUESTION_RELATION_SAVE_KEYS = (
+    "queId",
+    "relationType",
+    "displayedQueId",
+    "qlinkerAlias",
+    "displayedQueInfo",
+    "aliasConfig",
+    "matchRules",
+    "tableMatchRules",
+    "matchRuleType",
+    "matchRuleFormula",
+    "sortConfig",
+)
+
+_RELATION_QUESTION_SAVE_KEYS = (
+    "queId",
+    "queTempId",
+    "queType",
+    "queOriginType",
+    "queTitle",
+    "queWidth",
+    "scanType",
+    "status",
+    "required",
+    "queHint",
+    "linkedQuestions",
+    "logicalShow",
+    "queDefaultType",
+    "queDefaultValue",
+    "queDefaultValues",
+    "subQueWidth",
+    "innerQuestions",
+    "minOpts",
+    "maxOpts",
+    "beingHide",
+    "beingDesensitized",
+    "relationDisplayMode",
+    "customRenderConfig",
+)
+
+_REFERENCE_CONFIG_SAVE_KEYS = (
+    "referAppKey",
+    "referQueId",
+    "customButtonText",
+    "beingTableSource",
+    "referMatchRules",
+    "canAddData",
+    "dataAdditionButtonText",
+    "canViewProcessLog",
+    "optionalDataNum",
+    "beingDataLogVisible",
+    "beingDefaultFormulaAutoFillEnabled",
+    "defaultValueMatchRules",
+    "configShowForm",
+    "configSortFieldId",
+    "configAsc",
+    "dataShowForm",
+    "defaultRow",
+    "fieldNameShow",
+    "dataSortFieldId",
+    "dataSortAsc",
+)
+
+_REFERENCE_QUESTION_SAVE_KEYS = (
+    "queId",
+    "queTitle",
+    "queType",
+    "queAuth",
+    "ordinal",
+)
+
+_REFERENCE_FILL_RULE_SAVE_KEYS = (
+    "queId",
+    "relatedQueId",
+    "queTitle",
+    "relatedQueTitle",
+)
+
+_REFERENCE_AUTH_QUESTION_SAVE_KEYS = (
+    "queId",
+    "queAuth",
+)
+
+
+def _copy_present_keys(
+    source: dict[str, Any],
+    keys: tuple[str, ...],
+    *,
+    keep_none_keys: tuple[str, ...] = (),
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {}
+    keep_none = set(keep_none_keys)
+    for key in keys:
+        if key not in source:
+            continue
+        value = source.get(key)
+        if value is None and key not in keep_none:
+            continue
+        payload[key] = deepcopy(value)
+    return payload
+
+
+def _normalize_reference_question_for_save(value: Any, *, ordinal: int) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    payload = _copy_present_keys(value, _REFERENCE_QUESTION_SAVE_KEYS)
+    que_id = _coerce_any_int(value.get("queId"))
+    if que_id is not None:
+        payload["queId"] = que_id
+    if "ordinal" not in payload:
+        payload["ordinal"] = _coerce_nonnegative_int(value.get("ordinal"))
+    if payload.get("ordinal") is None:
+        payload["ordinal"] = ordinal
+    if not any(key in payload for key in ("queId", "queTitle", "queType")):
+        return None
+    return payload
+
+
+def _normalize_reference_fill_rule_for_save(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    payload = _copy_present_keys(value, _REFERENCE_FILL_RULE_SAVE_KEYS)
+    que_id = _coerce_nonnegative_int(value.get("queId"))
+    related_que_id = _coerce_nonnegative_int(value.get("relatedQueId", value.get("referQueId")))
+    if que_id is not None:
+        payload["queId"] = que_id
+    if related_que_id is not None:
+        payload["relatedQueId"] = related_que_id
+    if "relatedQueTitle" not in payload and value.get("referQueTitle") is not None:
+        payload["relatedQueTitle"] = str(value.get("referQueTitle") or "")
+    if "queId" not in payload or "relatedQueId" not in payload:
+        return None
+    return payload
+
+
+def _normalize_reference_auth_question_for_save(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    payload = _copy_present_keys(value, _REFERENCE_AUTH_QUESTION_SAVE_KEYS)
+    que_id = _coerce_any_int(value.get("queId"))
+    if que_id is not None:
+        payload["queId"] = que_id
+    que_auth = _coerce_nonnegative_int(value.get("queAuth"))
+    if que_auth is not None:
+        payload["queAuth"] = que_auth
+    sub_ques = [
+        item
+        for item in (
+            _normalize_reference_auth_question_for_save(raw_item)
+            for raw_item in cast(list[Any], value.get("subQues") or [])
+        )
+        if item is not None
+    ]
+    inner_ques = [
+        item
+        for item in (
+            _normalize_reference_auth_question_for_save(raw_item)
+            for raw_item in cast(list[Any], value.get("innerQues") or [])
+        )
+        if item is not None
+    ]
+    if sub_ques or "subQues" in value:
+        payload["subQues"] = sub_ques
+    if inner_ques or "innerQues" in value:
+        payload["innerQues"] = inner_ques
+    if "queId" not in payload or "queAuth" not in payload:
+        return None
+    return payload
+
+
+def _normalize_reference_config_for_save(
+    reference: Any,
+    *,
+    field: dict[str, Any],
+) -> dict[str, Any]:
+    source = reference if isinstance(reference, dict) else {}
+    payload = _copy_present_keys(source, _REFERENCE_CONFIG_SAVE_KEYS)
+    if str(field.get("target_app_key") or "").strip():
+        payload["referAppKey"] = str(field.get("target_app_key") or "").strip()
+    if field.get("target_field_que_id") is not None:
+        payload["referQueId"] = _coerce_nonnegative_int(field.get("target_field_que_id"))
+    if field.get("field_name_show") is not None:
+        payload["fieldNameShow"] = bool(field.get("field_name_show"))
+
+    refer_questions: list[dict[str, Any]] = []
+    for index, raw_item in enumerate(cast(list[Any], source.get("referQuestions") or []), start=1):
+        normalized_item = _normalize_reference_question_for_save(raw_item, ordinal=index)
+        if normalized_item is not None:
+            refer_questions.append(normalized_item)
+    if refer_questions or "referQuestions" in source:
+        payload["referQuestions"] = refer_questions
+
+    refer_fill_rules = [
+        item
+        for item in (
+            _normalize_reference_fill_rule_for_save(raw_item)
+            for raw_item in cast(list[Any], source.get("referFillRules") or [])
+        )
+        if item is not None
+    ]
+    if refer_fill_rules or "referFillRules" in source:
+        payload["referFillRules"] = refer_fill_rules
+
+    refer_auth_ques = [
+        item
+        for item in (
+            _normalize_reference_auth_question_for_save(raw_item)
+            for raw_item in cast(list[Any], source.get("referAuthQues") or [])
+        )
+        if item is not None
+    ]
+    if refer_auth_ques or "referAuthQues" in source:
+        payload["referAuthQues"] = refer_auth_ques
+
+    return payload
+
+
+def _normalize_relation_question_for_save(question: dict[str, Any], *, field: dict[str, Any]) -> dict[str, Any]:
+    payload = _copy_present_keys(question, _RELATION_QUESTION_SAVE_KEYS)
+    overlay_keys = _field_question_overlay_keys(field)
+    que_id = _coerce_nonnegative_int(question.get("queId"))
+    if que_id is not None:
+        payload["queId"] = que_id
+    que_temp_id = _coerce_nonnegative_int(question.get("queTempId"))
+    if que_temp_id is not None and "queId" not in payload:
+        payload["queTempId"] = que_temp_id
+    payload["queType"] = _coerce_positive_int(question.get("queType")) or 25
+    payload["queTitle"] = str(field.get("name") or question.get("queTitle") or "")
+    if "required" in overlay_keys or "required" in question or field.get("required") is not None:
+        payload["required"] = bool(field.get("required", question.get("required", False)))
+    if "description" in overlay_keys:
+        payload["queHint"] = "" if field.get("description") is None else str(field.get("description"))
+    elif "queHint" in question and question.get("queHint") is not None:
+        payload["queHint"] = str(question.get("queHint") or "")
+    if field.get("default_type") is not None:
+        payload["queDefaultType"] = _coerce_positive_int(field.get("default_type")) or 1
+    if "default_value" in field:
+        payload["queDefaultValue"] = field.get("default_value")
+    payload["referenceConfig"] = _normalize_reference_config_for_save(question.get("referenceConfig"), field=field)
+    return payload
+
+
+def _build_form_save_base_payload(current_schema: dict[str, Any], title: str) -> dict[str, Any]:
+    payload: dict[str, Any] = {"formTitle": title}
+    for key in _FORM_SAVE_BASE_KEYS:
+        if key in current_schema:
+            payload[key] = deepcopy(current_schema.get(key))
+    payload["editVersionNo"] = int(current_schema.get("editVersionNo") or 1)
+    payload["formQues"] = []
+    payload["questionRelations"] = []
+    return payload
+
+
+def _normalize_question_relations_for_save(question_relations: list[dict[str, Any]] | None) -> list[dict[str, Any]]:
+    normalized: list[dict[str, Any]] = []
+    for relation in question_relations or []:
+        if not isinstance(relation, dict):
+            continue
+        item: dict[str, Any] = {}
+        for key in _QUESTION_RELATION_SAVE_KEYS:
+            if key not in relation:
+                continue
+            value = relation.get(key)
+            if value is None:
+                continue
+            item[key] = deepcopy(value)
+        if item:
+            normalized.append(item)
+    return normalized
+
+
+def _field_rename_maps(fields: list[dict[str, Any]]) -> tuple[dict[int, str], dict[str, str]]:
+    by_que_id: dict[int, str] = {}
+    by_title: dict[str, str] = {}
+    for field in fields:
+        if not isinstance(field, dict):
+            continue
+        template = field.get("_question_template")
+        if not isinstance(template, dict):
+            continue
+        old_title = str(template.get("queTitle") or "").strip()
+        new_title = str(field.get("name") or "").strip()
+        if not old_title or not new_title or old_title == new_title:
+            continue
+        que_id = _coerce_nonnegative_int(field.get("que_id"))
+        if que_id is None:
+            que_id = _coerce_nonnegative_int(template.get("queId"))
+        if que_id is not None:
+            by_que_id[que_id] = new_title
+        by_title[old_title] = new_title
+    return by_que_id, by_title
+
+
+def _sync_question_title_references(value: Any, *, by_que_id: dict[int, str], by_title: dict[str, str]) -> None:
+    if isinstance(value, list):
+        for item in value:
+            _sync_question_title_references(item, by_que_id=by_que_id, by_title=by_title)
+        return
+    if not isinstance(value, dict):
+        return
+
+    title_keys = ("queTitle", "_field_id")
+    que_id = _coerce_nonnegative_int(value.get("queId"))
+    replacement = None
+    if que_id is not None and que_id in by_que_id:
+        replacement = by_que_id[que_id]
+    elif que_id is None:
+        for key in title_keys:
+            current_title = str(value.get(key) or "").strip()
+            if current_title and current_title in by_title:
+                replacement = by_title[current_title]
+                break
+    if replacement is not None:
+        for key in title_keys:
+            current_title = str(value.get(key) or "").strip()
+            if (que_id is not None and que_id in by_que_id and key in value) or (current_title and current_title in by_title):
+                value[key] = replacement
+    sup_id = _coerce_nonnegative_int(value.get("supId"))
+    if sup_id is not None and sup_id in by_que_id and "supQueTitle" in value:
+        value["supQueTitle"] = by_que_id[sup_id]
+
+    for child_value in value.values():
+        if isinstance(child_value, (dict, list)):
+            _sync_question_title_references(child_value, by_que_id=by_que_id, by_title=by_title)
+
+
 def _materialize_preserved_question(field: dict[str, Any]) -> dict[str, Any] | None:
     template = deepcopy(field.get("_question_template"))
     if not isinstance(template, dict):
@@ -12825,6 +13163,8 @@ def _materialize_preserved_question(field: dict[str, Any]) -> dict[str, Any] | N
     if "description" in overlay_keys:
         description = field.get("description")
         template["queHint"] = "" if description is None else str(description)
+    if str(field.get("type") or "") == FieldType.relation.value:
+        return _normalize_relation_question_for_save(template, field=field)
     return template
 
 
@@ -12932,6 +13272,7 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
             if field.get("target_field_que_id") is not None:
                 reference["referQueId"] = field.get("target_field_que_id")
             question["referenceConfig"] = reference
+        question = _normalize_relation_question_for_save(question, field=field)
     if field.get("type") == FieldType.department.value:
         scope_type, scope_payload = _serialize_department_scope_for_question(field.get("department_scope"))
         question["deptSelectScopeType"] = scope_type
@@ -13072,7 +13413,9 @@ def _build_form_payload_from_fields(
         _apply_row_widths(row)
     payload = default_form_payload(title, form_rows)
     payload["editVersionNo"] = int(current_schema.get("editVersionNo") or 1)
-    payload["questionRelations"] = deepcopy(question_relations if question_relations is not None else (current_schema.get("questionRelations") or []))
+    payload["questionRelations"] = _normalize_question_relations_for_save(
+        question_relations if question_relations is not None else (current_schema.get("questionRelations") or [])
+    )
     return payload
 
 
@@ -13175,10 +13518,18 @@ def _build_form_payload_for_edit_fields(
         wrapper["innerQuestions"] = inner_rows
         form_rows.append([wrapper])
 
-    payload = deepcopy(current_schema)
-    payload["formTitle"] = title
+    rename_by_que_id, rename_by_title = _field_rename_maps(fields)
+    if rename_by_que_id or rename_by_title:
+        _sync_question_title_references(form_rows, by_que_id=rename_by_que_id, by_title=rename_by_title)
+    normalized_relations = _normalize_question_relations_for_save(
+        question_relations if question_relations is not None else (current_schema.get("questionRelations") or [])
+    )
+    if rename_by_que_id or rename_by_title:
+        _sync_question_title_references(normalized_relations, by_que_id=rename_by_que_id, by_title=rename_by_title)
+
+    payload = _build_form_save_base_payload(current_schema, title)
     payload["formQues"] = form_rows
-    payload["questionRelations"] = deepcopy(question_relations if question_relations is not None else (current_schema.get("questionRelations") or []))
+    payload["questionRelations"] = normalized_relations
     payload["editVersionNo"] = int(current_schema.get("editVersionNo") or 1)
     return payload
 
@@ -14592,9 +14943,9 @@ def _build_form_payload_from_existing_schema(
         wrapper["queWidth"] = 100
         form_rows.append([wrapper])
 
-    payload = deepcopy(current_schema)
+    payload = _build_form_save_base_payload(current_schema, str(current_schema.get("formTitle") or "未命名应用"))
     payload["formQues"] = form_rows
-    payload["questionRelations"] = deepcopy(current_schema.get("questionRelations") or [])
+    payload["questionRelations"] = _normalize_question_relations_for_save(current_schema.get("questionRelations") or [])
     payload["editVersionNo"] = int(current_schema.get("editVersionNo") or 1)
     payload.setdefault("formTitle", current_schema.get("formTitle") or "未命名应用")
     return payload