feat(mcp): schema.table.create 落地 + P2-b 冒烟闭环,修 data.query 泄漏口令列

- MCP:新增 schema.table.create(第 26 个业务工具)—— 库内功能按设计稿建表并回写
  f_tables_data;内联 formData/tablesData 只能演练(INLINE_REQUIRES_DRY_RUN);
  写且幂等(表已存在跳 DDL,列不同报 TABLE_EXISTS_DIFFERENT),默认 dryRun=true
- mcp-smoke 32 → 48 条:先 --seed-lowcode-demo 造 receivableDemo,再用同一 PGLITE_DIR
  起 --mcp,python 动态驱动(主键是服务端 UUID)跑通「默认演练不落库 → 真写 → 查证 →
  子表差集三类 → 删除 → 建表演练/幂等」;M4 回复数改为按请求文件计算,不再写死 29
- lowcode-smoke 8 → 15 条:用内联演练钉建表规则(类型映射+dataLength / 复合主键 /
  逻辑删除三列 / 系统列视图类型),外加两条反自证(不开逻辑删除就不加删除列;
  inline 不许落库)
- fix:data.query 不再投影 f_password / f_secretkey(实测能拖走全库口令哈希);
  缺省滤掉并返回 hiddenColumns,显式 columns/where/orderBy 要用 ⇒ SENSITIVE_COLUMN
- docs:PLAN / CLAUDE / docs/mcp / docs/visualdev-mechanism 补 P2-b 结论;
  业务工具数 21 → 26 由 tool_count_matches_doc 钉死;清 f_foreign_id 文档漂移
  (子表外键列来自模型 tableField);补单租户口径的三条交叉证据(K8s 配置 / Java 常量 /
  官方 DDL);记 UNIQUE_CONSTRAINT_VIOLATED / BUSINESS_KEY_VIOLATED
This commit is contained in:
admin committed 2026-10-31 21:34:37 +08:00
1 parent bcbe46c92b
commit 1d1a3b1ef9
13 files changed
+1104 -56

No files matched your search

