@qingflow-tech/qingflow-cli 1.1.43-beta.3 → 1.1.43-beta.5

package/src/qingflow_mcp/app_form_validator.py

@@ -2,12 +2,28 @@ from __future__ import annotations
 
 from copy import deepcopy
 import json
+import re
 from typing import Any, Iterable
 
 from jsonschema import Draft202012Validator, FormatChecker
 
-from .app_form_compat import normalize_app_form_declaration, validate_app_form_create_icon
-from .builder_facade.app_form_schema import AppFormContractError
+from .app_form_compat import normalize_app_form_declaration
+from .builder_facade.app_form_schema import AppFormContractError, compact_schema_errors, schema_error_message
+
+
+_INTEGRATION_OUTPUT_TARGET_FIELD_TYPES = {
+    "text",
+    "long_text",
+    "number",
+    "amount",
+    "date",
+    "datetime",
+    "single_choice",
+    "single_select",
+    "multi_select",
+}
+_Q_LINKER_TEMPLATE_RE = re.compile(r"\{\{(?P<key>[^{}\s]+)\}\}")
+_FORMULA_IDENTIFIER_RE = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
 
 
 class AppFormValidationError(ValueError):
@@ -20,13 +36,17 @@ class AppFormValidationError(ValueError):
         self.api_version = api_version
 
 
+def _field_type(field: dict[str, Any]) -> str:
+    return str(field.get("questionType") or field.get("type") or "").strip()
+
+
 def _field_types(payload: dict[str, Any]) -> tuple[str, ...]:
     found: set[str] = set()
 
     def visit(field: Any) -> None:
         if not isinstance(field, dict):
             return
-        field_type = str(field.get("type") or "").strip()
+        field_type = _field_type(field)
         if field_type:
             found.add(field_type)
         for child in field.get("subfields") or []:
@@ -49,6 +69,18 @@ def _local_schema_call(schema_version: str | None, field_type: str | None) -> di
     return {"status": "success", **app_form_schema_registry().schema(schema_version=schema_version, field_type=field_type)}
 
 
+def _supported_formula_functions(schema_version: str) -> frozenset[str]:
+    """Load the version-pinned formula function catalogue used by local validation."""
+    from .builder_facade.app_form_schema import app_form_schema_registry
+
+    response = app_form_schema_registry().schema(schema_version=schema_version, schema_kind="formula")
+    schema = response.get("schema") if isinstance(response, dict) else None
+    functions = schema.get("x-qingflow-functions") if isinstance(schema, dict) else None
+    if not isinstance(functions, dict) or not functions:
+        raise RuntimeError(f"/: AppForm formula Schema has no function catalogue for {schema_version}")
+    return frozenset(str(name).upper() for name in functions if isinstance(name, str) and name)
+
+
 def _compose(summary: dict[str, Any], details: list[dict[str, Any]]) -> dict[str, Any]:
     if not details:
         raise RuntimeError("at least one field Schema is required to compose AppForm validation")
