@josephyan/qingflow-cli 1.1.4 → 1.1.5

package/src/qingflow_mcp/builder_facade/models.py

@@ -71,17 +71,36 @@ class PublicExternalVisibilityMode(str, Enum):
 
 
 FIELD_TYPE_ALIASES: dict[str, PublicFieldType] = {
+    "multiline": PublicFieldType.long_text,
+    "multiline_text": PublicFieldType.long_text,
+    "multi_line": PublicFieldType.long_text,
+    "multi_line_text": PublicFieldType.long_text,
     "textarea": PublicFieldType.long_text,
+    "longtext": PublicFieldType.long_text,
+    "long-text": PublicFieldType.long_text,
     "amount": PublicFieldType.amount,
     "currency": PublicFieldType.amount,
     "mobile": PublicFieldType.phone,
     "user": PublicFieldType.member,
     "users": PublicFieldType.member,
     "select": PublicFieldType.single_select,
+    "single_choice": PublicFieldType.single_select,
+    "single-choice": PublicFieldType.single_select,
+    "single choice": PublicFieldType.single_select,
+    "choice": PublicFieldType.single_select,
+    "dropdown": PublicFieldType.single_select,
     "radio": PublicFieldType.single_select,
     "checkbox": PublicFieldType.multi_select,
     "multi_select": PublicFieldType.multi_select,
     "multi-select": PublicFieldType.multi_select,
+    "multi select": PublicFieldType.multi_select,
+    "multiselect": PublicFieldType.multi_select,
+    "multi_choice": PublicFieldType.multi_select,
+    "multi-choice": PublicFieldType.multi_select,
+    "multi choice": PublicFieldType.multi_select,
+    "multiple_choice": PublicFieldType.multi_select,
+    "multiple-choice": PublicFieldType.multi_select,
+    "multiple choice": PublicFieldType.multi_select,
     "departments": PublicFieldType.department,
     "qlinker": PublicFieldType.q_linker,
     "q_linker": PublicFieldType.q_linker,
@@ -184,6 +203,10 @@ class LayoutPreset(str, Enum):
     single_section = "single_section"
 
 
+class FlowPreset(str, Enum):
+    basic_approval = "basic_approval"
+    basic_fill_then_approve = "basic_fill_then_approve"
+
 
 class ViewsPreset(str, Enum):
     default_table = "default_table"
@@ -1256,11 +1279,30 @@ class CustomButtonFieldMappingPatch(StrictModel):
 
 
 class FieldMatchMappingPatch(StrictModel):
-    target_field: Any = Field(validation_alias=AliasChoices("target_field", "targetField", "target", "field"))
+    target_field: Any = Field(
+        validation_alias=AliasChoices("target_field", "targetField", "target", "field", "field_name", "fieldName")
+    )
     source_field: Any | None = Field(default=None, validation_alias=AliasChoices("source_field", "sourceField", "source"))
     value: Any | None = Field(default=None, validation_alias=AliasChoices("value", "static_value", "staticValue"))
     operator: str = Field(default="eq", validation_alias=AliasChoices("operator", "op", "judge_type", "judgeType"))
 
+    @model_validator(mode="before")
+    @classmethod
+    def normalize_semantic_aliases(cls, value: Any) -> Any:
+        if not isinstance(value, dict):
+            return value
+        payload = dict(value)
+        has_static_value = any(key in payload for key in ("value", "static_value", "staticValue"))
+        if "values" in payload:
+            values = payload.pop("values")
+            if has_static_value:
+                return payload
+            if isinstance(values, list) and len(values) == 1:
+                payload["value"] = values[0]
+            else:
+                payload["value"] = values
+        return payload
+
     @model_validator(mode="after")
     def validate_shape(self) -> "FieldMatchMappingPatch":
         has_source = self.source_field is not None and str(self.source_field).strip() != ""
@@ -1607,6 +1649,7 @@ class AssociatedResourcesApplyRequest(StrictModel):
         if not isinstance(value, dict):
             return value
         payload = dict(value)
+        default_target_app_key = str(payload.get("app_key", payload.get("appKey", "")) or "").strip()
         if "upsertResources" in payload and "upsert_resources" not in payload:
             payload["upsert_resources"] = payload.pop("upsertResources")
         if "patchResources" in payload and "patch_resources" not in payload:
@@ -1619,6 +1662,16 @@ class AssociatedResourcesApplyRequest(StrictModel):
             payload["reorder_associated_item_ids"] = payload.pop("reorderAssociatedItemIds")
         if "viewConfigs" in payload and "view_configs" not in payload:
             payload["view_configs"] = payload.pop("viewConfigs")
+        if default_target_app_key and isinstance(payload.get("upsert_resources"), list):
+            normalized_resources = []
+            for item in payload["upsert_resources"]:
+                if isinstance(item, dict) and not any(
+                    str(item.get(key) or "").strip()
+                    for key in ("target_app_key", "targetAppKey", "app_key", "appKey")
+                ):
+                    item = {**item, "target_app_key": default_target_app_key}
+                normalized_resources.append(item)
+            payload["upsert_resources"] = normalized_resources
         return payload
 
     @model_validator(mode="after")
@@ -1763,68 +1816,63 @@ class ChartFilterRulePatch(StrictModel):
         return self
 
 
-_CHART_METRIC_RE = re.compile(r"^\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\((.*)\)\s*$")
-
-
-def _normalize_chart_string_list(value: Any) -> list[str]:
-    if value is None:
-        return []
-    if isinstance(value, (list, tuple)):
-        return [str(item).strip() for item in value if item is not None and str(item).strip()]
-    raw = str(value).strip()
-    return [raw] if raw else []
+class ChartMetricPatch(StrictModel):
+    op: str = "count"
+    field_name: str | None = Field(default=None, validation_alias=AliasChoices("field", "field_name", "fieldName", "name"))
+    alias: str | None = None
 
+    @model_validator(mode="before")
+    @classmethod
+    def normalize_metric(cls, value: Any) -> Any:
+        if isinstance(value, str):
+            raw = value.strip()
+            match = re.fullmatch(r"([A-Za-z_][A-Za-z0-9_]*)\s*\(\s*(.*?)\s*\)", raw)
+            if match:
+                op = match.group(1).strip().lower()
+                field = match.group(2).strip()
+                payload: dict[str, Any] = {"op": op}
+                if field and field != "*":
+                    payload["field_name"] = field
+                return payload
+            if raw:
+                return {"op": "sum", "field_name": raw}
+            return {"op": "count"}
+        if not isinstance(value, dict):
+            return value
+        payload = dict(value)
+        if "operation" in payload and "op" not in payload:
+            payload["op"] = payload.pop("operation")
+        if "agg" in payload and "op" not in payload:
+            payload["op"] = payload.pop("agg")
+        if "aggregate" in payload and "op" not in payload:
+            payload["op"] = payload.pop("aggregate")
+        if "aggregation" in payload and "op" not in payload:
+            payload["op"] = payload.pop("aggregation")
+        return payload
 
-def _parse_chart_metric_item(value: Any) -> tuple[list[str], str | None]:
-    if value is None:
-        return [], None
-    if isinstance(value, dict):
-        op = str(value.get("op") or value.get("agg") or value.get("aggregate") or value.get("aggregation") or "").strip().lower()
-        field = value.get("field", value.get("field_name", value.get("name", value.get("selector"))))
-        selectors = _normalize_chart_string_list(field)
-        return selectors, op or ("count" if not selectors else None)
-    raw = str(value).strip()
-    if not raw:
-        return [], None
-    matched = _CHART_METRIC_RE.match(raw)
-    if matched:
-        op = matched.group(1).strip().lower()
-        field = matched.group(2).strip()
-        if field in {"*", ""}:
-            return [], op
-        return [field], op
-    if raw.lower() in {"count", "count(*)"}:
-        return [], "count"
-    return [raw], None
-
-
-def _apply_semantic_chart_metric_aliases(payload: dict[str, Any]) -> None:
-    raw_metrics: list[Any] = []
-    if "metric" in payload:
-        raw_metrics.append(payload.pop("metric"))
-    if "metrics" in payload:
-        metrics = payload.pop("metrics")
-        raw_metrics.extend(metrics if isinstance(metrics, list) else [metrics])
-    if not raw_metrics:
-        return
-    selectors: list[str] = []
-    aggregates: list[str] = []
-    for metric in raw_metrics:
-        metric_selectors, aggregate = _parse_chart_metric_item(metric)
-        selectors.extend(metric_selectors)
-        if aggregate:
-            aggregates.append(aggregate)
-    if selectors and "indicator_field_ids" not in payload:
-        payload["indicator_field_ids"] = selectors
-    if aggregates:
-        normalized_aggregate = aggregates[0]
-        config = payload.get("config")
-        if not isinstance(config, dict):
-            config = {}
-        else:
-            config = dict(config)
-        config.setdefault("aggregate", normalized_aggregate)
-        payload["config"] = config
+    @model_validator(mode="after")
+    def validate_metric(self) -> "ChartMetricPatch":
+        normalized_op = str(self.op or "count").strip().lower()
+        op_aliases = {
+            "average": "avg",
+            "mean": "avg",
+            "total": "sum",
+            "cnt": "count",
+            "count_all": "count",
+        }
+        self.op = op_aliases.get(normalized_op, normalized_op)
+        if self.field_name is not None:
+            field_name = str(self.field_name).strip()
+            self.field_name = field_name or None
+        if self.alias is not None:
+            alias = str(self.alias).strip()
+            self.alias = alias or None
+        supported = {"count", "sum", "avg", "max", "min"}
+        if self.op not in supported:
+            raise ValueError(f"chart metric op must be one of {sorted(supported)}")
+        if self.op != "count" and not self.field_name:
+            raise ValueError(f"chart metric op '{self.op}' requires field")
+        return self
 
 
 class ChartUpsertPatch(StrictModel):
@@ -1834,6 +1882,17 @@ class ChartUpsertPatch(StrictModel):
     dimension_field_ids: list[str] = Field(default_factory=list)
     indicator_field_ids: list[str] = Field(default_factory=list)
     filters: list[ChartFilterRulePatch] = Field(default_factory=list)
+    group_by: list[str] = Field(default_factory=list)
+    rows: list[str] = Field(default_factory=list)
+    columns: list[str] = Field(default_factory=list)
+    metric: ChartMetricPatch | None = None
+    metrics: list[ChartMetricPatch] = Field(default_factory=list)
+    x_metric: ChartMetricPatch | None = None
+    y_metric: ChartMetricPatch | None = None
+    left_metric: ChartMetricPatch | None = None
+    right_metric: ChartMetricPatch | None = None
+    value_metric: ChartMetricPatch | None = None
+    target_metric: ChartMetricPatch | None = None
     question_config: list[dict[str, Any]] = Field(default_factory=list)
     user_config: list[dict[str, Any]] = Field(default_factory=list)
     config: dict[str, Any] = Field(default_factory=dict)
@@ -1851,19 +1910,74 @@ class ChartUpsertPatch(StrictModel):
             payload["chart_type"] = payload.pop("type")
         if "dimension_fields" in payload and "dimension_field_ids" not in payload:
             payload["dimension_field_ids"] = payload.pop("dimension_fields")
+        if "dimensions" in payload and "dimension_field_ids" not in payload and "group_by" not in payload:
+            payload["group_by"] = payload.pop("dimensions")
+        if "groupBy" in payload and "group_by" not in payload:
+            payload["group_by"] = payload.pop("groupBy")
+        if "where" in payload and "filters" not in payload:
+            payload["filters"] = payload.pop("where")
+        if "filter_rules" in payload and "filters" not in payload:
+            payload["filters"] = payload.pop("filter_rules")
+        if "filterRules" in payload and "filters" not in payload:
+            payload["filters"] = payload.pop("filterRules")
         if "indicator_fields" in payload and "indicator_field_ids" not in payload:
             payload["indicator_field_ids"] = payload.pop("indicator_fields")
         if "metric_field_ids" in payload and "indicator_field_ids" not in payload:
             payload["indicator_field_ids"] = payload.pop("metric_field_ids")
-        if "group_by" in payload and "dimension_field_ids" not in payload:
-            payload["dimension_field_ids"] = _normalize_chart_string_list(payload.pop("group_by"))
-        if "groupBy" in payload and "dimension_field_ids" not in payload:
-            payload["dimension_field_ids"] = _normalize_chart_string_list(payload.pop("groupBy"))
-        if "where" in payload and "filters" not in payload:
-            payload["filters"] = payload.pop("where")
-        else:
-            payload.pop("where", None)
-        _apply_semantic_chart_metric_aliases(payload)
+        metric_slots: list[Any] = []
+        generic_metric_keys = ("metric", "metrics")
+        axis_metric_keys = (
+            "x_metric",
+            "xMetric",
+            "y_metric",
+            "yMetric",
+            "left_metric",
+            "leftMetric",
+            "right_metric",
+            "rightMetric",
+            "value_metric",
+            "valueMetric",
+            "target_metric",
+            "targetMetric",
+        )
+
+        def has_metric_value(key: str) -> bool:
+            entry = payload.get(key)
+            return entry is not None and entry != "" and entry != []
+
+        if any(has_metric_value(key) for key in generic_metric_keys) and any(has_metric_value(key) for key in axis_metric_keys):
+            raise ValueError(
+                "chart metric input is ambiguous: use either metric/metrics or axis-specific "
+                "x_metric/y_metric, left_metric/right_metric, value_metric/target_metric, not both"
+            )
+        if "metric" in payload and "metrics" not in payload:
+            payload["metrics"] = [payload["metric"]]
+        for key in ("x_metric", "xMetric", "left_metric", "leftMetric", "value_metric", "valueMetric"):
+            if key in payload:
+                slot_value = payload.get(key)
+                if slot_value is not None:
+                    metric_slots.append(slot_value)
+                canonical = {
+                    "xMetric": "x_metric",
+                    "leftMetric": "left_metric",
+                    "valueMetric": "value_metric",
+                }.get(key)
+                if canonical and canonical not in payload:
+                    payload[canonical] = payload.pop(key)
+        for key in ("y_metric", "yMetric", "right_metric", "rightMetric", "target_metric", "targetMetric"):
+            if key in payload:
+                slot_value = payload.get(key)
+                if slot_value is not None:
+                    metric_slots.append(slot_value)
+                canonical = {
+                    "yMetric": "y_metric",
+                    "rightMetric": "right_metric",
+                    "targetMetric": "target_metric",
+                }.get(key)
+                if canonical and canonical not in payload:
+                    payload[canonical] = payload.pop(key)
+        if metric_slots and "metrics" not in payload:
+            payload["metrics"] = metric_slots
         raw_type = payload.get("chart_type")
         if isinstance(raw_type, str):
             normalized = raw_type.strip().lower()
@@ -1890,8 +2004,31 @@ class ChartUpsertPatch(StrictModel):
             payload["dimension_field_ids"] = [str(item) for item in payload["dimension_field_ids"] if item is not None and str(item).strip()]
         if isinstance(payload.get("indicator_field_ids"), list):
             payload["indicator_field_ids"] = [str(item) for item in payload["indicator_field_ids"] if item is not None and str(item).strip()]
+        for key in ("group_by", "rows", "columns"):
+            if isinstance(payload.get(key), str):
+                payload[key] = [payload[key]]
+            if isinstance(payload.get(key), list):
+                payload[key] = [str(item) for item in payload[key] if item is not None and str(item).strip()]
         return payload
 
+    @model_validator(mode="after")
+    def apply_semantic_chart_fields(self) -> "ChartUpsertPatch":
+        if self.group_by and not self.dimension_field_ids:
+            self.dimension_field_ids = list(self.group_by)
+        if self.rows and not self.dimension_field_ids:
+            self.dimension_field_ids = list(self.rows)
+        semantic_metrics: list[ChartMetricPatch] = []
+        if self.metrics:
+            semantic_metrics.extend(self.metrics)
+        for metric in (self.x_metric, self.y_metric, self.left_metric, self.right_metric, self.value_metric, self.target_metric):
+            if metric is not None and metric not in semantic_metrics:
+                semantic_metrics.append(metric)
+        if semantic_metrics and not self.metrics:
+            self.metrics = semantic_metrics
+        if self.metrics and not self.metric:
+            self.metric = self.metrics[0]
+        return self
+
 
 class ChartPartialPatch(StrictModel):
     chart_id: str | None = None
@@ -2000,35 +2137,14 @@ class PortalComponentPositionPatch(StrictModel):
 
 
 class PortalChartRefPatch(StrictModel):
-    app_key: str | None = None
+    app_key: str
     chart_id: str | None = None
-    chart_key: str | None = None
     chart_name: str | None = None
 
-    @model_validator(mode="before")
-    @classmethod
-    def normalize_aliases(cls, value: Any) -> Any:
-        if not isinstance(value, dict):
-            return value
-        payload = dict(value)
-        if "chartKey" in payload and "chart_key" not in payload:
-            payload["chart_key"] = payload.pop("chartKey")
-        if "chartId" in payload and "chart_id" not in payload:
-            payload["chart_id"] = payload.pop("chartId")
-        if "biChartId" in payload and "chart_id" not in payload:
-            payload["chart_id"] = payload.pop("biChartId")
-        if "chartName" in payload and "chart_name" not in payload:
-            payload["chart_name"] = payload.pop("chartName")
-        if "appKey" in payload and "app_key" not in payload:
-            payload["app_key"] = payload.pop("appKey")
-        return payload
-
     @model_validator(mode="after")
     def validate_target(self) -> "PortalChartRefPatch":
-        if not (self.chart_id or self.chart_key or self.chart_name):
-            raise ValueError("chart_ref requires chart_id, chart_key, or chart_name")
-        if self.chart_name and not self.app_key and not (self.chart_id or self.chart_key):
-            raise ValueError("chart_ref with chart_name requires app_key unless chart_id/chart_key is also provided")
+        if not (self.chart_id or self.chart_name):
+            raise ValueError("chart_ref requires chart_id or chart_name")
         return self
 
 
@@ -2054,7 +2170,7 @@ class PortalViewRefPatch(StrictModel):
 class PortalSectionPatch(StrictModel):
     title: str
     source_type: str = Field(validation_alias=AliasChoices("source_type", "sourceType"))
-    role: str | None = None
+    role: str | None = Field(default=None, validation_alias=AliasChoices("role", "zone", "section_role", "sectionRole"))
     position: PortalComponentPositionPatch | None = None
     dash_style_config: dict[str, Any] | None = Field(default=None, validation_alias=AliasChoices("dash_style_config", "dashStyleConfigBO"))
     config: dict[str, Any] = Field(default_factory=dict)
@@ -2072,6 +2188,9 @@ class PortalSectionPatch(StrictModel):
         raw_type = payload.get("source_type", payload.get("sourceType"))
         if isinstance(raw_type, str):
             payload["source_type"] = raw_type.strip().lower()
+        raw_role = payload.get("role", payload.get("zone", payload.get("section_role", payload.get("sectionRole"))))
+        if isinstance(raw_role, str):
+            payload["role"] = raw_role.strip().lower()
         if "chartRef" in payload and "chart_ref" not in payload:
             payload["chart_ref"] = payload.pop("chartRef")
         if "viewRef" in payload and "view_ref" not in payload:
@@ -2085,13 +2204,6 @@ class PortalSectionPatch(StrictModel):
         supported = {"chart", "view", "grid", "filter", "text", "link"}
         if self.source_type not in supported:
             raise ValueError(f"unsupported portal source_type '{self.source_type}'")
-        if self.role is not None:
-            normalized_role = str(self.role or "").strip().lower()
-            if normalized_role not in {"metric"}:
-                raise ValueError(f"unsupported portal section role '{self.role}'")
-            self.role = normalized_role
-            if self.source_type != "chart":
-                raise ValueError("portal section role is only supported for chart sections")
         if self.source_type == "chart" and self.chart_ref is None:
             raise ValueError("chart section requires chart_ref")
         if self.source_type == "view" and self.view_ref is None:
@@ -2230,6 +2342,7 @@ AppReadSummaryResponse = AppGetResponse
 AppFieldsReadResponse = AppGetFieldsResponse
 AppLayoutReadResponse = AppGetLayoutResponse
 AppViewsReadResponse = AppGetViewsResponse
+AppFlowReadResponse = AppGetFlowResponse
 AppChartsReadResponse = AppGetChartsResponse
 
 
@@ -2283,6 +2396,9 @@ class ChartGetResponse(StrictModel):
     chart_id: str
     base: dict[str, Any] = Field(default_factory=dict)
     visibility: dict[str, Any] = Field(default_factory=dict)
+    filters: list[list[dict[str, Any]]] = Field(default_factory=list)
+    group_by: list[str] = Field(default_factory=list)
+    metrics: list[dict[str, Any]] = Field(default_factory=list)
     config: dict[str, Any] = Field(default_factory=dict)
 
 
@@ -2316,6 +2432,40 @@ class LayoutPlanRequest(StrictModel):
         return payload
 
 
+class FlowPlanRequest(StrictModel):
+    app_key: str
+    mode: str = "replace"
+    nodes: list[FlowNodePatch] = Field(default_factory=list)
+    transitions: list[FlowTransitionPatch] = Field(default_factory=list)
+    preset: FlowPreset | None = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def normalize_mode_alias(cls, value: Any) -> Any:
+        if not isinstance(value, dict):
+            return value
+        payload = dict(value)
+        if str(payload.get("mode") or "").strip().lower() == "overwrite":
+            payload["mode"] = "replace"
+        raw_preset = payload.get("preset")
+        if raw_preset is None and isinstance(payload.get("base_preset"), str):
+            raw_preset = payload["base_preset"]
+            payload["preset"] = raw_preset
+        if isinstance(raw_preset, str):
+            normalized_preset = raw_preset.strip().lower()
+            preset_aliases = {
+                "default_approval": FlowPreset.basic_approval.value,
+                "approval": FlowPreset.basic_approval.value,
+                "basic approval": FlowPreset.basic_approval.value,
+                "default_fill_then_approve": FlowPreset.basic_fill_then_approve.value,
+                "default-fill-then-approve": FlowPreset.basic_fill_then_approve.value,
+                "fill_then_approve": FlowPreset.basic_fill_then_approve.value,
+            }
+            if normalized_preset in preset_aliases:
+                payload["preset"] = preset_aliases[normalized_preset]
+        return payload
+
+
 class ViewsPlanRequest(StrictModel):
     app_key: str
     upsert_views: list[ViewUpsertPatch] = Field(default_factory=list)
@@ -2345,6 +2495,8 @@ def _normalize_field_payload(value: Any) -> Any:
     payload = dict(value)
     if "fields" in payload and "subfields" not in payload:
         payload["subfields"] = payload.pop("fields")
+    if "options" in payload:
+        payload["options"] = _normalize_field_options(payload.get("options"))
     raw_type = payload.get("type")
     if isinstance(raw_type, int):
         normalized_from_id = FIELD_TYPE_ID_ALIASES.get(raw_type)
@@ -2377,6 +2529,34 @@ def _normalize_field_payload(value: Any) -> Any:
     return payload
 
 
+def _normalize_field_options(value: Any) -> Any:
+    if not isinstance(value, list):
+        return value
+    normalized: list[str] = []
+    for item in value:
+        if isinstance(item, str):
+            normalized.append(item)
+            continue
+        if isinstance(item, (int, float, bool)):
+            normalized.append(str(item))
+            continue
+        if isinstance(item, dict):
+            label = (
+                item.get("label")
+                or item.get("name")
+                or item.get("title")
+                or item.get("value")
+                or item.get("text")
+                or item.get("optValue")
+                or item.get("optName")
+            )
+            if label is not None:
+                normalized.append(str(label))
+                continue
+        normalized.append(str(item))
+    return normalized
+
+
 def _slugify_title(title: str) -> str:
     normalized = "".join(ch.lower() if ch.isalnum() else "_" for ch in str(title or ""))
     collapsed = "_".join(part for part in normalized.split("_") if part)