+196 -10
View File
@@ -383,14 +383,25 @@ impl NativeAdapter {
.field("table")
.next("schema.table.list", json!({}), "确认表名"));
}
let allowed: HashSet<String> = cols.iter().cloned().collect();
// 选列:缺省全选;显式给了就逐个校验
// 🔴 口令/密钥列**不许经通用读口子投影**(红线⑤)。
// `data.query` 是「按表名读任意表」的通用口子:不挡这里,
// 一句 `{"table":"base_user"}` 就能把全库口令哈希拖走(实测会返回 password)。
let readable: Vec<String> = cols
.iter()
.filter(|c| !is_sensitive_column(c))
.cloned()
.collect();
let allowed: HashSet<String> = readable.iter().cloned().collect();
let n_hidden = cols.len() - readable.len();
// 选列:缺省全选(已滤掉敏感列);显式给了就逐个校验
let select = match args.get("columns").and_then(Value::as_array) {
Some(arr) if !arr.is_empty() => {
let mut v = Vec::with_capacity(arr.len());
for c in arr {
let name = c.as_str().unwrap_or("");
ensure_not_sensitive(name, "columns")?;
if !allowed.contains(name) {
return Err(ToolError::new(
"UNKNOWN_COLUMN",
@@ -403,7 +414,7 @@ impl NativeAdapter {
}
v.join(", ")
}
_ => cols
_ => readable
.iter()
.map(|c| format!("\"{c}\""))
.collect::<Vec<_>>()
@@ -416,12 +427,17 @@ impl NativeAdapter {
.and_then(Value::as_array)
.cloned()
.unwrap_or_default();
for c in &conds {
let col = c.get("column").and_then(Value::as_str).unwrap_or("");
ensure_not_sensitive(col, "where.column")?;
}
let mut params: Vec<String> = Vec::new();
let where_sql = Self::build_where(&conds, &allowed, &mut params)?;
// 排序(列名同样走白名单)
let order_sql = match args.get("orderBy").and_then(Value::as_str) {
Some(ob) if !ob.is_empty() => {
ensure_not_sensitive(ob, "orderBy")?;
if !allowed.contains(ob) {
return Err(ToolError::new("UNKNOWN_COLUMN", format!("排序列不存在: {ob}"))
.field("orderBy"));
@@ -454,6 +470,8 @@ impl NativeAdapter {
"table": table,
"count": rows.len(),
"limit": limit,
// 🔴 明说「藏着几列」—— 否则 AI 会以为这张表就这么多列
"hiddenColumns": n_hidden,
"rows": rows,
}))
}
@@ -476,6 +494,10 @@ impl NativeAdapter {
.and_then(Value::as_array)
.cloned()
.unwrap_or_default();
for c in &conds {
let col = c.get("column").and_then(Value::as_str).unwrap_or("");
ensure_not_sensitive(col, "where.column")?;
}
let mut params: Vec<String> = Vec::new();
let where_sql = Self::build_where(&conds, &allowed, &mut params)?;
@@ -1858,9 +1880,26 @@ impl NativeAdapter {
args: &Value,
) -> Result<(sspf_lowcode::FormSchema, sspf_lowcode::ModelSchema), ToolError> {
let row = self.load_visualdev(args).await?;
Self::lowcode_from_row(&row)
}
let form_text = row["formData"].as_str().unwrap_or("").trim().to_string();
let tables_text = row["tablesData"].as_str().unwrap_or("").trim().to_string();
/// 从 `base_visual_dev` 的一行解析出(表单, 模型)。
fn lowcode_from_row(
row: &Value,
) -> Result<(sspf_lowcode::FormSchema, sspf_lowcode::ModelSchema), ToolError> {
Self::lowcode_from_json(
row["formData"].as_str().unwrap_or(""),
row["tablesData"].as_str().unwrap_or(""),
)
}
/// 🔴 解析设计稿(`f_form_data` + `f_tables_data`)—— 库内行与内联入参共用。
fn lowcode_from_json(
form_text: &str,
tables_text: &str,
) -> Result<(sspf_lowcode::FormSchema, sspf_lowcode::ModelSchema), ToolError> {
let form_text = form_text.trim();
let tables_text = tables_text.trim();
if form_text.is_empty() || tables_text.is_empty() {
return Err(ToolError::new(
@@ -1870,15 +1909,14 @@ impl NativeAdapter {
.hint("只有表单没模型 = 不知道该存哪张表;只有模型没表单 = 不知道该展示什么"));
}
let fv: Value = serde_json::from_str(&form_text)
let fv: Value = serde_json::from_str(form_text)
.map_err(|e| ToolError::new("BAD_JSON", format!("form 不是合法 JSON: {e}")))?;
let tv: Value = serde_json::from_str(&tables_text)
let tv: Value = serde_json::from_str(tables_text)
.map_err(|e| ToolError::new("BAD_JSON", format!("tables 不是合法 JSON: {e}")))?;
let form = sspf_lowcode::FormSchema::parse(&fv).map_err(form_err)?;
let model = sspf_lowcode::ModelSchema::parse(&tv).map_err(|e| {
ToolError::new(e.code(), e.message()).field("tablesData")
})?;
let model = sspf_lowcode::ModelSchema::parse(&tv)
.map_err(|e| ToolError::new(e.code(), e.message()).field("tablesData"))?;
Ok((form, model))
}
@@ -1923,6 +1961,103 @@ impl NativeAdapter {
})
}
/// `schema.table.create` —— 按设计稿建物理表,并回写 `f_tables_data`。
///
/// 两种模式:
///
/// | 模式 | 入参 | 能落库吗 |
/// |---|---|---|
/// | 库内功能 | `id` / `enCode` | ✅(`dryRun=false` 时建表 + 回写) |
/// | 内联设计稿 | `formData` + `tablesData` | ❌ 只能演练(没有回写目标) |
///
/// 🔴 内联模式的意义:设计稿还没入库时就能看到 DDL ——
/// 与 `form.validate` 的 inline 模式同款,也方便冒烟脚本钉住建表规则。
async fn schema_table_create(&self, args: &Value) -> Result<Value, ToolError> {
let dry_run = Self::dry_run_flag(args);
let inline_form = args
.get("formData")
.and_then(Value::as_str)
.unwrap_or("")
.trim()
.to_string();
let inline_tables = args
.get("tablesData")
.and_then(Value::as_str)
.unwrap_or("")
.trim()
.to_string();
// ---- 内联设计稿:只能演练 ----
if !inline_form.is_empty() || !inline_tables.is_empty() {
if inline_form.is_empty() || inline_tables.is_empty() {
let missing = if inline_form.is_empty() {
"formData"
} else {
"tablesData"
};
return Err(ToolError::new(
"MISSING_ARG",
"内联模式要同时给 formData 与 tablesData",
)
.field(missing)
.hint(
"表单决定 logicalDelete / 主键策略,模型决定列 —— \
只给一半就建不出正确的表",
));
}
if !dry_run {
return Err(ToolError::new(
"INLINE_REQUIRES_DRY_RUN",
"内联设计稿只能演练,不能落库",
)
.field("dryRun")
.hint(
"落库要绑定一条功能记录(回写的目标)—— \
先把设计稿存进 base_visual_dev,再用 id / enCode 调",
));
}
let (form, model) = Self::lowcode_from_json(&inline_form, &inline_tables)?;
let outcome =
crate::lowcode_ddl::create_tables(&self.state.db, &model, &form, true).await?;
return Ok(Self::ddl_json(None, &outcome));
}
// ---- 库内功能:建表 + 回写 ----
let row = self.load_visualdev(args).await?;
let (form, model) = Self::lowcode_from_row(&row)?;
let visualdev_id = row["id"].as_str().unwrap_or("").to_string();
let outcome = crate::lowcode_ddl::create_and_sync(
&self.state.db,
&visualdev_id,
&model,
&form,
dry_run,
)
.await?;
Ok(Self::ddl_json(Some(&visualdev_id), &outcome))
}
/// 把建表结果整理成工具输出。
fn ddl_json(
visualdev_id: Option<&str>,
outcome: &crate::lowcode_ddl::CreateTablesOutcome,
) -> Value {
json!({
"id": visualdev_id,
"dryRun": outcome.dry_run,
"tables": outcome.tables,
"skipped": outcome.skipped,
"statements": outcome.ddl.len(),
"ddl": outcome.ddl,
"model": outcome.model,
"notes": outcome.notes,
})
}
/// `data.record.insert` —— 按设计稿新增一条记录(主表 + 子表)。
async fn data_record_insert(&self, args: &Value) -> Result<Value, ToolError> {
let (form, model) = self.load_lowcode(args).await?;
@@ -2032,6 +2167,43 @@ impl NativeAdapter {
}
}
/// 🔴 **不许经通用读工具投影/过滤的列**(口令与密钥)。
///
/// ## 为什么需要这一层
///
/// `data.query` / `data.count` 是「按表名读任意表」的通用口子。
/// 不在这里挡,一句 `{"table":"base_user"}` 就能把全库口令哈希拖走
/// (实测修复前确实返回了 `password` / `secretkey` 两列)。
///
/// ⇒ 三条约束:
/// 1. 缺省投影**滤掉**这些列;
/// 2. 显式 `columns` 要这些列 ⇒ `SENSITIVE_COLUMN`(不静默少给);
/// 3. `where` / `orderBy` 用它们 ⇒ 同样拒绝(否则成了「按哈希猜明文」的 oracle)。
const SENSITIVE_COLUMNS: &[&str] = &["f_password", "f_secretkey"];
/// 是否敏感列(大小写不敏感 —— PG 会把标识符折叠成小写)。
fn is_sensitive_column(name: &str) -> bool {
SENSITIVE_COLUMNS.iter().any(|c| c.eq_ignore_ascii_case(name))
}
/// 🔴 敏感列一律拒绝,并说清「为什么 + 去哪拿」。
fn ensure_not_sensitive(name: &str, field: &'static str) -> Result<(), ToolError> {
if !is_sensitive_column(name) {
return Ok(());
}
Err(ToolError::new(
"SENSITIVE_COLUMN",
format!("列 {name} 属于口令/密钥,不允许经通用读工具访问"),
)
.field(field.to_string())
.hint("口令列只存在于 base_user,任何工具都不投影它")
.next(
"permission.user.list",
json!({}),
"要看用户信息用这个(它本来就不返回口令字段)",
))
}
/// `form_err` —— 把 lowcode 的解析错误转成结构化工具错误。
fn form_err(e: sspf_lowcode::FormError) -> ToolError {
ToolError::new(e.code(), e.message())
@@ -2361,6 +2533,7 @@ impl PlatformAdapter for NativeAdapter {
"form.validate" => self.form_validate(&args).await,
// ------------------------------------------------ 低代码动态 CRUD(P2-b,写)
"schema.table.create" => self.schema_table_create(&args).await,
"data.record.insert" => self.data_record_insert(&args).await,
"data.record.update" => self.data_record_update(&args).await,
"data.record.delete" => self.data_record_delete(&args).await,
@@ -2394,6 +2567,19 @@ mod tests {
assert!(valid_table("").is_none());
}
/// 🔴 口令/密钥列必须在通用读工具入口就被挡住。
#[test]
fn sensitive_columns_are_blocked() {
assert!(is_sensitive_column("f_password"));
assert!(is_sensitive_column("F_PASSWORD"), "PG 折叠大小写,判断要不敏感");
assert!(is_sensitive_column("f_secretkey"));
assert!(!is_sensitive_column("f_account"));
let e = ensure_not_sensitive("f_password", "columns").unwrap_err();
assert_eq!(e.code, "SENSITIVE_COLUMN");
assert!(!e.hints.is_empty(), "拒绝时要说清去哪拿用户信息");
assert!(ensure_not_sensitive("f_account", "columns").is_ok());
}
/// 错误对象必须带 next_actions(AI 自纠的依据)。
#[test]
fn db_error_carries_hint_and_is_retryable() {