feat(mcp): 参考 dacli 扩面到 49 个业务工具

- 新增 workflow×7 / form.create|update|delete / ops×4 / dict×3 / menu×2 / permission×3 / context.app.list
- 实现方式:mcp_compat 进程内直调契约面 handler(与 HTTP 同一函数),不重写 SQL
- 自动把 formData 等对象字段序列化为 TEXT,避免 value_to_text 静默丢弃
- 管理员头缓存按 SessionStore 实例缓存并设上界(防地址复用 602 与无界内存)
- 新增 tests/mcp_tools_it.rs 6 条;全量 667 passed,verify.sh --smoke 14 步全绿
This commit is contained in:
admin committed 2026-11-02 23:46:17 +08:00
1 parent 31e0e457ba
commit c55d111e88
13 files changed
+1931 -7

No files matched your search

+1
View File
@@ -18,6 +18,7 @@ pub mod lowcode_crud;
pub mod lowcode_ddl;
pub mod lowcode_seed;
pub mod mcp_adapter;
pub mod mcp_compat;
pub mod modules;
// 🔴 **本文件是 `scripts/pack-sync.py` 生成的**(业务包清单 + `pack.toml` 快照)
// ⇒ 不要手改;加包跑 `bash scripts/new-pack.sh`。
+56
View File
@@ -2538,6 +2538,62 @@ impl PlatformAdapter for NativeAdapter {
"data.record.update" => self.data_record_update(&args).await,
"data.record.delete" => self.data_record_delete(&args).await,
// ------------------------------------------------ 流程(直调契约面 handler)
"workflow.template.list" => {
crate::mcp_compat::workflow_template_list(&self.state, args).await
}
"workflow.template.info" => {
crate::mcp_compat::workflow_template_info(&self.state, args).await
}
"workflow.template.create" => {
crate::mcp_compat::workflow_template_create(&self.state, args).await
}
"workflow.template.update" => {
crate::mcp_compat::workflow_template_update(&self.state, args).await
}
"workflow.template.delete" => {
crate::mcp_compat::workflow_template_delete(&self.state, args).await
}
"workflow.template.selector" => {
crate::mcp_compat::workflow_template_selector(&self.state, args).await
}
"workflow.task.list" => {
crate::mcp_compat::workflow_task_list(&self.state, args).await
}
// ------------------------------------------------ 字典 / 菜单(写)
"dict.type.update" => crate::mcp_compat::dict_type_update(&self.state, args).await,
"dict.type.delete" => crate::mcp_compat::dict_type_delete(&self.state, args).await,
"dict.data.create" => crate::mcp_compat::dict_data_create(&self.state, args).await,
"menu.info" => crate::mcp_compat::menu_info(&self.state, args).await,
"menu.update" => crate::mcp_compat::menu_update(&self.state, args).await,
// ------------------------------------------------ 权限(角色 / 用户)
"permission.role.create" => {
crate::mcp_compat::role_create(&self.state, args).await
}
"permission.role.delete" => {
crate::mcp_compat::role_delete(&self.state, args).await
}
"permission.user.delete" => {
crate::mcp_compat::user_delete(&self.state, args).await
}
// ------------------------------------------------ 低代码表单(写 / 发布)
"form.create" => crate::mcp_compat::form_create(&self.state, args).await,
"form.update" => crate::mcp_compat::form_update(&self.state, args).await,
"form.delete" => crate::mcp_compat::form_delete(&self.state, args).await,
"form.release" => crate::mcp_compat::form_release(&self.state, args).await,
// ------------------------------------------------ 应用 / 运维
"context.app.list" => crate::mcp_compat::app_list(&self.state, args).await,
"ops.health" => crate::mcp_compat::ops_health(&self.state, args).await,
"ops.logs" => crate::mcp_compat::ops_logs(&self.state, args).await,
"ops.online" => crate::mcp_compat::ops_online(&self.state, args).await,
"ops.schedule.list" => {
crate::mcp_compat::ops_schedule_list(&self.state, args).await
}
other => Err(ToolError::new(
"OP_NOT_IMPLEMENTED",
format!("原生适配器还没实现 op: {other}"),
+565
View File
@@ -0,0 +1,565 @@
//! mcp_compat —— MCP 工具对**契约面 handler** 的进程内直调。
//!
//! ## 为什么直调 handler,而不是重写一遍 SQL
//!
//! MCP 与 HTTP 是同一套能力的两个入口。若 MCP 自己拼 SQL,两边会**双份实现**:
//! 校验规则、默认值、软删语义、审计列都会各写一遍 ⇒ 必然漂移(dacli 踩过:
//! 50+ 处漂移修了 6 周)。这里直接调 `platform::compat::*` 的 handler
//! (与 HTTP 路由注册的是同一个函数),语义天然一致。
//!
//! ## 身份从哪来
//!
//! 进程内没有 HTTP 登录态。这里给 handler 造一套**管理员请求头**:
//! 用 `SessionStore::issue` 签发一个 `admin` 会话(与 HTTP 登录同一个表),
//! 再把 token 塞进 `Authorization`。`App-Code` 默认 `mainSystem`,可由工具入参覆盖。
//!
//! 🔴 **等价于「本地 AI 就是管理员」** —— 与 `mcp_adapter.rs` 顶部的安全前提一致:
//! 该适配器只用于本地开发;对外暴露必须走 `BaselineHttpAdapter` 带真实 token。
//!
//! ## 失败怎么报
//!
//! handler 返回 `ActionResult{code,msg,data}`:
//! - `code=200` ⇒ 透传 `data`;`data` 为 null 时回 `{ok:true,msg}`(保留官方提示语)
//! - 其它 ⇒ `ToolError`(`BUSINESS_FAILED` / `NO_PERMISSION` / `NOT_LOGGED_IN`),
//! 带 `hints + next_actions`,让 AI 自己改参数而不是原样重试。
use std::collections::HashMap;
use std::sync::{Arc, Mutex, OnceLock};
use axum::body::Bytes;
use axum::extract::{Path, RawQuery, State};
use axum::http::HeaderMap;
use serde_json::{json, Map, Value};
use sspf_mcp::adapter::ToolError;
use crate::platform::envelope::ActionResult;
use crate::platform::state::AppState;
/// handler 调用用的管理员头 —— **按 `SessionStore` 实例缓存**。
///
/// 🔴 不能用全局单例:测试里每个用例一个 `AppState`(各自一张 token 表),
/// 全局缓存的 token 在别的表里解析不出来 ⇒ 所有工具都 602。
static ADMIN_HEADERS: OnceLock<Mutex<HashMap<usize, (Arc<crate::platform::session::SessionStore>, HeaderMap)>>> =
OnceLock::new();
/// 管理员头缓存的**上界**。
///
/// 正常进程只有 1 个 `AppState`(1 条);测试里每个用例一个实例 ⇒ 不设界会随用例数增长。
/// 满了直接清空(代价只是下次多签一个 token),**不做 LRU** —— 这里是缓存不是状态。
const MAX_ADMIN_HEADER_CACHE: usize = 8;
/// 造/复用管理员请求头,并按入参覆盖 `App-Code`。
async fn headers(state: &AppState, args: &Value) -> HeaderMap {
let key = Arc::as_ptr(&state.sessions) as usize;
let cached = ADMIN_HEADERS
.get_or_init(|| Mutex::new(HashMap::new()))
.lock()
.ok()
.and_then(|m| m.get(&key).map(|(_, h)| h.clone()));
let base = match cached {
Some(h) => h,
None => {
let mut h = HeaderMap::new();
let admin_id = state
.db
.scalar_text("SELECT f_id FROM base_user WHERE f_account = 'admin' LIMIT 1")
.await
.ok()
.flatten()
.unwrap_or_default();
let token = state.sessions.issue("admin", &admin_id, 1);
if let Ok(v) = token.parse() {
h.insert("authorization", v);
}
if let Ok(v) = "3".parse() {
h.insert("vue-version", v);
}
if let Ok(mut m) = ADMIN_HEADERS
.get_or_init(|| Mutex::new(HashMap::new()))
.lock()
{
if m.len() >= MAX_ADMIN_HEADER_CACHE {
m.clear();
}
// 🔴 连同 Arc 一起存:地址可能被分配器复用,只存 headers 会让
// 新 AppState 命中旧 token(测试里表现为随机 602)。
m.insert(key, (Arc::clone(&state.sessions), h.clone()));
}
h
}
};
let mut h = base;
let app = args
.get("appCode")
.and_then(Value::as_str)
.unwrap_or("mainSystem");
if let Ok(v) = app.parse() {
h.insert("app-code", v);
}
h
}
/// 从入参挑出若干键,拼成 URL query(中文等字符会被正确百分号编码)。
fn qs(args: &Value, keys: &[&str]) -> String {
let Some(obj) = args.as_object() else {
return String::new();
};
let mut pairs: Vec<(String, String)> = Vec::new();
for k in keys {
let Some(v) = obj.get(*k) else { continue };
if v.is_null() {
continue;
}
let s = match v {
Value::String(s) => s.clone(),
other => other.to_string(),
};
if s.is_empty() {
continue;
}
pairs.push(((*k).to_string(), s));
}
serde_urlencoded::to_string(&pairs).unwrap_or_default()
}
/// 入参原样当 body(去掉 MCP 控制字段)。
///
/// 🔴 **`formData` / `columnData` / `tablesData` 这类列是 TEXT,但 handler 的
/// `value_to_text()` 只接受 string/number/bool —— 传对象会被**静默丢弃**。**
/// ⇒ 这里统一把对象/数组序列化成 JSON 字符串,AI 可以直接写对象。
fn body_of(args: &Value) -> Result<Bytes, ToolError> {
let mut v = args.clone();
if let Some(o) = v.as_object_mut() {
o.remove("dryRun");
o.remove("appCode");
for key in [
"formData",
"columnData",
"tablesData",
"appColumnData",
"buttonData",
"appButtonData",
"interfaceParam",
] {
let Some(slot) = o.get_mut(key) else { continue };
if slot.is_object() || slot.is_array() {
let text = serde_json::to_string(slot).unwrap_or_default();
*slot = Value::String(text);
}
}
}
if !v.is_object() {
return Err(ToolError::new("BAD_ARGS", "入参必须是 JSON 对象").field("args"));
}
serde_json::to_vec(&v)
.map(Bytes::from)
.map_err(|e| ToolError::new("BAD_ARGS", format!("序列化入参失败: {e}")))
}
/// 取必填字符串参数。
fn need_str(args: &Value, key: &str) -> Result<String, ToolError> {
let s = args.get(key).and_then(Value::as_str).unwrap_or("").trim();
if s.is_empty() {
return Err(ToolError::new("MISSING_ARG", format!("缺少必填参数 {key}"))
.field(key)
.hint("先 sspf_describe 看该工具的 input_schema")
.next("sspf_discover", json!({}), "先确认该用哪个工具"));
}
Ok(s.to_string())
}
/// 该域的「查证」工具 —— 业务失败时建议 AI 先列一下再改参数。
fn next_tool_for(op: &str) -> Option<&'static str> {
if op.starts_with("workflow.") {
Some("workflow.template.list")
} else if op.starts_with("dict.") {
Some("dict.type.list")
} else if op.starts_with("menu.") {
Some("menu.tree")
} else if op.starts_with("permission.role.") {
Some("permission.role.list")
} else if op.starts_with("permission.user.") {
Some("permission.user.list")
} else if op.starts_with("form.") {
Some("form.list")
} else {
None
}
}
/// `Json<ActionResult>` ⇒ 工具结果 / 结构化错误。
fn out(op: &str, resp: axum::Json<ActionResult>) -> Result<Value, ToolError> {
let a = resp.0;
if a.code == 200 {
return Ok(match a.data {
// 新建设备类端点常返裸 id 字符串(官方 `ActionResult.success(id)`)——
// 包成 `{id}` 让 AI 拿到稳定字段,不用猜「这串是什么」。
Value::String(s) => json!({ "id": s }),
Value::Null => json!({ "ok": true, "msg": a.msg }),
other => other,
});
}
let code = match a.code {
602 => "NOT_LOGGED_IN",
403 => "NO_PERMISSION",
_ => "BUSINESS_FAILED",
};
let mut err = ToolError::new(code, a.msg).hint("先 sspf_describe 看该工具的 pitfalls 与示例");
if let Some(t) = next_tool_for(op) {
err = err.next(t, json!({}), "先列出现有数据,确认 id / enCode 是否正确");
}
Err(err)
}
// ================================================================ workflow
pub async fn workflow_template_list(state: &AppState, args: Value) -> Result<Value, ToolError> {
let raw = RawQuery(Some(qs(
&args,
&["keyword", "category", "type", "state", "currentPage", "pageSize"],
)));
let r = crate::platform::compat::workflow::workflow_template_list(
State(state.clone()),
headers(state, &args).await,
raw,
)
.await;
out("workflow.template.list", r)
}
pub async fn workflow_template_info(state: &AppState, args: Value) -> Result<Value, ToolError> {
let id = need_str(&args, "id")?;
let r = crate::platform::compat::workflow::workflow_template_info(
State(state.clone()),
headers(state, &args).await,
Path(id),
)
.await;
out("workflow.template.info", r)
}
pub async fn workflow_template_create(state: &AppState, args: Value) -> Result<Value, ToolError> {
let body = body_of(&args)?;
let r = crate::platform::compat::workflow::workflow_template_create(
State(state.clone()),
headers(state, &args).await,
body,
)
.await;
out("workflow.template.create", r)
}
pub async fn workflow_template_update(state: &AppState, args: Value) -> Result<Value, ToolError> {
let id = need_str(&args, "id")?;
let body = body_of(&args)?;
let r = crate::platform::compat::workflow::workflow_template_update(
State(state.clone()),
headers(state, &args).await,
Path(id),
body,
)
.await;
out("workflow.template.update", r)
}
pub async fn workflow_template_delete(state: &AppState, args: Value) -> Result<Value, ToolError> {
let id = need_str(&args, "id")?;
let r = crate::platform::compat::workflow::workflow_template_delete(
State(state.clone()),
headers(state, &args).await,
Path(id),
)
.await;
out("workflow.template.delete", r)
}
pub async fn workflow_task_list(state: &AppState, args: Value) -> Result<Value, ToolError> {
let raw = RawQuery(Some(qs(
&args,
&["keyword", "type", "category", "currentPage", "pageSize"],
)));
let r = crate::platform::compat::workflow::workflow_task_list(
State(state.clone()),
headers(state, &args).await,
raw,
)
.await;
out("workflow.task.list", r)
}
pub async fn workflow_template_selector(state: &AppState, args: Value) -> Result<Value, ToolError> {
let raw = RawQuery(Some(qs(
&args,
&["keyword", "category", "type", "currentPage", "pageSize"],
)));
let r = crate::platform::compat::workflow::workflow_template_selector(
State(state.clone()),
headers(state, &args).await,
raw,
)
.await;
out("workflow.template.selector", r)
}
// ================================================================ dict
pub async fn dict_type_update(state: &AppState, args: Value) -> Result<Value, ToolError> {
let id = need_str(&args, "id")?;
let body = body_of(&args)?;
let r = crate::platform::compat::system::dict_type_update(
State(state.clone()),
headers(state, &args).await,
Path(id),
body,
)
.await;
out("dict.type.update", r)
}
pub async fn dict_type_delete(state: &AppState, args: Value) -> Result<Value, ToolError> {
let id = need_str(&args, "id")?;
let r = crate::platform::compat::system::dict_type_delete(
State(state.clone()),
headers(state, &args).await,
Path(id),
)
.await;
out("dict.type.delete", r)
}
pub async fn dict_data_create(state: &AppState, args: Value) -> Result<Value, ToolError> {
let body = body_of(&args)?;
let r = crate::platform::compat::system::dict_data_create(
State(state.clone()),
headers(state, &args).await,
body,
)
.await;
out("dict.data.create", r)
}
// ================================================================ menu
pub async fn menu_info(state: &AppState, args: Value) -> Result<Value, ToolError> {
let id = need_str(&args, "id")?;
let r = crate::platform::compat::system::menu_info(
State(state.clone()),
headers(state, &args).await,
Path(id),
)
.await;
out("menu.info", r)
}
pub async fn menu_update(state: &AppState, args: Value) -> Result<Value, ToolError> {
let id = need_str(&args, "id")?;
let body = body_of(&args)?;
let r = crate::platform::compat::system::menu_update(
State(state.clone()),
headers(state, &args).await,
Path(id),
body,
)
.await;
out("menu.update", r)
}
// ================================================================ permission
pub async fn role_create(state: &AppState, args: Value) -> Result<Value, ToolError> {
let body = body_of(&args)?;
let r = crate::platform::compat::permission::role_create(
State(state.clone()),
headers(state, &args).await,
body,
)
.await;
out("permission.role.create", r)
}
pub async fn role_delete(state: &AppState, args: Value) -> Result<Value, ToolError> {
let id = need_str(&args, "id")?;
let r = crate::platform::compat::permission::role_delete(
State(state.clone()),
headers(state, &args).await,
Path(id),
)
.await;
out("permission.role.delete", r)
}
pub async fn user_delete(state: &AppState, args: Value) -> Result<Value, ToolError> {
let id = need_str(&args, "id")?;
let r = crate::platform::compat::permission::user_delete(
State(state.clone()),
headers(state, &args).await,
Path(id),
)
.await;
out("permission.user.delete", r)
}
// ================================================================ form
pub async fn form_create(state: &AppState, args: Value) -> Result<Value, ToolError> {
let body = body_of(&args)?;
let r = crate::platform::compat::online_dev::visual_dev_create(
State(state.clone()),
headers(state, &args).await,
body,
)
.await;
out("form.create", r)
}
pub async fn form_update(state: &AppState, args: Value) -> Result<Value, ToolError> {
let id = need_str(&args, "id")?;
let body = body_of(&args)?;
let r = crate::platform::compat::online_dev::visual_dev_update(
State(state.clone()),
headers(state, &args).await,
Path(id),
body,
)
.await;
out("form.update", r)
}
pub async fn form_delete(state: &AppState, args: Value) -> Result<Value, ToolError> {
let id = need_str(&args, "id")?;
let r = crate::platform::compat::online_dev::visual_dev_delete(
State(state.clone()),
headers(state, &args).await,
Path(id),
)
.await;
out("form.delete", r)
}
pub async fn form_release(state: &AppState, args: Value) -> Result<Value, ToolError> {
let id = need_str(&args, "id")?;
let r = crate::platform::compat::online_dev::visual_dev_release(
State(state.clone()),
headers(state, &args).await,
Path(id),
)
.await;
out("form.release", r)
}
// ================================================================ context / ops
pub async fn app_list(state: &AppState, args: Value) -> Result<Value, ToolError> {
let raw = RawQuery(Some(qs(
&args,
&["keyword", "type", "currentPage", "pageSize"],
)));
let r = crate::platform::compat::system::system_list(
State(state.clone()),
headers(state, &args).await,
raw,
)
.await;
out("context.app.list", r)
}
pub async fn ops_logs(state: &AppState, args: Value) -> Result<Value, ToolError> {
let raw = RawQuery(Some(qs(
&args,
&[
"category",
"keyword",
"startTime",
"endTime",
"currentPage",
"pageSize",
],
)));
let r = crate::platform::compat::system::log_list(
State(state.clone()),
headers(state, &args).await,
raw,
)
.await;
out("ops.logs", r)
}
pub async fn ops_schedule_list(state: &AppState, args: Value) -> Result<Value, ToolError> {
let raw = RawQuery(Some(qs(
&args,
&["keyword", "currentPage", "pageSize"],
)));
let r = crate::platform::compat::scheduletask::task_list(
State(state.clone()),
headers(state, &args).await,
raw,
)
.await;
out("ops.schedule.list", r)
}
/// 健康检查:表数 / 会话数 / admin 是否在 —— 不走 HTTP,直接读库。
pub async fn ops_health(state: &AppState, _args: Value) -> Result<Value, ToolError> {
let tables = state
.db
.scalar_text(
"SELECT count(*)::text FROM information_schema.tables \
WHERE table_schema = 'public' AND table_type = 'BASE TABLE'",
)
.await
.ok()
.flatten()
.and_then(|s| s.parse::<i64>().ok())
.unwrap_or(0);
let admin = state
.db
.scalar_text("SELECT f_account FROM base_user WHERE f_account = 'admin' LIMIT 1")
.await
.ok()
.flatten();
let sessions = state.sessions.snapshot();
Ok(json!({
"backend": "native",
"version": env!("CARGO_PKG_VERSION"),
"tables": tables,
"adminSeeded": admin.is_some(),
"sessions": sessions.len(),
}))
}
/// 在线会话:**按账号聚合**,不返回 token 本身(token 是凭据,不进工具输出)。
pub async fn ops_online(state: &AppState, _args: Value) -> Result<Value, ToolError> {
let snap = state.sessions.snapshot();
let mut by_account: Map<String, Value> = Map::new();
for (_, u) in snap {
let entry = by_account.entry(u.account.clone()).or_insert_with(|| {
json!({
"account": u.account,
"isAdmin": u.is_admin == 1,
"sessions": 0,
"lastIssuedAtMs": 0,
"ips": Vec::<String>::new(),
})
});
if let Some(o) = entry.as_object_mut() {
let n = o.get("sessions").and_then(Value::as_i64).unwrap_or(0) + 1;
o.insert("sessions".to_string(), json!(n));
let last = o.get("lastIssuedAtMs").and_then(Value::as_i64).unwrap_or(0);
o.insert("lastIssuedAtMs".to_string(), json!(last.max(u.issued_at_ms)));
if !u.ip.is_empty() {
if let Some(arr) = o.get_mut("ips").and_then(Value::as_array_mut) {
if !arr.iter().any(|v| v.as_str() == Some(u.ip.as_str())) {
arr.push(json!(u.ip));
}
}
}
}
}
Ok(json!({
"online": by_account.len(),
"users": by_account.into_values().collect::<Vec<_>>(),
}))
}
+228
View File
@@ -0,0 +1,228 @@
//! MCP 新工具(P2-c / P3)—— 适配器直调契约面 handler 的回归测试。
//!
//! 覆盖:`form.create/update/delete`、`workflow.template.*`、`dict.*`、`menu.info`、
//! `permission.role.*`、`permission.user.delete`、`ops.*`、`context.app.list`。
//!
//! 🔴 这些工具的实现方式是「构造管理员头 → 直调 compat handler」,
//! 所以本测试同时钉住两件事:① handler 能被进程内调用;② 管理员会话能通过守卫。
use std::path::PathBuf;
use std::sync::Arc;
use serde_json::{json, Value};
use ssw_platform::mcp_adapter::NativeAdapter;
use ssw_platform::platform::db::Db;
use ssw_platform::platform::seed::first_seed;
use ssw_platform::platform::session::{SessionStore, TicketStore};
use ssw_platform::platform::state::AppState;
use sspf_mcp::adapter::PlatformAdapter;
use tokio::sync::{Mutex, OnceCell};
static DB: OnceCell<Db> = OnceCell::const_new();
static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
ssw_platform::bootstrap::ensure_base(&db)
.await
.expect("ensure_base 失败");
first_seed(&db, "123456").await.expect("first_seed 失败");
db
})
.await
}
fn adapter(db: &Db) -> NativeAdapter {
let state = AppState {
config: Arc::new(ssw_platform::platform::config::Config::from_env(PathBuf::from(
"/tmp/ssw-platform-mcp-tools-it",
))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::default()),
tickets: Arc::new(TicketStore::default()),
};
NativeAdapter::new(state)
}
async fn call(a: &NativeAdapter, op: &str, args: Value) -> Result<Value, sspf_mcp::adapter::ToolError> {
a.invoke(op, args).await
}
/// ops.health / ops.online / context.app.list 三条只读链路。
#[tokio::test]
async fn ops_and_app_tools_work() {
let _g = LOCK.lock().await;
let a = adapter(db().await);
let health = call(&a, "ops.health", json!({})).await.expect("ops.health 失败");
assert!(health["tables"].as_i64().unwrap_or(0) > 50, "表数应 > 50: {health}");
assert_eq!(health["adminSeeded"], true);
let apps = call(&a, "context.app.list", json!({"pageSize":5})).await.expect("app.list 失败");
assert!(apps["list"].is_array(), "必须是 ListVO: {apps}");
let online = call(&a, "ops.online", json!({})).await.expect("ops.online 失败");
assert!(online["users"].is_array(), "{online}");
let logs = call(&a, "ops.logs", json!({"category":1,"pageSize":1})).await;
assert!(logs.is_ok(), "登录日志查询失败: {logs:?}");
}
/// 流程模板 CRUD 闭环(元数据面)。
#[tokio::test]
async fn workflow_template_crud_roundtrip() {
let _g = LOCK.lock().await;
let a = adapter(db().await);
let created = call(
&a,
"workflow.template.create",
json!({"fullName":"MCP验证流程","enCode":"mcp_verify_flow"}),
)
.await
.expect("建流程失败");
let id = created["id"].as_str().expect("必须返回 id").to_string();
let listed = call(&a, "workflow.template.list", json!({"keyword":"MCP验证"})).await.expect("列流程失败");
let total = listed["pagination"]["total"].as_i64().unwrap_or(0);
assert!(total >= 1, "新流程应能被列出: {listed}");
let info = call(&a, "workflow.template.info", json!({"id":id})).await.expect("详情失败");
assert_eq!(info["enCode"], "mcp_verify_flow", "{info}");
call(&a, "workflow.template.update", json!({"id":id,"fullName":"MCP验证流程2"}))
.await
.expect("更新失败");
let info2 = call(&a, "workflow.template.info", json!({"id":id})).await.expect("详情失败");
assert_eq!(info2["fullName"], "MCP验证流程2");
call(&a, "workflow.template.delete", json!({"id":id})).await.expect("删除失败");
let after = call(&a, "workflow.template.list", json!({"keyword":"MCP验证"})).await.expect("列流程失败");
assert_eq!(after["pagination"]["total"], 0, "软删后不应再出现: {after}");
}
/// 字典写面 + 菜单详情。
#[tokio::test]
async fn dict_and_menu_tools_work() {
let _g = LOCK.lock().await;
let a = adapter(db().await);
let created = call(
&a,
"dict.type.create",
json!({"enCode":"mcp_dict_verify","fullName":"MCP字典"}),
)
.await
.expect("建字典失败");
let type_id = created["id"].as_str().expect("必须有 id").to_string();
call(&a, "dict.type.update", json!({"id":type_id,"fullName":"MCP字典2"}))
.await
.expect("改字典失败");
call(
&a,
"dict.data.create",
json!({"dictionaryTypeId":type_id,"enCode":"a","fullName":"甲"}),
)
.await
.expect("加字典项失败");
let items = call(&a, "dict.data.list", json!({"dictionaryTypeId":type_id})).await.expect("列字典项失败");
assert!(items["count"].as_i64().unwrap_or(0) >= 1, "{items}");
let menu_id = db()
.await
.scalar_text("SELECT f_id FROM base_module WHERE f_en_code = 'permission.user' LIMIT 1")
.await
.expect("查菜单失败")
.expect("permission.user 菜单必须存在");
let menu = call(&a, "menu.info", json!({"id":menu_id})).await.expect("菜单详情失败");
assert_eq!(menu["enCode"], "permission.user");
}
/// 角色建/删 + 用户软删。
#[tokio::test]
async fn permission_role_and_user_tools_work() {
let _g = LOCK.lock().await;
let a = adapter(db().await);
let role = call(
&a,
"permission.role.create",
json!({"fullName":"MCP角色","enCode":"mcp_role_verify"}),
)
.await
.expect("建角色失败");
let role_id = role["id"].as_str().expect("必须有 id").to_string();
let roles = call(&a, "permission.role.list", json!({"keyword":"MCP角色"})).await.expect("列角色失败");
assert!(roles["count"].as_i64().unwrap_or(0) >= 1, "{roles}");
call(&a, "permission.role.delete", json!({"id":role_id})).await.expect("删角色失败");
db()
.await
.exec(
"INSERT INTO base_user (f_id,f_tenant_id,f_account,f_real_name,f_enabled_mark,f_delete_mark,f_is_administrator,f_creator_time) \
VALUES ('mcp-del-user','0','mcp_del_user','待删',1,0,0,now())",
)
.await
.expect("插用户失败");
call(&a, "permission.user.delete", json!({"id":"mcp-del-user"})).await.expect("删用户失败");
let users = call(&a, "permission.user.list", json!({"keyword":"mcp_del_user"})).await.expect("列用户失败");
assert_eq!(users["count"], 0, "软删后不应出现: {users}");
}
/// 表单定义建/改/删(不发布:本仓 release 未支持)。
#[tokio::test]
async fn form_create_update_delete_roundtrip() {
let _g = LOCK.lock().await;
let a = adapter(db().await);
let created = call(
&a,
"form.create",
json!({"fullName":"MCP验证表单","enCode":"mcp_verify_form","type":1,
"formData":{"formRef":"formRef","fields":[]}}),
)
.await
.expect("建表单失败");
let id = created["id"].as_str().expect("必须返回 id").to_string();
let listed = call(&a, "form.list", json!({"keyword":"MCP验证表单"})).await.expect("列表单失败");
assert!(listed["count"].as_i64().unwrap_or(0) >= 1, "{listed}");
call(&a, "form.update", json!({"id":id,"description":"改过"}))
.await
.expect("改表单失败");
let desc = db()
.await
.scalar_text(&format!(
"SELECT f_description FROM base_visual_dev WHERE f_id = '{id}' LIMIT 1"
))
.await
.expect("查表单失败");
assert_eq!(desc.as_deref(), Some("改过"), "更新必须真的落库");
call(&a, "form.delete", json!({"id":id})).await.expect("删表单失败");
let after = call(&a, "form.list", json!({"keyword":"MCP验证表单"})).await.expect("列表单失败");
assert_eq!(after["count"], 0, "软删后不应出现: {after}");
}
/// 业务失败必须是结构化 ToolError(带 hints / next_actions),不是 panic 也不是纯字符串。
#[tokio::test]
async fn business_failure_is_structured() {
let _g = LOCK.lock().await;
let a = adapter(db().await);
let err = call(
&a,
"workflow.template.info",
json!({"id":"00000000-0000-0000-0000-000000000000"}),
)
.await
.expect_err("不存在的模板必须失败");
assert_eq!(err.code, "BUSINESS_FAILED");
assert!(!err.hints.is_empty(), "必须给 hints");
assert!(!err.next_actions.is_empty(), "必须给 next_actions");
}