@@ -77,19 +109,92 @@ def _compose(summary: dict[str, Any], details: list[dict[str, Any]]) -> dict[str
     return schema
 
 
-def _leaf_errors(error: Any) -> Iterable[Any]:
-    if not error.context:
-        yield error
-        return
-    for child in error.context:
-        yield from _leaf_errors(child)
-
-
 def _pointer(parts: Iterable[Any]) -> str:
     encoded = [str(item).replace("~", "~0").replace("/", "~1") for item in parts]
     return "/" + "/".join(encoded) if encoded else "/"
 
 
+def _formula_function_calls(expression: str) -> set[str]:
+    """Extract calls outside quoted string literals without parsing the full formula grammar."""
+    calls: set[str] = set()
+    index = 0
+    while index < len(expression):
+        character = expression[index]
+        if character in {"'", '"'}:
+            quote = character
+            index += 1
+            while index < len(expression):
+                if expression[index] == "\\":
+                    index += 2
+                    continue
+                if expression[index] == quote:
+                    index += 1
+                    break
+                index += 1
+            continue
+        match = _FORMULA_IDENTIFIER_RE.match(expression, index)
+        if match is None:
+            index += 1
+            continue
+        name = match.group(0)
+        cursor = match.end()
+        while cursor < len(expression) and expression[cursor].isspace():
+            cursor += 1
+        if cursor < len(expression) and expression[cursor] in {"(", "（"}:
+            calls.add(name)
+        index = match.end()
+    return calls
+
+
+def _iter_formula_expressions(payload: dict[str, Any]) -> Iterable[tuple[str, str]]:
+    spec = payload.get("spec")
+    body = spec.get("body") if isinstance(spec, dict) else None
+    if not isinstance(body, list):
+        return
+
+    def visit(field: Any, path: str) -> Iterable[tuple[str, str]]:
+        if not isinstance(field, dict):
+            return
+        if field.get("defaultType") == 3 and isinstance(field.get("defaultValue"), str):
+            yield f"{path}/defaultValue", field["defaultValue"]
+        config = field.get("config") if isinstance(field.get("config"), dict) else {}
+        default_value_formula = config.get("defaultValueFormula")
+        if isinstance(default_value_formula, str):
+            yield f"{path}/config/defaultValueFormula", default_value_formula
+        filters = config.get("filters") if isinstance(config.get("filters"), dict) else {}
+        if filters.get("mode") == "advanced" and isinstance(filters.get("formula"), str):
+            yield f"{path}/config/filters/formula", filters["formula"]
+        for child_index, child in enumerate(field.get("subfields") or []):
+            yield from visit(child, f"{path}/subfields/{child_index}")
+
+    for block_index, block in enumerate(body):
+        if not isinstance(block, dict):
+            continue
+        rows = [(block, f"/spec/body/{block_index}")] if block.get("kind") == "row" else [
+            (row, f"/spec/body/{block_index}/rows/{row_index}")
+            for row_index, row in enumerate(block.get("rows") or [])
+        ]
+        for row, row_path in rows:
+            if not isinstance(row, dict):
+                continue
+            for field_index, field in enumerate(row.get("fields") or []):
+                yield from visit(field, f"{row_path}/fields/{field_index}")
+
+
+def _formula_errors(payload: dict[str, Any], supported_functions: frozenset[str]) -> list[tuple[str, str]]:
+    errors: list[tuple[str, str]] = []
+    for pointer, expression in _iter_formula_expressions(payload):
+        unknown = sorted(name for name in _formula_function_calls(expression) if name.upper() not in supported_functions)
+        for name in unknown:
+            errors.append(
+                (
+                    pointer,
+                    f"unsupported formula function '{name}'; use a function declared by builder app-form schema --schema-kind formula",
+                )
+            )
+    return errors
+
+
 def _static_errors(payload: dict[str, Any]) -> list[tuple[str, str]]:
     errors: list[tuple[str, str]] = []
     spec = payload.get("spec")
@@ -116,38 +221,198 @@ def _static_errors(payload: dict[str, Any]) -> list[tuple[str, str]]:
             for field_index, field in enumerate(fields):
                 if isinstance(field, dict):
                     top_fields.append((f"{row_path}/{field_index}", field))
-    if top_fields and sum(field.get("dataTitle") is True for _, field in top_fields) != 1:
-        errors.append(("/spec/body", "a non-empty body must contain exactly one dataTitle field"))
-    covers = [(path, field) for path, field in top_fields if field.get("dataCover") is True]
-    if len(covers) > 1:
-        errors.append(("/spec/body", "body may contain at most one dataCover field"))
-    for path, field in covers:
-        if field.get("type") != "attachment":
-            errors.append((f"{path}/dataCover", "dataCover is only valid on attachment fields"))
+    def resolve_local_selector(selector: Any) -> tuple[str, tuple[str, dict[str, Any]] | None]:
+        """Resolve against the declared body, preserving backend-dependent ID-only cases."""
+        if not isinstance(selector, dict):
+            return "schema", None
+        raw_que_id = selector.get("queId")
+        que_id = raw_que_id if isinstance(raw_que_id, int) and not isinstance(raw_que_id, bool) else None
+        raw_name = selector.get("name")
+        name = raw_name if isinstance(raw_name, str) and raw_name else ""
+        if raw_que_id is not None and que_id is None:
+            return "schema", None
+        if raw_name is not None and not name:
+            return "schema", None
+        if que_id is not None:
+            matches = [(path, field) for path, field in top_fields if field.get("queId") == que_id]
+            if len(matches) != 1:
+                return "invalid", None
+            declared_name = str(matches[0][1].get("name") or "")
+            if name and declared_name and name != declared_name:
+                return "invalid", None
+            return "resolved", matches[0]
+        if name:
+            matches = [(path, field) for path, field in top_fields if str(field.get("name") or "") == name]
+            if len(matches) == 1:
+                return "resolved", matches[0]
+            if len(matches) > 1:
+                return "invalid", None
+            if any(not str(field.get("name") or "") for _, field in top_fields):
+                return "unknown", None
+            return "invalid", None
+        return "schema", None
+
+    title_selector = spec.get("dataTitleField")
+    if top_fields:
+        if "dataTitleField" not in spec and "appKey" in payload:
+            pass
+        elif title_selector is None or resolve_local_selector(title_selector)[0] == "invalid":
+            errors.append(("/spec/dataTitleField", "dataTitleField must resolve to exactly one top-level field"))
+    elif title_selector is not None:
+        errors.append(("/spec/dataTitleField", "dataTitleField must be null when body is empty"))
+
+    cover_selector = spec.get("dataCoverField")
+    if cover_selector is not None:
+        cover_resolution, cover = resolve_local_selector(cover_selector)
+        if cover_resolution == "invalid":
+            errors.append(("/spec/dataCoverField", "dataCoverField must resolve to exactly one top-level field"))
+        elif cover_resolution == "resolved" and cover is not None and _field_type(cover[1]) != "attachment":
+            errors.append(("/spec/dataCoverField", "dataCoverField must select a top-level attachment field"))
     names: dict[str, str] = {}
     fields_by_id = {
         field.get("queId"): field
         for _, field in top_fields
         if isinstance(field.get("queId"), int) and not isinstance(field.get("queId"), bool)
     }
+    output_targets: dict[str, tuple[str, str]] = {}
     for path, field in top_fields:
         name = str(field.get("name") or "")
-        if name in names:
-            errors.append((f"{path}/name", f"duplicate top-level field name; first declared at {names[name]}"))
+        if name:
+            if name in names:
+                errors.append((f"{path}/name", f"duplicate top-level field name; first declared at {names[name]}"))
+            else:
+                names[name] = f"{path}/name"
+        field_type = _field_type(field)
+        if field_type == "data_relation":
+            config = field.get("config") if isinstance(field.get("config"), dict) else {}
+            filters = config.get("filters") if isinstance(config.get("filters"), dict) else {}
+            if filters.get("mode") == "simple":
+                for group_index, group in enumerate(filters.get("groups") or []):
+                    for condition_index, condition in enumerate(group if isinstance(group, list) else []):
+                        if not isinstance(condition, dict):
+                            continue
+                        operator = condition.get("operator")
+                        operand = condition.get("operand") if isinstance(condition.get("operand"), dict) else {}
+                        values = operand.get("values") if isinstance(operand.get("values"), list) else None
+                        operand_path = (
+                            f"{path}/config/filters/groups/{group_index}/{condition_index}/operand"
+                        )
+                        if operator in {"is_empty", "is_not_empty"}:
+                            if operand.get("kind") != "literal" or values != []:
+                                errors.append(
+                                    (
+                                        operand_path,
+                                        "is_empty and is_not_empty require a literal operand with values: []",
+                                    )
+                                )
+                        elif operand.get("kind") == "literal" and not values:
+                            errors.append(
+                                (
+                                    f"{operand_path}/values",
+                                    "literal operands for non-empty operators must contain at least one value",
+                                )
+                            )
+        if field_type == "q_linker":
+            binding_name = "qLinkerBinding"
+        elif field_type == "code_block":
+            binding_name = "codeBlockBinding"
         else:
-            names[name] = f"{path}/name"
-        if field.get("type") != "q_linker":
             continue
-        binding = (field.get("config") or {}).get("qLinkerBinding") if isinstance(field.get("config"), dict) else None
-        for index, item in enumerate((binding or {}).get("inputs") or [] if isinstance(binding, dict) else []):
-            if not isinstance(item, dict) or item.get("source") != "json_path":
+        binding = (field.get("config") or {}).get(binding_name) if isinstance(field.get("config"), dict) else None
+        if not isinstance(binding, dict):
+            continue
+        for index, item in enumerate(binding.get("inputs") or []):
+            if not isinstance(item, dict):
                 continue
             selector = item.get("field") if isinstance(item.get("field"), dict) else {}
-            selected_name = selector.get("name")
+            input_path = f"{path}/config/{binding_name}/inputs/{index}"
+            resolution, selected = resolve_local_selector(selector)
+            if resolution == "invalid":
+                errors.append((f"{input_path}/field", "input field must resolve to exactly one top-level field"))
+                continue
+            if field_type != "q_linker" or item.get("source") != "json_path":
+                continue
+            selected_name = selected[1].get("name") if selected is not None else selector.get("name")
             if not selected_name and selector.get("queId") in fields_by_id:
                 selected_name = fields_by_id[selector["queId"]].get("name")
             if selected_name and item.get("key") != selected_name:
-                errors.append((f"{path}/config/qLinkerBinding/inputs/{index}/key", "json_path key must equal the selected field name"))
+                errors.append((f"{input_path}/key", "json_path key must equal the selected field name"))
+
+        if field_type == "q_linker":
+            request = binding.get("request") if isinstance(binding.get("request"), dict) else {}
+            template_paths: dict[str, list[str]] = {}
+            for property_name in ("url", "jsonValue", "xmlValue"):
+                raw_template = request.get(property_name)
+                if not isinstance(raw_template, str):
+                    continue
+                for match in _Q_LINKER_TEMPLATE_RE.finditer(raw_template):
+                    template_paths.setdefault(match.group("key"), []).append(
+                        f"{path}/config/{binding_name}/request/{property_name}"
+                    )
+            input_items = [item for item in binding.get("inputs") or [] if isinstance(item, dict)]
+            json_path_inputs: dict[str, list[int]] = {}
+            for index, item in enumerate(input_items):
+                key = str(item.get("key") or "")
+                if key and item.get("source") == "json_path":
+                    json_path_inputs.setdefault(key, []).append(index)
+            for key, request_paths in template_paths.items():
+                providers = json_path_inputs.get(key) or []
+                if len(providers) == 1:
+                    continue
+                if not providers:
+                    message = (
+                        f"placeholder '{{{{{key}}}}}' requires an input with source 'json_path' and the same key; "
+                        "query_param, header, and url_encoded inputs do not replace request templates"
+                    )
+                else:
+                    message = f"placeholder '{{{{{key}}}}}' must have exactly one json_path input"
+                errors.append((request_paths[0], message))
+            for key, indexes in json_path_inputs.items():
+                if key in template_paths:
+                    continue
+                for index in indexes:
+                    errors.append(
+                        (
+                            f"{path}/config/{binding_name}/inputs/{index}/source",
+                            f"json_path input key '{key}' must appear as '{{{{{key}}}}}' in request.url, request.jsonValue, or request.xmlValue",
+                        )
+                    )
+
+        producer = name or str(field.get("queId") or field_type)
+        for index, item in enumerate(binding.get("outputs") or []):
+            if not isinstance(item, dict):
+                continue
+            selector = item.get("targetField")
+            target_path = f"{path}/config/{binding_name}/outputs/{index}/targetField"
+            resolution, selected = resolve_local_selector(selector)
+            if resolution == "invalid":
+                errors.append((target_path, "targetField must resolve to exactly one top-level field"))
+                continue
+            if resolution != "resolved" or selected is None:
+                continue
+            selected_path, target_field = selected
+            target_name = str(target_field.get("name") or target_field.get("queId") or "")
+            target_type = _field_type(target_field)
+            if target_type and target_type not in _INTEGRATION_OUTPUT_TARGET_FIELD_TYPES:
+                allowed = ", ".join(sorted(_INTEGRATION_OUTPUT_TARGET_FIELD_TYPES))
+                errors.append(
+                    (
+                        target_path,
+                        f"output target field '{target_name}' uses unsupported questionType '{target_type}'; allowed types: {allowed}",
+                    )
+                )
+            previous = output_targets.get(selected_path)
+            if previous is None:
+                output_targets[selected_path] = (producer, target_path)
+                continue
+            previous_producer, previous_path = previous
+            errors.append(
+                (
+                    target_path,
+                    f"field '{target_name}' is already targeted by output from '{previous_producer}' at {previous_path}; "
+                    "each field can receive output from only one Q-Linker or code block relation",
+                )
+            )
     return errors
 
 
@@ -175,6 +440,7 @@ def validate_declaration(
         ) from error
     if declaration.get("apiVersion") != api_version:
         raise ValueError(f"/apiVersion: expected {api_version!r} for schemaVersion {pinned!r}")
+    supported_formula_functions = _supported_formula_functions(pinned)
     types = _field_types(declaration)
     details = [schema_call(pinned, field_type) for field_type in (types or ("text",))]
     for detail in details:
@@ -184,15 +450,12 @@ def validate_declaration(
     Draft202012Validator.check_schema(schema)
     validator = Draft202012Validator(schema, format_checker=FormatChecker())
     found: dict[tuple[str, str], None] = {}
-    for error in validator.iter_errors(declaration):
-        for leaf in _leaf_errors(error):
-            found[(_pointer(leaf.absolute_path), f"{leaf.validator}: {leaf.message}")] = None
+    for error in compact_schema_errors(validator.iter_errors(declaration), schema):
+        found[(_pointer(error.absolute_path), f"{error.validator}: {schema_error_message(error)}")] = None
     for pointer, message in _static_errors(declaration):
         found[(pointer, message)] = None
-    try:
-        validate_app_form_create_icon(declaration)
-    except AppFormContractError as error:
-        found[(error.path or "/", error.message)] = None
+    for pointer, message in _formula_errors(declaration, supported_formula_functions):
+        found[(pointer, message)] = None
     if found:
         issues = [{"pointer": pointer, "message": message} for pointer, message in sorted(found)]
         raise AppFormValidationError(issues, schema_version=pinned, api_version=api_version)